Manu J j-manu

My theory is that folks are hallucinating complex structure for these docs. If you read the Cursor forums, people are asking the Cursor LLM how to format them 🙃 Those shared above are the results of writing in the UI and what gets puts into version control.

My approach is that when I am annoyed by something I have to manually fix up, I go update the file.

Some of it is just impossible, like using the new Strong Params expects syntax given the training cutoffs. I’m not going to completely document the interface (cursor/rules can’t link to docs and can only link to a single file) . So I hint it, and it simply hallucinates the interface mostly correctly most of the time. Principle of Least Surprise in practice!

My .cursorrules were pretty inconsistent project to project, and I don’t believe that putting very generic things like “Use exceptions for exceptional cases, not for control flow” or “Use Active Record effectively” improves things.

In my application every time I send a newsletter to a User, I create a NewsletterDelivery record. I frequently want to be able to query, for each user, what is the most recent newsletter delivery record. This is called a "last n per group" query and a LATERAL JOIN is the best way to do it imo. But the query I've been using (and I've told people to use, and seen blogged about) is not very good, because the conditions don't get pushed down into the subselect which means that the query ends-up lateral-joining all the records before it applies the conditions for the association.

Instead of doing subselect_table.* the better query does association.id AS assocation_id, subselect_table.id, subselect_table.title, .... and enumerates over all of the columns. This allows the association query, which Active Record tacks on at the end as WHERE association_id = $1 or WHERE association_id IN ($1, $2, $3, ...) to be pushed down c

Pure ESM package

The package that linked you here is now pure ESM. It cannot be require()'d from CommonJS.

This means you have the following choices:

Use ESM yourself. (preferred)
Use import foo from 'foo' instead of const foo = require('foo') to import the package. You also need to put "type": "module" in your package.json and more. Follow the below guide.
If the package is used in an async context, you could use await import(…) from CommonJS instead of require(…).
Stay on the existing version of the package until you can move to ESM.

I want to build a system which uses rules. These rules will change hourly (i.e. "this rule is effective from 2pm to 6pm"). The rules must support arbitrarily complex logic on just 2-3 pre-defined variables and result in a boolean:

item.a > 10 && item.b == 0 || item.category == FOOTWEAR

These rules will be executed hundreds of times per second so I can't afford the overhead of plain old eval. I want to reload the current effective ruleset from the database hourly, precompile each rule's logic string and execute it via the quickest method possible. It might look something like this:

class Rule

Rails 4 Differences

Chapter 1

No differences.

Chapter 2

root :to => "dashboard#index" is now root "dashboard#index"`
Need to permit parameters within Subscribem::AccountsController

Frontend Development

Attention: the list was moved to

https://github.com/dypsilon/frontend-dev-bookmarks

This page is not maintained anymore, please update your bookmarks.

	require 'date'

	class Sorter
	def initialize(*instructions)
	@defaults = {
	direction: :ascending,
	nils: :small,
	accessor: :itself,
	case_sensitive: true,
	normalized: false,

	# This hack is designed to prevent a thread from implicitly checking out an AR connection by
	# just accessing ActiveRecord::Base.connection. The point of doing this is to ensure that threads
	# don't tie up connections that they are not using, by making sure we're explicit about where we
	# need to use an AR connection.
	#
	# See also http://tenderlovemaking.com/2011/10/20/connection-management-in-activerecord.html

	ActiveSupport.on_load(:active_record) do
	ActiveRecord::ConnectionAdapters::ConnectionPool # ensure loaded

	module CapybaraHelpers
	class << self
	def local_ip
	ipv4_addr_info.ip_address
	end

	def setup_selenium_remote
	app_host \|\|= ENV.fetch('SELENIUM_APP_HOST', local_ip)
	Capybara.server_host = app_host
	Capybara.app_host = "http://#{app_host}:#{Capybara.current_session.server.port}"

	module Capybara::Poltergeist
	class Client
	private
	def redirect_stdout
	prev = STDOUT.dup
	prev.autoclose = false
	$stdout = @write_io
	STDOUT.reopen(@write_io)

	prev = STDERR.dup