active_scaffold 3.3.3 → 3.4.0

data/lib/active_scaffold/data_structures/action_columns.rb

@@ -12,6 +12,9 @@ module ActiveScaffold::DataStructures
     def label
       as_(@label) if @label
     end
+    def name
+      @label.to_s.underscore
+    end
     def css_class
       @label.to_s.underscore
     end
@@ -124,9 +127,22 @@ module ActiveScaffold::DataStructures
       end
     end
 
-    attr_writer :constraint_columns
+    def action_name
+      @action.class.name.demodulize.underscore
+    end
+
+    def constraint_columns_key
+      "#{@action.core.model_id.to_s.underscore}-#{action_name}"
+    end
+
+    def constraint_columns=(columns)
+      Thread.current[:constraint_columns] ||= {}
+      Thread.current[:constraint_columns][constraint_columns_key] = columns
+    end
+      
     def constraint_columns
-      @constraint_columns ||= []
+      constraints = Thread.current[:constraint_columns]
+      (constraints[constraint_columns_key] if constraints) || []
     end
     
     attr_writer :unauthorized_columns

data/lib/active_scaffold/data_structures/action_link.rb

@@ -13,19 +13,27 @@ module ActiveScaffold::DataStructures
       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 = {}
       self.column = nil
       self.image = nil
       self.dynamic_parameters = nil
+      self.weight = 0
 
       # apply quick properties
       options.each_pair do |k, v|
         setter = "#{k}="
         self.send(setter, v) if self.respond_to? setter
       end
+      self.toggle = self.action.try(:to_sym) == :index && (parameters.present? || dynamic_parameters) unless options.include? :toggle
     end
 
+    def initialize_copy(action_link)
+      self.parameters = self.parameters.clone if action_link.instance_variable_get(:@parameters)
+      self.html_options = self.html_options.clone if action_link.instance_variable_get(:@html_options)
+    end
+
+    # the weight for this link in the action links collection, it will be used to sort the collection
+    attr_accessor :weight
+
     # the action-path for this link. what page to request? this is required!
     attr_accessor :action
     
@@ -42,7 +50,15 @@ module ActiveScaffold::DataStructures
     end
 
     # a hash of request parameters
-    attr_accessor :parameters
+    attr_writer :parameters
+    def parameters
+      @parameters ||= {}
+    end
+
+    # if active class is added to link when current request matches link
+    # enabled automatically for links to index with parameters or dynamic parameters
+    # disable when is not needed so current request match check is skipped
+    attr_accessor :toggle
 
     # a block for dynamic_parameters
     attr_accessor :dynamic_parameters
@@ -167,7 +183,10 @@ module ActiveScaffold::DataStructures
     attr_accessor :type
 
     # html options for the link
-    attr_accessor :html_options
+    attr_writer :html_options
+    def html_options
+      @html_options ||= {}
+    end
     
     # nested action_links are referencing a column
     attr_accessor :column
@@ -183,8 +202,8 @@ module ActiveScaffold::DataStructures
       @column || (parameters && parameters[:named_scope])
     end
     
-    def name_to_cache_link_url
-      @name_to_cache_link_url ||= :"#{controller || 'self'}_#{action}#{'_' if parameters.present?}#{parameters.map{|k,v| "#{k}_#{v}"}.join('_')}_link_url"
+    def name_to_cache
+      @name_to_cache ||= "#{controller || 'self'}_#{type}_#{action}#{'_' if parameters.present?}#{parameters.map{|k,v| "#{k}=#{v.is_a?(Array) ? v.join(',') : v}"}.join('_')}"
     end
     
     

data/lib/active_scaffold/data_structures/action_links.rb

@@ -5,6 +5,7 @@ module ActiveScaffold::DataStructures
     def initialize
       @set = []
       @name = :root
+      @weight = 0
     end
 
     # adds an ActionLink, creating one from the arguments if need be
@@ -72,6 +73,7 @@ module ActiveScaffold::DataStructures
       self.each({:include_set => true}) do |link, set|
         if link.action.to_s == val.to_s
           set.delete link
+          break
         end
       end
     end
@@ -80,8 +82,10 @@ module ActiveScaffold::DataStructures
       @set.each do |group|
         if group.name == name
           @set.delete group
+          break
         else
           group.delete_group(name)
+          break
         end if group.is_a?(ActiveScaffold::DataStructures::ActionLinks)
       end
     end
@@ -89,7 +93,7 @@ module ActiveScaffold::DataStructures
     # iterates over the links, possibly by type
     def each(options = {}, &block)
       method = options[:reverse] ? :reverse_each : :each
-      @set.send(method) do |item|
+      @set.sort_by(&:weight).send(method) do |item|
         if item.is_a?(ActiveScaffold::DataStructures::ActionLinks) && !options[:groups]
           item.each(options, &block)
         else
@@ -138,16 +142,17 @@ module ActiveScaffold::DataStructures
 
     def method_missing(name, *args, &block)
       class_eval %{
-        def #{name}
-          @#{name} ||= subgroup('#{name}'.to_sym)
+        def #{name}(label = nil)
+          @#{name} ||= subgroup('#{name}'.to_sym, label)
           yield @#{name} if block_given?
           @#{name}
         end
       }
-      send(name, &block)
+      send(name, args.first, &block)
     end
 
     attr_accessor :name
+    attr_accessor :weight
 
     protected
 

data/lib/active_scaffold/data_structures/actions.rb

@@ -21,7 +21,7 @@ class ActiveScaffold::DataStructures::Actions
   end
 
   def include?(val)
-    super val.to_sym
+    val.is_a?(Symbol) ? super : @set.any?{|item| item.to_s == val.to_s}
   end
 
   # swaps one element in the list with the other.

data/lib/active_scaffold/data_structures/column.rb

@@ -260,16 +260,16 @@ module ActiveScaffold::DataStructures
     # the association from the ActiveRecord class
     attr_reader :association
     def singular_association?
-      self.association and [:has_one, :belongs_to].include? self.association.macro
+      self.association and !self.association.collection?
     end
     def plural_association?
-      self.association and [:has_many, :has_and_belongs_to_many].include? self.association.macro
+      self.association and self.association.collection?
     end
     def through_association?
       self.association and self.association.options[:through]
     end
     def polymorphic_association?
-      self.association and self.association.options.has_key? :polymorphic and self.association.options[:polymorphic]
+      self.association and self.association.options[:polymorphic]
     end
     def readonly_association?
       if self.association
@@ -324,14 +324,14 @@ module ActiveScaffold::DataStructures
       elsif polymorphic_association?
         [field, quoted_field(@active_record_class.connection.quote_column_name(@association.foreign_type))]
       elsif @association
-        if self.association.macro == :belongs_to
+        if self.association.belongs_to?
           [field]
         else
           columns = []
           if active_record_class.columns_hash[count_column = "#{@association.name}_count"]
             columns << quoted_field(@active_record_class.connection.quote_column_name(count_column))
           end
-          if @association.through_reflection.try(:macro) == :belongs_to
+          if @association.through_reflection.try(:belongs_to?)
             columns << quoted_field(@active_record_class.connection.quote_column_name(@association.through_reflection.foreign_key))
           end
           columns
@@ -350,7 +350,7 @@ module ActiveScaffold::DataStructures
       self.css_class = ''
       self.required = active_record_class.validators_on(self.name).any? do |val|
         !val.options[:if] && !val.options[:unless] && (ActiveModel::Validations::PresenceValidator === val ||
-          (ActiveModel::Validations::InclusionValidator === val && !val.options[:allow_nil] && !val.options[:allow_blank])
+          (ActiveModel::Validations::InclusionValidator === val && !val.options[:allow_nil] && !val.options[:allow_blank] && !(@form_ui == :checkbox && [[true, false], [false, true]].include?(val.send(:delimiter))))
         )
       end
       self.sort = true

data/lib/active_scaffold/data_structures/columns.rb

@@ -42,7 +42,7 @@ module ActiveScaffold::DataStructures
 
     def exclude(*args)
       # only remove columns from _inheritable. we never want to completely forget about a column.
-      args.each { |a| @_inheritable.delete a }
+      args.each { |a| @_inheritable.delete a.to_sym }
     end
 
     # returns an array of columns with the provided names
@@ -72,4 +72,4 @@ module ActiveScaffold::DataStructures
       end
     end
   end
-end
+end

data/lib/active_scaffold/data_structures/nested_info.rb

@@ -119,7 +119,11 @@ module ActiveScaffold::DataStructures
     end
 
     def default_sorting
-      association.options[:order]
+      if association.options[:order] # TODO remove when rails 3 compatibility is removed
+        association.options[:order]
+      elsif association.respond_to?(:scope) # rails 4
+        association.klass.class_eval(&association.scope).values[:order] if association.scope.is_a? Proc
+      end
     end
     
     def to_params

data/lib/active_scaffold/data_structures/sorting.rb

@@ -13,15 +13,17 @@ module ActiveScaffold::DataStructures
     
     def set_default_sorting(model)
       model_scope = model.send(:build_default_scope)
-      order_clause = model_scope.arel.order_clauses.join(",") if model_scope
+      order_clause = model_scope.order_values.join(",") if model_scope
 
-      # If an ORDER BY clause is found set default sorting according to it, else
       # fallback to setting primary key ordering
+      if model.column_names.include?(model.primary_key)
+        set(model.primary_key, 'ASC')
+        @sorting_by_primary_key = clause
+      end
+      # If an ORDER BY clause is found set default sorting according to it
       if order_clause
         set_sorting_from_order_clause(order_clause, model.table_name)
         @default_sorting = true
-      else
-        set(model.primary_key, 'ASC') if model.column_names.include?(model.primary_key)
       end
     end
 
@@ -69,6 +71,13 @@ module ActiveScaffold::DataStructures
       clause[1]
     end
 
+    SORTING_STAGES = Hash[%w(reset ASC DESC reset).each_cons(2).map{|a|a}].freeze
+    DEFAULT_SORTING_STAGES = Hash[%w(ASC DESC ASC).each_cons(2).map{|a|a}].freeze
+    def next_sorting_of(column, sorted_by_default)
+      stages = sorted_by_default ? DEFAULT_SORTING_STAGES : SORTING_STAGES
+      stages[direction_of(column)] || 'ASC'
+    end
+
     # checks whether any column is configured to sort by method (using a proc)
     def sorts_by_method?
       @clauses.any? { |sorting| sorting[0].sort.is_a? Hash and sorting[0].sort.has_key? :method }
@@ -102,6 +111,7 @@ module ActiveScaffold::DataStructures
         order << Array(sql).map {|column| "#{column} #{sort_direction}"}.join(', ')
       end
 
+      order << @sorting_by_primary_key if @sorting_by_primary_key # mandatory for postgres
       order unless order.empty?
     end
 
@@ -135,7 +145,7 @@ module ActiveScaffold::DataStructures
       order_clause.to_s.split(',').each do |criterion|
         unless criterion.blank?
           order_parts = extract_order_parts(criterion)
-          add(order_parts[:column_name], order_parts[:direction]) unless different_table?(model_table_name, order_parts[:table_name])
+          add(order_parts[:column_name], order_parts[:direction]) unless different_table?(model_table_name, order_parts[:table_name]) || get_column(order_parts[:column_name]).nil?
         end
       end
     end

data/lib/active_scaffold/delayed_setup.rb

@@ -0,0 +1,30 @@
+module ActiveScaffold
+  module DelayedSetup
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def process(*)
+      self.class.config_active_scaffold_delayed
+      super
+    end
+    
+    module ClassMethods
+      def active_scaffold(model_id = nil, &block)
+        @active_scaffold_delayed = proc{ super(model_id, &block) }
+      end
+
+      def config_active_scaffold_delayed
+        if @active_scaffold_delayed
+          block, @active_scaffold_delayed = @active_scaffold_delayed, nil
+          block.call
+        end
+      end
+
+      def active_scaffold_config
+        config_active_scaffold_delayed
+        super
+      end
+    end
+  end
+end

data/lib/active_scaffold/engine.rb

@@ -1,4 +1,29 @@
 module ActiveScaffold
   class Engine < ::Rails::Engine
+    initializer "active_scaffold.action_controller" do |app|
+      ActiveSupport.on_load :action_controller do
+        include ActiveScaffold::Core
+        include ActiveScaffold::DelayedSetup if ActiveScaffold.delayed_setup
+        include ActiveScaffold::RespondsToParent
+        include ActiveScaffold::Helpers::ControllerHelpers
+        include ActiveScaffold::ActiveRecordPermissions::ModelUserAccess::Controller
+      end
+    end
+
+    initializer "active_scaffold.action_view" do |app|
+      ActiveSupport.on_load :action_view do
+        include ActiveScaffold::Helpers::ViewHelpers
+      end
+    end
+
+    initializer "active_scaffold.active_record" do |app|
+      ActiveSupport.on_load :active_record do
+        include ActiveScaffold::ActiveRecordPermissions::ModelUserAccess::Model
+        ActiveRecord::Associations::Association.send :include, ActiveScaffold::Tableless::Association
+        ActiveRecord::Associations::CollectionAssociation.send :include, ActiveScaffold::Tableless::CollectionAssociation
+        ActiveRecord::Associations::SingularAssociation.send :include, ActiveScaffold::Tableless::SingularAssociation
+      end
+    end
+
   end
 end

data/lib/active_scaffold/extensions/action_view_rendering.rb

@@ -80,7 +80,7 @@ module ActionView::Helpers #:nodoc:
             if ActiveScaffold.js_framework == :prototype
               javascript_tag("new Ajax.Updater('#{id}', '#{url}', {method: 'get', evalScripts: true});")
             elsif ActiveScaffold.js_framework == :jquery
-              javascript_tag("jQuery('##{id}').load('#{url}', function() { $(this).trigger('as:element_updated'); });")
+              javascript_tag("jQuery('##{id}').load('#{url}', function() { jQuery(this).trigger('as:element_updated'); });")
             end
           end
         end

data/lib/active_scaffold/extensions/left_outer_joins.rb

@@ -1,33 +1,73 @@
 module ActiveScaffold
   module OuterJoins
-    def outer_joins(*assocs)
-      joins(outer_joins_sql(*assocs))
+    extend ActiveSupport::Concern
+    attr_accessor :outer_joins_values
+
+    if Rails::VERSION::MAJOR < 4
+      included do
+        const_get(:MULTI_VALUE_METHODS) << :outer_joins
+      end
+
+      def outer_joins(*args)
+        return self if args.compact.blank?
+
+        relation = clone
+
+        args.flatten!
+        relation.joins_values += [''] # HACK for using outer_joins in update_all/delete_all
+        relation.outer_joins_values += args
+
+        relation
+      end
+    else
+      def outer_joins_values
+        @values[:outer_joins] || []
+      end
+
+      def outer_joins_values=(values)
+        raise ImmutableRelation if @loaded
+        @values[:outer_joins] = values
+      end
+
+      def outer_joins(*args)
+        check_if_method_has_arguments!("outer_joins", args)
+        spawn.outer_joins!(*args.compact.flatten)
+      end
+
+      def outer_joins!(*args)
+        self.joins_values += [''] # HACK for using outer_joins in update_all/delete_all
+        self.outer_joins_values += args
+        self
+      end
     end
 
-    private
-    def outer_joins_sql(*assocs)
-      assocs.collect do |assoc|
-        if assoc.is_a? Array
-          outer_joins_sql(*assoc)
-        elsif assoc.is_a? Hash
-          assoc.collect do |key, val|
-            [left_outer_join_sql(key), klass.reflect_on_association(key).klass.outer_joins_sql(*val)]
+    if Rails.version < '4.1'
+      def build_arel
+        unless outer_joins_values.empty?
+          relation = self.except(:outer_joins)
+          join_dependency = ActiveRecord::Associations::JoinDependency.new(@klass, outer_joins_values, [])
+          join_dependency.join_associations.each do |association|
+            relation = association.join_relation(relation)
           end
-        elsif assoc.is_a? Symbol
-          left_outer_join_sql(assoc)
-        elsif assoc
-          assoc
+          relation.build_arel
+        else
+          super
         end
-      end.flatten.compact
-    end
-
-    def left_outer_join_sql(association_name)
-      t = ActiveRecord::Associations::JoinDependency.new(klass, association_name, []).join_associations.first.join_relation(klass).arel
-      t.joins(t)
+      end
+    else
+      def build_arel
+        unless outer_joins_values.empty?
+          relation = self.except(:outer_joins)
+          relation.joins! ActiveRecord::Associations::JoinDependency.new(@klass, outer_joins_values, [])
+          relation.build_arel
+        else
+          super
+        end
+      end
     end
   end
 end
 ActiveRecord::Relation.send :include, ActiveScaffold::OuterJoins
 module ActiveRecord::Querying
-  delegate :outer_joins, :outer_joins_sql, :to => :scoped
+  delegate :outer_joins, :to => Rails::VERSION::MAJOR < 4 ? :scoped : :all
 end