active_scaffold 3.2.17 → 3.2.18

data/lib/active_scaffold/bridges/file_column/form_ui.rb

@@ -1,34 +0,0 @@
-module ActiveScaffold
-  module Helpers
-    # Helpers that assist with the rendering of a Form Column
-    module FormColumnHelpers
-      def active_scaffold_input_file_column(column, options)
-       if @record.send(column.name) 
-          # we already have a value? display the form for deletion.
-          if ActiveScaffold.js_framework == :jquery
-            remove_file_js = "$(this).prev().val('true'); $(this).parent().hide().next().show(); return false;";
-          else
-            remove_file_js = "$(this).previous().value='true'; p=$(this).up(); p.hide(); p.next().show(); return false;";
-          end            
-          
-          hidden_options = options.dup
-          hidden_options[:id] += '_delete'
-          hidden_options[:name].sub!("[#{column.name}]", "[delete_#{column.name}]")
-          hidden_options[:value] = 'false'          
-          custom_hidden_field_tag = hidden_field(:record, column.name, hidden_options)
-
-          content_tag(:div) do
-            content_tag(:div) do
-              content = get_column_value(@record, column) + " #{custom_hidden_field_tag} | ".html_safe
-              content += content_tag(:a, as_(:remove_file), {:href => '#', :onclick => remove_file_js})
-              content += content_tag(:div, file_column_field("record", column.name, options), :style => "display: none")
-            end           
-          end
-       else
-          file_column_field("record", column.name, options)          
-       end        
-      end
-      
-    end
-  end
-end

data/lib/active_scaffold/bridges/file_column/list_ui.rb

@@ -1,26 +0,0 @@
-module ActiveScaffold
-  module Helpers
-    # Helpers that assist with the rendering of a List Column
-    module ListColumnHelpers
-      def active_scaffold_column_download_link_with_filename(column, record)
-        return nil if record.send(column.name).nil?
-        active_scaffold_column_download_link(column, record, File.basename(record.send(column.name)))
-      end
-      
-      def active_scaffold_column_download_link(column, record, label = nil)
-        return nil if record.send(column.name).nil?
-        label||=as_(:download)
-        link_to( label, url_for_file_column(record, column.name.to_s), :popup => true)
-      end
-      
-      def active_scaffold_column_thumbnail(column, record)
-        return nil if record.send(column.name).nil?
-        link_to( 
-          image_tag(url_for_file_column(record, column.name.to_s, "thumb"), :border => 0), 
-          url_for_file_column(record, column.name.to_s), 
-          :popup => true)
-      end
-      
-    end
-  end
-end

data/lib/active_scaffold/bridges/file_column/test/functional/file_column_keep_test.rb

@@ -1,43 +0,0 @@
-require File.join(File.dirname(__FILE__), "../test_helper.rb")
-
-class DeleteFileColumnTest < Test::Unit::TestCase
-  def setup
-    DeleteFileColumn.generate_delete_helpers(MockModel)
-    @model = MockModel.new
-    @model.band_image = "coolio.jpg"
-  end
-  
-  def test__file_column_fields
-    assert_equal(1, @model.file_column_fields.length)
-  end
-  
-	def test__delete_band_image__boolean__should_delete
-		@model.delete_band_image = true
-    assert_nil @model.band_image
-  end
-  
-	def test__delete_band_image__string__should_delete
-		@model.delete_band_image = "true"
-    assert_nil @model.band_image
-  end
-  
-  
-	def test__delete_band_image__boolean_false__shouldnt_delete
-		@model.delete_band_image = false
-    assert_not_nil @model.band_image
-  end
-  
-	def test__delete_band_image__string_false__shouldnt_delete
-		@model.delete_band_image = "false"
-    assert_not_nil @model.band_image
-  end
-  
-  
-  def test__just_uploaded__shouldnt_delete
-    @model.band_image_just_uploaded = true
-    @model.delete_band_image = "true"
-    assert_not_nil(@model.band_image)
-  end
-  
-  
-end

data/lib/active_scaffold/bridges/file_column/test/mock_model.rb

@@ -1,9 +0,0 @@
-class MockModel
-  attr_accessor :name
-  attr_accessor :bio
-  
-  attr_accessor :band_image
-  attr_accessor :band_image_just_uploaded
-  def band_image_just_uploaded?; self.band_image_just_uploaded ? true : false; end
-  
-end

data/lib/active_scaffold/bridges/file_column/test/test_helper.rb

@@ -1,15 +0,0 @@
-require 'test/unit'
-require "rubygems"
-require 'active_support'
-
-for file in ["../lib/delete_file_column.rb", "mock_model.rb"]
-  require File.expand_path(File.join(File.dirname(__FILE__), file))
-end
-
-
-
-def dbg
-  require 'ruby-debug'
-  Debugger.start
-  debugger
-end

data/lib/active_scaffold/bridges/paperclip.rb

@@ -1,12 +0,0 @@
-class ActiveScaffold::Bridges::Paperclip < ActiveScaffold::DataStructures::Bridge
-  def self.install
-    if ActiveScaffold::Config::Core.instance_methods.include?("initialize_with_paperclip")
-      raise RuntimeError, "We've detected that you have active_scaffold_paperclip_bridge installed. This plugin has been moved to core. Please remove active_scaffold_paperclip_bridge to prevent any conflicts"
-    end
-    require File.join(File.dirname(__FILE__), "paperclip/form_ui")
-    require File.join(File.dirname(__FILE__), "paperclip/list_ui")
-    require File.join(File.dirname(__FILE__), "paperclip/paperclip_bridge_helpers")
-    require File.join(File.dirname(__FILE__), "paperclip/paperclip_bridge")
-    ActiveScaffold::Config::Core.send :include, ActiveScaffold::Bridges::Paperclip::PaperclipBridge
-  end
-end

data/lib/active_scaffold/bridges/paperclip/form_ui.rb

@@ -1,27 +0,0 @@
-module ActiveScaffold
-  module Helpers
-    module FormColumnHelpers
-      def active_scaffold_input_paperclip(column, options)
-        options = active_scaffold_input_text_options(options)
-        input = file_field(:record, column.name, options)
-        paperclip = @record.send("#{column.name}")
-        if paperclip.file?
-          if ActiveScaffold.js_framework == :jquery
-            js_remove_file_code = "$(this).prev().val('true'); $(this).parent().hide().next().show(); return false;";
-          else
-            js_remove_file_code = "$(this).previous().value='true'; $(this).up().hide().next().show(); return false;";
-          end
-          
-          content = active_scaffold_column_paperclip(column, @record)
-          content_tag(:div,
-            content + " | " +
-              hidden_field(:record, "delete_#{column.name}", :value => "false") +
-              content_tag(:a, as_(:remove_file), {:href => '#', :onclick => js_remove_file_code}) 
-          ) + content_tag(:div, input, :style => "display: none")
-        else
-          input
-        end
-      end
-    end
-  end
-end

data/lib/active_scaffold/bridges/paperclip/list_ui.rb

@@ -1,16 +0,0 @@
-module ActiveScaffold
-  module Helpers
-    module ListColumnHelpers
-      def active_scaffold_column_paperclip(column, record)
-        paperclip = record.send("#{column.name}")
-        return nil unless paperclip.file?
-        content = if paperclip.styles.include?(ActiveScaffold::Bridges::Paperclip::PaperclipBridgeHelpers.thumbnail_style)
-          image_tag(paperclip.url(ActiveScaffold::Bridges::Paperclip::PaperclipBridgeHelpers.thumbnail_style), :border => 0)
-        else
-          paperclip.original_filename
-        end
-        link_to(content, paperclip.url, {'data-popup' => true, :target => '_blank'})
-      end
-    end
-  end
-end

data/lib/active_scaffold/bridges/paperclip/paperclip_bridge.rb

@@ -1,36 +0,0 @@
-module ActiveScaffold
-  module Bridges
-    class Paperclip
-      module PaperclipBridge
-        def initialize_with_paperclip(model_id)
-          initialize_without_paperclip(model_id)
-          return unless self.model.respond_to?(:attachment_definitions) && !self.model.attachment_definitions.nil? 
-
-          self.update.multipart = true
-          self.create.multipart = true
-
-          self.model.attachment_definitions.keys.each do |field|
-            configure_paperclip_field(field.to_sym)
-            # define the "delete" helper for use with active scaffold, unless it's already defined
-            ActiveScaffold::Bridges::Paperclip::PaperclipBridgeHelpers.generate_delete_helper(self.model, field)
-          end
-        end
-
-        def self.included(base)
-          base.alias_method_chain :initialize, :paperclip
-        end
-
-        private
-        def configure_paperclip_field(field)
-          self.columns << field
-          self.columns[field].form_ui ||= :paperclip
-          self.columns[field].params.add "delete_#{field}"
-
-          [:file_name, :content_type, :file_size, :updated_at].each do |f|
-            self.columns.exclude("#{field}_#{f}".to_sym)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_scaffold/bridges/paperclip/paperclip_bridge_helpers.rb

@@ -1,24 +0,0 @@
-module ActiveScaffold
-  module Bridges
-    class Paperclip
-      module PaperclipBridgeHelpers
-        mattr_accessor :thumbnail_style
-        self.thumbnail_style = :thumbnail
-
-        def self.generate_delete_helper(klass, field)
-          klass.class_eval <<-EOF, __FILE__, __LINE__ + 1 unless klass.instance_methods.include?("delete_#{field}=")
-            attr_reader :delete_#{field}
-
-            def delete_#{field}=(value)
-              value = (value == "true") if String === value
-              return unless value
-
-              # passing nil to the file column causes the file to be deleted. Don't delete if we just uploaded a file!
-              self.#{field} = nil unless self.#{field}.dirty?
-            end
-          EOF
-        end
-      end
-    end
-  end
-end

data/lib/active_scaffold/bridges/record_select.rb

@@ -1,11 +0,0 @@
-class ActiveScaffold::Bridges::RecordSelect < ActiveScaffold::DataStructures::Bridge
-  def self.install
-    require File.join(File.dirname(__FILE__), "record_select/helpers.rb")
-  end
-  def self.stylesheets
-    'record_select'
-  end
-  def self.javascripts
-    'record_select'
-  end
-end

data/lib/active_scaffold/bridges/record_select/helpers.rb

@@ -1,92 +0,0 @@
-class ActiveScaffold::Bridges::RecordSelect
-  module Helpers
-    def self.included(base)
-      base.class_eval do
-        include FormColumnHelpers
-        include SearchColumnHelpers
-      end
-    end
-
-    module FormColumnHelpers
-      # requires RecordSelect plugin to be installed and configured.
-      def active_scaffold_input_record_select(column, options)
-        if column.singular_association?
-          multiple = false
-          multiple = column.options[:html_options][:multiple] if column.options[:html_options] &&  column.options[:html_options][:multiple]
-          active_scaffold_record_select(column, options, @record.send(column.name), multiple)
-        elsif column.plural_association?
-          active_scaffold_record_select(column, options, @record.send(column.name), true)
-        else
-          active_scaffold_record_select_autocomplete(column, options)
-        end
-      end
-
-      def active_scaffold_record_select(column, options, value, multiple)
-        unless column.association
-          raise ArgumentError, "record_select can only work against associations (and #{column.name} is not).  A common mistake is to specify the foreign key field (like :user_id), instead of the association (:user)."
-        end
-        klass = if column.polymorphic_association?
-          @record.send(column.association.foreign_type).constantize rescue nil
-        else
-          column.association.klass
-        end
-        return content_tag :span, '', :class => options[:class] unless klass
-
-        remote_controller = active_scaffold_controller_for(klass).controller_path
-
-        # if the opposite association is a :belongs_to (in that case association in this class must be has_one or has_many)
-        # then only show records that have not been associated yet
-        if [:has_one, :has_many].include?(column.association.macro)
-          params.merge!({column.association.foreign_key => ''})
-        end
- 
-        record_select_options = active_scaffold_input_text_options(options).merge(
-          :controller => remote_controller
-        )
-        record_select_options.merge!(column.options)
- 
-        html = if multiple
-          record_multi_select_field(options[:name], value || [], record_select_options)
-        else
-          record_select_field(options[:name], value || klass.new, record_select_options)
-        end
-        html = self.class.field_error_proc.call(html, self) if @record.errors[column.name].any?
-        html
-      end
-      
-      def active_scaffold_record_select_autocomplete(column, options)
-        record_select_options = active_scaffold_input_text_options(options).merge(
-          :controller => active_scaffold_controller_for(@record.class).controller_path
-        )
-        html = record_select_autocomplete(options[:name], @record, record_select_options)
-        html = self.class.field_error_proc.call(html, self) if @record.errors[column.name].any?
-        html
-      end
-    end
-
-    module SearchColumnHelpers
-      def active_scaffold_search_record_select(column, options)
-        value = field_search_record_select_value(column)
-        active_scaffold_record_select(column, options, value, column.options[:multiple])
-      end
-      
-      def field_search_record_select_value(column)
-        begin
-          value = field_search_params[column.name]
-          unless value.blank?
-            if column.options[:multiple]
-              column.association.klass.find value.collect!(&:to_i)
-            else
-              column.association.klass.find(value.to_i)
-            end
-          end
-        rescue Exception => e
-          logger.error Time.now.to_s + "Sorry, we are not that smart yet. Attempted to restore search values to search fields but instead got -- #{e.inspect} -- on the ActiveScaffold column = :#{column.name} in #{@controller.class}"
-          raise e
-        end
-      end
-    end
-  end
-end
-
-ActionView::Base.class_eval { include ActiveScaffold::Bridges::RecordSelect::Helpers }

data/lib/active_scaffold/bridges/semantic_attributes.rb

@@ -1,5 +0,0 @@
-class ActiveScaffold::Bridges::SemanticAttributes < ActiveScaffold::DataStructures::Bridge
-  def self.install
-    require File.join(File.dirname(__FILE__), "semantic_attributes/column.rb")
-  end
-end

data/lib/active_scaffold/bridges/semantic_attributes/column.rb

@@ -1,20 +0,0 @@
-class ActiveScaffold::Bridges::SemanticAttributes
-  module Column
-    def self.included(base)
-      base.class_eval { alias_method_chain :initialize, :semantic_attributes }
-    end
-
-    def initialize_with_semantic_attributes(name, active_record_class)
-      initialize_without_semantic_attributes(name, active_record_class)
-      self.required = !active_record_class.semantic_attributes[self.name].predicates.find {|p| p.allow_empty? == false }.nil?
-      active_record_class.semantic_attributes[self.name].predicates.find do |p|
-        sem_type = p.class.to_s.split('::')[1].underscore.to_sym
-        next if [:required, :association].include?(sem_type)
-        @form_ui = sem_type
-      end
-    end
-  end
-end
-ActiveScaffold::DataStructures::Column.class_eval do
-  include ActiveScaffold::Bridges::SemanticAttributes::Column
-end

data/lib/active_scaffold/bridges/shared/date_bridge.rb

@@ -1,209 +0,0 @@
-module ActiveScaffold
-  module Bridges
-    module Shared
-      module DateBridge
-        module SearchColumnHelpers
-          def active_scaffold_search_date_bridge(column, options)
-            current_search = {'from' => nil, 'to' => nil, 'opt' => 'BETWEEN',
-                              'number' => 1, 'unit' => 'DAYS', 'range' => nil}
-            current_search.merge!(options[:value]) unless options[:value].nil?
-            tags = []
-            tags << active_scaffold_search_date_bridge_comparator_tag(column, options, current_search)
-            tags << active_scaffold_search_date_bridge_trend_tag(column, options, current_search)
-            tags << active_scaffold_search_date_bridge_numeric_tag(column, options, current_search)
-            tags << active_scaffold_search_date_bridge_range_tag(column, options, current_search)
-            tags.join("&nbsp;").html_safe
-          end
-          
-          def active_scaffold_search_date_bridge_comparator_options(column)
-            select_options = ActiveScaffold::Finder::DateComparators.collect {|comp| [as_(comp.downcase.to_sym), comp]}
-            select_options + ActiveScaffold::Finder::NumericComparators.collect {|comp| [as_(comp.downcase.to_sym), comp]}
-          end
-          
-          def active_scaffold_search_date_bridge_comparator_tag(column, options, current_search)
-            select_tag("#{options[:name]}[opt]", options_for_select(active_scaffold_search_date_bridge_comparator_options(column),current_search['opt']), :id => "#{options[:id]}_opt", :class => "as_search_range_option as_search_date_time_option")
-          end
-          
-          def active_scaffold_search_date_bridge_numeric_tag(column, options, current_search)
-            numeric_controls = "" << 
-            active_scaffold_search_date_bridge_calendar_control(column, options, current_search, 'from') <<
-            content_tag(:span, (" - " + active_scaffold_search_date_bridge_calendar_control(column, options, current_search, 'to')).html_safe,
-              :id => "#{options[:id]}_between", :class => "as_search_range_between", :style => current_search['opt'] == 'BETWEEN' ? nil : "display: none")
-            content_tag("span", numeric_controls.html_safe, :id => "#{options[:id]}_numeric", :style => ActiveScaffold::Finder::NumericComparators.include?(current_search['opt']) ? nil : "display: none")
-          end
-  
-          def active_scaffold_search_date_bridge_trend_tag(column, options, current_search)
-            active_scaffold_date_bridge_trend_tag(column, options, 
-                                                 {:name_prefix => 'search',
-                                                  :number_value => current_search['number'],
-                                                  :unit_value => current_search["unit"],
-                                                  :show => (current_search['opt'] == 'PAST' || current_search['opt'] == 'FUTURE')})
-          end
-
-          def active_scaffold_date_bridge_trend_tag(column, options, trend_options)
-            trend_controls = text_field_tag("#{trend_options[:name_prefix]}[#{column.name}][number]", trend_options[:number_value], :class => 'text-input', :size => 10, :autocomplete => 'off') << " " <<
-            select_tag("#{trend_options[:name_prefix]}[#{column.name}][unit]",
-             options_for_select(active_scaffold_search_date_bridge_trend_units(column), trend_options[:unit_value]),
-             :class => 'text-input')
-            content_tag("span", trend_controls.html_safe, :id => "#{options[:id]}_trend", :style => trend_options[:show] ? nil : "display: none")
-          end
-
-          def active_scaffold_search_date_bridge_trend_units(column)
-             options = ActiveScaffold::Finder::DateUnits.collect{|unit| [as_(unit.downcase.to_sym), unit]}
-             options = ActiveScaffold::Finder::TimeUnits.collect{|unit| [as_(unit.downcase.to_sym), unit]} + options if column_datetime?(column)
-             options
-          end
-          
-          def active_scaffold_search_date_bridge_range_tag(column, options, current_search)
-            range_controls = select_tag("search[#{column.name}][range]", 
-              options_for_select( ActiveScaffold::Finder::DateRanges.collect{|range| [as_(range.downcase.to_sym), range]}, current_search["range"]), 
-             :class => 'text-input')
-            content_tag("span", range_controls.html_safe, :id => "#{options[:id]}_range", :style => (current_search['opt'] == 'RANGE') ? nil : "display: none")
-          end
-          
-          def column_datetime?(column)
-            (!column.column.nil? && [:datetime, :time].include?(column.column.type))
-          end
-        end
-
-        module HumanConditionHelpers
-          def active_scaffold_human_condition_date_bridge(column, value)
-            case value[:opt]
-            when 'RANGE'
-              range_type, range = value[:range].downcase.split('_')
-              format = active_scaffold_human_condition_date_bridge_range_format(range_type, range)
-              from, to = controller.class.date_bridge_from_to(column, value)
-              "#{column.active_record_class.human_attribute_name(column.name)} = #{as_(value[:range].downcase).downcase} (#{I18n.l(from, :format => format)})"
-            when 'PAST', 'FUTURE'
-              from, to = controller.class.date_bridge_from_to(column, value)
-              "#{column.active_record_class.human_attribute_name(column.name)} #{as_('BETWEEN'.downcase).downcase} #{I18n.l(from)} - #{I18n.l(to)}"
-            else
-              from, to = controller.class.date_bridge_from_to(column, value)
-              "#{column.active_record_class.human_attribute_name(column.name)} #{as_(value[:opt].downcase).downcase} #{I18n.l(from)} #{value[:opt] == 'BETWEEN' ? '- ' + I18n.l(to) : ''}"
-            end
-          end
-
-          def active_scaffold_human_condition_date_bridge_range_format(range_type, range)
-            case range
-            when 'week'
-              first_day_of_week = I18n.translate 'active_scaffold.date_picker_options.firstDay'
-              if first_day_of_week == 1
-                '%W %Y'
-              else
-                '%U %Y'
-              end
-            when 'month'
-              '%b %Y'
-            when 'year'
-              '%Y'
-            else
-              I18n.translate 'date.formats.default'
-            end
-          end
-        end
-        
-        module Finder
-          module ClassMethods
-            def condition_for_date_bridge_type(column, value, like_pattern)
-              operator = ActiveScaffold::Finder::NumericComparators.include?(value[:opt]) && value[:opt] != 'BETWEEN' ? value[:opt] : nil
-              from_value, to_value = date_bridge_from_to(column, value)
-              
-              if column.search_sql.is_a? Proc
-                column.search_sql.call(from_value, to_value, operator)
-              else
-                unless operator.nil?
-                  ["%{search_sql} #{value[:opt]} ?", from_value.to_s(:db)] unless from_value.nil?
-                else
-                  ["%{search_sql} BETWEEN ? AND ?", from_value.to_s(:db), to_value.to_s(:db)] unless from_value.nil? && to_value.nil?  
-                end
-              end
-            end
-            
-            def date_bridge_from_to(column, value)
-              conversion = datetime_conversion_for_condition(column)
-              case value[:opt]
-              when 'RANGE'
-                date_bridge_from_to_for_range(column, value).collect(&conversion)
-              when 'PAST', 'FUTURE'
-                date_bridge_from_to_for_trend(column, value).collect(&conversion)
-              else
-                ['from', 'to'].collect { |field| condition_value_for_datetime(value[field], conversion)}
-              end
-            end
-
-            def date_bridge_now
-              Time.zone.now
-            end
-            
-            def date_bridge_from_to_for_trend(column, value)
-              case value['opt']
-              when "PAST"
-                trend_number = [value['number'].to_i,  1].max
-                now = date_bridge_now
-                if date_bridge_column_date?(column)
-                  from = now.beginning_of_day.ago((trend_number).send(value['unit'].downcase.singularize.to_sym))
-                  to = now.end_of_day
-                else
-                  from = now.ago((trend_number).send(value['unit'].downcase.singularize.to_sym))
-                  to = now
-                end
-                return from, to
-              when "FUTURE"
-                trend_number = [value['number'].to_i,  1].max
-                now = date_bridge_now
-                if date_bridge_column_date?(column)
-                  from = now.beginning_of_day
-                  to = now.end_of_day.in((trend_number).send(value['unit'].downcase.singularize.to_sym))
-                else
-                  from = now
-                  to = now.in((trend_number).send(value['unit'].downcase.singularize.to_sym))
-                end
-                return from, to
-              end
-            end
-            
-            def date_bridge_from_to_for_range(column, value)
-              case value[:range]
-              when 'TODAY'
-                return date_bridge_now.beginning_of_day, date_bridge_now.end_of_day
-              when 'YESTERDAY'
-                return date_bridge_now.ago(1.day).beginning_of_day, date_bridge_now.ago(1.day).end_of_day
-              when 'TOMORROW'
-                return date_bridge_now.in(1.day).beginning_of_day, date_bridge_now.in(1.day).end_of_day
-              else
-                range_type, range = value[:range].downcase.split('_')
-                raise ArgumentError unless ['week', 'month', 'year'].include?(range)
-                case range_type
-                when 'this'
-                  return date_bridge_now.send("beginning_of_#{range}".to_sym), date_bridge_now.send("end_of_#{range}")
-                when 'prev'
-                  return date_bridge_now.ago(1.send(range.to_sym)).send("beginning_of_#{range}".to_sym), date_bridge_now.ago(1.send(range.to_sym)).send("end_of_#{range}".to_sym)
-                when 'next'
-                  return date_bridge_now.in(1.send(range.to_sym)).send("beginning_of_#{range}".to_sym), date_bridge_now.in(1.send(range.to_sym)).send("end_of_#{range}".to_sym)
-                else
-                  return nil, nil    
-                end
-              end
-            end
-
-            def date_bridge_column_date?(column)
-              if [:date_picker, :datetime_picker].include? column.form_ui
-                column.form_ui == :date_picker
-              else
-                (!column.column.nil? && [:date].include?(column.column.type))
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-ActiveScaffold::Finder.const_set('DateComparators', ["PAST", "FUTURE", "RANGE"])
-ActiveScaffold::Finder.const_set('DateUnits', ["DAYS", "WEEKS", "MONTHS", "YEARS"])
-ActiveScaffold::Finder.const_set('TimeUnits', ["SECONDS", "MINUTES", "HOURS"])
-ActiveScaffold::Finder.const_set('DateRanges', ["TODAY", "YESTERDAY", "TOMORROW",
-                                                "THIS_WEEK", "PREV_WEEK", "NEXT_WEEK",
-                                                "THIS_MONTH", "PREV_MONTH", "NEXT_MONTH",
-                                                "THIS_YEAR", "PREV_YEAR", "NEXT_YEAR"])