[PATCH] Add boolean finders and markers to ActiveRecord::Base

Patch for ActiveRecord::Base to enable dynamic boolean finders and markers. With docs and unit tests

I don't find Order.mark_as_paid that much clearer than Order.update_attributes(:paid => true).

The finder methods are better, though it might be nice to precede them with find, similar to the current dynamic finders i.e find_unpaid, find_all_unpaid

Finally, it's going to be really hard to find a natural sounding inverse to every boolean parameter. Using your example above, what are the opposite of hot and sunny? unhot and unsunny?

So, while I can see how it can be useful in some circumstances, IMO I don't think it' can ever be comprehensive enough or adds enough value to deserve be part of rails core. If you released it as a plugin however, I'm sure you'd make many people happy.

What if 'not_' were allowed as a prefix? I did consider that listing all the known opposite word pairs would be way more effort than it was worth, but I'd like to come up with a general ruleset that covers most plausible use cases. Besides, if you're really unhappy with the method names this generates, you can always roll your own. This is supposed to give you some generally useful functionality without writing any code.

My main motivation for this patch is increasing code legibility - Rails excels in that it allows you to write controller code that reads like a story. I find myself writing these methods again and again simply for that reason - they make my code more legible and keep column names all wrapped up in the model in case you need to change them. If you've use mark_as_paid all over your app, you can just define this method yourself in the model if you need to change the column name.

The other reason is that including this as a plugin or as library code means copy-pasting the existing method_missing hooks from ActiveRecord, which means it needs maintaining should these hooks change across Rails versions.

Replying to jcoglan:

My main motivation for this patch is increasing code legibility - Rails excels in that it allows you to write controller code that reads like a story. I find myself writing these methods again and again simply for that reason - they make my code more legible and keep column names all wrapped up in the model in case you need to change them. If you've use mark_as_paid all over your app, you can just define this method yourself in the model if you need to change the column name.

To clarify, I do think your patch makes some model methods clearer, just not enough to justify inclusion. I also fully support the goal of making code as easy to read as possible and reducing repetition in your app. Again, this is something I can see your patch does, but again, IMO not enough to justify inclusion. That said, I'm not a member of core so the decision isn't ultimately mine.

The other reason is that including this as a plugin or as library code means copy-pasting the existing method_missing hooks from ActiveRecord, which means it needs maintaining should these hooks change across Rails versions.

If this were the case it would be a compelling argument for inclusion, but it's not. Here's how you can implement a plugin to intercept method_missing, without having to copy/paste active record code. This is off the top of my head (as usual), so be lenient!

module MethodMissingInterceptor
  def self.included(base)
    base.class_eval do
      alias_method_chain :method_missing, :interception
    end
  end

  def method_missing_with_interception(method, *args, &block)
    if (method_should_be_intercepted?(method))
      handle_intercepted_method
    else
      # call to original method misssing
      method_missing_without_interception
    end
  end
end

ActiveRecord::Base.send :include, MethodMissingInterceptor

Using this, all calls to ActiveRecord::Base#method_missing will go to MethodMissingInterceptor#method_missing_with_interception, which can choose whether to pass them on to the original method or not.

Neat idea. This is perfect for a plugin rather than going straight into core.

For the finders take a look at the scope_out plugin. It doesn't provide the mark_* methods, but you can easily create the finders.

  class Order < ActiveRecord::Base
    scope_out :paid
  end
  Order.find_paid(:all)