active_scaffold 3.2.17 → 3.2.18

data/lib/active_scaffold/config/show.rb

@@ -1,31 +0,0 @@
-module ActiveScaffold::Config
-  class Show < Base
-    self.crud_type = :read
-
-    def initialize(core_config)
-      super
-      # start with the ActionLink defined globally
-      @link = self.class.link.clone
-    end
-
-    # global level configuration
-    # --------------------------
-    cattr_accessor :link
-    @@link = ActiveScaffold::DataStructures::ActionLink.new('show', :label => :show, :type => :member, :security_method => :show_authorized?, :ignore_method => :show_ignore?)
-    # instance-level configuration
-    # ----------------------------
-
-    # the ActionLink for this action
-    attr_accessor :link
-    # the label for this action. used for the header.
-    attr_writer :label
-
-    # provides access to the list of columns specifically meant for this action to use
-    def columns
-      self.columns = @core.columns._inheritable unless @columns # lazy evaluation
-      @columns
-    end
-    
-    public :columns=
-  end
-end

data/lib/active_scaffold/config/subform.rb

@@ -1,35 +0,0 @@
-module ActiveScaffold::Config
-  class Subform < Base
-    def initialize(core_config)
-      super
-      @layout = self.class.layout # default layout
-    end
-
-    # global level configuration
-    # --------------------------
-
-    cattr_accessor :layout
-    @@layout = :horizontal
-
-    # instance-level configuration
-    # ----------------------------
-
-    attr_accessor :layout
-
-    # provides access to the list of columns specifically meant for the Sub-Form to use
-    def columns
-      # we want to delay initializing to the @core.update.columns set for as long as possible. but we have to eventually clone, or else have a configuration "leak"
-      unless @columns
-        if @core.actions.include? :update
-          @columns = @core.update.columns.clone
-        else
-          self.columns = @core.columns._inheritable
-        end
-      end
-
-      @columns
-    end
-
-    public :columns=
-  end
-end

data/lib/active_scaffold/config/update.rb

@@ -1,33 +0,0 @@
-module ActiveScaffold::Config
-  class Update < ActiveScaffold::Config::Form
-    self.crud_type = :update
-    def initialize(core_config)
-      super
-      self.nested_links = self.class.nested_links
-    end
-
-    # global level configuration
-    # --------------------------
-    # the ActionLink for this action
-    def self.link
-      @@link
-    end
-    def self.link=(val)
-      @@link = val
-    end
-    @@link = ActiveScaffold::DataStructures::ActionLink.new('edit', :label => :edit, :type => :member, :security_method => :update_authorized?, :ignore_method => :update_ignore?)
-
-    # instance-level configuration
-    # ----------------------------
-
-    attr_accessor :nested_links
-    cattr_accessor :nested_links
-    @@nested_links = false
-    
-    attr_writer :hide_nested_column
-    def hide_nested_column
-      @hide_nested_column.nil? ? true : @hide_nested_column
-    end
- 
-  end
-end

data/lib/active_scaffold/configurable.rb

@@ -1,29 +0,0 @@
-module ActiveScaffold
-  # Exposes a +configure+ method that accepts a block and runs all contents of the block in two contexts, as opposed to the normal one. First, everything gets evaluated as part of the object including Configurable. Then, as a failover, missing methods and variables are evaluated in the original binding of the block.
-  #
-  # Note that this only works with "barewords". Constants, instance variables, and class variables are not currently supported in both contexts.
-  #
-  # May add the given functionality at both the class and instance level. For the former, use +extend+, and for the latter, use +include+.
-  module Configurable
-    def configure(&configuration_block)
-      return unless configuration_block
-      @configuration_binding = configuration_block.binding
-      ret = instance_exec self, &configuration_block
-      @configuration_binding = nil
-      return ret
-    end
-
-    # this method will surely need tweaking. for example, i'm not sure if it should call super before or after it tries to eval with the binding.
-    def method_missing(name, *args)
-      begin
-        super
-      rescue NoMethodError, NameError
-        if @configuration_binding.nil?
-          raise $!
-        else
-          eval("self", @configuration_binding).send(name, *args)
-        end
-      end
-    end
-  end
-end

data/lib/active_scaffold/constraints.rb

@@ -1,171 +0,0 @@
-module ActiveScaffold
-  module Constraints
-
-    protected
-
-    # Returns the current constraints
-    def active_scaffold_constraints
-      @active_scaffold_constraints ||= active_scaffold_session_storage[:constraints] || {}
-    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(constrained_fields = nil)
-      constrained_fields ||= []
-      constrained_fields |= active_scaffold_constraints.reject{|k, v| v.is_a? Hash}.keys.collect(&:to_sym)
-      exclude_actions = []
-      [:list, :update].each do |action_name|
-        if active_scaffold_config.actions.include? action_name
-          exclude_actions << action_name unless active_scaffold_config.send(action_name).hide_nested_column
-        end
-      end
-
-      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
-      hash_conditions = {}
-      conditions = [hash_conditions]
-      active_scaffold_constraints.each do |k, v|
-        column = active_scaffold_config.columns[k]
-        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 => far_association.name}]) # e.g. {:den => :park}
-            hash_conditions.merge!("#{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
-            hash_conditions.merge!(condition_from_association_constraint(column.association, v))
-
-          # regular column constraints
-          elsif column.searchable? && params[column.name] != v
-            active_scaffold_includes.concat column.includes
-            conditions << [column.search_sql.collect { |search_sql| "#{search_sql} = ?" }.join(' OR '), *([v] * column.search_sql.size)]
-          end
-        # unknown-to-activescaffold-but-real-database-column constraint
-        elsif active_scaffold_config.model.columns_hash[k.to_s] && params[column.name] != v
-          hash_conditions.merge!(k => v)
-        else
-          raise ActiveScaffold::MalformedConstraint, constraint_error(active_scaffold_config.model, k), caller
-        end
-      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 = {"#{table}.#{field}" => value}
-      if association.options[:polymorphic]
-        raise ActiveScaffold::MalformedConstraint, polymorphic_constraint_error(association), caller unless params[:parent_model]
-        condition["#{table}.#{association.name}_type"] = params[:parent_model].constantize.model.to_s
-      end
-
-      condition
-    end
-
-    def polymorphic_constraint_error(association)
-      "Malformed constraint. You have added a constraint for #{association.name} polymorphic association but parent_model is not set."
-    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]
-            raise ActiveScaffold::MalformedConstraint, polymorphic_constraint_error(column.association), caller unless params[:parent_model]
-            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
-  end
-end

data/lib/active_scaffold/data_structures/action_columns.rb

@@ -1,142 +0,0 @@
-module ActiveScaffold::DataStructures
-  # A set of columns. These structures can be nested for organization.
-  class ActionColumns < ActiveScaffold::DataStructures::Set
-    include ActiveScaffold::Configurable
-
-    # this lets us refer back to the action responsible for this link, if it exists.
-    # the immediate need here is to get the crud_type so we can dynamically filter columns from the set.
-    attr_accessor :action
-
-    # labels are useful for the Create/Update forms, when we display columns in a grouped fashion and want to name them separately
-    attr_writer :label
-    def label
-      as_(@label) if @label
-    end
-    def css_class
-      @label.to_s.underscore
-    end
-
-    # Whether this column set is collapsed by default in contexts where collapsing is supported
-    attr_accessor :collapsed
-    
-    # nests a subgroup in the column set
-    def add_subgroup(label, &proc)
-      columns = ActiveScaffold::DataStructures::ActionColumns.new
-      columns.label = label
-      columns.action = self.action
-      columns.configure &proc
-      self.exclude columns.collect_columns
-      self.add columns
-    end
-
-    def include?(item)
-      @set.each do |c|
-        return true if !c.is_a? Symbol and c.include? item
-        return true if c == item.to_sym
-      end
-      return false
-    end
-
-    def names
-      if @columns
-        self.collect(&:name)
-      else
-        names_without_auth_check
-      end
-    end
-
-    def names_without_auth_check
-      Array(@set)
-    end
-
-    # A package of stuff to add after the configuration block. This is an attempt at making a certain level of functionality inaccessible during configuration, to reduce possible breakage from misuse.
-    # The bulk of the package is a means of connecting the referential column set (ActionColumns) with the actual column objects (Columns). This lets us iterate over the set and yield real column objects.
-    #module AfterConfiguration
-      # Redefine the each method to yield actual Column objects.
-      # It will skip constrained and unauthorized columns.
-      #
-      # Options:
-      #  * :flatten - whether to recursively iterate on nested sets. default is false.
-      #  * :for - the record (or class) being iterated over. used for column-level security. default is the class.
-      def each(options = {}, &proc)
-        options[:for] ||= @columns.active_record_class unless @columns.nil?
-        self.unauthorized_columns = []
-        @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)
-          end
-          if item.is_a? ActiveScaffold::DataStructures::ActionColumns and options.has_key?(:flatten) and options[:flatten]
-            item.each(options, &proc)
-          else
-            yield item
-          end
-        end
-      end
-      
-      def collect_visible(options = {}, &proc)
-        columns = []
-        options[:for] ||= @columns.active_record_class
-        self.unauthorized_columns = []
-        @set.each do |item|
-          unless item.is_a? ActiveScaffold::DataStructures::ActionColumns
-            item = (@columns[item] || ActiveScaffold::DataStructures::Column.new(item.to_sym, @columns.active_record_class))
-            next if self.skip_column?(item, options)
-          end
-          if item.is_a? ActiveScaffold::DataStructures::ActionColumns and options.has_key?(:flatten) and options[:flatten]
-            columns = columns + item.collect(options, &proc)
-          else
-            columns << item
-          end
-        end
-        columns
-      end      
-      
-      def skip_column?(column, options)
-        result = false
-        # skip if this matches a constrained column
-        result = true if constraint_columns.include?(column.name.to_sym)
-        # skip this field if it's not authorized
-        unless options[:for].authorized_for?(:action => options[:action], :crud_type => options[:crud_type] || self.action.crud_type, :column => column.name)
-          self.unauthorized_columns << column.name.to_sym
-          result = true
-        end
-        return result
-      end
-
-      # registers a set of column objects (recursively, for all nested ActionColumns)
-      def set_columns(columns)
-        @columns = columns
-        # iterate over @set instead of self to avoid dealing with security queries
-        @set.each do |item|
-          item.set_columns(columns) if item.respond_to? :set_columns
-        end
-      end
-
-      attr_writer :constraint_columns
-      def constraint_columns
-        @constraint_columns ||= []
-      end
-      
-      attr_writer :unauthorized_columns
-      def unauthorized_columns
-        @unauthorized_columns ||= []
-      end
-      
-      def length
-        ((@set - self.constraint_columns) - self.unauthorized_columns).length
-      end
-    #end
-
-    protected
-
-    def collect_columns
-      @set.collect {|col| col.is_a?(ActiveScaffold::DataStructures::ActionColumns) ? col.collect_columns : col}
-    end
-
-    # called during clone or dup. makes the clone/dup deeper.
-    def initialize_copy(from)
-      @set = from.instance_variable_get('@set').clone
-    end
-  end
-end