brisk-bills 0.7.0 → 0.8.1

data/vendor/plugins/active_scaffold/lib/active_scaffold/data_structures/action_columns.rb

@@ -1,97 +1,101 @@
-module ActiveScaffold::DataStructures
-  # A set of columns. These structures can be nested for organization.
-  class ActionColumns < 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
-
-    # 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
-
-    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
-
-        @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))
-            # skip if this matches a constrained column
-            next if constraint_columns.include?(item.name.to_sym)
-            # skip if this matches the field_name of a constrained column
-            next if item.field_name and constraint_columns.include?(item.field_name.to_sym)
-            # skip this field if it's not authorized
-            next unless options[:for].authorized_for?(:action => options[:action] || self.action.crud_type, :column => item.name)
-          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
-
-      # 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
-      
-      def length
-        (@set - self.constraint_columns).length
-      end
-    end
-  end
-end
+module ActiveScaffold::DataStructures
+  # A set of columns. These structures can be nested for organization.
+  class ActionColumns < 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
+
+    # 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
+
+    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
+
+        @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))
+            # skip if this matches a constrained column
+            next if constraint_columns.include?(item.name.to_sym)
+            # skip if this matches the field_name of a constrained column
+            next if item.field_name and constraint_columns.include?(item.field_name.to_sym)
+            # skip this field if it's not authorized
+            next unless options[:for].authorized_for?(:action => options[:action], :crud_type => options[:crud_type] || self.action.crud_type, :column => item.name)
+          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
+
+      # 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
+      
+      def length
+        (@set - self.constraint_columns).length
+      end
+    end
+  end
+end

data/vendor/plugins/active_scaffold/lib/active_scaffold/data_structures/action_link.rb

@@ -6,13 +6,14 @@ module ActiveScaffold::DataStructures
       self.action = action.to_s
       self.label = action
       self.confirm = false
-      self.type = :table
+      self.type = :collection
       self.inline = true
       self.method = :get
-      self.crud_type = :destroy if [:destroy].include?(action.to_sym)
+      self.crud_type = :delete if [:destroy].include?(action.to_sym)
       self.crud_type = :create if [:create, :new].include?(action.to_sym)
       self.crud_type = :update if [:edit, :update].include?(action.to_sym)
       self.crud_type ||= :read
+      self.parameters = {}
       self.html_options = {}
 
       # apply quick properties
@@ -41,33 +42,41 @@ module ActiveScaffold::DataStructures
     end
 
     # if the action requires confirmation
-    attr_writer :confirm
-    def confirm
-      @confirm.is_a?(String) ? as_(@confirm) : @confirm
+    def confirm=(value)
+      @dhtml_confirm = nil if value
+      @confirm = value
+    end
+    def confirm(label = '')
+      @confirm.is_a?(String) ? @confirm : as_(@confirm, :label => label)
     end
     def confirm?
-      @confirm ? true : false
+      !!@confirm
     end
     
     # if the action uses a DHTML based (i.e. 2-phase) confirmation
-    attr_writer :dhtml_confirm
-    def dhtml_confirm
-      @dhtml_confirm
+    attr_accessor :dhtml_confirm
+    def dhtml_confirm=(value)
+      @confirm = nil if value
+      @dhtml_confirm = value
     end
     def dhtml_confirm?
-      @dhtml_confirm
+      !!@dhtml_confirm
     end
 
     # what method to call on the controller to see if this action_link should be visible
     # note that this is only the UI part of the security. to prevent URL hax0rz, you also need security on requests (e.g. don't execute update method unless authorized).
     attr_writer :security_method
     def security_method
-      @security_method || "#{self.label.underscore.downcase.gsub(/ /, '_')}_authorized?"
+      @security_method || "#{self.action}_authorized?"
+    end
+
+    def security_method_set?
+      !!@security_method
     end
 
     # the crud type of the (eventual?) action. different than :method, because this crud action may not be imminent.
-    # this is used to determine record-level authorization (e.g. record.authorized_for?(:action => link.crud_type).
-    # options are :create, :read, :update, and :destroy
+    # this is used to determine record-level authorization (e.g. record.authorized_for?(:crud_type => link.crud_type).
+    # options are :create, :read, :update, and :delete
     attr_accessor :crud_type
 
     # an "inline" link is inserted into the existing page
@@ -110,12 +119,12 @@ module ActiveScaffold::DataStructures
     def page?; @page end
 
     # where the result of this action should insert in the display.
-    # for :type => :table, supported values are:
+    # for :type => :collection, supported values are:
     #   :top
     #   :bottom
     #   :replace (for updating the entire table)
     #   false (no attempt at positioning)
-    # for :type => :record, supported values are:
+    # for :type => :member, supported values are:
     #   :before
     #   :replace
     #   :after
@@ -123,14 +132,15 @@ module ActiveScaffold::DataStructures
     attr_writer :position
     def position
       return @position unless @position.nil? or @position == true
-      return :replace if self.type == :record
-      return :top if self.type == :table
+      return :replace if self.type == :member
+      return :top if self.type == :collection
       raise "what should the default position be for #{self.type}?"
     end
 
-    # what type of link this is. currently supported values are :table and :record.
+    # what type of link this is. currently supported values are :collection and :member.
     attr_accessor :type
+
     # html options for the link
     attr_accessor :html_options
   end
-end
+end

data/vendor/plugins/active_scaffold/lib/active_scaffold/data_structures/column.rb

@@ -8,10 +8,17 @@ module ActiveScaffold::DataStructures
     attr_accessor :name
 
     # Whether to enable inplace editing for this column. Currently works for text columns, in the List.
-    attr_accessor :inplace_edit
+    attr_reader :inplace_edit
+    def inplace_edit=(value)
+      self.clear_link if value
+      @inplace_edit = value
+    end
 
     # Whether this column set is collapsed by default in contexts where collapsing is supported
     attr_accessor :collapsed
+
+    # Whether to enable add_existing for this column
+    attr_accessor :allow_add_existing
     
     # Any extra parameters this particular column uses.  This is for create/update purposes.
     def params
@@ -29,7 +36,11 @@ module ActiveScaffold::DataStructures
     # a textual description of the column and its contents. this will be displayed with any associated form input widget, so you may want to consider adding a content example.
     attr_writer :description
     def description
-      @description.is_a?(Symbol) ? as_(@description, {:scope => [:activerecord, :attributes, active_record_class.to_s.underscore.to_sym]}) : as_(@description) if @description
+      if @description
+        @description
+      else
+        I18n.t name, :scope => [:activerecord, :description, active_record_class.to_s.underscore.to_sym], :default => ''
+      end
     end
 
     # this will be /joined/ to the :name for the td's class attribute. useful if you want to style columns on different ActiveScaffolds the same way, but the columns have different names.
@@ -42,6 +53,13 @@ module ActiveScaffold::DataStructures
       @required
     end
 
+    # column to be updated in a form when this column changes
+    attr_accessor :update_column
+
+    # send all the form instead of only new value when this column change
+    cattr_accessor :send_form_on_update_column
+    attr_accessor :send_form_on_update_column
+
     # sorting on a column can be configured four ways:
     #   sort = true               default, uses intelligent sorting sql default
     #   sort = false              sometimes sorting doesn't make sense
@@ -85,28 +103,27 @@ module ActiveScaffold::DataStructures
 
     attr_writer :search_ui
     def search_ui
-      @search_ui || @form_ui
-    end
-
-    # DEPRECATED
-    alias :ui_type :form_ui
-    def ui_type=(val)
-      ::ActiveSupport::Deprecation.warn("config.columns[:#{name}].ui_type will disappear in version 2.0. Please use config.columns[:#{name}].form_ui instead.", caller)
-      self.form_ui = val
+      @search_ui || @form_ui || (@association && !polymorphic_association? ? :select : nil)
     end
 
     # a place to store dev's column specific options
     attr_accessor :options
     def options
-      @options || {}
+      @options ||= {}
     end
 
     # associate an action_link with this column
     attr_reader :link
 
+    # set an action_link to nested list or inline form in this column
+    def autolink?
+      @autolink and self.association.reverse
+    end
+
     # this should not only delete any existing link but also prevent column links from being automatically added by later routines
     def clear_link
-      @link = false
+      @link = nil
+      @autolink = false
     end
 
     def set_link(action, options = {})
@@ -115,7 +132,7 @@ module ActiveScaffold::DataStructures
       else
         options[:label] ||= self.label
         options[:position] ||= :after unless options.has_key?(:position)
-        options[:type] ||= :record
+        options[:type] ||= :member
         @link = ActiveScaffold::DataStructures::ActionLink.new(action, options)
       end
     end
@@ -134,6 +151,9 @@ module ActiveScaffold::DataStructures
       @includes = value.is_a?(Array) ? value : [value] # automatically convert to an array
     end
 
+    # a collection of columns to load when eager loading is disabled, if it's nil all columns will be loaded
+    attr_accessor :select_columns
+
     # describes how to search on a column
     #   search = true           default, uses intelligent search sql
     #   search = "CONCAT(a, b)" define your own sql for searching. this should be the "left-side" of a WHERE condition. the operator and value will be supplied by ActiveScaffold.
@@ -165,7 +185,13 @@ module ActiveScaffold::DataStructures
     # whether a blank row must be shown in the subform
     cattr_accessor :show_blank_record
     @@show_blank_record = true
-    attr_accessor :show_blank_record
+    attr_writer :show_blank_record
+    def show_blank_record?(associated)
+      if @show_blank_record
+        return false unless self.association.klass.authorized_for?(:crud_type => :create)
+        self.plural_association? or (self.singular_association? and associated.blank?)
+      end
+    end
 
     # methods for automatic links in singular association columns
     cattr_accessor :actions_for_association_links
@@ -218,27 +244,22 @@ module ActiveScaffold::DataStructures
       self.name = name.to_sym
       @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
       @weight = 0
       @associated_limit = self.class.associated_limit
       @associated_number = self.class.associated_number
       @show_blank_record = self.class.show_blank_record
-      @actions_for_association_links = self.class.actions_for_association_links if @association
+      @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
+      @options = {:format => :i18n_number} if @column.try(:number?)
+      @form_ui = :checkbox if @column and @column.type == :boolean and !@column.null
+      @allow_add_existing = true
 
       # default all the configurable variables
       self.css_class = ''
-      if active_record_class.respond_to? :reflect_on_validations_for
-        column_names = [name]
-        column_names << @association.primary_key_name if @association
-        self.required = column_names.any? do |column_name|
-          active_record_class.reflect_on_validations_for(column_name.to_sym).any? do |val|
-            val.macro == :validates_presence_of or (val.macro == :validates_inclusion_of and not val.options[:allow_nil] and not val.options[:allow_blank])
-          end
-        end
-      else
-        self.required = false
-      end
+      self.required = false
       self.sort = true
       self.search_sql = true
 
@@ -256,6 +277,26 @@ module ActiveScaffold::DataStructures
       order_weight != 0 ? order_weight : self.name.to_s <=> other_column.name.to_s
     end
 
+    def number_to_native(value)
+      return value if value.blank? || !value.is_a?(String)
+      native = '.' # native ruby separator
+      format = {:separator => '', :delimiter => ''}.merge! I18n.t('number.format', :default => {})
+      specific = case self.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)
+      end
+      format.merge! specific unless specific.nil?
+      unless format[:separator].blank? || !value.include?(format[:separator]) && value.include?(native) && (format[:delimiter] != native || value !~ /\.\d{3}$/)
+        value.gsub(/[^0-9\-#{format[:separator]}]/, '').gsub(format[:separator], native)
+      else
+        value
+      end
+    end
+
     protected
 
     def initialize_sort
@@ -274,14 +315,13 @@ module ActiveScaffold::DataStructures
     end
 
     def initialize_search_sql
-      if self.virtual?
-        self.search_sql = nil
-      else
+      self.search_sql = unless self.virtual?
         if association.nil?
-          self.search_sql = self.field.to_s
-        else
-          # with associations we really don't know what to sort by without developer intervention. we could sort on the primary key ('id'), but that's hardly useful. previously ActiveScaffold would try and search using the same sql as from :sort, but we decided to just punt.
-          self.search_sql = nil
+          self.field.to_s
+        elsif !self.polymorphic_association?
+          [association.klass.table_name, association.klass.primary_key].collect! do |str|
+            association.klass.connection.quote_column_name str
+          end.join('.')
         end
       end
     end
@@ -291,7 +331,7 @@ module ActiveScaffold::DataStructures
 
     # the table.field name for this column, if applicable
     def field
-      @field ||= [@table, field_name].join('.')
+      @field ||= [@active_record_class.connection.quote_table_name(@table), field_name].join('.')
     end
   end
 end