active_scaffold 3.4.17 → 3.4.18

data/lib/active_scaffold/bridges/semantic_attributes.rb

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

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

@@ -6,7 +6,7 @@ class ActiveScaffold::Bridges::SemanticAttributes
 
     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?
+      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)

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

@@ -12,54 +12,63 @@ module ActiveScaffold
             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
+            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]}
+            select_options = ActiveScaffold::Finder::DATE_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] }
+            select_options + ActiveScaffold::Finder::NUMERIC_COMPARATORS.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")
+            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", :class => "search-date-numeric", :style => ActiveScaffold::Finder::NumericComparators.include?(current_search['opt']) ? nil : "display: none")
+            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", :class => 'search-date-numeric',
+                        :style => ActiveScaffold::Finder::NUMERIC_COMPARATORS.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, 
-                                                 {:number_value => current_search['number'],
-                                                  :unit_value => current_search["unit"],
-                                                  :show => (current_search['opt'] == 'PAST' || current_search['opt'] == 'FUTURE')})
+            active_scaffold_date_bridge_trend_tag(column, options,
+                                                  :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("#{options[:name]}[number]", trend_options[:number_value], :class => 'text-input', :size => 10, :autocomplete => 'off') << " " <<
-            select_tag("#{options[: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", :class => "search-date-trend", :style => trend_options[:show] ? nil : "display: none")
+            trend_controls =
+              text_field_tag("#{options[:name]}[number]", trend_options[:number_value], :class => 'text-input', :size => 10, :autocomplete => 'off') << ' ' <<
+              select_tag("#{options[: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", :class => 'search-date-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
+            options = ActiveScaffold::Finder::DATE_UNITS.collect { |unit| [as_(unit.downcase.to_sym), unit] }
+            options = ActiveScaffold::Finder::TIME_UNITS.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("#{options[:name]}[range]", 
-              options_for_select( ActiveScaffold::Finder::DateRanges.collect{|range| [as_(range.downcase.to_sym), range]}, current_search["range"]), 
-             :class => 'text-input', :id => nil)
-            content_tag("span", range_controls.html_safe, :id => "#{options[:id]}_range", :class => "search-date-range", :style => (current_search['opt'] == 'RANGE') ? nil : "display: none")
+            range_controls = select_tag("#{options[:name]}[range]",
+                                        options_for_select(ActiveScaffold::Finder::DATE_RANGES.collect { |range| [as_(range.downcase.to_sym), range] }, current_search['range']),
+                                        :class => 'text-input', :id => nil)
+            content_tag('span', range_controls.html_safe,
+                        :id => "#{options[:id]}_range", :class => 'search-date-range',
+                        :style => (current_search['opt'] == 'RANGE') ? nil : 'display: none')
           end
-          
+
           def column_datetime?(column)
             (!column.column.nil? && [:datetime, :time].include?(column.column.type))
           end
@@ -100,24 +109,24 @@ module ActiveScaffold
             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
+              operator = ActiveScaffold::Finder::NUMERIC_COMPARATORS.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?
+                if operator.nil?
+                  ['%{search_sql} BETWEEN ? AND ?', from_value.to_s(:db), to_value.to_s(:db)] unless from_value.nil? || to_value.nil?
                 else
-                  ["%{search_sql} BETWEEN ? AND ?", from_value.to_s(:db), to_value.to_s(:db)] unless from_value.nil? || to_value.nil?
+                  ["%{search_sql} #{value[:opt]} ?", from_value.to_s(:db)] unless from_value.nil?
                 end
               end
             end
-            
+
             def date_bridge_from_to(column, value)
               conversion = datetime_conversion_for_condition(column)
               case value[:opt]
@@ -126,17 +135,17 @@ module ActiveScaffold
               when 'PAST', 'FUTURE'
                 date_bridge_from_to_for_trend(column, value).collect(&conversion)
               else
-                ['from', 'to'].collect { |field| condition_value_for_datetime(column, value[field], conversion)}
+                %w(from to).collect { |field| condition_value_for_datetime(column, 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"
+              when 'PAST'
                 trend_number = [value['number'].to_i,  1].max
                 now = date_bridge_now
                 if date_bridge_column_date?(column)
@@ -147,7 +156,7 @@ module ActiveScaffold
                   to = now
                 end
                 return from, to
-              when "FUTURE"
+              when 'FUTURE'
                 trend_number = [value['number'].to_i,  1].max
                 now = date_bridge_now
                 if date_bridge_column_date?(column)
@@ -160,7 +169,7 @@ module ActiveScaffold
                 return from, to
               end
             end
-            
+
             def date_bridge_from_to_for_range(column, value)
               case value[:range]
               when 'TODAY'
@@ -171,7 +180,7 @@ module ActiveScaffold
                 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)
+                raise ArgumentError unless %w(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}")
@@ -180,7 +189,7 @@ module ActiveScaffold
                 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    
+                  return nil, nil
                 end
               end
             end
@@ -199,10 +208,7 @@ module ActiveScaffold
   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"])
+ActiveScaffold::Finder.const_set('DATE_COMPARATORS', %w(PAST FUTURE RANGE))
+ActiveScaffold::Finder.const_set('DATE_UNITS', %w(DAYS WEEKS MONTHS YEARS))
+ActiveScaffold::Finder.const_set('TIME_UNITS', %w(SECONDS MINUTES HOURS))
+ActiveScaffold::Finder.const_set('DATE_RANGES', %w(TODAY YESTERDAY TOMORROW THIS_WEEK PREV_WEEK NEXT_WEEK THIS_MONTH PREV_MONTH NEXT_MONTH THIS_YEAR PREV_YEAR NEXT_YEAR))

data/lib/active_scaffold/bridges/tiny_mce.rb

@@ -5,9 +5,9 @@ class ActiveScaffold::Bridges::TinyMce < ActiveScaffold::DataStructures::Bridge
   end
 
   def self.install?
-    Object.const_defined? "TinyMCE"
+    Object.const_defined? 'TinyMCE'
   end
- 
+
   def self.javascripts
     case ActiveScaffold.js_framework
     when :jquery

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

@@ -14,10 +14,10 @@ class ActiveScaffold::Bridges::TinyMce
 
       def active_scaffold_input_text_editor(column, options)
         options[:class] = "#{options[:class]} mceEditor #{column.options[:class]}".strip
-				
-				settings = { :theme => 'simple' }.merge(column.options[:tinymce] || {})
+
+        settings = {:theme => 'simple'}.merge(column.options[:tinymce] || {})
         settings = settings.to_json
-				settings = "tinyMCE.settings = #{settings};"
+        settings = "tinyMCE.settings = #{settings};"
 
         html = []
         html << send(override_input(:textarea), column, options)

data/lib/active_scaffold/config/base.rb

@@ -16,7 +16,7 @@ module ActiveScaffold::Config
       class << subclass
         # the crud type of the action. possible values are :create, :read, :update, :delete, and nil.
         # this is not a setting for the developer. it's self-description for the actions.
-        def crud_type; @crud_type; end
+        attr_reader :crud_type
 
         protected
 
@@ -28,13 +28,15 @@ module ActiveScaffold::Config
     end
 
     # delegate
-    def crud_type; self.class.crud_type end
+    def crud_type
+      self.class.crud_type
+    end
 
     def label(model = nil)
       model ||= @core.label(:count => 1)
       @label.nil? ? model : as_(@label, :model => model)
     end
-    
+
     # the user property gets set to the instantiation of the local UserSettings class during the automatic instantiation of this class.
     attr_accessor :user
 
@@ -70,17 +72,14 @@ module ActiveScaffold::Config
         end
       end
     end
-    
+
     def formats
       @formats ||= []
     end
-    
-    def formats=(val)
-      @formats=val
-    end
-    
+    attr_writer :formats
+
     private
-    
+
     def columns=(val)
       @columns.set_values(*val) if @columns
       @columns ||= ActiveScaffold::DataStructures::ActionColumns.new(*val).tap do |columns|

data/lib/active_scaffold/config/core.rb

@@ -94,9 +94,9 @@ module ActiveScaffold::Config
     # provides read/write access to the local Columns DataStructure
     attr_reader :columns
     def columns=(val)
-      @columns._inheritable = val.collect {|c| c.to_sym}
+      @columns._inheritable = val.collect(&:to_sym)
       # Add virtual columns
-      @columns << val.collect {|c| c.to_sym unless @columns[c.to_sym]}.compact
+      @columns << val.collect { |c| c.to_sym unless @columns[c.to_sym] }.compact
     end
 
     # lets you override the global ActiveScaffold frontend for a specific controller
@@ -120,7 +120,7 @@ module ActiveScaffold::Config
     # lets you specify whether add a create link for each sti child for a specific controller
     attr_accessor :sti_create_links
     def add_sti_create_links?
-      self.sti_create_links and not self.sti_children.nil?
+      sti_create_links && !sti_children.nil?
     end
 
     # action links are used by actions to tie together. they appear as links for each record, or general links for the ActiveScaffold.
@@ -128,7 +128,7 @@ module ActiveScaffold::Config
 
     # a generally-applicable name for this ActiveScaffold ... will be used for generating page/section headers
     attr_writer :label
-    def label(options={})
+    def label(options = {})
       as_(@label, options) || model.model_name.human(options.merge(options[:count].to_i == 1 ? {} : {:default => model.name.pluralize}))
     end
 
@@ -153,15 +153,15 @@ module ActiveScaffold::Config
       @actions = self.class.actions.clone
 
       # create a new default columns datastructure, since it doesn't make sense before now
-      attribute_names = self.model.columns.collect{ |c| c.name.to_sym }.sort_by { |c| c.to_s }
-      association_column_names = self.model.reflect_on_all_associations.collect{ |a| a.name.to_sym }.sort_by { |c| c.to_s }
-      @columns = ActiveScaffold::DataStructures::Columns.new(self.model, attribute_names + association_column_names)
+      attribute_names = model.columns.collect { |c| c.name.to_sym }.sort_by(&:to_s)
+      association_column_names = model.reflect_on_all_associations.collect { |a| a.name.to_sym }.sort_by(&:to_s)
+      @columns = ActiveScaffold::DataStructures::Columns.new(model, attribute_names + association_column_names)
 
       # and then, let's remove some columns from the inheritable set.
-      content_columns = Set.new(self.model.content_columns.map(&:name))
+      content_columns = Set.new(model.content_columns.map(&:name))
       @columns.exclude(*self.class.ignore_columns)
-      @columns.exclude(*@columns.find_all { |c| c.column and content_columns.exclude?(c.column.name) }.collect {|c| c.name})
-      @columns.exclude(*self.model.reflect_on_all_associations.collect{|a| :"#{a.name}_type" if a.options[:polymorphic]}.compact)
+      @columns.exclude(*@columns.find_all { |c| c.column && content_columns.exclude?(c.column.name) }.collect(&:name))
+      @columns.exclude(*model.reflect_on_all_associations.collect { |a| :"#{a.name}_type" if a.options[:polymorphic] }.compact)
 
       # inherit the global frontend
       @frontend = self.class.frontend
@@ -181,21 +181,21 @@ module ActiveScaffold::Config
     # To be called after your finished configuration
     def _load_action_columns
       # then, register the column objects
-      self.actions.each do |action_name|
-        action = self.send(action_name)
-        action.columns.set_columns(self.columns) if action.respond_to?(:columns)
+      actions.each do |action_name|
+        action = send(action_name)
+        action.columns.set_columns(columns) if action.respond_to?(:columns)
       end
     end
 
     # To be called after your finished configuration
     def _configure_sti
-      column = self.model.inheritance_column
+      column = model.inheritance_column
       if sti_create_links
-        self.columns[column].form_ui ||= :hidden
+        columns[column].form_ui ||= :hidden
       else
-        self.columns[column].form_ui ||= :select
-        self.columns[column].options ||= {}
-        self.columns[column].options[:options] = self.sti_children.collect do |model_name|
+        columns[column].form_ui ||= :select
+        columns[column].options ||= {}
+        columns[column].options[:options] = sti_children.collect do |model_name|
           [model_name.to_s.camelize.constantize.model_name.human, model_name.to_s.camelize]
         end
       end
@@ -221,17 +221,13 @@ module ActiveScaffold::Config
 
     def self.method_missing(name, *args)
       klass = "ActiveScaffold::Config::#{name.to_s.camelcase}".constantize rescue nil
-      if @@actions.include? name.to_s.underscore and klass
-        return eval("ActiveScaffold::Config::#{name.to_s.camelcase}")
-      end
+      return klass if @@actions.include?(name.to_s.underscore) && klass
       super
     end
     # some utility methods
     # --------------------
 
-    def model_id
-      @model_id
-    end
+    attr_reader :model_id
 
     def model
       @model ||= @model_id.to_s.camelize.constantize
@@ -239,7 +235,7 @@ module ActiveScaffold::Config
 
     # warning - this won't work as a per-request dynamic attribute in rails 2.0.  You'll need to interact with Controller#generic_view_paths
     def inherited_view_paths
-      @inherited_view_paths||=[]
+      @inherited_view_paths ||= []
     end
 
     # must be a class method so the layout doesn't depend on a controller that uses active_scaffold
@@ -251,14 +247,13 @@ module ActiveScaffold::Config
     # must be a class method so the layout doesn't depend on a controller that uses active_scaffold
     # note that this is unaffected by per-controller frontend configuration.
     def self.javascripts(frontend = self.frontend)
-      javascript_dir = File.join(Rails.public_path, "javascripts", asset_path('', frontend))
-      Dir.entries(javascript_dir).reject { |e| !e.match(/\.js$/) or (!self.dhtml_history? and e.match('dhtml_history')) }
+      javascript_dir = File.join(Rails.public_path, 'javascripts', asset_path('', frontend))
+      Dir.entries(javascript_dir).reject { |e| !e.match(/\.js$/) || (!self.dhtml_history? && e.match('dhtml_history')) }
     end
 
     def self.available_frontends
-      frontends_dir = File.join(Rails.root, "vendor", "plugins", ActiveScaffold::Config::Core.plugin_directory, "frontends")
+      frontends_dir = File.join(Rails.root, 'vendor', 'plugins', ActiveScaffold::Config::Core.plugin_directory, 'frontends')
       Dir.entries(frontends_dir).reject { |e| e.match(/^\./) } # Get rid of files that start with .
     end
   end
 end
-

data/lib/active_scaffold/config/create.rb

@@ -27,6 +27,5 @@ module ActiveScaffold::Config
 
     # whether the form stays open after a create or not
     attr_accessor :action_after_create
-
   end
 end

data/lib/active_scaffold/config/field_search.rb

@@ -8,7 +8,6 @@ module ActiveScaffold::Config
       @human_conditions = self.class.human_conditions
     end
 
-
     # global level configuration
     # --------------------------
     # the ActionLink for this action
@@ -28,7 +27,7 @@ module ActiveScaffold::Config
     # instead of just filtered you may show the user a humanized search condition statment
     cattr_accessor :human_conditions
     @@human_conditions = false
-    
+
     # instance-level configuration
     # ----------------------------
 
@@ -37,7 +36,7 @@ module ActiveScaffold::Config
       # we want to delay initializing to the @core.columns set for as long as possible. Too soon and .search_sql will not be available to .searchable?
       unless @columns
         self.columns = @core.columns._inheritable
-        self.columns.exclude @core.columns.active_record_class.locking_column.to_sym
+        columns.exclude @core.columns.active_record_class.locking_column.to_sym
       end
       @columns
     end
@@ -51,26 +50,25 @@ module ActiveScaffold::Config
     # * false: LIKE ?
     # Default is :full
     attr_accessor :text_search
-    
+
     # the ActionLink for this action
     attr_accessor :link
-    
+
     # rarely searched columns may be placed in a hidden subgroup
     def optional_columns=(optionals)
       @optional_columns = Array(optionals)
     end
-    
+
     def optional_columns
       @optional_columns ||= []
     end
-    
+
     # default search params
-    # default_params = {:title => {"from"=>"test", "to"=>"", "opt"=>"%?%"}} 
+    # default_params = {:title => {"from"=>"test", "to"=>"", "opt"=>"%?%"}}
     attr_accessor :default_params
-    
+
     # human conditions
     # instead of just filtered you may show the user a humanized search condition statment
     attr_accessor :human_conditions
-    
   end
 end