brisk-bills 0.7.0 → 0.8.1

data/vendor/plugins/active_scaffold/lib/active_scaffold/config/search.rb

@@ -3,9 +3,10 @@ module ActiveScaffold::Config
     self.crud_type = :read
 
     def initialize(core_config)
-      @core = core_config
-
-      @full_text_search = self.class.full_text_search?
+      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
@@ -16,13 +17,22 @@ module ActiveScaffold::Config
     # --------------------------
     # the ActionLink for this action
     cattr_accessor :link
-    @@link = ActiveScaffold::DataStructures::ActionLink.new('show_search', :label => :search, :type => :table, :security_method => :search_authorized?)
+    @@link = ActiveScaffold::DataStructures::ActionLink.new('show_search', :label => :search, :type => :collection, :security_method => :search_authorized?)
+
+    # 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
 
-    cattr_writer :full_text_search
-    def self.full_text_search?
-      @@full_text_search
+    # whether submits the search as you type
+    cattr_writer :live
+    def self.live?
+      @@live
     end
-    @@full_text_search = true
 
     # instance-level configuration
     # ----------------------------
@@ -36,17 +46,27 @@ module ActiveScaffold::Config
       @columns
     end
 
-    def columns=(val)
-      @columns = ActiveScaffold::DataStructures::ActionColumns.new(*val)
-      @columns.action = self
-    end
+    public :columns=
 
-    attr_writer :full_text_search
-    def full_text_search?
-      @full_text_search
-    end
+    # 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/vendor/plugins/active_scaffold/lib/active_scaffold/config/show.rb

@@ -3,37 +3,30 @@ module ActiveScaffold::Config
     self.crud_type = :read
 
     def initialize(core_config)
-      @core = core_config
-
+      super
       # start with the ActionLink defined globally
       @link = self.class.link.clone
+      @label = :show_model
     end
 
     # global level configuration
     # --------------------------
     cattr_accessor :link
-    @@link = ActiveScaffold::DataStructures::ActionLink.new('show', :label => :show, :type => :record, :security_method => :show_authorized?)
-
+    @@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
-    def label
-      @label ? as_(@label) : as_(:show_model, :model => @core.label(:count => 1))
-    end
 
     # 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
-    def columns=(val)
-      @columns = ActiveScaffold::DataStructures::ActionColumns.new(*val)
-      @columns.action = self
-    end
+    
+    public :columns=
   end
 end

data/vendor/plugins/active_scaffold/lib/active_scaffold/config/subform.rb

@@ -1,15 +1,21 @@
 module ActiveScaffold::Config
   class Subform < Base
     def initialize(core_config)
-      @core = 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"
@@ -24,10 +30,6 @@ module ActiveScaffold::Config
       @columns
     end
 
-    def columns=(val)
-      @columns = ActiveScaffold::DataStructures::ActionColumns.new(*val)
-      @columns.action = self
-      return @columns
-    end
+    public :columns=
   end
 end

data/vendor/plugins/active_scaffold/lib/active_scaffold/config/update.rb

@@ -1,9 +1,11 @@
 module ActiveScaffold::Config
-  class Update < Form
+  class Update < ActiveScaffold::Config::Form
     self.crud_type = :update
-    def initialize(*args)
+    def initialize(core_config)
       super
       self.nested_links = self.class.nested_links
+      self.persistent = self.class.persistent
+      @label = :update_model
     end
 
     # global level configuration
@@ -15,18 +17,20 @@ module ActiveScaffold::Config
     def self.link=(val)
       @@link = val
     end
-    @@link = ActiveScaffold::DataStructures::ActionLink.new('edit', :label => :edit, :type => :record, :security_method => :update_authorized?)
+    @@link = ActiveScaffold::DataStructures::ActionLink.new('edit', :label => :edit, :type => :member, :security_method => :update_authorized?)
 
+    # whether the form stays open after an update or not
+    cattr_accessor :persistent
+    @@persistent = false
+    
     # instance-level configuration
     # ----------------------------
 
-    # the label= method already exists in the Form base class
-    def label
-      @label ? as_(@label) : as_(:update_model, :model => @core.label(:count => 1))
-    end
-
     attr_accessor :nested_links
     cattr_accessor :nested_links
     @@nested_links = false
+    
+    # whether the form stays open after an update or not
+    attr_accessor :persistent
   end
 end

data/vendor/plugins/active_scaffold/lib/active_scaffold/configurable.rb

@@ -8,7 +8,7 @@ module ActiveScaffold
     def configure(&configuration_block)
       return unless configuration_block
       @configuration_binding = configuration_block.binding
-      ret = instance_eval &configuration_block
+      ret = instance_exec self, &configuration_block
       @configuration_binding = nil
       return ret
     end
@@ -26,4 +26,4 @@ module ActiveScaffold
       end
     end
   end
-end
+end

data/vendor/plugins/active_scaffold/lib/active_scaffold/constraints.rb

@@ -1,178 +1,173 @@
-module ActiveScaffold
-  module Constraints
-    def self.included(base)
-      base.module_eval do
-        before_filter :register_constraints_with_action_columns
-      end
-    end
-
-    protected
-
-    # Returns the current constraints
-    def active_scaffold_constraints
-      return 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 = active_scaffold_constraints.reject{|k, v| v.is_a? Hash}.keys.collect{|k| k.to_sym}
-
-      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|
-          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 = column.association.klass.reflect_on_association(v.keys.first)
-            field = far_association.klass.primary_key
-            table = far_association.table_name
-
-            active_scaffold_joins.concat([{k => v.keys.first}]) # e.g. {:den => :park}
-            constraint_condition_for("#{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_joins.concat column.includes
-            end
-            condition_from_association_constraint(column.association, v)
-
-          # regular column constraints
-          elsif column.searchable?
-            active_scaffold_joins.concat column.includes
-            constraint_condition_for(column.search_sql, v)
-          end
-        # unknown-to-activescaffold-but-real-database-column constraint
-        elsif active_scaffold_config.model.column_names.include? k.to_s
-          constraint_condition_for(k.to_s, 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 [:has_one, :has_many].include?(association.macro)
-        association.klass.primary_key
-      else
-        association.options[:association_foreign_key] || association.options[:foreign_key] || association.association_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
-
-        when :has_many
-        association.table_name
-
-        else
-        association.table_name
-      end
-
-      condition = constraint_condition_for("#{table}.#{field}", value)
-      if association.options[:polymorphic]
-        condition = merge_conditions(
-          condition,
-          constraint_condition_for("#{table}.#{association.name}_type", params[:parent_model].to_s)
-        )
-      end
-
-      condition
-    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 v.is_a? Hash # reverse of a through association ... we need to set the far association
-            # example
-            #   data model: Park -> Den -> Bear
-            #   constraint: :den => {:park => 5}
-            #   remote_klass: Park
-            remote_klass = column.association.klass.reflect_on_association(v.keys.first).klass
-            first_associated = record.send("#{k}")
-            first_associated.send("#{v.keys.first}=", remote_klass.find(v.values.first)) if first_associated
-          elsif column.plural_association?
-            record.send("#{k}").send(:<<, column.association.klass.find(v))
-          elsif column.association.options[:polymorphic]
-            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
-
-    private
-
-    def constraint_condition_for(sql, value)
-      value.nil? ? "#{sql} IS NULL" : ["#{sql} = ?", value]
-    end
-  end
-end
+module ActiveScaffold
+  module Constraints
+    def self.included(base)
+      base.module_eval do
+        before_filter :register_constraints_with_action_columns
+      end
+    end
+
+    protected
+
+    # Returns the current constraints
+    def active_scaffold_constraints
+      return 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 = active_scaffold_constraints.reject{|k, v| v.is_a? Hash}.keys.collect{|k| k.to_sym}
+
+      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|
+          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 = 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 => v.keys.first}]) # e.g. {:den => :park}
+            constraint_condition_for("#{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
+            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.column_names.include? k.to_s
+          constraint_condition_for(k.to_s, 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 [: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 = constraint_condition_for("#{table}.#{field}", value)
+      if association.options[:polymorphic]
+        condition = merge_conditions(
+          condition,
+          constraint_condition_for("#{table}.#{association.name}_type", params[:parent_model].to_s)
+        )
+      end
+
+      condition
+    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]
+            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
+
+    private
+
+    def constraint_condition_for(sql, value)
+      value.nil? ? "#{sql} IS NULL" : ["#{sql} = ?", value]
+    end
+  end
+end