Simple Model Search with Rails

<% form_for :search, @search,
            :html => { :method => :get } do |f| %>
  <%= f.label :offense_type_id, "Type" %>
  <%= f.collection_select :offense_type_id, @offensetypes,
                          :id_before_type_cast, :name,
                          { :include_blank => true } %>
  <br />
  <%= f.label :offense_level_id, "Level" %>
  <%= f.collection_select :offense_level_id, @offenselevels,
                          :id_before_type_cast, :name,
                          { :include_blank => true } %>
  <br />
  <%= f.label :investigation_number, "Investigation #" %>
  <%= f.text_field :investigation_number %>
  <br />
  <%= f.label :created_from, "Created after" %>
  <%= f.date_select :created_from, :order => [:month, :day, :year],
                    :include_blank => true %>
  (more...)
<% end %>

  def index
    munge_params
    @offenses = []
    @search = Search.new(Offense,params[:search])
 
    if @search.conditions
      @offenses = Offense.search(@search, :page => params[:page])
    end
 
    respond_to do |format|
      format.html # index.html.erb
      format.xml  { render :xml => @offenses }
    end
  end

  # The "s" parameter is an instance of Search, instantiated from form input. 
  def self.search(s, args = {})
    Offense.paginate(:all, :conditions => s.conditions, :page => args[:page],
                     :per_page => 100, :order => 'offenses.created_at',
                     :include => [:offense_level, :offense_type,
                                  :account_type, :account_status, :site])
  end

class Search
  attr_reader :options
 
  def initialize(model, options)
    @model = model
    @options = options || {}
  end
 
  def created_from
    date_from_options(:created_from)
  end
 
  def created_to
    date_from_options(:created_to)
  end
 
  def updated_from 
    date_from_options(:updated_from)
  end
 
  def updated_to
    date_from_options(:updated_to)
  end
 
  def modem_mac
    options[:modem_mac].to_s.gsub(/[^0-9a-f]/i, '').upcase
  end
 
  # method_missing will autogenerate an accessor for any attribute other
  # than the methods already written. I love this magic. :)
  def method_missing(method_id, *arguments)
    if @model.column_names.include?(method_id.to_s)
      options[method_id].to_s
    else
      raise NoMethodError, "undefined method #{method_id}"
    end
  end
 
  def conditions
    conditions = []
    parameters = []
 
    return nil if options.empty?
 
    if created_from
      conditions << "#{@model.table_name}.created_at >= ?"
      parameters << created_from.to_time
    end
 
    if created_to
      conditions << "#{@model.table_name}.created_at <= ?"
      parameters << created_to.to_time.end_of_day
    end
 
    if updated_from
      conditions << "#{@model.table_name}.updated_at >= ?"
      parameters << updated_from.to_time
    end
 
    if updated_to
      conditions << "#{@model.table_name}.updated_at <= ?"
      parameters << updated_to.to_time.end_of_day
    end
 
    # note that we're using self.send to make sure we use the getter methods
    # so that stuff like modem_mac gets its proper formatting in parameters
    options.each_key do |k|
      next unless @model.column_names.include?(k.to_s)
      v = self.send(k) unless k == :conditions # No infinite recursion for you.
      next if v.blank?
      if k =~ /_id$/
        conditions << "#{@model.table_name}.#{k} = ?"
        parameters << v.to_i
      else
        conditions << "#{@model.table_name}.#{k} LIKE ?"
        parameters << "%#{v}%"
      end
    end
 
    unless conditions.empty?
      [conditions.join(" AND "), *parameters]
    else
      nil
    end
  end
 
  private
 
  # Just like the one in the Report model, but just for dates instead of times.
  # Using a Proc to generate input parameter names like those for date_select.
  def date_from_options(which)
    part = Proc.new { |n| options["#{which}(#{n}i)"] }
    y,m,d = part[1], part[2], part[3]
    y = Date.today.year if y.blank?
    Date.new(y.to_i, m.to_i, d.to_i)
  rescue ArgumentError => e
    return nil
  end
end