active_scaffold-sequel 0.3.0

data/lib/active_scaffold/config/search.rb

@@ -0,0 +1,73 @@
+module ActiveScaffold::Config
+  class Search < Base
+    self.crud_type = :read
+
+    def initialize(core_config)
+      super
+      @text_search = self.class.text_search
+      @live = self.class.live?
+      @split_terms = self.class.split_terms
+
+      # start with the ActionLink defined globally
+      @link = self.class.link.clone
+      @action_group = self.class.action_group.clone if self.class.action_group
+    end
+
+
+    # global level configuration
+    # --------------------------
+    # the ActionLink for this action
+    cattr_accessor :link
+    @@link = ActiveScaffold::DataStructures::ActionLink.new('show_search', :label => :search, :type => :collection, :security_method => :search_authorized?, :ignore_method => :search_ignore?)
+
+    # A flag for how the search should do full-text searching in the database:
+    # * :full: LIKE %?%
+    # * :start: LIKE ?%
+    # * :end: LIKE %?
+    # * false: LIKE ?
+    # Default is :full
+    cattr_accessor :text_search
+    @@text_search = :full
+
+    # whether submits the search as you type
+    cattr_writer :live
+    def self.live?
+      @@live
+    end
+
+    # instance-level configuration
+    # ----------------------------
+
+    # provides access to the list of columns specifically meant for the Search to use
+    def columns
+      # we want to delay initializing to the @core.columns set for as long as possible. Too soon and .search_sql will not be available to .searchable?
+      unless @columns
+        self.columns = @core.columns.collect{|c| c.name if @core.columns._inheritable.include?(c.name) and c.searchable? and c.column and c.column[:type] == :string}.compact
+      end
+      @columns
+    end
+
+    public :columns=
+
+    # A flag for how the search should do full-text searching in the database:
+    # * :full: LIKE %?%
+    # * :start: LIKE ?%
+    # * :end: LIKE %?
+    # * false: LIKE ?
+    # Default is :full
+    attr_accessor :text_search
+
+    @@split_terms = " "
+    cattr_accessor :split_terms
+    attr_accessor :split_terms
+
+    # the ActionLink for this action
+    attr_accessor :link
+
+    # whether submits the search as you type
+    attr_writer :live
+    def live?
+      @live
+    end
+  end
+end

data/lib/active_scaffold/config/show.rb

@@ -0,0 +1,32 @@
+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
+      @action_group = self.class.action_group.clone if self.class.action_group
+    end
+
+    # global level configuration
+    # --------------------------
+    cattr_accessor :link
+    @@link = ActiveScaffold::DataStructures::ActionLink.new('show', :label => :show, :type => :member, :security_method => :show_authorized?)
+    # 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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,41 @@
+module ActiveScaffold::Config
+  class Update < ActiveScaffold::Config::Form
+    self.crud_type = :update
+    def initialize(core_config)
+      super
+      self.nested_links = self.class.nested_links
+      self.refresh_list = self.class.refresh_list
+    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?)
+
+    # whether we should refresh list after update or not
+    cattr_accessor :refresh_list
+    @@refresh_list = false
+
+    # 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
+
+    # whether we should refresh list after update or not
+    attr_accessor :refresh_list
+ 
+  end
+end

data/lib/active_scaffold/configurable.rb

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,170 @@
+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.association_reflections.each do |name,association|
+        associations_by_params[association[:class_name].foreign_key] = association[:name]
+      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 = [])
+      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
+      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_klass = column.association.associated_class.association_reflection(v.keys.first).associated_class
+            field = far_association_klass.primary_key
+            table = far_association_klass.table_name
+
+            active_scaffold_includes.concat([{k => v.keys.first}]) # e.g. {:den => :park}
+            constraint_condition_for("#{table}__#{field}".to_sym, v.values.first)
+
+          # association column constraint
+          elsif column.association
+            if column.association[:type] == :many_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.columns.include? k
+          constraint_condition_for(k, 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 [:one_to_one, :one_to_many].include?(association[:type])
+        association.associated_class.primary_key
+      elsif [:many_to_many].include?(association[:type])
+        association[:class_name].foreign_key
+      else
+        association[:name].to_s.foreign_key
+      end
+
+      table = case association[:type]
+        when :many_to_many
+        association[:join_table]
+
+        when :many_to_one
+        active_scaffold_config.model.table_name
+
+        else
+        association.associated_class.table_name
+      end
+
+# XXX no idea what this is supposed to do, in my setup are all association.options[:primary_key] nils
+#      if association.options[:primary_key]
+#        value = association.klass.find(value).send(association.options[:primary_key])
+#      end
+
+      constraint_condition_for("#{table}__#{field}".to_sym, value)
+    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("add_#{k.to_s.singularize}", column.association.associated_class.filter(v))
+          else # regular singular association
+            record.send("#{k}=", column.association.associated_class.filter(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.associated_class.association_reflection(column.association.reciprocal)
+            if reverse[:type] == :one_to_one and options[:allow_autosave]
+              record.send(k).send("#{column.association.reciprocal}=", record)
+            end
+          end
+        else
+          record.send("#{k}=", v)
+        end
+      end
+    end
+
+    private
+
+    def constraint_condition_for(sql, value)
+      {sql => value}
+    end
+  end
+end

data/lib/active_scaffold/data_structures/action_columns.rb

@@ -0,0 +1,140 @@
+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
+      self.collect(&:name)
+    end
+
+    def names_without_auth_check
+      Array(@set)
+    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
+
+    # 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
+        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]
+            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)
+        # skip if this matches the field_name of a constrained column
+        result = true if column.field_name and constraint_columns.include?(column.field_name)
+        # 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
+          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
+  end
+end