active_scaffold 3.0.23 → 3.0.24

data/lib/active_scaffold/extensions/action_view_rendering.rb~

@@ -0,0 +1,108 @@
+module ActionView
+  class LookupContext
+    module ViewPaths
+      def find_all_templates(name, partial = false, locals = {})
+        prefixes.collect do |prefix|
+          view_paths.collect do |resolver|
+            temp_args = *args_for_lookup(name, [prefix], partial, locals)
+            temp_args[1] = temp_args[1][0]
+            resolver.find_all(*temp_args)
+          end
+        end.flatten!
+      end
+    end
+  end
+end
+
+# wrap the action rendering for ActiveScaffold views
+module ActionView::Helpers #:nodoc:
+  module RenderingHelper
+    #
+    # Adds two rendering options.
+    #
+    # ==render :super
+    #
+    # This syntax skips all template overrides and goes directly to the provided ActiveScaffold templates.
+    # Useful if you want to wrap an existing template. Just call super!
+    #
+    # ==render :active_scaffold => #{controller.to_s}, options = {}+
+    #
+    # Lets you embed an ActiveScaffold by referencing the controller where it's configured.
+    #
+    # You may specify options[:constraints] for the embedded scaffold. These constraints have three effects:
+    #   * the scaffold's only displays records matching the constraint
+    #   * all new records created will be assigned the constrained values
+    #   * constrained columns will be hidden (they're pretty boring at this point)
+    #
+    # You may also specify options[:conditions] for the embedded scaffold. These only do 1/3 of what
+    # constraints do (they only limit search results). Any format accepted by ActiveRecord::Base.find is valid.
+    #
+    # Defining options[:label] lets you completely customize the list title for the embedded scaffold.
+    #
+    def render_with_active_scaffold(*args, &block)
+      if args.first == :super
+        last_view = view_stack.last || {:view => instance_variable_get(:@virtual_path).split('/').last}
+        options = args[1] || {}
+        options[:locals] ||= {}
+        options[:locals].reverse_merge!(last_view[:locals] || {})
+        if last_view[:templates].nil?
+          last_view[:templates] = lookup_context.find_all_templates(last_view[:view], last_view[:partial], options[:locals].keys)
+          last_view[:templates].shift
+        end
+        options[:file] = last_view[:templates].shift
+        view_stack << last_view
+        result = render_without_active_scaffold options
+        view_stack.pop
+        result
+      elsif args.first.is_a? Hash and args.first[:active_scaffold]
+        require 'digest/md5'
+        options = args.first
+
+        remote_controller = options[:active_scaffold]
+        constraints = options[:constraints]
+        conditions = options[:conditions]
+        eid = Digest::MD5.hexdigest(params[:controller] + remote_controller.to_s + constraints.to_s + conditions.to_s)
+        session["as:#{eid}"] = {:constraints => constraints, :conditions => conditions, :list => {:label => args.first[:label]}}
+        options[:params] ||= {}
+        options[:params].merge! :eid => eid, :embedded => true
+
+        id = "as_#{eid}-embedded"
+        url_options = {:controller => remote_controller.to_s, :action => 'index'}.merge(options[:params])
+
+        if controller.respond_to?(:render_component_into_view)
+          controller.send(:render_component_into_view, url_options)
+        else
+          content_tag(:div, :id => id, :class => 'active-scaffold-component') do
+            url = url_for(url_options)
+            content_tag(:div, :class => 'active-scaffold-header') do
+              content_tag :h2, link_to(args.first[:label] || active_scaffold_config_for(remote_controller.to_s.singularize).list.label, url, :remote => true)
+            end <<
+            if ActiveScaffold.js_framework == :prototype
+              javascript_tag("new Ajax.Updater('#{id}', '#{url}', {method: 'get', evalScripts: true});")
+            elsif ActiveScaffold.js_framework == :jquery
+              javascript_tag("$('##{id}').load('#{url}');")
+            end
+          end
+        end
+
+      else
+        options = args.first
+        if options.is_a?(Hash)
+          current_view = {:view => options[:partial], :partial => true} if options[:partial]
+          current_view = {:view => options[:template], :partial => false} if current_view.nil? && options[:template]
+          current_view[:locals] = options[:locals] if !current_view.nil? && options[:locals]
+          view_stack << current_view if current_view.present?
+        end
+        result = render_without_active_scaffold(*args, &block)
+        view_stack.pop if current_view.present?
+        result
+      end
+    end
+    alias_method_chain :render, :active_scaffold
+    
+    def view_stack
+      @_view_stack ||= []
+    end
+
+  end
+end

data/lib/active_scaffold/extensions/cache_association.rb~

@@ -0,0 +1,12 @@
+module ActiveRecord
+  class Relation
+    def target=(records)
+      debugger
+      @loaded = true
+      @records = records
+      puts loaded?.inspect
+      puts self.object_id
+      @records
+    end
+  end
+end

data/lib/active_scaffold/extensions/reverse_associations.rb~

@@ -0,0 +1,64 @@
+module ActiveRecord
+  module Reflection
+    class AssociationReflection #:nodoc:
+      def inverse_for?(klass)
+        inverse_class = self.klass unless options[:polymorphic]
+        inverse_class.present? && (inverse_class == klass || klass < inverse_class)
+      end
+
+      attr_writer :reverse
+      def reverse
+        @reverse ||= inverse_of.try(:name)
+      end
+
+      def inverse_of_with_autodetect
+        inverse_of_without_autodetect || autodetect_inverse
+      end
+      alias_method_chain :inverse_of, :autodetect
+      
+      protected
+
+        def autodetect_inverse
+          return nil if options[:polymorphic]
+          reverse_matches = []
+
+          # stage 1 filter: collect associations that point back to this model and use the same foreign_key
+          klass.reflect_on_all_associations.each do |assoc|
+            if self.options[:through]
+              # only iterate has_many :through associations
+              next unless assoc.options[:through]
+              next unless assoc.through_reflection.klass == self.through_reflection.klass
+            else
+              # skip over has_many :through associations
+              next if assoc.options[:through]
+              next unless assoc.options[:polymorphic] or assoc.class_name.constantize == self.active_record
+
+              case [assoc.macro, self.macro].find_all{|m| m == :has_and_belongs_to_many}.length
+                # if both are a habtm, then match them based on the join table
+                when 2
+                next unless assoc.options[:join_table] == self.options[:join_table]
+
+                # if only one is a habtm, they do not match
+                when 1
+                next
+
+                # otherwise, match them based on the foreign_key
+                when 0
+                next unless assoc.foreign_key.to_sym == self.foreign_key.to_sym
+              end
+            end
+
+            reverse_matches << assoc
+          end
+
+          # stage 2 filter: name-based matching (association name vs self.active_record.to_s)
+          reverse_matches.find_all do |assoc|
+            self.active_record.to_s.underscore.include? assoc.name.to_s.pluralize.singularize
+          end if reverse_matches.length > 1
+
+          reverse_matches.first
+        end
+
+    end
+  end
+end

data/lib/active_scaffold/extensions/routing_mapper.rb~

@@ -0,0 +1,34 @@
+module ActionDispatch
+  module Routing
+    ACTIVE_SCAFFOLD_CORE_ROUTING = {
+        :collection => {:show_search => :get, :render_field => :get},
+        :member => {:row => :get, :update_column => :post, :render_field => :get}
+    }
+    ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING = {
+        :collection => {:edit_associated => :get, :new_existing => :get, :add_existing => :post},
+        :member => {:edit_associated => :get, :add_association => :get, :destroy_existing => :delete}
+    }
+    class Mapper
+      module Base
+        def as_routes(options = {:association => true})
+          collection do
+            ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection].each {|name, type| send(type, name)}
+          end
+          member do
+            ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:member].each {|name, type| send(type, name)}
+          end
+          as_association_routes if options[:association]
+        end
+        
+        def as_association_routes
+          collection do 
+            ActionDispatch::Routing::ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING[:collection].each {|name, type| send(type, name)}
+          end
+          member do
+            ActionDispatch::Routing::ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING[:member].each {|name, type| send(type, name)}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_scaffold/extensions/unsaved_associated.rb~

@@ -0,0 +1,62 @@
+# save and validation support for associations.
+class ActiveRecord::Base
+  def associated_valid?(path = [])
+    return true if path.include?(self) # prevent recursion (if associated and parent are new records)
+    path << self
+    # using [].all? syntax to avoid a short-circuit
+    with_unsaved_associated { |a| debugger; [a.valid?, a.associated_valid?(path)].all? {|v| v == true} }
+  end
+
+  def save_associated
+    with_unsaved_associated { |a| a.save and a.save_associated }
+  end
+
+  def save_associated!
+    save_associated or raise(ActiveRecord::RecordNotSaved)
+  end
+
+  def no_errors_in_associated?
+    with_unsaved_associated {|a| a.errors.count == 0 and a.no_errors_in_associated?}
+  end
+
+  protected
+
+  # Provide an override to allow the model to restrict which associations are considered
+  # by ActiveScaffolds update mechanism. This allows the model to restrict things like
+  # Acts-As-Versioned versions associations being traversed.
+  #
+  # By defining the method :scaffold_update_nofollow returning an array of associations
+  # these associations will not be traversed.
+  # By defining the method :scaffold_update_follow returning an array of associations,
+  # only those associations will be traversed.
+  #
+  # Otherwise the default behaviour of traversing all associations will be preserved.
+  def associations_for_update
+    if self.respond_to?( :scaffold_update_nofollow )
+      self.class.reflect_on_all_associations.reject { |association| self.scaffold_update_nofollow.include?( association.name ) }
+    elsif self.respond_to?( :scaffold_update_follow )
+      self.class.reflect_on_all_associations.select { |association| self.scaffold_update_follow.include?( association.name ) }
+    else
+      self.class.reflect_on_all_associations
+    end
+  end
+
+  private
+
+  # yields every associated object that has been instantiated and is flagged as unsaved.
+  # returns false if any yield returns false.
+  # returns true otherwise, even when none of the associations have been instantiated. build wrapper methods accordingly.
+  def with_unsaved_associated
+    associations_for_update.all? do |association|
+      association_proxy = send(association.name)
+      if association_proxy
+        records = association_proxy
+        records = [records] unless records.is_a? Array # convert singular associations into collections for ease of use
+        debugger
+        records.select {|r| r.unsaved? and not r.readonly?}.all? {|r| yield r} # must use select instead of find_all, which Rails overrides on association proxies for db access
+      else
+        true
+      end
+    end
+  end
+end

data/lib/active_scaffold/finder.rb~

@@ -0,0 +1,370 @@
+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
+            unless column.search_sql.instance_of? Proc
+              case search_ui
+                when :boolean, :checkbox
+                  ["#{column.search_sql} = ?", column.column.type_cast(value)]
+                when :integer, :decimal, :float
+                  condition_for_numeric(column, value)
+                when :string, :range
+                  condition_for_range(column, value, like_pattern)
+                when :date, :time, :datetime, :timestamp
+                  condition_for_datetime(column, value)
+                when :select, :multi_select, :country, :usa_state
+                ["#{column.search_sql} in (?)", Array(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
+            else
+              column.search_sql.call(value)
+            end
+          end
+        rescue Exception => e
+          logger.error Time.now.to_s + "#{e.inspect} -- on the ActiveScaffold column :#{column.name}, search_ui = #{search_ui} in #{self.name}"
+          raise e
+        end
+      end
+
+      def condition_for_numeric(column, value)
+        if !value.is_a?(Hash)
+          ["#{column.search_sql} = ?", condition_value_for_numeric(column, value)]
+        elsif value[:from].blank? or not ActiveScaffold::Finder::NumericComparators.include?(value[:opt])
+          nil
+        elsif value[:opt] == 'BETWEEN'
+          ["#{column.search_sql} BETWEEN ? AND ?", condition_value_for_numeric(column, value[:from]), condition_value_for_numeric(column, value[:to])]
+         else
+          ["#{column.search_sql} #{value[:opt]} ?", condition_value_for_numeric(column, value[:from])]
+        end
+      end
+
+      def condition_for_range(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_for_null_type(column, value[:opt], like_pattern)
+        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
+      
+      def condition_value_for_datetime(value, conversion = :to_time)
+        if value.is_a? Hash
+          Time.zone.local(*[:year, :month, :day, :hour, :minute, :second].collect {|part| value[part].to_i}) rescue nil
+        elsif value.respond_to?(:strftime)
+          value.send(conversion)
+        elsif conversion == :to_date
+          Date.strptime(value, I18n.t('date.formats.default')) rescue nil
+        else
+          parts = Date._parse(value)
+          time_parts = [[:hour, '%H'], [:min, '%M'], [:sec, '%S']].collect {|part, format_part| format_part if parts[part].present?}.compact
+          format = "#{I18n.t('date.formats.default')} #{time_parts.join(':')} #{'%z' if parts[:offset].present?}"
+          time = DateTime.strptime(value, format)
+          time = Time.zone.local_to_utc(time) unless parts[:offset]
+          time.in_time_zone.send(conversion) rescue nil
+        end unless value.nil? || value.blank?
+      end
+
+      def condition_value_for_numeric(column, value)
+        return value if value.nil?
+        value = i18n_number_to_native_format(value) if [:i18n_number, :currency].include?(column.options[:format])
+        case (column.search_ui || column.column.type)
+        when :integer   then value.to_i rescue value ? 1 : 0
+        when :float     then value.to_f
+        when :decimal   then ActiveRecord::ConnectionAdapters::Column.value_to_decimal(value)
+        else
+          value
+        end
+      end
+
+      def i18n_number_to_native_format(value)
+        native = '.'
+        delimiter = I18n.t('number.format.delimiter')
+        separator = I18n.t('number.format.separator')
+        return value if value.blank? || !value.is_a?(String)
+        unless delimiter == native && !value.include?(separator) && value !~ /\.\d{3}$/
+          value.gsub(/[^0-9\-#{I18n.t('number.format.separator')}]/, '').gsub(I18n.t('number.format.separator'), native)
+        else
+          value
+        end
+      end
+            
+      def condition_for_datetime(column, value, like_pattern = nil)
+        conversion = column.column.type == :date ? :to_date : :to_time
+        from_value = condition_value_for_datetime(value[:from], conversion)
+        to_value = condition_value_for_datetime(value[:to], conversion)
+
+        if from_value.nil? and to_value.nil?
+          nil
+        elsif !from_value
+          ["#{column.search_sql} <= ?", to_value.to_s(:db)]
+        elsif !to_value
+          ["#{column.search_sql} >= ?", from_value.to_s(:db)]
+        else
+          ["#{column.search_sql} BETWEEN ? AND ?", from_value.to_s(:db), to_value.to_s(:db)]
+        end
+      end
+
+      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 condition_for_null_type(column, value, like_pattern = nil)
+        case value.to_sym
+        when :null
+          ["#{column.search_sql} is null"]
+        when :not_null
+          ["#{column.search_sql} is not null"]
+        else
+          nil
+        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 = {
+      :contains    => '%?%',
+      :begins_with => '?%',
+      :ends_with   => '%?'
+    }
+    NullComparators = [
+      :null,
+      :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),
+                         :where => search_conditions,
+                         :joins => joins_for_finder,
+                         :includes => 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[:includes] unless find_options[:where].nil?
+      options = find_options.reject{|k,v| [:select, :order].include? k}
+      options[:includes] = 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
+      if options[:pagination] && options[:pagination] != :infinite
+        count_query = append_to_query(klass, count_options(find_options, options[:count_includes]))
+        debugger
+        count = count_query.count unless options[:pagination] == :infinite
+      end
+  
+      # 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(append_to_query(klass, find_options).all, *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]
+          append_to_query(klass, find_options).all
+        end
+      end
+      pager.page(options[:page])
+    end
+    
+    def append_to_query(query, options)
+      options.assert_valid_keys :where, :select, :group, :order, :limit, :offset, :joins, :includes, :lock, :readonly, :from
+      options.reject{|k, v| v.blank?}.inject(query) do |query, (k, v)|
+        # default ordering of model has a higher priority than current queries ordering
+        # fix this by removing existing ordering from arel
+        if k.to_sym == :order
+          query = query.where('1=1') unless query.is_a?(ActiveRecord::Relation)
+          query = query.except(:order)
+        end
+        query.send((k.to_sym), v) 
+      end
+    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)
+      segments = []
+      conditions.each do |condition|
+        unless condition.blank?
+          sql = active_scaffold_config.model.send(:sanitize_sql, condition)
+          segments << sql unless sql.blank?
+        end
+      end
+      "(#{segments.join(') AND (')})" unless segments.empty?
+    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