active_scaffold_vho 3.0.6

data/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/active_scaffold/data_structures/column.rb

@@ -0,0 +1,351 @@
+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
+
+    # 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
+      # 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
+    attr_writer :label
+    def label
+      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
+    
+    attr_reader :update_columns
+    
+    # update dependent columns after value change in form
+    #  update_columns = :name
+    #  update_columns = [:name, :age]
+    def update_columns=(column_names)
+      @update_columns = Array(column_names)
+    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 || (@association && !polymorphic_association? ? :select : nil)
+    end
+
+    # a place to store dev's column specific options
+    attr_accessor :options
+    def options
+      @options ||= {}
+    end
+
+    def link
+      @link = @link.call(self) if @link.is_a? Proc
+      @link
+    end
+
+     # associate an action_link with this column
+    def set_link(action, options = {})
+      if action.is_a?(ActiveScaffold::DataStructures::ActionLink) || (action.is_a? Proc)
+        @link = action
+      else
+        options[:label] ||= self.label
+        options[:position] ||= :after unless options.has_key?(:position)
+        options[:type] ||= :member
+        @link = ActiveScaffold::DataStructures::ActionLink.new(action, options)
+      end
+    end
+
+    # set an action_link to nested list or inline form in this column
+    def autolink?
+      @autolink
+    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
+
+    # 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 unless self.association.klass.authorized_for?(:crud_type => :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
+    @@actions_for_association_links = [:new, :edit, :show]
+    attr_accessor :actions_for_association_links
+    
+    cattr_accessor :association_form_ui
+    @@association_form_ui = nil
+
+    # ----------------------------------------------------------------- #
+    # 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
+    def readonly_association?
+      if self.association
+        if self.association.options.has_key? :readonly
+          self.association.options[:readonly]
+        else
+          self.through_association?
+        end
+      end
+    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
+      @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
+      @options = {:format => :i18n_number} if @column.try(:number?)
+      @form_ui = :checkbox if @column and @column.type == :boolean
+      @allow_add_existing = true
+      @form_ui = self.class.association_form_ui if @association && self.class.association_form_ui
+      
+      # default all the configurable variables
+      self.css_class = ''
+      self.required = active_record_class.validators_on(self.name).map(&:class).include? ActiveModel::Validations::PresenceValidator
+      self.sort = true
+      self.search_sql = true
+      
+      @weight = estimate_weight
+
+      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
+    
+    def estimate_weight
+      if singular_association?
+        400
+      elsif plural_association?
+        500
+      elsif [:created_at, :updated_at].include?(self.name) 
+        600
+      elsif [:name, :label, :title].include?(self.name)
+        100
+      elsif required?
+        200
+      else
+        300
+      end
+    end
+  end
+end

data/lib/active_scaffold/data_structures/columns.rb

@@ -0,0 +1,75 @@
+module ActiveScaffold::DataStructures
+  class Columns
+    include Enumerable
+    include ActiveScaffold::Configurable
+
+    # The motivation for this collection is that this Columns data structure fills two roles: it provides
+    # the master list of all known columns, and it provides an inheritable list for all other actions (e.g.
+    # Create and Update and List). Well we actually want to *know* about as many columns as possible, so
+    # we don't want people actually removing columns from @set. But at the same time, we want to be able to
+    # manage which columns get inherited. Tada!
+    #
+    # This collection is referenced by other parts of ActiveScaffold and by methods within this DataStructure.
+    # IT IS NOT MEANT FOR PUBLIC USE (but if you know what you're doing, go ahead)
+    def _inheritable=(value)
+      @sorted = true
+      @_inheritable = value
+    end
+
+    # This accessor is used by ActionColumns to create new Column objects without adding them to this set
+    attr_reader :active_record_class
+
+    def initialize(active_record_class, *args)
+      @active_record_class = active_record_class
+      @_inheritable = []
+      @set = []
+
+      self.add *args
+    end
+
+    # the way to add columns to the set. this is primarily useful for virtual columns.
+    # note that this also makes columns inheritable
+    def add(*args)
+      args.flatten! # allow [] as a param
+      args = args.collect{ |a| a.to_sym }
+
+      # make the columns inheritable
+      @_inheritable.concat(args)
+      # then add columns to @set (unless they already exist)
+      args.each { |a| @set << ActiveScaffold::DataStructures::Column.new(a.to_sym, @active_record_class) unless find_by_name(a) }
+    end
+    alias_method :<<, :add
+
+    def exclude(*args)
+      # only remove columns from _inheritable. we never want to completely forget about a column.
+      args.each { |a| @_inheritable.delete a }
+    end
+
+    # returns an array of columns with the provided names
+    def find_by_names(*names)
+      @set.find_all { |column| names.include? column.name }
+    end
+
+    # returns the column of the given name.
+    def find_by_name(name)
+      # this works because of `def column.=='
+      column = @set.find { |c| c == name }
+      column
+    end
+    alias_method :[], :find_by_name
+
+    def each
+      @set.each {|i| yield i }
+    end
+
+    def _inheritable
+      if @sorted
+        @_inheritable
+      else
+        @_inheritable.sort do |a, b|
+          self[a] <=> self[b]
+        end
+      end
+    end
+  end
+end

data/lib/active_scaffold/data_structures/error_message.rb

@@ -0,0 +1,24 @@
+module ActiveScaffold::DataStructures
+  # Wrapper for error strings so that they may be exported using to_xxx
+  class ErrorMessage
+    def initialize(error)
+      @error = error
+    end
+
+    def public_attributes
+      { :error => @error }
+    end
+
+    def to_xml
+      public_attributes.to_xml(:root => "errors")
+    end
+
+    def to_yaml
+      public_attributes.to_yaml
+    end
+
+    def to_s
+      @error
+    end
+  end
+end

data/lib/active_scaffold/data_structures/nested_info.rb

@@ -0,0 +1,123 @@
+module ActiveScaffold::DataStructures
+  class NestedInfo
+    def self.get(model, session_storage)
+      if session_storage[:nested].nil? 
+        nil
+      else
+        session_info = session_storage[:nested].clone
+        begin
+          session_info[:parent_scaffold] = "#{session_info[:parent_scaffold].to_s.camelize}Controller".constantize
+          session_info[:parent_model] = session_info[:parent_scaffold].active_scaffold_config.model
+          session_info[:association] = session_info[:parent_model].reflect_on_association(session_info[:name])
+          unless session_info[:association].nil?
+            ActiveScaffold::DataStructures::NestedInfoAssociation.new(model, session_info)
+          else
+            ActiveScaffold::DataStructures::NestedInfoScope.new(model, session_info)
+          end
+        rescue ActiveScaffold::ControllerNotFound
+          nil
+        end
+      end
+    end
+    
+    attr_accessor :association, :child_association, :parent_model, :parent_scaffold, :parent_id, :constrained_fields, :scope
+        
+    def initialize(model, session_info)
+      @parent_model = session_info[:parent_model]
+      @parent_id = session_info[:parent_id]
+      @parent_scaffold = session_info[:parent_scaffold]
+    end
+    
+    def new_instance?
+      result = @new_instance.nil?
+      @new_instance = false
+      result
+    end
+    
+    def parent_scope
+      parent_model.find(parent_id)
+    end
+    
+    def habtm?
+      false 
+    end
+    
+    def belongs_to?
+      false
+    end
+
+    def has_one?
+      false
+    end
+    
+    def readonly?
+      false
+    end
+
+    def sorted?
+      false
+    end
+  end
+  
+  class NestedInfoAssociation < NestedInfo
+    def initialize(model, session_info)
+      super(model, session_info)
+      @association = session_info[:association]
+      iterate_model_associations(model)
+    end
+    
+    def habtm?
+      association.macro == :has_and_belongs_to_many 
+    end
+    
+    def belongs_to?
+      association.belongs_to?
+    end
+
+    def has_one?
+      association.macro == :has_one
+    end
+    
+    def readonly?
+      if association.options.has_key? :readonly
+        association.options[:readonly]
+      else
+        association.options.has_key? :through
+      end
+    end
+
+    def sorted?
+      association.options.has_key? :order
+    end
+
+    def default_sorting
+      association.options[:order]
+    end
+    
+    protected
+    
+    def iterate_model_associations(model)
+      @constrained_fields = [] 
+      @constrained_fields << association.primary_key_name.to_sym unless association.belongs_to?
+      model.reflect_on_all_associations.each do |current|
+        if !current.belongs_to? && association.primary_key_name == current.association_foreign_key
+          constrained_fields << current.name.to_sym
+          @child_association = current
+        end
+        if association.primary_key_name == current.primary_key_name
+          # show columns for has_many and has_one child associationes
+          constrained_fields << current.name.to_sym if current.belongs_to? 
+          @child_association = current
+        end
+      end
+    end
+  end
+  
+  class NestedInfoScope < NestedInfo
+    def initialize(model, session_info)
+      super(model, session_info)
+      @scope = session_info[:name]
+      @constrained_fields = [] 
+    end
+  end
+end

data/lib/active_scaffold/data_structures/set.rb

@@ -0,0 +1,62 @@
+module ActiveScaffold::DataStructures
+  class Set
+    include Enumerable
+    include ActiveScaffold::Configurable
+
+    attr_writer :label
+    def label
+      as_(@label)
+    end
+
+    def initialize(*args)
+      @set = []
+      self.add *args
+    end
+
+    # the way to add items to the set.
+    def add(*args)
+      args.flatten! # allow [] as a param
+      args.each { |arg|
+        arg = arg.to_sym if arg.is_a? String
+        @set << arg unless @set.include? arg # avoid duplicates
+      }
+    end
+    alias_method :<<, :add
+
+    # the way to remove items from the set.
+    def exclude(*args)
+      args.flatten! # allow [] as a param
+      args.collect! { |a| a.to_sym } # symbolize the args
+      # check respond_to? :to_sym, ActionColumns doesn't respond to to_sym
+      @set.reject! { |c| c.respond_to? :to_sym and args.include? c.to_sym } # reject all items specified
+    end
+    alias_method :remove, :exclude
+
+    # returns an array of items with the provided names
+    def find_by_names(*names)
+      @set.find_all { |item| names.include? item }
+    end
+
+    # returns the item of the given name.
+    def find_by_name(name)
+      # this works because of `def item.=='
+      item = @set.find { |c| c == name }
+      item
+    end
+    alias_method :[], :find_by_name
+
+    def each
+      @set.each {|i| yield i }
+    end
+
+    # returns the number of items in the set
+    def length
+      @set.length
+    end
+    
+    def empty?
+      @set.empty?
+    end
+
+  end
+end