active_scaffold 3.1.20 → 3.2.0

data/lib/active_scaffold/data_structures/nested_info.rb~

@@ -1,147 +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] = params[nested_info[:parent_model].name.foreign_key]
-        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_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, 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 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
-    
-    def to_params
-      super.merge(:association => @association.name, :assoc_id => parent_id)
-    end
-    
-    protected
-    
-    def iterate_model_associations(model)
-      @constrained_fields = []
-      @constrained_fields << association.foreign_key.to_sym unless association.belongs_to?
-      model.reflect_on_all_associations.each do |current|
-        debugger
-        if !current.belongs_to? && association.foreign_key == current.association_foreign_key
-          constrained_fields << current.name.to_sym
-          @child_association = current if current.klass == @parent_model
-        end
-        if association.foreign_key == current.foreign_key
-          # 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
-    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/extensions/action_controller_rendering.rb~

@@ -1,22 +0,0 @@
-# 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?
-        @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
-
-    # Rails 2.x implementation is post-initialization on :active_scaffold method
-  end
-end
-

data/lib/active_scaffold/extensions/action_view_rendering.rb~

@@ -1,120 +0,0 @@
-module ActionView
-  class LookupContext
-    attr_accessor :uses_active_scaffold
-    module ViewPaths
-      def find_all_templates(name, partial = false, locals = {})
-        prefixes.collect do |prefix|
-          view_paths.collect do |resolver|
-            temp_args = *args_for_lookup(name, [prefix], partial, locals)
-            temp_args[1] = temp_args[1][0]
-            resolver.find_all(*temp_args)
-          end
-        end.flatten!
-      end
-    end
-    
-    # Overload formats= to expand ["*/*"] values and automatically
-    # add :html as fallback to :js.
-    def formats=(values)
-      debugger
-      if values == [:js] && uses_active_scaffold
-        _set_detail(:formats, values) if values != @details[:formats]
-      else
-        super(values)
-      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)
-            content_tag(:div, :class => 'active-scaffold-header') do
-              content_tag :h2, link_to(args.first[:label] || active_scaffold_config_for(remote_controller.to_s.singularize).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("$('##{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_association_reflection.rb~

@@ -1,22 +0,0 @@
-# Bugfix: building an sti model from an association fails
-# https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/6306-collection-associations-build-method-not-supported-for-sti
-# https://github.com/rails/rails/issues/815
-# https://github.com/rails/rails/pull/1686
-ActiveRecord::Reflection::AssociationReflection.class_eval do
-  def klass_with_sti(*opts)
-    sti_col = klass.inheritance_column
-    if (h = opts.first).is_a? Hash and (passed_type = ( h[sti_col] || h[sti_col.to_sym] )) and (new_klass = active_record.send(:compute_type, passed_type)) < klass
-      new_klass
-    else
-      klass
-    end
-  end
-  def build_association(*opts, &block)
-    self.original_build_association_called = true
-    klass_with_sti(*opts).new(*opts, &block)
-  end
-  def create_association(*opts, &block)
-    self.original_build_association_called = true
-    klass_with_sti(*opts).create(*opts, &block)
-  end
-end

data/lib/active_scaffold/extensions/cache_association.rb~

@@ -1,12 +0,0 @@
-module ActiveRecord
-  class Relation
-    def target=(records)
-      debugger
-      @loaded = true
-      @records = records
-      puts loaded?.inspect
-      puts self.object_id
-      @records
-    end
-  end
-end

data/lib/active_scaffold/extensions/reverse_associations.rb~

@@ -1,64 +0,0 @@
-module ActiveRecord
-  module Reflection
-    class AssociationReflection #:nodoc:
-      def inverse_for?(klass)
-        inverse_class = self.klass unless options[:polymorphic]
-        inverse_class.present? && (inverse_class == klass || klass < inverse_class)
-      end
-
-      attr_writer :reverse
-      def reverse
-        @reverse ||= inverse_of.try(:name)
-      end
-
-      def inverse_of_with_autodetect
-        inverse_of_without_autodetect || autodetect_inverse
-      end
-      alias_method_chain :inverse_of, :autodetect
-      
-      protected
-
-        def autodetect_inverse
-          return nil if options[:polymorphic]
-          reverse_matches = []
-
-          # stage 1 filter: collect associations that point back to this model and use the same foreign_key
-          klass.reflect_on_all_associations.each do |assoc|
-            if self.options[:through]
-              # only iterate has_many :through associations
-              next unless assoc.options[:through]
-              next unless assoc.through_reflection.klass == self.through_reflection.klass
-            else
-              # skip over has_many :through associations
-              next if assoc.options[:through]
-              next unless assoc.options[:polymorphic] or assoc.class_name.constantize == self.active_record
-
-              case [assoc.macro, self.macro].find_all{|m| m == :has_and_belongs_to_many}.length
-                # if both are a habtm, then match them based on the join table
-                when 2
-                next unless assoc.options[:join_table] == self.options[:join_table]
-
-                # if only one is a habtm, they do not match
-                when 1
-                next
-
-                # otherwise, match them based on the foreign_key
-                when 0
-                next unless assoc.foreign_key.to_sym == self.foreign_key.to_sym
-              end
-            end
-
-            reverse_matches << assoc
-          end
-
-          # stage 2 filter: name-based matching (association name vs self.active_record.to_s)
-          reverse_matches.find_all do |assoc|
-            self.active_record.to_s.underscore.include? assoc.name.to_s.pluralize.singularize
-          end if reverse_matches.length > 1
-
-          reverse_matches.first
-        end
-
-    end
-  end
-end

data/lib/active_scaffold/extensions/routing_mapper.rb~

@@ -1,48 +0,0 @@
-module ActionDispatch
-  module Routing
-    ACTIVE_SCAFFOLD_CORE_ROUTING = {
-        :collection => {:show_search => :get, :render_field => :get},
-        :member => {:row => :get, :update_column => :post, :render_field => :get}
-    }
-    ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING = {
-        :collection => {:edit_associated => :get, :new_existing => :get, :add_existing => :post},
-        :member => {:edit_associated => :get, :add_association => :get, :destroy_existing => :delete}
-    }
-    class Mapper
-      module Base
-        def as_routes(options = {:association => true})
-          collection do
-            ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection].each {|name, type| send(type, name)}
-          end
-          member do
-            ActionDispatch::Routing::ACTIVE_SCAFFOLD_CORE_ROUTING[:member].each {|name, type| send(type, name)}
-          end
-          as_association_routes if options[:association]
-        end
-        
-        def as_association_routes
-          collection do 
-            ActionDispatch::Routing::ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING[:collection].each {|name, type| send(type, name)}
-          end
-          member do
-            ActionDispatch::Routing::ACTIVE_SCAFFOLD_ASSOCIATION_ROUTING[:member].each {|name, type| send(type, name)}
-          end
-        end
-        
-        def as_nested_resources(*resources)
-          options = resources.extract_options!
-          resources.each do |resource|
-            resources(resource, options.merge(:parent_scaffold => merge_module_scope(@scope[:module], parent_resource.plural), :association => resource)) { yield if block_given? }
-          end
-        end
-        
-        def as_scoped_routes(*scopes)
-          options = scopes.extract_options!
-          scopes.each do |scope|
-            resources(parent_resource.plural, options.merge(:parent_scaffold => merge_module_scope(@scope[:module], parent_resource.plural), :named_scope => scope, :as => :scope)) { yield if block_given? }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_scaffold/extensions/unsaved_associated.rb~

@@ -1,62 +0,0 @@
-# save and validation support for associations.
-class ActiveRecord::Base
-  def associated_valid?(path = [])
-    return true if path.include?(self) # prevent recursion (if associated and parent are new records)
-    path << self
-    # using [].all? syntax to avoid a short-circuit
-    with_unsaved_associated { |a| debugger; [a.valid?, a.associated_valid?(path)].all? {|v| v == true} }
-  end
-
-  def save_associated
-    with_unsaved_associated { |a| a.save and a.save_associated }
-  end
-
-  def save_associated!
-    save_associated or raise(ActiveRecord::RecordNotSaved)
-  end
-
-  def no_errors_in_associated?
-    with_unsaved_associated {|a| a.errors.count == 0 and a.no_errors_in_associated?}
-  end
-
-  protected
-
-  # Provide an override to allow the model to restrict which associations are considered
-  # by ActiveScaffolds update mechanism. This allows the model to restrict things like
-  # Acts-As-Versioned versions associations being traversed.
-  #
-  # By defining the method :scaffold_update_nofollow returning an array of associations
-  # these associations will not be traversed.
-  # By defining the method :scaffold_update_follow returning an array of associations,
-  # only those associations will be traversed.
-  #
-  # Otherwise the default behaviour of traversing all associations will be preserved.
-  def associations_for_update
-    if self.respond_to?( :scaffold_update_nofollow )
-      self.class.reflect_on_all_associations.reject { |association| self.scaffold_update_nofollow.include?( association.name ) }
-    elsif self.respond_to?( :scaffold_update_follow )
-      self.class.reflect_on_all_associations.select { |association| self.scaffold_update_follow.include?( association.name ) }
-    else
-      self.class.reflect_on_all_associations
-    end
-  end
-
-  private
-
-  # yields every associated object that has been instantiated and is flagged as unsaved.
-  # returns false if any yield returns false.
-  # returns true otherwise, even when none of the associations have been instantiated. build wrapper methods accordingly.
-  def with_unsaved_associated
-    associations_for_update.all? do |association|
-      association_proxy = send(association.name)
-      if association_proxy
-        records = association_proxy
-        records = [records] unless records.is_a? Array # convert singular associations into collections for ease of use
-        debugger
-        records.select {|r| r.unsaved? and not r.readonly?}.all? {|r| yield r} # must use select instead of find_all, which Rails overrides on association proxies for db access
-      else
-        true
-      end
-    end
-  end
-end