active_scaffold 3.2.18 → 3.2.19

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,171 @@
+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

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

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

data/lib/active_scaffold/engine.rb

@@ -0,0 +1,4 @@
+module ActiveScaffold
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/active_scaffold/extensions/action_controller_rendering.rb

@@ -0,0 +1,20 @@
+# wrap the action rendering for ActiveScaffold controllers
+module ActionController #:nodoc:
+  class Base
+    def render_with_active_scaffold(*args, &block)
+      if self.class.uses_active_scaffold? and params[:adapter] and @rendering_adapter.nil? and request.xhr?
+        @rendering_adapter = true # recursion control
+        # if we need an adapter, then we render the actual stuff to a string and insert it into the adapter template
+        opts = args.blank? ? Hash.new : args.first
+        render :partial => params[:adapter][1..-1],
+        :locals => {:payload => render_to_string(opts.merge(:layout => false), &block).html_safe},
+               :use_full_path => true, :layout => false, :content_type => :html
+        @rendering_adapter = nil # recursion control
+      else
+        render_without_active_scaffold(*args, &block)
+      end
+    end
+    alias_method_chain :render, :active_scaffold
+  end
+end
+

data/lib/active_scaffold/extensions/action_controller_rescueing.rb

@@ -0,0 +1,7 @@
+module ActionController #:nodoc:
+  class Base
+    def deny_access
+      head :unauthorized
+    end
+  end
+end

data/lib/active_scaffold/extensions/action_view_rendering.rb

@@ -0,0 +1,115 @@
+module ActionView
+  class LookupContext
+    module ViewPaths
+      def find_all_templates(name, partial = false, locals = {})
+        prefixes.collect do |prefix|
+          view_paths.collect do |resolver|
+            if Rails.version < '3.2.0' # FIXME: remove when rails 3.1 support is dropped
+              temp_args = *args_for_lookup(name, [prefix], partial, locals)
+            else
+              temp_args = *args_for_lookup(name, [prefix], partial, locals, {})
+            end
+            temp_args[1] = temp_args[1][0]
+            resolver.find_all(*temp_args)
+          end
+        end.flatten!
+      end
+    end
+  end
+end
+
+# wrap the action rendering for ActiveScaffold views
+module ActionView::Helpers #:nodoc:
+  module RenderingHelper
+    #
+    # Adds two rendering options.
+    #
+    # ==render :super
+    #
+    # This syntax skips all template overrides and goes directly to the provided ActiveScaffold templates.
+    # Useful if you want to wrap an existing template. Just call super!
+    #
+    # ==render :active_scaffold => #{controller.to_s}, options = {}+
+    #
+    # Lets you embed an ActiveScaffold by referencing the controller where it's configured.
+    #
+    # You may specify options[:constraints] for the embedded scaffold. These constraints have three effects:
+    #   * the scaffold's only displays records matching the constraint
+    #   * all new records created will be assigned the constrained values
+    #   * constrained columns will be hidden (they're pretty boring at this point)
+    #
+    # You may also specify options[:conditions] for the embedded scaffold. These only do 1/3 of what
+    # constraints do (they only limit search results). Any format accepted by ActiveRecord::Base.find is valid.
+    #
+    # Defining options[:label] lets you completely customize the list title for the embedded scaffold.
+    #
+    def render_with_active_scaffold(*args, &block)
+      if args.first == :super
+        last_view = view_stack.last || {:view => instance_variable_get(:@virtual_path).split('/').last}
+        options = args[1] || {}
+        options[:locals] ||= {}
+        options[:locals].reverse_merge!(last_view[:locals] || {})
+        if last_view[:templates].nil?
+          last_view[:templates] = lookup_context.find_all_templates(last_view[:view], last_view[:partial], options[:locals].keys)
+          last_view[:templates].shift
+        end
+        options[:template] = last_view[:templates].shift
+        view_stack << last_view
+        result = render_without_active_scaffold options
+        view_stack.pop
+        result
+      elsif args.first.is_a? Hash and args.first[:active_scaffold]
+        require 'digest/md5'
+        options = args.first
+
+        remote_controller = options[:active_scaffold]
+        constraints = options[:constraints]
+        conditions = options[:conditions]
+        eid = Digest::MD5.hexdigest(params[:controller] + remote_controller.to_s + constraints.to_s + conditions.to_s)
+        session["as:#{eid}"] = {:constraints => constraints, :conditions => conditions, :list => {:label => args.first[:label]}}
+        options[:params] ||= {}
+        options[:params].merge! :eid => eid, :embedded => true
+
+        id = "as_#{eid}-embedded"
+        url_options = {:controller => remote_controller.to_s, :action => 'index'}.merge(options[:params])
+
+        if controller.respond_to?(:render_component_into_view)
+          controller.send(:render_component_into_view, url_options)
+        else
+          content_tag(:div, :id => id, :class => 'active-scaffold-component') do
+            url = url_for(url_options)
+            # parse the ActiveRecord model name from the controller path, which
+            # might be a namespaced controller (e.g., 'admin/admins')
+            model = remote_controller.to_s.sub(/.*\//, '').singularize
+            content_tag(:div, :class => 'active-scaffold-header') do
+              content_tag :h2, link_to(args.first[:label] || active_scaffold_config_for(model).list.label, url, :remote => true)
+            end <<
+            if ActiveScaffold.js_framework == :prototype
+              javascript_tag("new Ajax.Updater('#{id}', '#{url}', {method: 'get', evalScripts: true});")
+            elsif ActiveScaffold.js_framework == :jquery
+              javascript_tag("jQuery('##{id}').load('#{url}');")
+            end
+          end
+        end
+
+      else
+        options = args.first
+        if options.is_a?(Hash)
+          current_view = {:view => options[:partial], :partial => true} if options[:partial]
+          current_view = {:view => options[:template], :partial => false} if current_view.nil? && options[:template]
+          current_view[:locals] = options[:locals] if !current_view.nil? && options[:locals]
+          view_stack << current_view if current_view.present?
+        end
+        result = render_without_active_scaffold(*args, &block)
+        view_stack.pop if current_view.present?
+        result
+      end
+    end
+    alias_method_chain :render, :active_scaffold
+    
+    def view_stack
+      @_view_stack ||= []
+    end
+
+  end
+end

data/lib/active_scaffold/extensions/active_record_offset.rb

@@ -0,0 +1,12 @@
+# Bugfix: Team.offset(1).limit(1) throws an error
+ActiveRecord::Base.instance_eval do
+  def offset(*args, &block) 
+    scoped.__send__(:offset, *args, &block)
+  rescue NoMethodError       
+    if scoped.nil?           
+      'depends on :allow_nil'
+    else                     
+      raise                  
+    end                      
+  end       
+end

data/lib/active_scaffold/extensions/array.rb

@@ -0,0 +1,7 @@
+class Array
+  # returns the value after the given value. wraps around. defaults to first element in array.
+  def after(value)
+    return nil unless include? value
+    self[(index(value).to_i + 1) % length]
+  end
+end

data/lib/active_scaffold/extensions/cache_association.rb

@@ -0,0 +1,16 @@
+module ActiveRecord
+  class Relation
+    def target=(records)
+      @loaded = true
+      @records = records
+      @records
+    end
+  end
+end
+module ActiveRecord
+  module Associations
+    class CollectionProxy
+      delegate :target=, :to => :@association
+    end
+  end
+end