active_scaffold 3.2.17 → 3.2.18

data/lib/active_scaffold/data_structures/columns.rb

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

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

@@ -1,171 +0,0 @@
-module ActiveScaffold::DataStructures
-  class NestedInfo
-    def self.get(model, params)
-      nested_info = {}
-      begin
-        nested_info[:name] = (params[:association] || params[:named_scope]).to_sym
-        nested_info[:parent_scaffold] = "#{params[:parent_scaffold].to_s.camelize}Controller".constantize
-        nested_info[:parent_model] = nested_info[:parent_scaffold].active_scaffold_config.model
-        nested_info[:parent_id] = if params[:association].nil?
-          params[nested_info[:parent_model].name.foreign_key]
-        else
-          params[nested_info[:parent_model].reflect_on_association(params[:association].to_sym).active_record.name.foreign_key]
-        end
-        if nested_info[:parent_id]
-          unless params[:association].nil?
-            ActiveScaffold::DataStructures::NestedInfoAssociation.new(model, nested_info)
-          else
-            ActiveScaffold::DataStructures::NestedInfoScope.new(model, nested_info)
-          end
-        end
-      rescue ActiveScaffold::ControllerNotFound
-        nil
-      end
-    end
-    
-    attr_accessor :association, :child_association, :parent_model, :parent_scaffold, :parent_id, :constrained_fields, :scope
-        
-    def initialize(model, nested_info)
-      @parent_model = nested_info[:parent_model]
-      @parent_id = nested_info[:parent_id]
-      @parent_scaffold = nested_info[:parent_scaffold]
-    end
-    
-    def to_params
-      {:parent_scaffold => parent_scaffold.controller_path}
-    end
-    
-    def new_instance?
-      result = @new_instance.nil?
-      @new_instance = false
-      result
-    end
-    
-    def parent_scope
-      @parent_scope ||= parent_model.find(parent_id)
-    end
-    
-    def habtm?
-      false 
-    end
-
-    def has_many?
-      false
-    end
-
-    def belongs_to?
-      false
-    end
-
-    def has_one?
-      false
-    end
-
-    def singular_association?
-      belongs_to? || has_one?
-    end
-
-    def plural_association?
-      has_many? || habtm?
-    end
-
-    def through_association?
-      false
-    end
-    
-    def readonly?
-      false
-    end
-
-    def sorted?
-      false
-    end
-  end
-  
-  class NestedInfoAssociation < NestedInfo
-    def initialize(model, nested_info)
-      super(model, nested_info)
-      @association = parent_model.reflect_on_association(nested_info[:name])
-      iterate_model_associations(model)
-    end
-    
-    def name
-      self.association.name
-    end
-    
-    def has_many?
-      association.macro == :has_many 
-    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 through_association?
-      association.options[:through]
-    end
-    
-    def readonly?
-      association.options[:readonly]
-    end
-
-    def sorted?
-      association.options.has_key? :order
-    end
-
-    def default_sorting
-      association.options[:order]
-    end
-    
-    def to_params
-      super.merge(:association => @association.name, :assoc_id => parent_id)
-    end
-    
-    protected
-    
-    def iterate_model_associations(model)
-      @constrained_fields = Set.new
-      constrained_fields << association.foreign_key.to_sym unless association.belongs_to?
-      model.reflect_on_all_associations.each do |current|
-        if !current.belongs_to? && association != current && association.foreign_key.to_s == current.association_foreign_key.to_s
-          constrained_fields << current.name.to_sym
-          @child_association = current if current.klass == @parent_model
-        end
-        if association.foreign_key.to_s == current.foreign_key.to_s
-          # show columns for has_many and has_one child associationes
-          constrained_fields << current.name.to_sym if current.belongs_to?
-          if association.options[:as] and current.options[:polymorphic]
-            @child_association = current if association.options[:as].to_sym == current.name
-          else
-            @child_association = current if current.klass == @parent_model
-          end
-        end
-      end
-      @constrained_fields = @constrained_fields.to_a
-    end
-  end
-  
-  class NestedInfoScope < NestedInfo
-    def initialize(model, nested_info)
-      super(model, nested_info)
-      @scope = nested_info[:name]
-      @constrained_fields = [] 
-    end
-    
-    def to_params
-      super.merge(:named_scope => @scope)
-    end
-    
-    def name
-      self.scope
-    end
-  end
-end

data/lib/active_scaffold/data_structures/set.rb

@@ -1,61 +0,0 @@
-module ActiveScaffold::DataStructures
-  class Set
-    include Enumerable
-    include ActiveScaffold::Configurable
-
-    def initialize(*args)
-      set_values(*args)
-    end
-
-    def set_values(*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

data/lib/active_scaffold/data_structures/sorting.rb

@@ -1,167 +0,0 @@
-module ActiveScaffold::DataStructures
-  # encapsulates the column sorting configuration for the List view
-  class Sorting
-    include Enumerable
-
-    def initialize(columns)
-      @columns = columns
-      @clauses = []
-    end
-    
-    def set_default_sorting(model)
-      model_scope = model.send(:build_default_scope)
-      order_clause = model_scope.arel.order_clauses.join(",") if model_scope
-
-      # If an ORDER BY clause is found set default sorting according to it, else
-      # fallback to setting primary key ordering
-      if order_clause
-        set_sorting_from_order_clause(order_clause, model.table_name)
-        @default_sorting = true
-      else
-        set(model.primary_key, 'ASC') if model.column_names.include?(model.primary_key)
-      end
-    end
-
-    def set_nested_sorting(table_name, order_clause)
-      clear
-      set_sorting_from_order_clause(order_clause, table_name)
-    end
-    
-    # add a clause to the sorting, assuming the column is sortable
-    def add(column_name, direction = nil)
-      direction ||= 'ASC'
-      direction = direction.to_s.upcase
-      column = get_column(column_name)
-      raise ArgumentError, "Sorting direction unknown" unless [:ASC, :DESC].include? direction.to_sym
-      @clauses << [column, direction.untaint] if column and column.sortable?
-      raise ArgumentError, "Can't mix :method- and :sql-based sorting" if mixed_sorting?
-    end
-
-    # an alias for +add+. must accept its arguments in a slightly different form, though.
-    def <<(arg)
-      add(*arg)
-    end
-
-    # clears the sorting before setting to the given column/direction
-    def set(*args)
-      clear
-      add(*args)
-    end
-
-    # clears the sorting
-    def clear
-      @default_sorting = false
-      @clauses = []
-    end
-
-    # checks whether the given column (a Column object or a column name) is in the sorting
-    def sorts_on?(column)
-      !get_clause(column).nil?
-    end
-
-    def direction_of(column)
-      clause = get_clause(column)
-      return if clause.nil?
-      clause[1]
-    end
-
-    # checks whether any column is configured to sort by method (using a proc)
-    def sorts_by_method?
-      @clauses.any? { |sorting| sorting[0].sort.is_a? Hash and sorting[0].sort.has_key? :method }
-    end
-
-    def sorts_by_sql?
-      @clauses.any? { |sorting| sorting[0].sort.is_a? Hash and sorting[0].sort.has_key? :sql }
-    end
-
-    # iterate over the clauses
-    def each
-      @clauses.each { |clause| yield clause }
-    end
-
-    # provides quick access to the first (and sometimes only) clause
-    def first
-      @clauses.first
-    end
-
-    # builds an order-by clause
-    def clause
-      return nil if sorts_by_method? || default_sorting?
-
-      # unless the sorting is by method, create the sql string
-      order = []
-      each do |sort_column, sort_direction|
-        sql = sort_column.sort[:sql]
-        next if sql.nil? or sql.empty?
-
-        order << Array(sql).map {|column| "#{column} #{sort_direction}"}.join(', ')
-      end
-
-      order unless order.empty?
-    end
-
-    protected
-
-    # retrieves the sorting clause for the given column
-    def get_clause(column)
-      column = get_column(column)
-      @clauses.find{ |clause| clause[0] == column}
-    end
-
-    # possibly converts the given argument into a column object from @columns (if it's not already)
-    def get_column(name_or_column)
-      # it's a column
-      return name_or_column if name_or_column.is_a? ActiveScaffold::DataStructures::Column
-      # it's a name
-      name_or_column = name_or_column.to_s.split('.').last if name_or_column.to_s.include? '.'
-      return @columns[name_or_column]
-    end
-
-    def mixed_sorting?
-      sorts_by_method? and sorts_by_sql?
-    end
-    
-    def default_sorting?
-      @default_sorting
-    end
-
-    def set_sorting_from_order_clause(order_clause, model_table_name = nil)
-      clear
-      order_clause.to_s.split(',').each do |criterion|
-        unless criterion.blank?
-          order_parts = extract_order_parts(criterion)
-          add(order_parts[:column_name], order_parts[:direction]) unless different_table?(model_table_name, order_parts[:table_name])
-        end
-      end
-    end
-    
-    def extract_order_parts(criterion_parts)
-      column_name_part, direction_part = criterion_parts.strip.split(' ')
-      column_name_parts = column_name_part.split('.')
-      order = {:direction => extract_direction(direction_part),
-        :column_name => remove_quotes(column_name_parts.last)}
-      order[:table_name] = remove_quotes(column_name_parts[-2]) if column_name_parts.length >= 2
-      order
-    end
-    
-    def different_table?(model_table_name, order_table_name)
-      !order_table_name.nil? && model_table_name != order_table_name
-    end
-    
-    def remove_quotes(sql_name)
-      if sql_name.starts_with?('"') || sql_name.starts_with?('`')
-        sql_name[1, (sql_name.length - 2)]
-      else
-        sql_name
-      end
-    end
-    
-    def extract_direction(direction_part)
-      if direction_part.to_s.upcase == 'DESC'
-        'DESC'
-      else
-        'ASC'
-      end
-    end
-  end
-end