six-updater-web 0.10.8 → 0.11.1

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

@@ -0,0 +1,140 @@
+module ActiveScaffold::DataStructures
+  class ActionLink
+    # provides a quick way to set any property of the object from a hash
+    def initialize(action, options = {})
+      # set defaults
+      self.action = action.to_s
+      self.label = action
+      self.confirm = false
+      self.type = :table
+      self.inline = true
+      self.method = :get
+      self.crud_type = :destroy 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.html_options = {}
+
+      # apply quick properties
+      options.each_pair do |k, v|
+        setter = "#{k}="
+        self.send(setter, v) if self.respond_to? setter
+      end
+    end
+
+    # the action-path for this link. what page to request? this is required!
+    attr_accessor :action
+    
+    # the controller for this action link. if nil, the current controller should be assumed.
+    attr_accessor :controller
+
+    # a hash of request parameters
+    attr_accessor :parameters
+
+    # the RESTful method
+    attr_accessor :method
+
+    # what string to use to represent this action
+    attr_writer :label
+    def label
+      @label.is_a?(Symbol) ? as_(@label) : @label
+    end
+
+    # if the action requires confirmation
+    attr_writer :confirm
+    def confirm
+      @confirm.is_a?(String) ? as_(@confirm) : @confirm
+    end
+    def confirm?
+      @confirm ? true : false
+    end
+    
+    # if the action uses a DHTML based (i.e. 2-phase) confirmation
+    attr_writer :dhtml_confirm
+    def dhtml_confirm
+      @dhtml_confirm
+    end
+    def 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?"
+    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
+    attr_accessor :crud_type
+
+    # an "inline" link is inserted into the existing page
+    # exclusive with popup? and page?
+    def inline=(val)
+      @inline = (val == true)
+      self.popup = self.page = false if @inline
+    end
+    def inline?; @inline end
+
+    # a "popup" link displays in a separate (browser?) window. this will eventually take arguments.
+    # exclusive with inline? and page?
+    def popup=(val)
+      @popup = (val == true)
+      if @popup
+        self.inline = self.page = false
+
+        # the :method parameter doesn't mix with the :popup parameter
+        # when/if we start using DHTML popups, we can bring :method back
+        self.method = nil
+      end
+    end
+    def popup?; @popup end
+
+    # a "page" link displays by reloading the current page
+    # exclusive with inline? and popup?
+    def page=(val)
+      @page = (val == true)
+      if @page
+        self.inline = self.popup = false
+
+        # when :method is defined, ActionView adds an onclick to use a form ...
+        # so it's best to just empty out :method whenever possible.
+        # we only ever need to know @method = :get for things that default to POST.
+        # the only things that default to POST are forms and ajax calls.
+        # when @page = true, we don't use ajax.
+        self.method = nil if method == :get
+      end
+    end
+    def page?; @page end
+
+    # where the result of this action should insert in the display.
+    # for :type => :table, supported values are:
+    #   :top
+    #   :bottom
+    #   :replace (for updating the entire table)
+    #   false (no attempt at positioning)
+    # for :type => :record, supported values are:
+    #   :before
+    #   :replace
+    #   :after
+    #   false (no attempt at positioning)
+    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
+      raise "what should the default position be for #{self.type}?"
+    end
+
+    # what type of link this is. currently supported values are :table and :record.
+    attr_accessor :type
+    # html options for the link
+    attr_accessor :html_options
+  end
+end

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

@@ -0,0 +1,47 @@
+module ActiveScaffold::DataStructures
+  class ActionLinks
+    include Enumerable
+
+    def initialize
+      @set = []
+    end
+
+    # adds an ActionLink, creating one from the arguments if need be
+    def add(action, options = {})
+      link = action.is_a?(ActiveScaffold::DataStructures::ActionLink) ? action : ActiveScaffold::DataStructures::ActionLink.new(action, options)
+      # NOTE: this duplicate check should be done by defining the comparison operator for an Action data structure
+      @set << link unless @set.any? {|a| a.action == link.action and a.controller == link.controller and a.parameters == link.parameters}
+    end
+    alias_method :<<, :add
+
+    # finds an ActionLink by matching the action
+    def [](val)
+      @set.find {|item| item.action == val.to_s}
+    end
+
+    def delete(val)
+      @set.delete_if{|item| item.action == val.to_s}
+    end
+
+    # iterates over the links, possibly by type
+    def each(type = nil)
+      type = type.to_sym if type
+      @set.each {|item|
+        next if type and item.type != type
+        yield item
+      }
+    end
+
+    def empty?
+      @set.size == 0
+    end
+
+    protected
+
+    # called during clone or dup. makes the clone/dup deeper.
+    def initialize_copy(from)
+      @set = []
+      from.instance_variable_get('@set').each { |link| @set << link.clone }
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+class ActiveScaffold::DataStructures::Actions
+  include Enumerable
+
+  def initialize(*args)
+    @set = []
+    self.add *args
+  end
+
+  def exclude(*args)
+    args.collect! { |a| a.to_sym } # symbolize the args
+    @set.reject! { |m| args.include? m } # reject all actions specified
+  end
+
+  def add(*args)
+    args.each { |arg| @set << arg.to_sym unless @set.include? arg.to_sym }
+  end
+  alias_method :<<, :add
+
+  def each
+    @set.each {|item| yield item}
+  end
+
+  def include?(val)
+    super val.to_sym
+  end
+
+  # swaps one element in the list with the other.
+  # accepts arguments in any order. it just figures out which one is in the list and which one is not.
+  def swap(one, two)
+    if include? one
+      exclude one
+      add two
+    else
+      exclude two
+      add one
+    end
+  end
+
+  protected
+
+  # called during clone or dup. makes the clone/dup deeper.
+  def initialize_copy(from)
+    @set = from.instance_variable_get('@set').clone
+  end
+end

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

@@ -0,0 +1,343 @@
+module ActiveScaffold::DataStructures
+  class Column
+    include ActiveScaffold::Configurable
+
+    attr_reader :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
+
+    # Whether to enable inplace editing for this column. Currently works for text columns, in the List.
+    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
+    
+    # AST allow_add_existing
+    # Whether to enable add_existing for this column
+    attr_accessor :allow_add_existing
+    @allow_add_existing = true
+    
+    # Any extra parameters this particular column uses.  This is for create/update purposes.
+    def params
+      # lazy initialize
+      @params ||= Set.new
+    end
+    
+    # the display-name of the column. this will be used, for instance, as the column title in the table and as the field name in the form.
+    # if left alone it will utilize human_attribute_name which includes localization for :scope => [:activerecord, :attributes]
+    attr_writer :label
+    # AST - still figuring out just exactly how to do this
+    def label(options = {:count => 1})
+      # as_(@label, options)# || active_record_class.human_attribute_name(name.to_s)
+      as_(@label) || active_record_class.human_attribute_name(name.to_s)
+    end
+
+    # 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
+      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.
+    attr_accessor :css_class
+
+    # whether the field is required or not. used on the form for visually indicating the fact to the user.
+    # TODO: move into predicate
+    attr_writer :required
+    def required?
+      @required
+    end
+
+    # 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
+    #   sort = {:sql => ""}       define your own sql for sorting. this should be result in a sortable value in SQL. ActiveScaffold will handle the ascending/descending.
+    #   sort = {:method => ""}    define ruby-side code for sorting. this is SLOW with large recordsets!
+    def sort=(value)
+      if value.is_a? Hash
+        value.assert_valid_keys(:sql, :method)
+        @sort = value
+      else
+        @sort = value ? true : false # force true or false
+      end
+    end
+
+    def sort
+      self.initialize_sort if @sort === true
+      @sort
+    end
+
+    def sortable?
+      sort != false && !sort.nil?
+    end
+
+    # a configuration helper for the self.sort property. simply provides a method syntax instead of setter syntax.
+    def sort_by(options)
+      self.sort = options
+    end
+
+    # supported options:
+    #   * for association columns
+    #     * :select - displays a simple <select> or a collection of checkboxes to (dis)associate records
+    attr_writer :form_ui
+    def form_ui
+      @form_ui
+    end
+
+    attr_writer :list_ui
+    def list_ui
+      @list_ui || @form_ui
+    end
+
+    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
+    end
+
+    # a place to store dev's column specific options
+    attr_accessor :options
+    def 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 = nil
+      @autolink = false
+    end
+
+    def set_link(action, options = {})
+      if action.is_a? ActiveScaffold::DataStructures::ActionLink
+        @link = action
+      else
+        options[:label] ||= self.label
+        options[:position] ||= :after unless options.has_key?(:position)
+        options[:type] ||= :record
+        @link = ActiveScaffold::DataStructures::ActionLink.new(action, options)
+      end
+    end
+
+    # define a calculation for the column. anything that ActiveRecord::Calculations::ClassMethods#calculate accepts will do.
+    attr_accessor :calculate
+
+    # get whether to run a calculation on this column
+    def calculation?
+      !(@calculate == false or @calculate.nil?)
+    end
+
+    # a collection of associations to pre-load when finding the records on a page
+    attr_reader :includes
+    def includes=(value)
+      @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.
+    attr_writer :search_sql
+    def search_sql
+      self.initialize_search_sql if @search_sql === true
+      @search_sql
+    end
+    def searchable?
+      search_sql != false && search_sql != nil
+    end
+
+    # to modify the default order of columns
+    attr_accessor :weight
+
+    # to set how many associated records a column with plural association must show in list
+    cattr_accessor :associated_limit
+    @@associated_limit = 3
+    attr_accessor :associated_limit
+
+    # whether the number of associated records must be shown or not
+    cattr_accessor :associated_number
+    @@associated_number = true
+    attr_writer :associated_number
+    def associated_number?
+      @associated_number
+    end
+
+    # whether a blank row must be shown in the subform
+    cattr_accessor :show_blank_record
+    @@show_blank_record = true
+    attr_writer :show_blank_record
+    def show_blank_record?(associated)
+      if @show_blank_record
+        return false if self.through_association?
+        return false unless self.association.klass.authorized_for?(:action => :create)
+        self.plural_association? or (self.singular_association? and associated.empty?)
+      end
+    end
+
+    # methods for automatic links in singular association columns
+    cattr_accessor :actions_for_association_links
+    # AST - I like to default to :show only
+    @@actions_for_association_links = [:show]
+    attr_accessor :actions_for_association_links
+
+    # ----------------------------------------------------------------- #
+    # the below functionality is intended for internal consumption only #
+    # ----------------------------------------------------------------- #
+
+    # the ConnectionAdapter::*Column object from the ActiveRecord class
+    attr_reader :column
+
+    # the association from the ActiveRecord class
+    attr_reader :association
+    def singular_association?
+      self.association and [:has_one, :belongs_to].include? self.association.macro
+    end
+    def plural_association?
+      self.association and [:has_many, :has_and_belongs_to_many].include? self.association.macro
+    end
+    def through_association?
+      self.association and self.association.options[:through]
+    end
+    def polymorphic_association?
+      self.association and self.association.options.has_key? :polymorphic and self.association.options[:polymorphic]
+    end
+
+    # an interpreted property. the column is virtual if it isn't from the active record model or any associated models
+    def virtual?
+      column.nil? && association.nil?
+    end
+
+    # this is so that array.delete and array.include?, etc., will work by column name
+    def ==(other) #:nodoc:
+      # another column
+      if other.respond_to? :name and other.class == self.class
+        self.name == other.name.to_sym
+      # a string or symbol
+      elsif other.respond_to? :to_sym
+        self.name == other.to_sym rescue false # catch "interning empty string"
+      # unknown
+      else
+        self.eql? other
+      end
+    end
+
+    # instantiation is handled internally through the DataStructures::Columns object
+    def initialize(name, active_record_class) #:nodoc:
+      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.clone if @association
+      # AST - this means I have to set my search_ui value for every field that uses record_select
+      # @search_ui = :select if @association and not polymorphic_association?
+      @options = {:format => :i18n_number} if @column.try(:number?)
+
+      # 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.sort = true
+      self.search_sql = true
+      
+      # AST Begin
+      if defined?(SemanticAttributes::Attribute)
+        #TODO 2009-05-08 (EJM) Level=0 - This isn't picking up the condition require with_options block
+        self.required = !active_record_class.semantic_attributes[self.name].predicates.find {|p| p.allow_empty? == false }.nil?
+        active_record_class.semantic_attributes[self.name].predicates.find do |p| 
+          sem_type = p.class.to_s.split('::')[1].underscore.to_sym
+          next if [:required, :association].include?(sem_type)
+          @form_ui = sem_type
+        end
+      end
+      # AST End
+      self.includes = (association and not polymorphic_association?) ? [association.name] : []
+    end
+
+    # just the field (not table.field)
+    def field_name
+      return nil if virtual?
+      column ? @active_record_class.connection.quote_column_name(column.name) : association.primary_key_name
+    end
+
+    def <=>(other_column)
+      order_weight = self.weight <=> other_column.weight
+      order_weight != 0 ? order_weight : self.name.to_s <=> other_column.name.to_s
+    end
+
+    protected
+
+    def initialize_sort
+      if self.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 self.singular_association?
+          self.sort = {:method => "#{self.name}.to_s"}
+        elsif self.plural_association?
+          self.sort = {:method => "#{self.name}.join(',')"}
+        else
+          self.sort = {:sql => self.field}
+        end
+      end
+    end
+
+    def initialize_search_sql
+      self.search_sql = unless self.virtual?
+        if association.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
+
+    # the table name from the ActiveRecord class
+    attr_reader :table
+
+    # the table.field name for this column, if applicable
+    def field
+      @field ||= [@active_record_class.connection.quote_column_name(@table), field_name].join('.')
+    end
+  end
+end