active_scaffold 3.4.43 → 3.5.0

data/lib/active_scaffold/core.rb

@@ -19,7 +19,7 @@ module ActiveScaffold
         ActiveScaffold::Bridges.run_all
 
         # converts Foo::BarController to 'bar' and FooBarsController to 'foo_bar' and AddressController to 'address'
-        model_id = to_s.split('::').last.sub(/Controller$/, '').pluralize.singularize.underscore unless model_id
+        model_id ||= to_s.split('::').last.sub(/Controller$/, '').pluralize.singularize.underscore
 
         # run the configuration
         @active_scaffold_config = ActiveScaffold::Config::Core.new(model_id)
@@ -33,14 +33,8 @@ module ActiveScaffold
         active_scaffold_config._load_action_columns
 
         # defines the attribute read methods on the model, so record.send() doesn't find protected/private methods instead
-        klass = active_scaffold_config.model
-        # Rails 4.0.4 has removed attribute_methods_generated,
-        # and made define_attribute_methods threadsave to call multiple times.
-        # Check for that here.
-        if (Rails::VERSION::MAJOR == 4 && !klass.respond_to?(:attribute_methods_generated)) ||
-           !klass.attribute_methods_generated?
-          klass.define_attribute_methods
-        end
+        # define_attribute_methods is safe to call multiple times since rails 4.0.4
+        active_scaffold_config.model.define_attribute_methods if active_scaffold_config.active_record?
         # include the rest of the code into the controller: the action core and the included actions
         module_eval do
           unless self < ActiveScaffold::Actions::Core
@@ -69,7 +63,13 @@ module ActiveScaffold
 
       module Prefixes
         define_method Rails.version < '4.2' ? 'parent_prefixes' : 'local_prefixes' do
-          @local_prefixes ||= super() << 'active_scaffold_overrides'
+          @local_prefixes ||= begin
+            prefixes = super()
+            unless superclass.uses_active_scaffold? || prefixes.include?('active_scaffold_overrides')
+              prefixes << 'active_scaffold_overrides'
+            end
+            prefixes
+          end
         end
       end
 
@@ -100,7 +100,7 @@ module ActiveScaffold
       end
 
       def active_scaffold_controller_for_column(column, options = {})
-        if column.polymorphic_association?
+        if column.association.polymorphic?
           :polymorph
         elsif options.include?(:controller)
           "#{options[:controller].to_s.camelize}Controller".constantize
@@ -117,11 +117,11 @@ module ActiveScaffold
                                :controller => (controller == :polymorph ? controller : "/#{controller.controller_path}")
         options[:parameters] ||= {}
         options[:parameters].reverse_merge! :association => column.association.name
-        if column.plural_association?
+        if column.association.collection?
           ActiveScaffold::DataStructures::ActionLink.new('index', options.merge(:refresh_on_close => true))
         else
           actions = controller.active_scaffold_config.actions unless controller == :polymorph
-          actions ||= [:create, :update, :show]
+          actions ||= %i[create update show]
           column.actions_for_association_links.delete :new unless actions.include? :create
           column.actions_for_association_links.delete :edit unless actions.include? :update
           column.actions_for_association_links.delete :show unless actions.include? :show
@@ -206,7 +206,9 @@ module ActiveScaffold
             end
           end
           raise ActiveScaffold::ControllerNotFound, "#{controller} missing ActiveScaffold", caller unless controller.uses_active_scaffold?
-          raise ActiveScaffold::ControllerNotFound, "ActiveScaffold on #{controller} is not for #{klass} model.", caller unless controller.active_scaffold_config.model.to_s == klass.to_s
+          unless controller.active_scaffold_config.model.to_s == klass.to_s
+            raise ActiveScaffold::ControllerNotFound, "ActiveScaffold on #{controller} is not for #{klass} model.", caller
+          end
           return controller
         end
       end
@@ -214,10 +216,29 @@ module ActiveScaffold
     end
 
     def self.column_type_cast(value, column)
+      if defined?(ActiveRecord) && ActiveRecord::ConnectionAdapters::Column === column
+        active_record_column_type_cast(value, column)
+      elsif defined?(Mongoid) && Mongoid::Fields::Standard === column
+        mongoid_column_type_cast(value, column)
+      else
+        value
+      end
+    end
+
+    def self.mongoid_column_type_cast(value, column)
+      column.type.evolve value
+    end
+
+    def self.active_record_column_type_cast(value, column)
       if Rails.version < '4.2'
         column.type_cast value
-      else
+      elsif Rails.version < '5.0'
         column.type_cast_from_user value
+      elsif column.type.respond_to? :cast # jruby-jdbc and rails 5
+        column.type.cast value
+      else
+        cast_type = ActiveModel::Type.lookup column.type
+        cast_type ? cast_type.cast(value) : value
       end
     end
   end

data/lib/active_scaffold/data_structures/action_columns.rb

@@ -18,7 +18,7 @@ module ActiveScaffold::DataStructures
     end
 
     def css_class
-      @label.to_s.underscore.gsub /[^-_0-9a-zA-Z]/, '-'
+      @label.to_s.underscore.gsub(/[^-_0-9a-zA-Z]/, '-')
     end
 
     # this is so that array.delete and array.include?, etc., will work by column name
@@ -54,7 +54,7 @@ module ActiveScaffold::DataStructures
 
     def names
       if @columns
-        collect_visible(:flatten => true) { |c| c.name }
+        collect_visible(:flatten => true, &:name)
       else
         names_without_auth_check
       end
@@ -76,7 +76,7 @@ module ActiveScaffold::DataStructures
       @set.each do |item|
         unless item.is_a?(ActiveScaffold::DataStructures::ActionColumns) || @columns.nil?
           item = (@columns[item] || ActiveScaffold::DataStructures::Column.new(item.to_sym, @columns.active_record_class))
-          next if self.skip_column?(item, options)
+          next if skip_column?(item, options)
         end
         if item.is_a? ActiveScaffold::DataStructures::ActionColumns
           if options[:flatten]
@@ -97,7 +97,7 @@ module ActiveScaffold::DataStructures
       @set.each do |item|
         unless item.is_a?(ActiveScaffold::DataStructures::ActionColumns) || @columns.nil?
           item = (@columns[item] || ActiveScaffold::DataStructures::Column.new(item.to_sym, @columns.active_record_class))
-          next if self.skip_column?(item, options)
+          next if skip_column?(item, options)
         end
         if item.is_a?(ActiveScaffold::DataStructures::ActionColumns) && options.key?(:flatten) && options[:flatten]
           columns += item.collect_visible(options, &proc)
@@ -132,23 +132,28 @@ module ActiveScaffold::DataStructures
       @action.class.name.demodulize.underscore
     end
 
-    def constraint_columns_key
+    def 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
+      Thread.current[:constraint_columns][columns_key] = columns
     end
 
     def constraint_columns
       constraints = Thread.current[:constraint_columns]
-      (constraints[constraint_columns_key] if constraints) || []
+      (constraints[columns_key] if constraints) || []
+    end
+
+    def unauthorized_columns=(columns)
+      Thread.current[:unauthorized_columns] ||= {}
+      Thread.current[:unauthorized_columns][columns_key] = columns
     end
 
-    attr_writer :unauthorized_columns
     def unauthorized_columns
-      @unauthorized_columns ||= []
+      Thread.current[:unauthorized_columns] ||= {}
+      Thread.current[:unauthorized_columns][columns_key] ||= []
     end
 
     def length

data/lib/active_scaffold/data_structures/action_link.rb

@@ -10,8 +10,8 @@ module ActiveScaffold::DataStructures
       self.inline = true
       self.method = :get
       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 = :create if %i[create new].include?(action.try(:to_sym))
+      self.crud_type = :update if %i[edit update].include?(action.try(:to_sym))
       self.crud_type ||= :read
       self.column = nil
       self.image = nil
@@ -21,7 +21,7 @@ module ActiveScaffold::DataStructures
       # apply quick properties
       options.each_pair do |k, v|
         setter = "#{k}="
-        send(setter, v) if self.respond_to? setter
+        send(setter, v) if respond_to? setter
       end
       self.toggle = self.action.try(:to_sym) == :index && (parameters.present? || dynamic_parameters) unless options.include? :toggle
     end
@@ -90,7 +90,7 @@ module ActiveScaffold::DataStructures
     end
 
     # if the action uses a DHTML based (i.e. 2-phase) confirmation
-    attr_accessor :dhtml_confirm
+    attr_reader :dhtml_confirm
     def dhtml_confirm=(value)
       @confirm = nil if value
       @dhtml_confirm = value
@@ -165,7 +165,6 @@ module ActiveScaffold::DataStructures
     # where the result of this action should insert in the display.
     # for :type => :collection, supported values are:
     #   :top
-    #   :bottom
     #   :replace (for updating the entire table)
     #   false (no attempt at positioning)
     # for :type => :member, supported values are:

data/lib/active_scaffold/data_structures/action_links.rb

@@ -31,7 +31,7 @@ module ActiveScaffold::DataStructures
         link
       end
     end
-    alias_method :<<, :add
+    alias << add
 
     def add_to_set(link)
       @set << link
@@ -84,13 +84,14 @@ module ActiveScaffold::DataStructures
 
     def delete_group(name)
       @set.each do |group|
+        next unless group.is_a?(ActiveScaffold::DataStructures::ActionLinks)
         if group.name == name
           @set.delete group
           break
         else
           group.delete_group(name)
           break
-        end if group.is_a?(ActiveScaffold::DataStructures::ActionLinks)
+        end
       end
     end
 
@@ -121,7 +122,7 @@ module ActiveScaffold::DataStructures
     end
 
     def empty?
-      @set.size == 0
+      @set.empty?
     end
 
     def subgroup(name, label = nil)
@@ -134,7 +135,7 @@ module ActiveScaffold::DataStructures
         group = ActiveScaffold::DataStructures::ActionLinks.new
         group.label = label || name
         group.name = name
-        group.default_type = self.name == :root ? (name.to_sym if %w(member collection).include?(name.to_s)) : default_type
+        group.default_type = self.name == :root ? (name.to_sym if %w[member collection].include?(name.to_s)) : default_type
         add_to_set group
       end
       group

data/lib/active_scaffold/data_structures/actions.rb

@@ -3,7 +3,7 @@ class ActiveScaffold::DataStructures::Actions
 
   def initialize(*args)
     @set = []
-    add *args
+    add(*args)
   end
 
   def exclude(*args)
@@ -14,7 +14,7 @@ class ActiveScaffold::DataStructures::Actions
   def add(*args)
     args.each { |arg| @set << arg.to_sym unless @set.include? arg.to_sym }
   end
-  alias_method :<<, :add
+  alias << add
 
   def each
     @set.each { |item| yield item }

data/lib/active_scaffold/data_structures/association.rb

@@ -0,0 +1,8 @@
+module ActiveScaffold::DataStructures
+  module Association
+    autoload :Abstract, 'active_scaffold/data_structures/association/abstract.rb'
+    autoload :ActiveRecord, 'active_scaffold/data_structures/association/active_record.rb'
+    autoload :Mongoid, 'active_scaffold/data_structures/association/mongoid.rb'
+    autoload :ActiveMongoid, 'active_scaffold/data_structures/association/active_mongoid.rb'
+  end
+end

data/lib/active_scaffold/data_structures/association/abstract.rb

@@ -0,0 +1,147 @@
+module ActiveScaffold::DataStructures::Association
+  class Abstract
+    def initialize(association)
+      @association = association
+    end
+    attr_writer :reverse
+    delegate :name, :klass, :foreign_key, :==, to: :@association
+
+    def allow_join?
+      !polymorphic?
+    end
+
+    def belongs_to?
+      @association.macro == :belongs_to
+    end
+
+    def has_one?
+      @association.macro == :has_one
+    end
+
+    def has_many?
+      @association.macro == :has_many
+    end
+
+    def habtm?
+      @association.macro == :has_and_belongs_to_many
+    end
+
+    def singular?
+      !collection?
+    end
+
+    def through?
+      false
+    end
+
+    def polymorphic?
+      false
+    end
+
+    def readonly?
+      false
+    end
+
+    def through_reflection; end
+
+    def source_reflection; end
+
+    def scope; end
+
+    def respond_to_target?
+      false
+    end
+
+    def counter_cache_hack?
+      false
+    end
+
+    def quoted_table_name
+      raise "define quoted_table_name method in #{self.class.name} class"
+    end
+
+    def quoted_primary_key
+      raise "define quoted_primary_key method in #{self.class.name} class"
+    end
+
+    def reverse(klass = nil)
+      unless polymorphic? || defined?(@reverse)
+        @reverse ||= inverse || get_reverse.try(:name)
+      end
+      @reverse || (get_reverse(klass).try(:name) unless klass.nil?)
+    end
+
+    def inverse_for?(klass)
+      inverse_class = reverse_association(klass).try(:inverse_klass)
+      inverse_class.present? && (inverse_class == klass || klass < inverse_class)
+    end
+
+    def reverse_association(klass = nil)
+      assoc = if polymorphic?
+                get_reverse(klass) unless klass.nil?
+              else
+                return unless reverse_name = reverse(klass)
+                reflect_on_association(reverse_name)
+      end
+      self.class.new(assoc) if assoc
+    end
+
+    protected
+
+    def reflect_on_association(name)
+      @association.klass.reflect_on_association(name)
+    end
+
+    def get_reverse(klass = nil)
+      return nil if klass.nil? && polymorphic?
+
+      # name-based matching (association name vs self.active_record.to_s)
+      matches = reverse_matches(klass || self.klass)
+      if matches.length > 1
+        matches.select! do |assoc|
+          inverse_klass.name.underscore.include? assoc.name.to_s.pluralize.singularize
+        end
+      end
+
+      matches.first
+    end
+
+    def reverse_matches(klass)
+      associations = self.class.reflect_on_all_associations(klass)
+      # collect associations that point back to this model and use the same foreign_key
+      associations.each_with_object([]) do |assoc, reverse_matches|
+        reverse_matches << assoc if reverse_match? assoc
+      end
+    end
+
+    def reverse_match?(assoc)
+      return false if assoc == @association
+      return false unless assoc.polymorphic? || assoc.class_name == inverse_klass.try(:name)
+
+      if through?
+        reverse_through_match?(assoc)
+      elsif habtm?
+        reverse_habtm_match?(assoc)
+      else
+        reverse_direct_match?(assoc)
+      end
+    end
+
+    def reverse_through_match?(assoc); end
+
+    def reverse_habtm_match?(assoc)
+      assoc.macro == :has_and_belongs_to_many
+    end
+
+    def reverse_direct_match?(assoc)
+      # skip over has_and_belongs_to_many associations
+      return false if assoc.macro == :has_and_belongs_to_many
+
+      if foreign_key.is_a?(Array) || assoc.foreign_key.is_a?(Array) # composite_primary_keys
+        assoc.foreign_key == foreign_key
+      else
+        assoc.foreign_key.to_sym == foreign_key.to_sym
+      end
+    end
+  end
+end

data/lib/active_scaffold/data_structures/association/active_mongoid.rb

@@ -0,0 +1,42 @@
+module ActiveScaffold::DataStructures::Association
+  class ActiveMongoid < Mongoid
+    def self.reflect_on_all_associations(klass)
+      return [] unless klass.respond_to? :am_relations
+      klass.am_relations.values
+    end
+
+    def inverse_klass
+      as ? @association[:inverse_class_name].constantize : super
+    end
+
+    def allow_join?
+      false
+    end
+
+    def belongs_to?
+      %i[belongs_to_record belongs_to_document].include?(@association.macro)
+    end
+
+    def has_one?
+      %i[has_one_record has_one_document].include?(@association.macro)
+    end
+
+    def has_many?
+      %i[has_many_records has_many_documents].include?(@association.macro)
+    end
+
+    def collection?
+      %i[has_many_documents has_many_records].include?(@association.macro)
+    end
+
+    def table_name
+      @association.klass < ActiveRecord::Base ? @association.klass.table_name : super
+    end
+
+    protected
+
+    def reflect_on_association(name)
+      @association.klass.reflect_on_am_association(name)
+    end
+  end
+end