lockbox_middleware 1.2.1 → 1.2.2

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

@@ -1,45 +0,0 @@
-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/vendor/plugins/active_scaffold/lib/active_scaffold/data_structures/column.rb

@@ -1,311 +0,0 @@
-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_accessor :inplace_edit
-
-    # Whether this column set is collapsed by default in contexts where collapsing is supported
-    attr_accessor :collapsed
-    
-    # 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
-
-    # 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_accessor :show_blank_record
-
-    # 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
-
-    # ----------------------------------------------------------------- #
-    # 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
-      @search_ui = :select if @association and not polymorphic_association?
-
-      # 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
-
-      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 ||= [@table, field_name].join('.')
-    end
-  end
-end

data/vendor/plugins/active_scaffold/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/vendor/plugins/active_scaffold/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/vendor/plugins/active_scaffold/lib/active_scaffold/data_structures/set.rb

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

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

@@ -1,159 +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)
-      last_scope = model.default_scoping.last
-      if last_scope.nil?  || last_scope[:find].nil? || last_scope[:find][:order].nil?
-        set(model.primary_key, 'ASC') if model.column_names.include?(model.primary_key)
-      else
-        set_sorting_from_order_clause(last_scope[:find][:order].to_s, model.table_name)
-        @default_sorting = true
-      end
-    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, "Could not find column #{column_name}" if column.nil?
-      raise ArgumentError, "Sorting direction unknown" unless [:ASC, :DESC].include? direction.to_sym
-      @clauses << [column, direction] if 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 << "#{sql} #{sort_direction}"
-      end
-
-      order.join(', ') 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.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