active_scaffold 3.4.43 → 3.5.0

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

@@ -0,0 +1,94 @@
+module ActiveScaffold::DataStructures::Association
+  class ActiveRecord < Abstract
+    def self.reflect_on_all_associations(klass)
+      klass.reflect_on_all_associations
+    end
+
+    delegate :collection?, :polymorphic?, :association_primary_key, :foreign_type, :table_name, to: :@association
+
+    def through?
+      @association.options[:through].present?
+    end
+
+    def readonly?
+      scope_values[:readonly]
+    end
+
+    def through_reflection
+      @association.through_reflection if through?
+    end
+
+    def source_reflection
+      @association.source_reflection if through?
+    end
+
+    def scope
+      @association.scope
+    end
+
+    def inverse_klass
+      @association.active_record
+    end
+
+    def primary_key
+      @association.options[:primary_key]
+    end
+
+    def counter_cache
+      @association.options[:counter_cache]
+    end
+
+    def as
+      @association.options[:as]
+    end
+
+    def dependent
+      @association.options[:dependent]
+    end
+
+    # name of inverse
+    def inverse
+      @association.inverse_of.try(:name)
+    end
+
+    def quoted_table_name
+      @association.klass.quoted_table_name
+    end
+
+    def quoted_primary_key
+      @association.klass.quoted_primary_key
+    end
+
+    def respond_to_target?
+      true
+    end
+
+    def counter_cache_hack?
+      if has_many?
+        Rails.version < '5.0' && as
+      elsif belongs_to?
+        counter_cache && (Rails.version >= '5.0' || !polymorphic?)
+      end
+    end
+
+    protected
+
+    def scope_values
+      return {} unless @association.scope
+      @scope_values ||= @association.klass.instance_exec(&@association.scope).values rescue {}
+    end
+
+    def reverse_through_match?(assoc)
+      assoc.options[:through] && assoc.through_reflection.class_name == through_reflection.class_name
+    end
+
+    def reverse_habtm_match?(assoc)
+      super && assoc.options[:join_table] == @association.options[:join_table]
+    end
+
+    def reverse_direct_match?(assoc)
+      # skip over has_many :through associations
+      !assoc.options[:through] && super
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module ActiveScaffold::DataStructures::Association
+  class Mongoid < Abstract
+    delegate :inverse_klass, :as, :dependent, :inverse, to: :@association
+    def collection?
+      %i[has_many has_and_belongs_to_many].include?(@association.macro)
+    end
+
+    # polymorphic belongs_to
+    def polymorphic?
+      belongs_to? && @association.polymorphic?
+    end
+
+    def primary_key
+      @association[:primary_key]
+    end
+
+    def association_primary_key
+      @association.primary_key
+    end
+
+    def foreign_type
+      @association.type
+    end
+
+    def counter_cache
+      @association[:counter_cache]
+    end
+
+    def table_name
+      @association.klass.collection.name
+    end
+
+    def quoted_table_name
+      table_name
+    end
+
+    def quoted_primary_key
+      '_id'
+    end
+
+    def self.reflect_on_all_associations(klass)
+      klass.relations.values
+    end
+  end
+end

data/lib/active_scaffold/data_structures/bridge.rb

@@ -4,8 +4,7 @@ module ActiveScaffold::DataStructures
       raise RunTimeError, "install not defined for bridge #{name}"
     end
 
-    def self.prepare
-    end
+    def self.prepare; end
 
     # by convention and default, use the bridge name as the required constant for installation
     def self.install?
@@ -16,10 +15,8 @@ module ActiveScaffold::DataStructures
       install if install?
     end
 
-    def self.stylesheets
-    end
+    def self.stylesheets; end
 
-    def self.javascripts
-    end
+    def self.javascripts; end
   end
 end

data/lib/active_scaffold/data_structures/column.rb

@@ -1,8 +1,10 @@
 module ActiveScaffold::DataStructures
   class Column
     include ActiveScaffold::Configurable
+    include ActiveScaffold::OrmChecks
 
     attr_reader :active_record_class
+    alias model active_record_class
 
     # this is the name of the getter on the ActiveRecord model. it is the only absolutely required attribute ... all others will be inferred from this name.
     attr_accessor :name
@@ -76,7 +78,7 @@ module ActiveScaffold::DataStructures
     end
 
     # send all the form instead of only new value when this column change
-    cattr_accessor :send_form_on_update_column
+    cattr_accessor :send_form_on_update_column, instance_accessor: false
     attr_accessor :send_form_on_update_column
 
     # sorting on a column can be configured four ways:
@@ -132,11 +134,11 @@ module ActiveScaffold::DataStructures
 
     attr_writer :search_ui
     def search_ui
-      @search_ui || @form_ui || (@association && !polymorphic_association? ? :select : nil)
+      @search_ui || @form_ui || (:select if association && !association.polymorphic?)
     end
 
     # a place to store dev's column specific options
-    attr_accessor :options
+    attr_writer :options
     def options
       @options ||= {}
     end
@@ -181,8 +183,8 @@ module ActiveScaffold::DataStructures
     attr_reader :includes
     def includes=(value)
       @includes = case value
-        when Array then value
-        else value ? [value] : value # not convert nil to [nil]
+                  when Array then value
+                  else value ? [value] : value # not convert nil to [nil]
       end
     end
 
@@ -193,8 +195,8 @@ module ActiveScaffold::DataStructures
 
     def search_joins=(value)
       @search_joins = case value
-        when Array then value
-        else [value] # automatically convert to an array
+                      when Array then value
+                      else [value] # automatically convert to an array
       end
     end
 
@@ -227,12 +229,12 @@ module ActiveScaffold::DataStructures
     attr_accessor :weight
 
     # to set how many associated records a column with plural association must show in list
-    cattr_accessor :associated_limit
+    cattr_accessor :associated_limit, instance_accessor: false
     @@associated_limit = 3
     attr_accessor :associated_limit
 
     # whether the number of associated records must be shown or not
-    cattr_accessor :associated_number
+    cattr_accessor :associated_number, instance_accessor: false
     @@associated_number = true
     attr_writer :associated_number
     def associated_number?
@@ -240,18 +242,18 @@ module ActiveScaffold::DataStructures
     end
 
     # whether a blank row must be shown in the subform
-    cattr_accessor :show_blank_record
+    cattr_accessor :show_blank_record, instance_accessor: false
     @@show_blank_record = true
     attr_writer :show_blank_record
     def show_blank_record?(associated)
       return false unless @show_blank_record
-      return false unless association.klass.authorized_for?(:crud_type => :create) && !association.options[:readonly]
-      self.plural_association? || (self.singular_association? && associated.blank?)
+      return false unless association.klass.authorized_for?(:crud_type => :create) && !association.readonly?
+      association.collection? || (association.singular? && associated.blank?)
     end
 
     # methods for automatic links in singular association columns
-    cattr_accessor :actions_for_association_links
-    @@actions_for_association_links = [:new, :edit, :show]
+    cattr_accessor :actions_for_association_links, instance_accessor: false
+    @@actions_for_association_links = %i[new edit show]
     attr_accessor :actions_for_association_links
 
     cattr_accessor :association_form_ui
@@ -266,30 +268,9 @@ module ActiveScaffold::DataStructures
 
     # the association from the ActiveRecord class
     attr_reader :association
-    def singular_association?
-      association && !association.collection?
-    end
-
-    def plural_association?
-      association && association.collection?
-    end
 
-    def through_association?
-      association && association.options[:through]
-    end
-
-    def polymorphic_association?
-      association && association.options[:polymorphic]
-    end
-
-    def readonly_association?
-      return false unless association
-      if association.options.key? :readonly
-        association.options[:readonly]
-      else
-        self.through_association?
-      end
-    end
+    # the singular association which this column belongs to
+    attr_reader :delegated_association
 
     # an interpreted property. the column is virtual if it isn't from the active record model or any associated models
     def virtual?
@@ -310,54 +291,57 @@ module ActiveScaffold::DataStructures
       # another column
       if other.respond_to?(:name) && other.class == self.class
         name == other.name.to_sym
-      # a string or symbol
-      elsif other.respond_to? :to_sym
-        name == other.to_sym rescue false # catch "interning empty string"
-      # unknown
-      else
-        self.eql? other
+      elsif other.is_a? Symbol
+        name == other
+      elsif other.is_a? String
+        name.to_s == other # avoid creating new symbols
+      else # unknown
+        eql? other
       end
     end
 
     # instantiation is handled internally through the DataStructures::Columns object
-    def initialize(name, active_record_class) #:nodoc:
+    def initialize(name, active_record_class, delegated_association = nil) #:nodoc:
       self.name = name.to_sym
-      @tableless = active_record_class < ActiveScaffold::Tableless
-      @column = active_record_class.columns_hash[self.name.to_s]
-      @association = active_record_class.reflect_on_association(self.name)
-      @autolink = !@association.nil?
       @active_record_class = active_record_class
-      @table = active_record_class.table_name
+      @column = _columns_hash[self.name.to_s]
+      @delegated_association = delegated_association
+      setup_association_info
+
+      @autolink = self.association.present?
+      @table = _table_name
       @associated_limit = self.class.associated_limit
       @associated_number = self.class.associated_number
       @show_blank_record = self.class.show_blank_record
       @send_form_on_update_column = self.class.send_form_on_update_column
-      @actions_for_association_links = self.class.actions_for_association_links.clone if @association
+      @actions_for_association_links = self.class.actions_for_association_links.clone if self.association
       @select_columns = default_select_columns
 
-      @text = @column.nil? || [:string, :text].include?(@column.type)
+      @text = @column.nil? || [:string, :text, String].include?(column_type)
+      @number = false
       if @column
         if active_record_class.respond_to?(:defined_enums) && active_record_class.defined_enums[name.to_s]
           @form_ui = :select
-          @options = {:options => active_record_class.send(name.to_s.pluralize).keys}
-        elsif @column.number?
+          @options = {:options => active_record_class.send(name.to_s.pluralize).keys.map(&:to_sym)}
+        elsif column_number?
           @number = true
           @form_ui = :number
           @options = {:format => :i18n_number}
         else
           @form_ui = case @column.type
-            when :boolean then :checkbox
-            when :text then :textarea
+                     when :boolean then :checkbox
+                     when :text then :textarea
           end
         end
       end
       @allow_add_existing = true
       @form_ui = self.class.association_form_ui if @association && self.class.association_form_ui
 
-      if association && !polymorphic_association?
-        self.includes = [association.name]
-        self.search_joins = includes.clone
+      self.includes = [association.name] if association && association.allow_join?
+      if delegated_association
+        self.includes = includes ? [delegated_association.name => includes] : [delegated_association.name]
       end
+      self.search_joins = includes.clone if includes
 
       # default all the configurable variables
       self.css_class = ''
@@ -373,12 +357,12 @@ module ActiveScaffold::DataStructures
     # just the field (not table.field)
     def field_name
       return nil if virtual?
-      @field_name ||= column ? @active_record_class.connection.quote_column_name(column.name) : association.foreign_key
+      @field_name ||= column ? quoted_field_name(column.name) : association.foreign_key
     end
 
     def <=>(other)
       order_weight = weight <=> other.weight
-      order_weight != 0 ? order_weight : name.to_s <=> other.name.to_s
+      order_weight.nonzero? ? order_weight : name.to_s <=> other.name.to_s
     end
 
     def number_to_native(value)
@@ -386,12 +370,12 @@ module ActiveScaffold::DataStructures
       native = '.' # native ruby separator
       format = {:separator => '', :delimiter => ''}.merge! I18n.t('number.format', :default => {})
       specific = case options[:format]
-      when :currency
-        I18n.t('number.currency.format', :default => nil)
-      when :size
-        I18n.t('number.human.format', :default => nil)
-      when :percentage
-        I18n.t('number.percentage.format', :default => nil)
+                 when :currency
+                   I18n.t('number.currency.format', :default => nil)
+                 when :size
+                   I18n.t('number.human.format', :default => nil)
+                 when :percentage
+                   I18n.t('number.percentage.format', :default => nil)
       end
       format.merge! specific unless specific.nil?
       if format[:separator].blank? || !value.include?(format[:separator]) && value.include?(native) && (format[:delimiter] != native || value !~ /\.\d{3}$/)
@@ -412,8 +396,29 @@ module ActiveScaffold::DataStructures
       @field ||= quoted_field(field_name)
     end
 
+    def type_for_attribute
+      ActiveScaffold::OrmChecks.type_for_attribute active_record_class, name
+    end
+
+    def column_type
+      ActiveScaffold::OrmChecks.column_type active_record_class, name
+    end
+
     protected
 
+    def setup_association_info
+      assoc = active_record_class.reflect_on_association(self.name)
+      @association = if assoc
+                       case
+                       when active_record? then Association::ActiveRecord.new(assoc)
+                       when mongoid? then Association::Mongoid.new(assoc)
+                       end
+                     elsif defined?(ActiveMongoid) && model < ActiveMongoid::Associations
+                       assoc = active_record_class.reflect_on_am_association(name)
+                       Association::ActiveMongoid.new(assoc) if assoc
+      end
+    end
+
     def validator_force_required?(val)
       return false if val.options[:if] || val.options[:unless]
       case val
@@ -433,34 +438,47 @@ module ActiveScaffold::DataStructures
     def default_select_columns
       if association.nil? && column
         [field]
-      elsif polymorphic_association?
-        [field, quoted_field(@active_record_class.connection.quote_column_name(association.foreign_type))]
+      elsif association.try(:polymorphic?)
+        [field, quoted_field(quoted_field_name(association.foreign_type))]
       elsif association
         if 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))
+          if _columns_hash[count_column = "#{association.name}_count"]
+            columns << quoted_field(quoted_field_name(count_column))
           end
           if association.through_reflection.try(:belongs_to?)
-            columns << quoted_field(@active_record_class.connection.quote_column_name(association.through_reflection.foreign_key))
+            columns << quoted_field(quoted_field_name(association.through_reflection.foreign_key))
           end
           columns
         end
       end
     end
 
+    def column_number?
+      return %i[float decimal integer].include? @column.type if active_record?
+      return @column.type < Numeric if mongoid?
+    end
+
+    def quoted_field_name(column_name)
+      if active_record?
+        @active_record_class.connection.quote_column_name(column_name)
+      else
+        column_name.to_s
+      end
+    end
+
     def quoted_field(name)
-      [@active_record_class.quoted_table_name, name].join('.')
+      active_record? ? [_quoted_table_name, name].compact.join('.') : name
     end
 
     def initialize_sort
-      if self.virtual?
+      if virtual?
         # we don't automatically enable method sorting for virtual columns because it's slow, and we expect fewer complaints this way.
         self.sort = false
       else
-        if column && !@tableless
+        if column && !tableless?
           self.sort = {:sql => field}
         else
           self.sort = false
@@ -470,11 +488,11 @@ module ActiveScaffold::DataStructures
 
     def initialize_search_sql
       self.search_sql =
-        unless self.virtual?
+        unless virtual?
           if association.nil?
-            field.to_s unless @tableless
-          elsif !self.polymorphic_association?
-            [association.klass.quoted_table_name, association.klass.quoted_primary_key].join('.') unless association.klass < ActiveScaffold::Tableless
+            field.to_s unless tableless?
+          elsif association.allow_join?
+            [association.quoted_table_name, association.quoted_primary_key].join('.') unless association.klass < ActiveScaffold::Tableless
           end
         end
     end
@@ -483,13 +501,13 @@ module ActiveScaffold::DataStructures
     attr_reader :table
 
     def estimate_weight
-      if singular_association?
+      if association.try(:singular?)
         400
-      elsif plural_association?
+      elsif association.try(:collection?)
         500
-      elsif [:created_at, :updated_at].include?(name)
+      elsif %i[created_at updated_at].include?(name)
         600
-      elsif [:name, :label, :title].include?(name)
+      elsif %i[name label title].include?(name)
         100
       elsif required?
         200