active_scaffold 3.1.4 → 3.1.5

data/lib/active_scaffold/actions/nested.rb

@@ -82,8 +82,12 @@ module ActiveScaffold::Actions
     end
     
     def beginning_of_chain
-      if nested? && nested.association && nested.association.collection?
-        nested.parent_scope.send(nested.association.name)
+      if nested? && nested.association && !nested.association.belongs_to?
+        if nested.association.collection?
+          nested.parent_scope.send(nested.association.name)
+        elsif nested.child_association.belongs_to?
+          active_scaffold_config.model.where(nested.child_association.foreign_key => nested.parent_scope)
+        end
       elsif nested? && nested.scope
         nested.parent_scope.send(nested.scope)
       else

data/lib/active_scaffold/actions/nested.rb~

@@ -82,8 +82,13 @@ module ActiveScaffold::Actions
     end
     
     def beginning_of_chain
-      if nested? && nested.association && nested.association.collection?
-        nested.parent_scope.send(nested.association.name)
+      if nested? && nested.association && !nested.association.belongs_to?
+        debugger
+        if nested.association.collection?
+          nested.parent_scope.send(nested.association.name)
+        elsif nested.child_association.belongs_to?
+          active_scaffold_config.model.where(nested.child_association.foreign_key => nested.parent_scope)
+        end
       elsif nested? && nested.scope
         nested.parent_scope.send(nested.scope)
       else
@@ -123,9 +128,6 @@ module ActiveScaffold::Actions::Nested
 
     def self.included(base)
       super
-      base.verify :method => :post,
-                  :only => :add_existing,
-                  :redirect_to => { :action => :index }
     end
 
     def new_existing

data/lib/active_scaffold/actions/update.rb~

@@ -32,8 +32,7 @@ module ActiveScaffold::Actions
     def edit_respond_to_js
       render(:partial => 'update_form')
     end
-    def update_respond_to_html  
-      debugger
+    def update_respond_to_html
       if params[:iframe]=='true' # was this an iframe post ?
         responds_to_parent do
           render :action => 'on_update.js', :layout => false
@@ -48,7 +47,6 @@ module ActiveScaffold::Actions
       end
     end
     def update_respond_to_js
-      debugger
       if successful? && update_refresh_list? && !render_parent?
         do_search if respond_to? :do_search
         do_list
@@ -84,6 +82,7 @@ module ActiveScaffold::Actions
           @record = update_record_from_params(@record, active_scaffold_config.update.columns, params[:record]) unless options[:no_record_param_update]
           before_update_save(@record)
           self.successful = [@record.valid?, @record.associated_valid?].all? {|v| v == true} # this syntax avoids a short-circuit
+          debugger
           if successful?
             @record.save! and @record.save_associated!
             after_update_save(@record)

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

@@ -0,0 +1,209 @@
+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 => "display:#{current_search['opt'] == 'BETWEEN' ? '' : 'none'}")  
+            content_tag("span", numeric_controls.html_safe, :id => "#{options[:id]}_numeric", :style => "display:#{ActiveScaffold::Finder::NumericComparators.include?(current_search['opt']) ? '' : '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 => "display:#{trend_options[:show] ? '' : '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 => "display:#{(current_search['opt'] == 'RANGE') ? '' : '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?
+                  ["#{column.search_sql} #{value[:opt]} ?", from_value.to_s(:db)] unless from_value.nil?
+                else
+                  ["#{column.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 = column.column.type == :date ? :to_date : :to_time
+              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"])

data/lib/active_scaffold/config/nested.rb

@@ -24,6 +24,7 @@ module ActiveScaffold::Config
       unless column.nil? || column.association.nil?
         options.reverse_merge! :security_method => :nested_authorized?, :label => column.association.klass.model_name.human({:count => 2, :default => column.association.klass.name.pluralize}) 
         action_link = @core.link_for_association(column, options)
+        action_link.action ||= :index
         @core.action_links.add_to_group(action_link, action_group) unless action_link.nil?
       else
         

data/lib/active_scaffold/config/nested.rb~

@@ -0,0 +1,41 @@
+module ActiveScaffold::Config
+  class Nested < Base
+    self.crud_type = :read
+
+    def initialize(core_config)
+      super
+      @label = :add_existing_model
+      self.shallow_delete = self.class.shallow_delete
+      @action_group = self.class.action_group.clone if self.class.action_group
+    end
+
+    # global level configuration
+    # --------------------------
+    cattr_accessor :shallow_delete
+    @@shallow_delete = true
+
+    # instance-level configuration
+    # ----------------------------
+    attr_accessor :shallow_delete
+
+    # Add a nested ActionLink
+    def add_link(attribute, options = {})
+      column = @core.columns[attribute.to_sym]
+      unless column.nil? || column.association.nil?
+        options.reverse_merge! :security_method => :nested_authorized?, :label => column.association.klass.model_name.human({:count => 2, :default => column.association.klass.name.pluralize}) 
+        action_link = @core.link_for_association(column, options)
+        @core.action_links.add_to_group(action_link, action_group) unless action_link.nil?
+      else
+        
+      end
+    end
+    
+    def add_scoped_link(named_scope, options = {})
+      action_link = @core.link_for_association_as_scope(named_scope.to_sym, options)
+      @core.action_links.add_to_group(action_link, action_group) unless action_link.nil?
+    end
+
+    # the label for this Nested action. used for the header.
+    attr_writer :label
+  end
+end

data/lib/active_scaffold/constraints.rb~

@@ -0,0 +1,186 @@
+module ActiveScaffold
+  module Constraints
+
+    protected
+
+    # Returns the current constraints
+    def active_scaffold_constraints
+      @active_scaffold_constraints ||= active_scaffold_session_storage[:constraints] || {}
+    end
+
+    def set_active_scaffold_constraints
+      associations_by_params = {}
+      active_scaffold_config.model.reflect_on_all_associations.each do |association|
+        associations_by_params[association.klass.name.foreign_key] = association.name unless association.options[:polymorphic]
+      end
+      params.each do |key, value|
+        active_scaffold_constraints[associations_by_params[key]] = value if associations_by_params.include? key
+      end
+    end
+
+    # For each enabled action, adds the constrained columns to the ActionColumns object (if it exists).
+    # This lets the ActionColumns object skip constrained columns.
+    #
+    # If the constraint value is a Hash, then we assume the constraint is a multi-level association constraint (the reverse of a has_many :through) and we do NOT register the constraint column.
+    def register_constraints_with_action_columns(association_constrained_fields = [], exclude_actions = [])
+      debugger
+      constrained_fields = active_scaffold_constraints.reject{|k, v| v.is_a? Hash}.keys.collect{|k| k.to_sym}
+      constrained_fields = constrained_fields | association_constrained_fields
+      if self.class.uses_active_scaffold?
+        # we actually want to do this whether constrained_fields exist or not, so that we can reset the array when they don't
+        active_scaffold_config.actions.each do |action_name|
+          next if exclude_actions.include?(action_name)
+          action = active_scaffold_config.send(action_name)
+          next unless action.respond_to? :columns
+          action.columns.constraint_columns = constrained_fields
+        end
+      end
+    end
+
+    # Returns search conditions based on the current scaffold constraints.
+    #
+    # Supports constraints based on either a column name (in which case it checks for an association
+    # or just uses the search_sql) or a database field name.
+    #
+    # All of this work is primarily to support nested scaffolds in a manner generally useful for other
+    # embedded scaffolds.
+    def conditions_from_constraints
+      conditions = nil
+      debugger
+      active_scaffold_constraints.each do |k, v|
+        column = active_scaffold_config.columns[k]
+        constraint_condition = if column
+          # Assume this is a multi-level association constraint.
+          # example:
+          #   data model: Park -> Den -> Bear
+          #   constraint: :den => {:park => 5}
+          if v.is_a? Hash
+            far_association = column.association.klass.reflect_on_association(v.keys.first)
+            field = far_association.klass.primary_key
+            table = far_association.table_name
+
+            active_scaffold_includes.concat([{k => v.keys.first}]) # e.g. {:den => :park}
+            constraint_condition_for("#{table}.#{field}", v.values.first)
+
+          # association column constraint
+          elsif column.association
+            if column.association.macro == :has_and_belongs_to_many
+              active_scaffold_habtm_joins.concat column.includes
+            else
+              active_scaffold_includes.concat column.includes
+            end
+            condition_from_association_constraint(column.association, v)
+
+          # regular column constraints
+          elsif column.searchable?
+            active_scaffold_includes.concat column.includes
+            constraint_condition_for(column.search_sql, v)
+          end
+        # unknown-to-activescaffold-but-real-database-column constraint
+        elsif active_scaffold_config.model.column_names.include? k.to_s
+          constraint_condition_for(k.to_s, v)
+        else
+          raise ActiveScaffold::MalformedConstraint, constraint_error(active_scaffold_config.model, k), caller
+        end
+
+        conditions = merge_conditions(conditions, constraint_condition)
+      end
+
+      conditions
+    end
+
+    # We do NOT want to use .search_sql. If anything, search_sql will refer
+    # to a human-searchable value on the associated record.
+    def condition_from_association_constraint(association, value)
+      # when the reverse association is a :belongs_to, the id for the associated object only exists as
+      # the primary_key on the other table. so for :has_one and :has_many (when the reverse is :belongs_to),
+      # we have to use the other model's primary_key.
+      #
+      # please see the relevant tests for concrete examples.
+      field = if [:has_one, :has_many].include?(association.macro)
+        association.klass.primary_key
+      elsif [:has_and_belongs_to_many].include?(association.macro)
+        association.association_foreign_key
+      else
+        association.options[:foreign_key] || association.name.to_s.foreign_key
+      end
+
+      table = case association.macro
+        when :has_and_belongs_to_many
+        association.options[:join_table]
+
+        when :belongs_to
+        active_scaffold_config.model.table_name
+
+        else
+        association.table_name
+      end
+
+      if association.options[:primary_key]
+        value = association.klass.find(value).send(association.options[:primary_key])
+      end
+
+      condition = constraint_condition_for("#{table}.#{field}", value)
+      if association.options[:polymorphic]
+        begin
+          parent_scaffold = "#{session_info[:parent_scaffold].to_s.camelize}Controller".constantize
+          condition = merge_conditions(
+            condition,
+            constraint_condition_for("#{table}.#{association.name}_type", parent_scaffold.active_scaffold_config.model_id.to_s)
+          )
+        rescue ActiveScaffold::ControllerNotFound
+          nil
+        end
+      end
+
+      condition
+    end
+
+    def constraint_error(klass, column_name)
+      "Malformed constraint `#{klass}##{column_name}'. If it's a legitimate column, and you are using a nested scaffold, please specify or double-check the reverse association name."
+    end
+
+    # Applies constraints to the given record.
+    #
+    # Searches through the known columns for association columns. If the given constraint is an association,
+    # it assumes that the constraint value is an id. It then does a association.klass.find with the value
+    # and adds the associated object to the record.
+    #
+    # For some operations ActiveRecord will automatically update the database. That's not always ok.
+    # If it *is* ok (e.g. you're in a transaction), then set :allow_autosave to true.
+    def apply_constraints_to_record(record, options = {})
+      options[:allow_autosave] = false if options[:allow_autosave].nil?
+
+      active_scaffold_constraints.each do |k, v|
+        column = active_scaffold_config.columns[k]
+        if column and column.association
+          if column.plural_association?
+            record.send("#{k}").send(:<<, column.association.klass.find(v))
+          elsif column.association.options[:polymorphic]
+            record.send("#{k}=", params[:parent_model].constantize.find(v))
+          else # regular singular association
+            record.send("#{k}=", column.association.klass.find(v))
+
+            # setting the belongs_to side of a has_one isn't safe. if the has_one was already
+            # specified, rails won't automatically clear out the previous associated record.
+            #
+            # note that we can't take the extra step to correct this unless we're permitted to
+            # run operations where activerecord auto-saves the object.
+            reverse = column.association.klass.reflect_on_association(column.association.reverse)
+            if reverse.macro == :has_one and options[:allow_autosave]
+              record.send(k).send("#{column.association.reverse}=", record)
+            end
+          end
+        else
+          record.send("#{k}=", v)
+        end
+      end
+    end
+
+    private
+
+    def constraint_condition_for(sql, value)
+      value.nil? ? "#{sql} IS NULL" : ["#{sql} = ?", value]
+    end
+  end
+end

data/lib/active_scaffold/data_structures/action_link.rb

@@ -3,15 +3,15 @@ module ActiveScaffold::DataStructures
     # provides a quick way to set any property of the object from a hash
     def initialize(action, options = {})
       # set defaults
-      self.action = action.to_s
+      self.action = action
       self.label = action
       self.confirm = false
       self.type = :collection
       self.inline = true
       self.method = :get
-      self.crud_type = :delete if [:destroy].include?(action.to_sym)
-      self.crud_type = :create if [:create, :new].include?(action.to_sym)
-      self.crud_type = :update if [:edit, :update].include?(action.to_sym)
+      self.crud_type = :delete if [:destroy].include?(action.try(:to_sym))
+      self.crud_type = :create if [:create, :new].include?(action.try(:to_sym))
+      self.crud_type = :update if [:edit, :update].include?(action.try(:to_sym))
       self.crud_type ||= :read
       self.parameters = {}
       self.html_options = {}