brisk-bills 0.7.0 → 0.8.1

data/vendor/plugins/active_scaffold/lib/active_scaffold/data_structures/columns.rb

@@ -1,75 +1,75 @@
-module ActiveScaffold::DataStructures
-  class Columns
-    include Enumerable
-    include ActiveScaffold::Configurable
-
-    # The motivation for this collection is that this Columns data structure fills two roles: it provides
-    # the master list of all known columns, and it provides an inheritable list for all other actions (e.g.
-    # Create and Update and List). Well we actually want to *know* about as many columns as possible, so
-    # we don't want people actually removing columns from @set. But at the same time, we want to be able to
-    # manage which columns get inherited. Tada!
-    #
-    # This collection is referenced by other parts of ActiveScaffold and by methods within this DataStructure.
-    # IT IS NOT MEANT FOR PUBLIC USE (but if you know what you're doing, go ahead)
-    def _inheritable=(value)
-      @sorted = true
-      @_inheritable = value
-    end
-
-    # This accessor is used by ActionColumns to create new Column objects without adding them to this set
-    attr_reader :active_record_class
-
-    def initialize(active_record_class, *args)
-      @active_record_class = active_record_class
-      @_inheritable = []
-      @set = []
-
-      self.add *args
-    end
-
-    # the way to add columns to the set. this is primarily useful for virtual columns.
-    # note that this also makes columns inheritable
-    def add(*args)
-      args.flatten! # allow [] as a param
-      args = args.collect{ |a| a.to_sym }
-
-      # make the columns inheritable
-      @_inheritable.concat(args)
-      # then add columns to @set (unless they already exist)
-      args.each { |a| @set << ActiveScaffold::DataStructures::Column.new(a.to_sym, @active_record_class) unless find_by_name(a) }
-    end
-    alias_method :<<, :add
-
-    def exclude(*args)
-      # only remove columns from _inheritable. we never want to completely forget about a column.
-      args.each { |a| @_inheritable.delete a }
-    end
-
-    # returns an array of columns with the provided names
-    def find_by_names(*names)
-      @set.find_all { |column| names.include? column.name }
-    end
-
-    # returns the column of the given name.
-    def find_by_name(name)
-      # this works because of `def column.=='
-      column = @set.find { |c| c == name }
-      column
-    end
-    alias_method :[], :find_by_name
-
-    def each
-      @set.each {|i| yield i }
-    end
-
-    def _inheritable
-      if @sorted
-        @_inheritable
-      else
-        @_inheritable.sort do |a, b|
-          self[a] <=> self[b]
-        end
-      end
-    end
-  end
+module ActiveScaffold::DataStructures
+  class Columns
+    include Enumerable
+    include ActiveScaffold::Configurable
+
+    # The motivation for this collection is that this Columns data structure fills two roles: it provides
+    # the master list of all known columns, and it provides an inheritable list for all other actions (e.g.
+    # Create and Update and List). Well we actually want to *know* about as many columns as possible, so
+    # we don't want people actually removing columns from @set. But at the same time, we want to be able to
+    # manage which columns get inherited. Tada!
+    #
+    # This collection is referenced by other parts of ActiveScaffold and by methods within this DataStructure.
+    # IT IS NOT MEANT FOR PUBLIC USE (but if you know what you're doing, go ahead)
+    def _inheritable=(value)
+      @sorted = true
+      @_inheritable = value
+    end
+
+    # This accessor is used by ActionColumns to create new Column objects without adding them to this set
+    attr_reader :active_record_class
+
+    def initialize(active_record_class, *args)
+      @active_record_class = active_record_class
+      @_inheritable = []
+      @set = []
+
+      self.add *args
+    end
+
+    # the way to add columns to the set. this is primarily useful for virtual columns.
+    # note that this also makes columns inheritable
+    def add(*args)
+      args.flatten! # allow [] as a param
+      args = args.collect{ |a| a.to_sym }
+
+      # make the columns inheritable
+      @_inheritable.concat(args)
+      # then add columns to @set (unless they already exist)
+      args.each { |a| @set << ActiveScaffold::DataStructures::Column.new(a.to_sym, @active_record_class) unless find_by_name(a) }
+    end
+    alias_method :<<, :add
+
+    def exclude(*args)
+      # only remove columns from _inheritable. we never want to completely forget about a column.
+      args.each { |a| @_inheritable.delete a }
+    end
+
+    # returns an array of columns with the provided names
+    def find_by_names(*names)
+      @set.find_all { |column| names.include? column.name }
+    end
+
+    # returns the column of the given name.
+    def find_by_name(name)
+      # this works because of `def column.=='
+      column = @set.find { |c| c == name }
+      column
+    end
+    alias_method :[], :find_by_name
+
+    def each
+      @set.each {|i| yield i }
+    end
+
+    def _inheritable
+      if @sorted
+        @_inheritable
+      else
+        @_inheritable.sort do |a, b|
+          self[a] <=> self[b]
+        end
+      end
+    end
+  end
 end

data/vendor/plugins/active_scaffold/lib/active_scaffold/data_structures/set.rb

@@ -1,62 +1,57 @@
-module ActiveScaffold::DataStructures
-  class Set
-    include Enumerable
-    include ActiveScaffold::Configurable
-
-    attr_writer :label
-    def label
-      as_(@label)
-    end
-
-    def initialize(*args)
-      @set = []
-      self.add *args
-    end
-
-    # the way to add items to the set.
-    def add(*args)
-      args.flatten! # allow [] as a param
-      args.each { |arg|
-        arg = arg.to_sym if arg.is_a? String
-        @set << arg unless @set.include? arg # avoid duplicates
-      }
-    end
-    alias_method :<<, :add
-
-    # the way to remove items from the set.
-    def exclude(*args)
-      args.flatten! # allow [] as a param
-      args.collect! { |a| a.to_sym } # symbolize the args
-      # check respond_to? :to_sym, ActionColumns doesn't respond to to_sym
-      @set.reject! { |c| c.respond_to? :to_sym and args.include? c.to_sym } # reject all items specified
-    end
-    alias_method :remove, :exclude
-
-    # returns an array of items with the provided names
-    def find_by_names(*names)
-      @set.find_all { |item| names.include? item }
-    end
-
-    # returns the item of the given name.
-    def find_by_name(name)
-      # this works because of `def item.=='
-      item = @set.find { |c| c == name }
-      item
-    end
-    alias_method :[], :find_by_name
-
-    def each
-      @set.each {|i| yield i }
-    end
-
-    # returns the number of items in the set
-    def length
-      @set.length
-    end
-    
-    def empty?
-      @set.empty?
-    end
-
-  end
-end
+module ActiveScaffold::DataStructures
+  class Set
+    include Enumerable
+    include ActiveScaffold::Configurable
+
+    def initialize(*args)
+      @set = []
+      self.add *args
+    end
+
+    # the way to add items to the set.
+    def add(*args)
+      args.flatten! # allow [] as a param
+      args.each { |arg|
+        arg = arg.to_sym if arg.is_a? String
+        @set << arg unless @set.include? arg # avoid duplicates
+      }
+    end
+    alias_method :<<, :add
+
+    # the way to remove items from the set.
+    def exclude(*args)
+      args.flatten! # allow [] as a param
+      args.collect! { |a| a.to_sym } # symbolize the args
+      # check respond_to? :to_sym, ActionColumns doesn't respond to to_sym
+      @set.reject! { |c| c.respond_to? :to_sym and args.include? c.to_sym } # reject all items specified
+    end
+    alias_method :remove, :exclude
+
+    # returns an array of items with the provided names
+    def find_by_names(*names)
+      @set.find_all { |item| names.include? item }
+    end
+
+    # returns the item of the given name.
+    def find_by_name(name)
+      # this works because of `def item.=='
+      item = @set.find { |c| c == name }
+      item
+    end
+    alias_method :[], :find_by_name
+
+    def each
+      @set.each {|i| yield i }
+    end
+
+    # returns the number of items in the set
+    def length
+      @set.length
+    end
+    
+    def empty?
+      @set.empty?
+    end
+
+  end
+end

data/vendor/plugins/active_scaffold/lib/active_scaffold/data_structures/sorting.rb

@@ -7,7 +7,17 @@ module ActiveScaffold::DataStructures
       @columns = columns
       @clauses = []
     end
-
+    
+    def set_default_sorting(model)
+      last_scope = model.default_scoping.last
+      if last_scope.nil?  || last_scope[:find].nil? || last_scope[:find][:order].nil?
+        set(model.primary_key, 'ASC') if model.column_names.include?(model.primary_key)
+      else
+        set_sorting_from_order_clause(last_scope[:find][:order].to_s, model.table_name)
+        @default_sorting = true
+      end
+    end
+    
     # add a clause to the sorting, assuming the column is sortable
     def add(column_name, direction = nil)
       direction ||= 'ASC'
@@ -15,7 +25,7 @@ module ActiveScaffold::DataStructures
       column = get_column(column_name)
       raise ArgumentError, "Could not find column #{column_name}" if column.nil?
       raise ArgumentError, "Sorting direction unknown" unless [:ASC, :DESC].include? direction.to_sym
-      @clauses << [column, direction] if column.sortable?
+      @clauses << [column, direction.untaint] if column.sortable?
       raise ArgumentError, "Can't mix :method- and :sql-based sorting" if mixed_sorting?
     end
 
@@ -32,6 +42,7 @@ module ActiveScaffold::DataStructures
 
     # clears the sorting
     def clear
+      @default_sorting = false
       @clauses = []
     end
 
@@ -65,6 +76,22 @@ module ActiveScaffold::DataStructures
       @clauses.first
     end
 
+    # builds an order-by clause
+    def clause
+      return nil if sorts_by_method? || default_sorting?
+
+      # unless the sorting is by method, create the sql string
+      order = []
+      each do |sort_column, sort_direction|
+        sql = sort_column.sort[:sql]
+        next if sql.nil? or sql.empty?
+
+        order << "#{sql} #{sort_direction}"
+      end
+
+      order.join(', ') unless order.empty?
+    end
+
     protected
 
     # retrieves the sorting clause for the given column
@@ -85,5 +112,48 @@ module ActiveScaffold::DataStructures
     def mixed_sorting?
       sorts_by_method? and sorts_by_sql?
     end
+    
+    def default_sorting?
+      @default_sorting
+    end
+
+    def set_sorting_from_order_clause(order_clause, model_table_name = nil)
+      clear
+      order_clause.split(',').each do |criterion|
+        unless criterion.blank?
+          order_parts = extract_order_parts(criterion)
+          add(order_parts[:column_name], order_parts[:direction]) unless different_table?(model_table_name, order_parts[:table_name])
+        end
+      end
+    end
+    
+    def extract_order_parts(criterion_parts)
+      column_name_part, direction_part = criterion_parts.strip.split(' ')
+      column_name_parts = column_name_part.split('.')
+      order = {:direction => extract_direction(direction_part),
+               :column_name => remove_quotes(column_name_parts.last)}
+      order[:table_name] = remove_quotes(column_name_parts[-2]) if column_name_parts.length >= 2
+      order
+    end
+    
+    def different_table?(model_table_name, order_table_name)
+      !order_table_name.nil? && model_table_name != order_table_name
+    end
+    
+    def remove_quotes(sql_name)
+      if sql_name.starts_with?('"') || sql_name.starts_with?('`')
+        sql_name[1, (sql_name.length - 2)]
+      else
+        sql_name
+      end
+    end
+    
+    def extract_direction(direction_part)
+      if direction_part.to_s.upcase == 'DESC'
+        'DESC'
+      else
+        'ASC'
+      end
+    end
   end
-end
+end

data/vendor/plugins/active_scaffold/lib/active_scaffold/finder.rb

@@ -1,234 +1,304 @@
-module ActiveScaffold
-  module Finder
-    module ClassMethods
-      # Takes a collection of search terms (the tokens) and creates SQL that
-      # searches all specified ActiveScaffold columns. A row will match if each
-      # token is found in at least one of the columns.
-      def create_conditions_for_columns(tokens, columns, like_pattern = '%?%')
-        # if there aren't any columns, then just return a nil condition
-        return unless columns.length > 0
-
-        tokens = [tokens] if tokens.is_a? String
-
-        where_clauses = []
-        columns.each do |column|
-          where_clauses << ((column.column.nil? || column.column.text?) ? "LOWER(#{column.search_sql}) LIKE ?" : "#{column.search_sql} = ?")
-        end
-        phrase = "(#{where_clauses.join(' OR ')})"
-
-        sql = ([phrase] * tokens.length).join(' AND ')
-        tokens = tokens.collect do |value|
-          columns.collect {|column| (column.column.nil? || column.column.text?) ? like_pattern.sub('?', value.downcase) : column.column.type_cast(value)}
-        end.flatten
-
-        [sql, *tokens]
-      end
-
-      # Generates an SQL condition for the given ActiveScaffold column based on
-      # that column's database type (or form_ui ... for virtual columns?).
-      # TODO: this should reside on the column, not the controller
-      def condition_for_column(column, value, like_pattern = '%?%')
-        # we must check false or not blank because we want to search for false but false is blank
-        return unless column and column.search_sql and not value.blank?
-        search_ui = column.search_ui || column.column.type
-        if self.respond_to?("condition_for_#{column.name}_column")
-          self.send("condition_for_#{column.name}_column", column, value, like_pattern)
-        elsif self.respond_to?("condition_for_#{search_ui}_type")
-          self.send("condition_for_#{search_ui}_type", column, value, like_pattern)
-        else
-          case search_ui
-            when :boolean, :checkbox
-            ["#{column.search_sql} = ?", column.column.type_cast(value)]
-            when :select
-            ["#{column.search_sql} = ?", value[:id]] unless value[:id].blank?
-            when :multi_select
-            ["#{column.search_sql} in (?)", value.values.collect{|hash| hash[:id]}]
-            else
-              if column.column.nil? || column.column.text?
-                ["LOWER(#{column.search_sql}) LIKE ?", like_pattern.sub('?', value.downcase)]
-              else
-                ["#{column.search_sql} = ?", column.column.type_cast(value)]
-              end
-          end
-        end
-      end
-
-      def condition_for_integer_type(column, value, like_pattern)
-        if value['from'].blank? or not ActiveScaffold::Finder::NumericComparators.include?(value['opt'])
-          nil
-        elsif value['opt'] == 'BETWEEN'
-          ["#{column.search_sql} BETWEEN ? AND ?", value['from'].to_f, value['to'].to_f]
-        else
-          ["#{column.search_sql} #{value['opt']} ?", value['from'].to_f]
-        end
-      end
-      alias_method :condition_for_decimal_type, :condition_for_integer_type
-      alias_method :condition_for_float_type, :condition_for_integer_type
-
-      def condition_for_datetime_type(column, value, like_pattern)
-        conversion = value['from']['hour'].blank? && value['to']['hour'].blank? ? 'to_date' : 'to_time'
-        from_value, to_value = ['from', 'to'].collect do |field|
-          Time.zone.local(*['year', 'month', 'day', 'hour', 'minutes', 'seconds'].collect {|part| value[field][part].to_i}) rescue nil
-        end
-
-        if from_value.nil? and to_value.nil?
-          nil
-        elsif !from_value
-          ["#{column.search_sql} <= ?", to_value.send(conversion).to_s(:db)]
-        elsif !to_value
-          ["#{column.search_sql} >= ?", from_value.send(conversion).to_s(:db)]
-        else
-          ["#{column.search_sql} BETWEEN ? AND ?", from_value.send(conversion).to_s(:db), to_value.send(conversion).to_s(:db)]
-        end
-      end
-      alias_method :condition_for_date_type, :condition_for_datetime_type
-      alias_method :condition_for_time_type, :condition_for_datetime_type
-      alias_method :condition_for_timestamp_type, :condition_for_datetime_type
-    end
-
-    NumericComparators = [
-      '=',
-      '>=',
-      '<=',
-      '>',
-      '<',
-      '!=',
-      'BETWEEN'
-    ]
-
-    def self.included(klass)
-      klass.extend ClassMethods
-    end
-
-    protected
-
-    attr_writer :active_scaffold_conditions
-    def active_scaffold_conditions
-      @active_scaffold_conditions ||= []
-    end
-
-    attr_writer :active_scaffold_joins
-    def active_scaffold_joins
-      @active_scaffold_joins ||= []
-    end
-
-    attr_writer :active_scaffold_habtm_joins
-    def active_scaffold_habtm_joins
-      @active_scaffold_habtm_joins ||= []
-    end
-    
-    def all_conditions
-      merge_conditions(
-        active_scaffold_conditions,                   # from the search modules
-        conditions_for_collection,                    # from the dev
-        conditions_from_params,                       # from the parameters (e.g. /users/list?first_name=Fred)
-        conditions_from_constraints,                  # from any constraints (embedded scaffolds)
-        active_scaffold_session_storage[:conditions] # embedding conditions (weaker constraints)
-      )
-    end
-
-    # returns a single record (the given id) but only if it's allowed for the specified action.
-    # accomplishes this by checking model.#{action}_authorized?
-    # TODO: this should reside on the model, not the controller
-    def find_if_allowed(id, action, klass = nil)
-      klass ||= active_scaffold_config.model
-      record = klass.find(id)
-      raise ActiveScaffold::RecordNotAllowed unless record.authorized_for?(:action => action.to_sym)
-      return record
-    end
-
-    # returns a Paginator::Page (not from ActiveRecord::Paginator) for the given parameters
-    # options may include:
-    # * :sorting - a Sorting DataStructure (basically an array of hashes of field => direction, e.g. [{:field1 => 'asc'}, {:field2 => 'desc'}]). please note that multi-column sorting has some limitations: if any column in a multi-field sort uses method-based sorting, it will be ignored. method sorting only works for single-column sorting.
-    # * :per_page
-    # * :page
-    # TODO: this should reside on the model, not the controller
-    def find_page(options = {})
-      options.assert_valid_keys :sorting, :per_page, :page, :count_includes
-
-      full_includes = (active_scaffold_joins.empty? ? nil : active_scaffold_joins)
-      options[:per_page] ||= 999999999
-      options[:page] ||= 1
-      options[:count_includes] ||= full_includes
-
-      klass = active_scaffold_config.model
-
-      # create a general-use options array that's compatible with Rails finders
-      finder_options = { :order => build_order_clause(options[:sorting]),
-                         :conditions => all_conditions,
-                         :joins => joins_for_finder,
-                         :include => options[:count_includes]}
-                         
-      finder_options.merge! custom_finder_options
-
-      # NOTE: we must use :include in the count query, because some conditions may reference other tables
-      count = klass.count(finder_options.reject{|k,v| [:order].include? k})
-
-      finder_options.merge! :include => full_includes
-
-      # we build the paginator differently for method- and sql-based sorting
-      if options[:sorting] and options[:sorting].sorts_by_method?
-        pager = ::Paginator.new(count, options[:per_page]) do |offset, per_page|
-          sorted_collection = sort_collection_by_column(klass.find(:all, finder_options), *options[:sorting].first)
-          sorted_collection.slice(offset, per_page)
-        end
-      else
-        pager = ::Paginator.new(count, options[:per_page]) do |offset, per_page|
-          klass.find(:all, finder_options.merge(:offset => offset, :limit => per_page))
-        end
-      end
-
-      pager.page(options[:page])
-    end
-
-    def joins_for_finder
-      case joins_for_collection
-        when String
-          [ joins_for_collection ]
-        when Array
-          joins_for_collection
-        else
-          []
-      end + active_scaffold_habtm_joins
-    end
-    
-    # TODO: this should reside on the model, not the controller
-    def merge_conditions(*conditions)
-      c = conditions.find_all {|c| not c.nil? and not c.empty? }
-      c.empty? ? nil : c.collect{|c| active_scaffold_config.model.send(:sanitize_sql, c)}.join(' AND ')
-    end
-
-    # accepts a DataStructure::Sorting object and builds an order-by clause
-    # TODO: this should reside on the model, not the controller
-    def build_order_clause(sorting)
-      return nil if sorting.nil? or sorting.sorts_by_method?
-
-      # unless the sorting is by method, create the sql string
-      order = []
-      sorting.each do |clause|
-        sort_column, sort_direction = clause
-        sql = sort_column.sort[:sql]
-        next if sql.nil? or sql.empty?
-
-        order << "#{sql} #{sort_direction}"
-      end
-
-      order = order.join(', ')
-      order = nil if order.empty?
-
-      order
-    end
-
-    # TODO: this should reside on the column, not the controller
-    def sort_collection_by_column(collection, column, order)
-      sorter = column.sort[:method]
-      collection = collection.sort_by { |record|
-        value = (sorter.is_a? Proc) ? record.instance_eval(&sorter) : record.instance_eval(sorter)
-        value = '' if value.nil?
-        value
-      }
-      collection.reverse! if order.downcase == 'desc'
-      collection
-    end
-  end
-end
+module ActiveScaffold
+  module Finder
+    def self.like_operator
+      @@like_operator ||= ::ActiveRecord::Base.connection.adapter_name == "PostgreSQL" ? "ILIKE" : "LIKE"
+    end
+
+    module ClassMethods
+      # Takes a collection of search terms (the tokens) and creates SQL that
+      # searches all specified ActiveScaffold columns. A row will match if each
+      # token is found in at least one of the columns.
+      def create_conditions_for_columns(tokens, columns, text_search = :full)
+        # if there aren't any columns, then just return a nil condition
+        return unless columns.length > 0
+        like_pattern = like_pattern(text_search)
+
+        tokens = [tokens] if tokens.is_a? String
+
+        where_clauses = []
+        columns.each do |column|
+          where_clauses << ((column.column.nil? || column.column.text?) ? "#{column.search_sql} #{ActiveScaffold::Finder.like_operator} ?" : "#{column.search_sql} = ?")
+        end
+        phrase = "(#{where_clauses.join(' OR ')})"
+
+        sql = ([phrase] * tokens.length).join(' AND ')
+        tokens = tokens.collect do |value|
+          columns.collect {|column| (column.column.nil? || column.column.text?) ? like_pattern.sub('?', value) : column.column.type_cast(value)}
+        end.flatten
+
+        [sql, *tokens]
+      end
+
+      # Generates an SQL condition for the given ActiveScaffold column based on
+      # that column's database type (or form_ui ... for virtual columns?).
+      # TODO: this should reside on the column, not the controller
+      def condition_for_column(column, value, text_search = :full)
+        like_pattern = like_pattern(text_search)
+        if self.respond_to?("condition_for_#{column.name}_column")
+          return self.send("condition_for_#{column.name}_column", column, value, like_pattern)
+        end
+        return unless column and column.search_sql and not value.blank?
+        search_ui = column.search_ui || column.column.try(:type)
+        begin
+          if search_ui && self.respond_to?("condition_for_#{search_ui}_type")
+            self.send("condition_for_#{search_ui}_type", column, value, like_pattern)
+          else
+            case search_ui
+              when :boolean, :checkbox
+              ["#{column.search_sql} = ?", column.column.type_cast(value)]
+              when :select, :multi_select, :country, :usa_state
+              ["#{column.search_sql} in (?)", value]
+              else
+                if column.column.nil? || column.column.text?
+                  ["#{column.search_sql} #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', value)]
+                else
+                  ["#{column.search_sql} = ?", column.column.type_cast(value)]
+                end
+            end
+          end
+        rescue Exception => e
+          logger.error Time.now.to_s + "#{e.inspect} -- on the ActiveScaffold column :#{column.name}, search_ui = #{search_ui} in #{@controller.class}"
+          raise e
+        end
+      end
+
+      def condition_for_integer_type(column, value, like_pattern = nil)
+        if column.options[:format]
+          if value.is_a?(Hash)
+            value[:from] = column.number_to_native(value[:from])
+            value[:to] = column.number_to_native(value[:to])
+          else
+            value = column.number_to_native(value)
+          end
+        end
+
+        if !value.is_a?(Hash)
+          ["#{column.search_sql} = ?", column.column.nil? ? value.to_f : column.column.type_cast(value)]
+        elsif ActiveScaffold::Finder::NullComparators.include?(value[:opt])
+          condition = "#{column.search_sql} #{value[:opt].humanize}"
+        elsif value[:from].blank?
+          nil
+        elsif value[:opt] == 'BETWEEN'
+          condition = "#{column.search_sql} BETWEEN ? AND ?"
+          if column.column.nil?
+            [condition, value[:from].to_f, value[:to].to_f]
+          else
+            [condition, column.column.type_cast(value[:from]), column.column.type_cast(value[:to])]
+          end
+        elsif ActiveScaffold::Finder::NumericComparators.include?(value[:opt])
+          ["#{column.search_sql} #{value[:opt]} ?", column.column.nil? ? value[:from].to_f : column.column.type_cast(value[:from])]
+        end
+      end
+      alias_method :condition_for_decimal_type, :condition_for_integer_type
+      alias_method :condition_for_float_type, :condition_for_integer_type
+
+      def condition_for_range_type(column, value, like_pattern = nil)
+        if !value.is_a?(Hash)
+          if column.column.nil? || column.column.text?
+            ["#{column.search_sql} #{ActiveScaffold::Finder.like_operator} ?", like_pattern.sub('?', value)]
+          else
+            ["#{column.search_sql} = ?", column.column.type_cast(value)]
+          end
+        elsif ActiveScaffold::Finder::NullComparators.include?(value[:opt])
+          condition = "#{column.search_sql} #{value[:opt].humanize}"
+        elsif value[:from].blank?
+          nil
+        elsif ActiveScaffold::Finder::StringComparators.values.include?(value[:opt])
+          ["#{column.search_sql} LIKE ?", value[:opt].sub('?', value[:from])]
+        elsif value[:opt] == 'BETWEEN'
+          ["#{column.search_sql} BETWEEN ? AND ?", value[:from], value[:to]]
+        elsif ActiveScaffold::Finder::NumericComparators.include?(value[:opt])
+          ["#{column.search_sql} #{value[:opt]} ?", value[:from]]
+        else
+          nil
+        end
+      end
+      alias_method :condition_for_string_type, :condition_for_range_type
+
+      def condition_for_datetime_type(column, value, like_pattern = nil)
+        conversion = value[:from][:hour].blank? && value[:to][:hour].blank? ? :to_date : :to_time
+        from_value, to_value = [:from, :to].collect do |field|
+          Time.zone.local(*[:year, :month, :day, :hour, :minute, :second].collect {|part| value[field][part].to_i}) rescue nil
+        end
+
+        if from_value.nil? and to_value.nil?
+          nil
+        elsif !from_value
+          ["#{column.search_sql} <= ?", to_value.send(conversion).to_s(:db)]
+        elsif !to_value
+          ["#{column.search_sql} >= ?", from_value.send(conversion).to_s(:db)]
+        else
+          ["#{column.search_sql} BETWEEN ? AND ?", from_value.send(conversion).to_s(:db), to_value.send(conversion).to_s(:db)]
+        end
+      end
+      alias_method :condition_for_date_type, :condition_for_datetime_type
+      alias_method :condition_for_time_type, :condition_for_datetime_type
+      alias_method :condition_for_timestamp_type, :condition_for_datetime_type
+
+      def condition_for_record_select_type(column, value, like_pattern = nil)
+        if value.is_a?(Array)
+          ["#{column.search_sql} IN (?)", value]
+        else
+          ["#{column.search_sql} = ?", value]
+        end
+      end
+
+      def like_pattern(text_search)
+        case text_search
+          when :full then '%?%'
+          when :start then '?%'
+          when :end then '%?'
+          else '?'
+        end
+      end
+    end
+
+    NumericComparators = [
+      '=',
+      '>=',
+      '<=',
+      '>',
+      '<',
+      '!=',
+      'BETWEEN'
+    ]
+    StringComparators = ActiveSupport::OrderedHash[
+      :contains,    '%?%',
+      :begins_with, '?%',
+      :ends_with,   '%?'
+    ]
+
+    NullComparators = ['is_null', 'is_not_null']
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    protected
+
+    attr_writer :active_scaffold_conditions
+    def active_scaffold_conditions
+      @active_scaffold_conditions ||= []
+    end
+
+    attr_writer :active_scaffold_includes
+    def active_scaffold_includes
+      @active_scaffold_includes ||= []
+    end
+
+    attr_writer :active_scaffold_habtm_joins
+    def active_scaffold_habtm_joins
+      @active_scaffold_habtm_joins ||= []
+    end
+    
+    def all_conditions
+      merge_conditions(
+        active_scaffold_conditions,                   # from the search modules
+        conditions_for_collection,                    # from the dev
+        conditions_from_params,                       # from the parameters (e.g. /users/list?first_name=Fred)
+        conditions_from_constraints,                  # from any constraints (embedded scaffolds)
+        active_scaffold_session_storage[:conditions] # embedding conditions (weaker constraints)
+      )
+    end
+    
+    # returns a single record (the given id) but only if it's allowed for the specified action.
+    # accomplishes this by checking model.#{action}_authorized?
+    # TODO: this should reside on the model, not the controller
+    def find_if_allowed(id, crud_type, klass = beginning_of_chain)
+      record = klass.find(id)
+      raise ActiveScaffold::RecordNotAllowed, "#{klass} with id = #{id}" unless record.authorized_for?(:crud_type => crud_type.to_sym)
+      return record
+    end
+
+    # returns a hash with options to find records
+    # valid options may include:
+    # * :sorting - a Sorting DataStructure (basically an array of hashes of field => direction, e.g. [{:field1 => 'asc'}, {:field2 => 'desc'}]). please note that multi-column sorting has some limitations: if any column in a multi-field sort uses method-based sorting, it will be ignored. method sorting only works for single-column sorting.
+    # * :per_page
+    # * :page
+    def finder_options(options = {})
+      options.assert_valid_keys :sorting, :per_page, :page, :count_includes, :pagination, :select
+
+      search_conditions = all_conditions
+      full_includes = (active_scaffold_includes.blank? ? nil : active_scaffold_includes)
+
+      # create a general-use options array that's compatible with Rails finders
+      finder_options = { :order => options[:sorting].try(:clause),
+                         :conditions => search_conditions,
+                         :joins => joins_for_finder,
+                         :include => full_includes}
+                         
+      finder_options.merge! custom_finder_options
+      finder_options
+    end
+
+    # Returns a hash with options to count records, rejecting select and order options
+    # See finder_options for valid options
+    def count_options(find_options = {}, count_includes = nil)
+      count_includes ||= find_options[:include] unless find_options[:conditions].nil?
+      options = find_options.reject{|k,v| [:select, :order].include? k}
+      options[:include] = count_includes
+      options
+    end
+
+    # returns a Paginator::Page (not from ActiveRecord::Paginator) for the given parameters
+    # See finder_options for valid options
+    # TODO: this should reside on the model, not the controller
+    def find_page(options = {})
+      options[:per_page] ||= 999999999
+      options[:page] ||= 1
+
+      find_options = finder_options(options)
+      klass = beginning_of_chain
+      
+      # NOTE: we must use :include in the count query, because some conditions may reference other tables
+      count = klass.count(count_options(find_options, options[:count_includes])) if options[:pagination] && options[:pagination] != :infinite
+
+      # Converts count to an integer if ActiveRecord returned an OrderedHash
+      # that happens when find_options contains a :group key
+      count = count.length if count.is_a? ActiveSupport::OrderedHash
+
+      # we build the paginator differently for method- and sql-based sorting
+      if options[:sorting] and options[:sorting].sorts_by_method?
+        pager = ::Paginator.new(count, options[:per_page]) do |offset, per_page|
+          sorted_collection = sort_collection_by_column(klass.all(find_options), *options[:sorting].first)
+          sorted_collection = sorted_collection.slice(offset, per_page) if options[:pagination]
+          sorted_collection
+        end
+      else
+        pager = ::Paginator.new(count, options[:per_page]) do |offset, per_page|
+          find_options.merge!(:offset => offset, :limit => per_page) if options[:pagination]
+          klass.all(find_options)
+        end
+      end
+
+      pager.page(options[:page])
+    end
+
+    def joins_for_finder
+      case joins_for_collection
+        when String
+          [ joins_for_collection ]
+        when Array
+          joins_for_collection
+        else
+          []
+      end + active_scaffold_habtm_joins
+    end
+    
+    def merge_conditions(*conditions)
+      active_scaffold_config.model.merge_conditions(*conditions)
+    end
+
+    # TODO: this should reside on the column, not the controller
+    def sort_collection_by_column(collection, column, order)
+      sorter = column.sort[:method]
+      collection = collection.sort_by { |record|
+        value = (sorter.is_a? Proc) ? record.instance_eval(&sorter) : record.instance_eval(sorter)
+        value = '' if value.nil?
+        value
+      }
+      collection.reverse! if order.downcase == 'desc'
+      collection
+    end
+  end
+end