benhoskings-hammock 0.2.5 → 0.2.6

data/History.txt

@@ -1,3 +1,32 @@
+== 0.2.6 2009-03-05
+
+Access current_nested_records in nested_route_for through the method instead of directly.
+Replaced #assign_nestable_resources with #assign_nesting_entities, to separately kick and assign an ivar for each of the current rou
+Added nesting_scope_list to encapsulate what @hammock_nesting_scopes was set to before.
+Updated nested_within? to use methods instead of ivars, removed duping from current_nested_[record,resource]s, and added add_nested_en
+Updated empty_scope for sqlite, to bring it in line with public_scope.
+Updated current_scope to fail gracefully if current_verb_scope (renamed from verb_scope along with [current_]nest_scope) returns nil.
+Replaced RouteNode#nesting_scope_for with nesting_scope_list_for, and changed nest_scope call appropriately. The scopes are returned s
+Replaced AR::Base#id_or_description with #description, added .description, and use in link_class_for for more consistent class names.
+Split Hammock::Callback (previously HammockCallback) out into its own file.
+Split RouteNode and RouteStep (previously HammockResource and HammockRoutePiece) out into their own files.
+Reject Hammock:: classes from hammock load. Classes are modules. Who knew?
+Changed inheritable_attribute keys from strings to symbols.
+Caching the model within HammockResource was causing stale class fails in development mode.
+retrieve_record uses mdl.routing_attribute now instead of the old find_column_name.
+Default routing_attribute to :id.
+Fixed the 'no valid AR reflections' message to be a user error instead of an internal hammock error (they just need to add a reflection)
+HammockRoutePiece erroneously had a root? check instead of a parent.nil? check - fixed.
+Only set creator_id if someone is logged in.
+Updated #nest_scope to use #nesting_scope_for instead of manually recursively selecting within a single context, and updated #curren
+Re-enabled logging of Ambition queries as they are assigned as entities.
+Replaced the questionable #current_route with #current_hammock_resource, which uses HammockResource#base_for.
+Added HammockResource#base_for, #nesting_scope_for and #nesting_scope_segment_for.
+Added HammockResource#determine_routing_parent, to determine which ActiveRecord reflection to use to generate joins for route queryi
+Added Hash#selekt, to sidestep the ruby-1.8/1.9 #select changes.
+Commented current_route-dependent code in hamlink_to until that is sorted out.
+Test if obj is defined before attempting to select .spinner within it.
+
 == 0.2.4 2009-02-25
 
 * Initial gem release

data/Manifest.txt

@@ -6,6 +6,7 @@ Rakefile
 hammock.gemspec
 lib/hammock.rb
 lib/hammock/ajaxinate.rb
+lib/hammock/callback.rb
 lib/hammock/callbacks.rb
 lib/hammock/canned_scopes.rb
 lib/hammock/constants.rb
@@ -34,6 +35,8 @@ lib/hammock/restful_rendering.rb
 lib/hammock/restful_support.rb
 lib/hammock/route_drawing_hooks.rb
 lib/hammock/route_for.rb
+lib/hammock/route_node.rb
+lib/hammock/route_step.rb
 lib/hammock/scope.rb
 lib/hammock/suggest.rb
 lib/hammock/utils.rb

data/hammock.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{hammock}
-  s.version = "0.2.5"
+  s.version = "0.2.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ben Hoskings"]
-  s.date = %q{2009-02-27}
+  s.date = %q{2009-03-05}
   s.description = %q{Hammock is a Rails plugin that eliminates redundant code in a very RESTful manner. It does this in lots in lots of different places, but in one manner: it encourages specification in place of implementation.   Hammock enforces RESTful resource access by abstracting actions away from the controller in favour of a clean, model-like callback system.  Hammock tackles the hard and soft sides of security at once with a scoping security system on your models. Specify who can verb what resources under what conditions once, and everything else - the actual security, link generation, index filtering - just happens.  Hammock inspects your routes and resources to generate a routing tree for each resource. Parent resources in a nested route are handled transparently at every point - record retrieval, creation, and linking.  It makes more sense when you see how it works though, so check out the screencast!}
   s.email = ["ben@hoskings.net"]
   s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc", "misc/scaffold.txt"]
-  s.files = ["History.txt", "LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "hammock.gemspec", "lib/hammock.rb", "lib/hammock/ajaxinate.rb", "lib/hammock/callbacks.rb", "lib/hammock/canned_scopes.rb", "lib/hammock/constants.rb", "lib/hammock/controller_attributes.rb", "lib/hammock/export_scope.rb", "lib/hammock/hamlink_to.rb", "lib/hammock/javascript_buffer.rb", "lib/hammock/logging.rb", "lib/hammock/model_attributes.rb", "lib/hammock/model_logging.rb", "lib/hammock/monkey_patches/action_pack.rb", "lib/hammock/monkey_patches/active_record.rb", "lib/hammock/monkey_patches/array.rb", "lib/hammock/monkey_patches/hash.rb", "lib/hammock/monkey_patches/logger.rb", "lib/hammock/monkey_patches/module.rb", "lib/hammock/monkey_patches/numeric.rb", "lib/hammock/monkey_patches/object.rb", "lib/hammock/monkey_patches/route_set.rb", "lib/hammock/monkey_patches/string.rb", "lib/hammock/overrides.rb", "lib/hammock/resource_mapping_hooks.rb", "lib/hammock/resource_retrieval.rb", "lib/hammock/restful_actions.rb", "lib/hammock/restful_rendering.rb", "lib/hammock/restful_support.rb", "lib/hammock/route_drawing_hooks.rb", "lib/hammock/route_for.rb", "lib/hammock/scope.rb", "lib/hammock/suggest.rb", "lib/hammock/utils.rb", "misc/scaffold.txt", "misc/template.rb", "tasks/hammock_tasks.rake", "test/hammock_test.rb", "test/rails_root/test/test_helper.rb"]
+  s.files = ["History.txt", "LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "hammock.gemspec", "lib/hammock.rb", "lib/hammock/ajaxinate.rb", "lib/hammock/callback.rb", "lib/hammock/callbacks.rb", "lib/hammock/canned_scopes.rb", "lib/hammock/constants.rb", "lib/hammock/controller_attributes.rb", "lib/hammock/export_scope.rb", "lib/hammock/hamlink_to.rb", "lib/hammock/javascript_buffer.rb", "lib/hammock/logging.rb", "lib/hammock/model_attributes.rb", "lib/hammock/model_logging.rb", "lib/hammock/monkey_patches/action_pack.rb", "lib/hammock/monkey_patches/active_record.rb", "lib/hammock/monkey_patches/array.rb", "lib/hammock/monkey_patches/hash.rb", "lib/hammock/monkey_patches/logger.rb", "lib/hammock/monkey_patches/module.rb", "lib/hammock/monkey_patches/numeric.rb", "lib/hammock/monkey_patches/object.rb", "lib/hammock/monkey_patches/route_set.rb", "lib/hammock/monkey_patches/string.rb", "lib/hammock/overrides.rb", "lib/hammock/resource_mapping_hooks.rb", "lib/hammock/resource_retrieval.rb", "lib/hammock/restful_actions.rb", "lib/hammock/restful_rendering.rb", "lib/hammock/restful_support.rb", "lib/hammock/route_drawing_hooks.rb", "lib/hammock/route_for.rb", "lib/hammock/route_node.rb", "lib/hammock/route_step.rb", "lib/hammock/scope.rb", "lib/hammock/suggest.rb", "lib/hammock/utils.rb", "misc/scaffold.txt", "misc/template.rb", "tasks/hammock_tasks.rake", "test/hammock_test.rb"]
   s.has_rdoc = true
   s.homepage = %q{http://github.com/benhoskings/hammock}
   s.rdoc_options = ["--main", "README.rdoc"]
@@ -18,7 +18,6 @@ Gem::Specification.new do |s|
   s.rubyforge_project = %q{hammock}
   s.rubygems_version = %q{1.3.1}
   s.summary = %q{Hammock is a Rails plugin that eliminates redundant code in a very RESTful manner}
-  s.test_files = ["test/rails_root/test/test_helper.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION

data/lib/hammock.rb

@@ -8,13 +8,13 @@ Dir.glob("#{File.dirname __FILE__}/hammock/**/*.rb").each {|dep|
 } if defined?(RAILS_ROOT) # Loading Hammock components under 'rake package' fails.
 
 module Hammock
-  VERSION = '0.2.5'
+  VERSION = '0.2.6'
 
   def self.included base # :nodoc:
     Hammock.constants.map {|constant_name|
       Hammock.const_get constant_name
     }.select {|constant|
-      constant.is_a? Module
+      constant.is_a?(Module) && !constant.is_a?(Class)
     }.partition {|mod|
       mod.constants.include?('LoadFirst') && mod::LoadFirst
     }.flatten.each {|mod|

data/lib/hammock/ajaxinate.rb

@@ -133,7 +133,7 @@ module Hammock
       private
 
       def link_class_for verb, record, attribute = nil
-        [verb, record.base_model, record.id, attribute].compact.join('_')
+        [verb, record.description, attribute].compact.join('_')
       end
 
       def clean_snippet snippet

data/lib/hammock/callback.rb

@@ -0,0 +1,16 @@
+module Hammock
+
+  class Callback < ActiveSupport::Callbacks::Callback
+    private
+
+    def evaluate_method method, *args, &block
+      if method.is_a? Proc
+        # puts "was a Hammock::Callback proc within #{args.first.class}."
+        method.bind(args.shift).call(*args, &block)
+      else
+        super
+      end
+    end
+  end
+
+end

data/lib/hammock/callbacks.rb

@@ -28,19 +28,6 @@ module Hammock
 
     module ClassMethods
 
-      class HammockCallback < ActiveSupport::Callbacks::Callback
-        private
-
-        def evaluate_method method, *args, &block
-          if method.is_a? Proc
-            # puts "was a HammockCallback proc within #{args.first.class}."
-            method.bind(args.shift).call(*args, &block)
-          else
-            super
-          end
-        end
-      end
-
       def define_hammock_callbacks *callbacks
         callbacks.each do |callback|
           class_eval <<-"end_eval"
@@ -54,7 +41,7 @@ module Hammock
                   raise ArgumentError, "Inline callback definitions require a description as their sole argument."
                 else
                   # logger.info "defining \#{methods.first} on \#{name} with method \#{block.inspect}."
-                  [HammockCallback.new(:#{callback}, block, :identifier => methods.first)]
+                  [Hammock::Callback.new(:#{callback}, block, :identifier => methods.first)]
                 end || []
               end
               # log callbacks

data/lib/hammock/canned_scopes.rb

@@ -109,7 +109,11 @@ module Hammock
       end
 
       def empty_scope
-        lambda {|record| false }
+        if sqlite?
+          lambda {|record| 0 } # TODO check what this should be
+        else
+          lambda {|record| false }
+        end
       end
 
     end

data/lib/hammock/constants.rb

@@ -1,4 +1,6 @@
 module Hammock
+  PleaseFileABug = "Ack, that shouldn't have happened. Please email the full stacktrace to <ben@hoskings.net>, so the problem you uncovered can be addressed. Thanks!"
+
   module Constants
     
     ImpliedUnsafeActions = [:new, :edit, :destroy]

data/lib/hammock/controller_attributes.rb

@@ -31,15 +31,6 @@ module Hammock
       def find_on_create
         write_inheritable_attribute :find_on_create, true
       end
-
-      # Use +find_column+ to specify the name of an alternate column with which record lookups should be performed.
-      #
-      # This is useful for controllers that are indexed by primary key, but are accessed with URLs containing some other unique attribute of the resource, like a randomly-generated key.
-      #     find_column :key
-      def find_column column_name
-        # TODO define to_param on model.
-        write_inheritable_attribute :find_column, column_name
-      end
     end
 
     module InstanceMethods
@@ -57,10 +48,6 @@ module Hammock
       def findable_on_create?
         self.class.read_inheritable_attribute :find_on_create
       end
-
-      def find_column_name
-        self.class.read_inheritable_attribute(:find_column) || :id
-      end
     end
   end
 end

data/lib/hammock/model_attributes.rb

@@ -9,24 +9,39 @@ module Hammock
 
     module ClassMethods
 
+      def route_by attribute
+        write_inheritable_attribute :routing_attribute, attribute.to_sym
+        define_method :to_param do
+          send self.class.routing_attribute
+        end
+      end
+      def nest_within *attributes
+        write_inheritable_attribute :nestable_routing_resources, attributes
+      end
       def has_defaults attrs
-        write_inheritable_attribute "default_attributes", (default_attributes || {}).merge(attrs)
+        write_inheritable_attribute :default_attributes, (default_attributes || {}).merge(attrs)
       end
       def attr_accessible_on_create *attributes
-        write_inheritable_attribute "attr_accessible_on_create", Set.new(attributes.map(&:to_s)) + (accessible_attributes_on_create || [])
+        write_inheritable_attribute :attr_accessible_on_create, Set.new(attributes.map(&:to_s)) + (accessible_attributes_on_create || [])
       end
       def attr_accessible_on_update *attributes
-        write_inheritable_attribute "attr_accessible_on_update", Set.new(attributes.map(&:to_s)) + (accessible_attributes_on_update || [])
+        write_inheritable_attribute :attr_accessible_on_update, Set.new(attributes.map(&:to_s)) + (accessible_attributes_on_update || [])
       end
 
+      def routing_attribute
+        read_inheritable_attribute(:routing_attribute) || :id
+      end
+      def nestable_routing_resources
+        read_inheritable_attribute(:nestable_routing_resources)
+      end
       def default_attributes
-        read_inheritable_attribute("default_attributes") || {}
+        read_inheritable_attribute(:default_attributes) || {}
       end
       def accessible_attributes_on_create
-        read_inheritable_attribute "attr_accessible_on_create"
+        read_inheritable_attribute :attr_accessible_on_create
       end
       def accessible_attributes_on_update
-        read_inheritable_attribute "attr_accessible_on_update"
+        read_inheritable_attribute :attr_accessible_on_update
       end
 
     end

data/lib/hammock/monkey_patches/active_record.rb

@@ -39,10 +39,18 @@ module Hammock
         base_class.to_s.pluralize.underscore
       end
 
+      def param_key
+        "#{base_model}_id"
+      end
+
       def base_model
         base_class.to_s.underscore
       end
 
+      def description
+        base_model
+      end
+
       def record?; false end
       def resource?; true end
 
@@ -122,12 +130,8 @@ module Hammock
         end
       end
 
-      def id_or_description
-        new_record? ? new_record_description : id
-      end
-      
-      def new_record_description
-        attributes.map {|k,v| "#{k}-#{(v.to_s || '')[0..10]}" }.join("_")
+      def description
+        new_record? ? "new_#{base_model}" : "#{base_model}_#{id}"
       end
 
       def base_model

data/lib/hammock/monkey_patches/hash.rb

@@ -21,6 +21,14 @@ module Hammock
         dup.discard! *keys
       end
 
+      def selekt &block
+        hsh = {}
+        each_pair {|k,v|
+          hsh[k] = v if yield(k,v)
+        }
+        hsh
+      end
+
       def dragnet *keys
         dup.dragnet! *keys
       end

data/lib/hammock/monkey_patches/route_set.rb

@@ -20,179 +20,7 @@ module Hammock
       private
 
       def initialize_hammock_route_map
-        self.route_map = HammockResource.new
-      end
-
-      class HammockResource < ActionController::Resources::Resource
-        class HammockRoutePiece
-          attr_reader :resource, :routeable_as, :verb, :entity, :parent
-
-          def initialize resource
-            @resource = resource
-          end
-
-          def for verb, entity
-            routeable_as = resource.routeable_as(verb, entity)
-
-            if !routeable_as
-              raise "The verb '#{verb}' can't be applied to " + (entity.record? ? "#{entity.resource} records" : "the #{entity.resource} resource") + "."
-            elsif (:record == routeable_as) && entity.new_record?
-              raise "The verb '#{verb}' requires a #{entity.resource} with an ID (i.e. not a new record)."
-            elsif (:build == routeable_as) && entity.record? && !entity.new_record?
-              raise "The verb '#{verb}' requires either the #{entity.resource} resource, or a #{entity.resource} without an ID (i.e. a new record)."
-            else
-              @verb, @entity, @routeable_as = verb, entity, routeable_as
-            end
-
-            self
-          end
-
-          def within parent
-            @parent = parent
-            self
-          end
-          
-          def setup?
-            !@entity.nil?
-          end
-          
-          def path params = nil
-            raise_unless_setup_while_trying_to 'render a path'
-
-            buf = '/'
-            buf << entity.resource_name
-            buf << '/' + entity.to_param if entity.record? && !entity.new_record?
-            buf << '/' + verb.to_s unless verb.nil? or implied_verb?(verb)
-
-            buf = parent.path + buf unless parent.nil?
-            buf << param_str(params)
-
-            buf
-          end
-          
-          def http_method
-            raise_unless_setup_while_trying_to 'extract the HTTP method'
-            resource.send("#{routeable_as}_routes")[verb]
-          end
-          
-          def fake_http_method
-            http_method.in?(:get, :post) ? http_method : :post
-          end
-
-          def get?;       :get == http_method end
-          def post?;     :post == http_method end
-          def put?;       :put == http_method end
-          def delete?; :delete == http_method end
-
-          def safe?
-            get? && !verb.in?(Hammock::Constants::ImpliedUnsafeActions)
-          end
-
-          private
-          
-          def implied_verb? verb
-            verb.in? :index, :create, :show, :update, :destroy
-          end
-          
-          def raise_unless_setup_while_trying_to task
-            raise "You have to call for(verb, entity) (and optionally within(parent)) on this HammockRoutePiece before you can #{task}." unless setup?
-          end
-          
-          def param_str params
-            link_params = entity.record? ? entity.unsaved_attributes.merge(params || {}) : params
-
-            if link_params.blank?
-              ''
-            else
-              '?' + {entity.base_model => link_params}.to_query
-            end
-          end
-
-        end
-        
-        DefaultRecordVerbs = {
-          :show => :get,
-          :edit => :get,
-          :update => :put,
-          :destroy => :delete
-        }.freeze
-        DefaultResourceVerbs = {
-          :index => :get
-        }.freeze
-        DefaultBuildVerbs = {
-          :new => :get,
-          :create => :post
-        }.freeze
-
-        attr_reader :mdl, :parent, :children, :record_routes, :resource_routes, :build_routes
-
-        def initialize entity = nil, options = {}
-          @mdl = entity if entity.is_a?(Symbol)
-          @parent = options[:parent]
-          @children = {}
-          define_routes options
-        end
-
-        def ancestry
-          parent.nil? ? [] : parent.ancestry.push(self)
-        end
-
-        def for verb, entities, options
-          raise "HammockResource#for requires an explicitly specified verb as its first argument." unless verb.is_a?(Symbol)
-          raise "You have to supply at least one record or resource." if entities.empty?
-
-          entity = entities.shift
-
-          if entities.empty?
-            piece_for verb, entity
-          else
-            children[entity.resource_sym].for(verb, entities, options).within piece_for(nil, entity)
-          end
-        end
-
-        def add entity, options, steps = nil
-          if steps.nil?
-            add entity, options, (options[:name_prefix] || '').chomp('_').split('_').map {|i| i.pluralize.underscore.to_sym }
-          elsif steps.empty?
-            add_child entity, options
-          else
-            children[steps.shift].add entity, options, steps
-          end
-        end
-
-        def routeable_as verb, entity
-          if entity.record? && record_routes[verb || :show]
-            :record
-          elsif entity.resource? && resource_routes[verb || :index]
-            :resource
-          elsif !verb.nil? && build_routes[verb]
-            :build
-          end
-        end
-
-        private
-
-        def define_routes options
-          @record_routes = DefaultRecordVerbs.dup.update(options[:member] || {})
-          @resource_routes = DefaultResourceVerbs.dup.update(options[:collection] || {})
-          @build_routes = DefaultBuildVerbs.dup.update(options[:build] || {})
-        end
-
-        def add_child entity, options
-          child = HammockResource.new entity, options.merge(:parent => self)
-          children[child.mdl] = child
-        end
-
-        def piece_for verb, entity
-          child = children[entity.resource_sym]
-
-          if child.nil?
-            raise "No routes are defined for #{entity.resource}#{' within ' + ancestry.map {|r| r.mdl.to_s }.join(', ') unless ancestry.empty?}."
-          else
-            HammockRoutePiece.new(child).for(verb, entity)
-          end
-        end
-
+        self.route_map = Hammock::RouteNode.new
       end
 
     end

data/lib/hammock/resource_retrieval.rb

@@ -15,10 +15,10 @@ module Hammock
         find_record :find_with_deleted
       end
 
-      def find_record finder = :find
+      def find_record
         result = if !callback(:before_find)
           # callbacks failed
-        elsif (record = retrieve_record(finder)).nil?
+        elsif (record = retrieve_record).nil?
           log "#{mdl}<#{params[:id]}> doesn't exist within #{requester_name.possessive} #{action_name} scope."
           :not_found
         elsif :ok != (verbability = can_verb_record?(action_name.to_sym, record))
@@ -44,11 +44,11 @@ module Hammock
         end
       end
 
-      def retrieve_record finder
+      def retrieve_record
         if (scope = current_scope).nil?
 
         else
-          record = scope.send finder, :first, :conditions => {find_column_name => params[:id]}
+          record = scope.send :find, :first, :conditions => {mdl.routing_attribute => params[:id]}
           record || required_callback(:after_failed_find)
         end
       end

data/lib/hammock/restful_actions.rb

@@ -142,7 +142,7 @@ module Hammock
 
       def find_record_on_create
         if findable_on_create?
-          if record = nest_scope.find(:first, :conditions => params_for(mdl.symbolize))
+          if record = current_nest_scope.find(:first, :conditions => params_for(mdl.symbolize))
             log "suitable record already exists: #{record}"
             assign_entity record
           else

data/lib/hammock/restful_support.rb

@@ -29,8 +29,10 @@ module Hammock
         @hammock_cached_mdl_name ||= self.class.to_s.sub('Controller', '').singularize.underscore
       end
 
-      def current_route
-        @hammock_cached_current_route ||= route_for(action_name.to_sym, *current_nested_records.push(@entity)) unless @entity.nil?
+      # Returns the node in the Hammock routing map corresponding to the (possibly nested) resource handling the current request.
+      def current_hammock_resource
+        nesting_resources = params.keys.select {|k| /_id$/ =~ k }.map {|k| k.gsub(/_id$/, '').pluralize }
+        ActionController::Routing::Routes.route_map.base_for nesting_resources.push(mdl.resource_name).map(&:to_sym)
       end
 
       # Returns true if the current action represents an edit on +record+.
@@ -57,7 +59,7 @@ module Hammock
         elsif record_or_records.is_a? ActiveRecord::Base
           instance_variable_set "@#{mdl_name}", (@record = record_or_records)
         elsif record_or_records.is_a? Ambition::Context
-          # log "Unkicked query: #{record_or_records.to_s}"
+          log "Unkicked query: #{record_or_records.to_hash.inspect}"
           instance_variable_set "@#{mdl_name.pluralize}", (@records = record_or_records)
         elsif record_or_records.is_a? Array
           instance_variable_set "@#{mdl_name.pluralize}", (@records = record_or_records)
@@ -65,15 +67,25 @@ module Hammock
           raise "Unknown record(s) type #{record_or_records.class}."
         end
 
-        if assign_nestable_resources
-          @entity
-        else
-          escort :not_found
-        end
+        @entity if assign_nesting_entities
       end
 
       private
 
+      def assign_nesting_entities
+        results = nesting_scope_list.map &:kick
+
+        if results.all? {|records| records.length == 1 }
+          results.map {|records|
+            records.first
+          }.all? {|record|
+            log "nested record #{record.concise_inspect} assigned to @#{record.base_model}."
+            add_nested_entity record
+            instance_variable_set "@#{record.base_model}", record
+          }
+        end
+      end
+
       def make_new_record resource = mdl
         resource.new_with(params_for(resource.symbolize))
       end
@@ -92,39 +104,24 @@ module Hammock
         end
       end
 
-      def assign_nestable_resources
-        @current_nested_records, @current_nested_resources = [], []
-        params.symbolize_keys.dragnet(*nestable_resources.keys).all? {|param_name,column_name|
-          constant_name = param_name.to_s.sub(/_id$/, '').camelize
-          constant = Object.const_get constant_name rescue nil
-
-          if constant.nil?
-            log "'#{constant_name}' is not available for #{param_name}."
-          elsif (record = constant.find_by_id(params[param_name])).nil?
-            log "#{constant}<#{params[param_name]}> not found."
-          else
-            @current_nested_records << record
-            @current_nested_resources << record.class
-            @record.send "#{nestable_resources[param_name]}=", params[param_name] unless @record.nil?
-            # log "Assigning @#{constant.name.underscore} with #{record.inspect}."
-            instance_variable_set "@#{constant_name.underscore}", record
-          end
-        }
-      end
-
       def current_nested_records
-        @current_nested_records.nil? ? [] : @current_nested_records.dup
+        (@current_nested_records || []).dup
       end
 
       def current_nested_resources
-        @current_nested_resources.nil? ? [] : @current_nested_resources.dup
+        (@current_nested_resources || []).dup
+      end
+
+      def add_nested_entity entity
+        (@current_nested_records ||= []).push entity
+        (@current_nested_resources ||= []).push entity.resource
       end
 
       def nested_within? record_or_resource
         if record_or_resource.is_a? ActiveRecord::Base
-          @current_nested_records.include? record_or_resource
+          current_nested_records.include? record_or_resource
         else
-          @current_nested_resources.include? record_or_resource
+          current_nested_resources.include? record_or_resource
         end
       end
 
@@ -136,8 +133,15 @@ module Hammock
         @editing = @record
       end
 
+      # TODO process /^creating_\w+_id$/ as well
       def set_creator_id_if_appropriate
-        @record.creator_id = @current_account.id if @record.respond_to?(:creator_id=)
+        if @record.respond_to?(:creator_id=)
+          if @current_account.nil?
+            log "Warning: @#{@record.base_model}.creator_id isn't being set, since @current_account was nil."
+          else
+            @record.creator_id = @current_account.id
+          end
+        end
       end
 
       def partial_exists? name, extension = nil

data/lib/hammock/route_for.rb

@@ -47,7 +47,7 @@ module Hammock
       def nested_route_for *resources
         resources.delete_if &:nil?
         requested_verb = resources.shift if resources.first.is_a?(Symbol)
-        args = @current_nested_records.dup.concat(resources)
+        args = current_nested_records.concat(resources)
 
         args.unshift(requested_verb) unless requested_verb.nil?
         route_for *args

data/lib/hammock/route_node.rb

@@ -0,0 +1,159 @@
+module Hammock
+  class RouteNode < ActionController::Resources::Resource
+
+    DefaultRecordVerbs = {
+      :show => :get,
+      :edit => :get,
+      :update => :put,
+      :destroy => :delete
+    }.freeze
+    DefaultResourceVerbs = {
+      :index => :get
+    }.freeze
+    DefaultBuildVerbs = {
+      :new => :get,
+      :create => :post
+    }.freeze
+
+    attr_reader :mdl, :resource, :parent, :children, :routing_parent, :record_routes, :resource_routes, :build_routes
+
+    def initialize entity = nil, options = {}
+      @parent = options[:parent]
+      @children = {}
+      unless root?
+        @mdl = entity if entity.is_a?(Symbol)
+        @routing_parent = determine_routing_parent
+        define_routes options
+      end
+    end
+
+    def resource
+      # TODO performance
+      Object.const_get mdl.to_s.classify rescue nil
+    end
+
+    def root?
+      parent.nil?
+    end
+
+    def ancestry
+      root? ? [] : parent.ancestry.push(self)
+    end
+
+    def for verb, entities, options
+      raise "Hammock::RouteNode#for requires an explicitly specified verb as its first argument." unless verb.is_a?(Symbol)
+      raise "You have to supply an Array of at least one record or resource." if entities.empty? unless entities.is_a?(Array)
+
+      entity = entities.shift
+
+      if entities.empty?
+        steps_for verb, entity
+      else
+        children[entity.resource_sym].for(verb, entities, options).within steps_for(nil, entity)
+      end
+    end
+
+    def base_for resources
+      # puts "base_for<#{mdl}>: resources=#{resources.inspect}."
+      if resources.empty?
+        self
+      else
+        match = nil
+        children.values.detect {|child|
+          # puts "  Trying #{child.ancestry.map(&:mdl).inspect} for #{resources.inspect}"
+          if !resources.include?(child.mdl)
+            # puts "  Can't match #{resources.inspect} against #{child.mdl}."
+            nil
+          else
+            # puts "  Matched #{child.mdl} from #{resources.inspect}."
+            match = child.base_for resources.discard(child.mdl)
+          end
+        } #|| raise("There is no routing path for #{resources.map(&:inspect).inspect}.")
+        match
+      end
+    end
+
+    def nesting_scope_list_for params
+      if root?
+        [ ]
+      else
+        parent.nesting_scope_list_for(params).push nesting_scope_segment_for(params)
+      end
+    end
+
+    def nesting_scope_segment_for params
+      raise "The root of the route map isn't associated with a resource." if root?
+      puts "is this undefined? #{resource.accessible_attributes_on_create.inspect}"
+      value = params.delete resource.param_key
+      puts "resource.select {|r| r.#{resource.routing_attribute} == value }"
+      eval "resource.select {|r| r.#{resource.routing_attribute} == value }"
+    end
+
+    def add entity, options, steps = nil
+      if steps.nil?
+        add entity, options, (options[:name_prefix] || '').chomp('_').split('_').map {|i| i.pluralize.underscore.to_sym }
+      elsif steps.empty?
+        add_child entity, options
+      else
+        children[steps.shift].add entity, options, steps
+      end
+    end
+
+    def routeable_as verb, entity
+      if entity.record? && record_routes[verb || :show]
+        :record
+      elsif entity.resource? && resource_routes[verb || :index]
+        :resource
+      elsif !verb.nil? && build_routes[verb]
+        :build
+      end
+    end
+
+    private
+
+    def define_routes options
+      @record_routes = DefaultRecordVerbs.dup.update(options[:member] || {})
+      @resource_routes = DefaultResourceVerbs.dup.update(options[:collection] || {})
+      @build_routes = DefaultBuildVerbs.dup.update(options[:build] || {})
+    end
+
+    def determine_routing_parent
+      puts "\ndetermine_routing_parent: #{mdl}:"
+      if parent.nil? || parent.resource.nil?
+        puts "Resource for #{mdl} has either no parent or no resource - not nestable."
+        nil
+      else
+        puts "reflections: #{resource.reflections.keys.inspect}"
+        puts "nestable_routing_resources: #{resource.nestable_routing_resources.inspect}"
+        scannable_reflections = resource.nestable_routing_resources.nil? ? resource.reflections : resource.reflections.dragnet(*resource.nestable_routing_resources)
+        puts "scannable reflections: #{scannable_reflections.keys.inspect}"
+        valid_reflections = scannable_reflections.selekt {|k,v| puts "#{v.klass}<#{v.object_id}> == #{parent.resource}<#{parent.resource.object_id}> #=> #{v.klass == parent.resource}"; v.klass == parent.resource }
+        puts "valid reflections: #{valid_reflections.keys.inspect}"
+
+        if valid_reflections.keys.length < 1
+          raise "The routing table specifies that #{mdl} is nested within #{parent.mdl}, but there is no ActiveRecord association linking #{resource} to #{parent.resource}. Example: 'belongs_to :#{parent.resource.base_model}' in the #{resource} model."
+        elsif valid_reflections.keys.length > 1
+          raise "#{resource} defines more than one association to #{parent.resource} (#{valid_reflections.keys.map(&:to_s).join(', ')}). That's fine, but you need to use #{resource}.nest_within to specify the one Hammock should nest scopes through. For example, 'nest_within #{valid_reflections.keys.first.inspect}' in the #{resource} model."
+        end
+
+        valid_reflections.keys.first
+      end
+    end
+
+    def add_child entity, options
+      child = RouteNode.new entity, options.merge(:parent => self)
+      children[child.mdl] = child
+    end
+
+    def steps_for verb, entity
+      child = children[entity.resource_sym]
+
+      if child.nil?
+        raise "No routes are defined for #{entity.resource}#{' within ' + ancestry.map {|r| r.mdl.to_s }.join(', ') unless ancestry.empty?}."
+      else
+        RouteStep.new(child).for(verb, entity)
+      end
+    end
+
+  end
+end

data/lib/hammock/route_step.rb

@@ -0,0 +1,87 @@
+module Hammock
+  class RouteStep
+    attr_reader :resource, :routeable_as, :verb, :entity, :parent
+
+    def initialize resource
+      @resource = resource
+    end
+
+    def for verb, entity
+      routeable_as = resource.routeable_as(verb, entity)
+
+      if !routeable_as
+        raise "The verb '#{verb}' can't be applied to " + (entity.record? ? "#{entity.resource} records" : "the #{entity.resource} resource") + "."
+      elsif (:record == routeable_as) && entity.new_record?
+        raise "The verb '#{verb}' requires a #{entity.resource} with an ID (i.e. not a new record)."
+      elsif (:build == routeable_as) && entity.record? && !entity.new_record?
+        raise "The verb '#{verb}' requires either the #{entity.resource} resource, or a #{entity.resource} without an ID (i.e. a new record)."
+      else
+        @verb, @entity, @routeable_as = verb, entity, routeable_as
+      end
+
+      self
+    end
+
+    def within parent
+      @parent = parent
+      self
+    end
+
+    def setup?
+      !@entity.nil?
+    end
+
+    def path params = nil
+      raise_unless_setup_while_trying_to 'render a path'
+
+      buf = '/'
+      buf << entity.resource_name
+      buf << '/' + entity.to_param if entity.record? && !entity.new_record?
+      buf << '/' + verb.to_s unless verb.nil? or implied_verb?(verb)
+
+      buf = parent.path + buf unless parent.nil?
+      buf << param_str(params)
+
+      buf
+    end
+
+    def http_method
+      raise_unless_setup_while_trying_to 'extract the HTTP method'
+      resource.send("#{routeable_as}_routes")[verb]
+    end
+
+    def fake_http_method
+      http_method.in?(:get, :post) ? http_method : :post
+    end
+
+    def get?;       :get == http_method end
+    def post?;     :post == http_method end
+    def put?;       :put == http_method end
+    def delete?; :delete == http_method end
+
+    def safe?
+      get? && !verb.in?(Hammock::Constants::ImpliedUnsafeActions)
+    end
+
+    private
+
+    def implied_verb? verb
+      verb.in? :index, :create, :show, :update, :destroy
+    end
+
+    def raise_unless_setup_while_trying_to task
+      raise "You have to call for(verb, entity) (and optionally within(parent)) on this RouteStep before you can #{task}." unless setup?
+    end
+
+    def param_str params
+      link_params = entity.record? ? entity.unsaved_attributes.merge(params || {}) : params
+
+      if link_params.blank?
+        ''
+      else
+        '?' + {entity.base_model => link_params}.to_query
+      end
+    end
+
+  end
+end

data/lib/hammock/scope.rb

@@ -62,7 +62,7 @@ module Hammock
         end
       end
 
-      def verb_scope
+      def current_verb_scope
         if @current_account && (scope_name = account_verb_scope?)
           # log "got an account_verb_scope #{scope_name}."
           mdl.send scope_name, @current_account
@@ -75,17 +75,24 @@ module Hammock
         end
       end
 
-      def nest_scope
-        params.symbolize_keys.dragnet(*nestable_resources.keys).inject(mdl.ambition_context) {|acc,(k,v)|
-          # TODO this would be more ductile if it used AR assocs instead of explicit FK
-          eval "acc.select {|r| r.#{nestable_resources[k]} == v }"
-        }
+      def nesting_scope_list
+        @hammock_cached_nesting_scope_list = current_hammock_resource.parent.nesting_scope_list_for params.selekt {|k,v| /_id$/ =~ k }
+      end
+
+      def current_nest_scope
+        nesting_scope_list.reverse.inject {|acc,scope| acc.within scope }
       end
 
       def current_scope
-        if (resultant_scope = nest_scope.chain(verb_scope)).nil?
+        log "#{current_hammock_resource.mdl}, #{current_hammock_resource.ancestry.map(&:mdl).inspect}"
+        if (verb_scope = current_verb_scope).nil?
+          nil
+        elsif (resultant_scope = verb_scope.within(current_nest_scope, current_hammock_resource.routing_parent)).nil?
           nil
         else
+          # puts "nest: #{current_nest_scope.clauses.inspect}"
+          # puts "verb: #{current_verb_scope.clauses.inspect}"
+          puts "chained in (#{resultant_scope.owner}) current_scope: #{resultant_scope.clauses.inspect}"
           resultant_scope = resultant_scope.chain(custom_scope) unless custom_scope.nil?
           resultant_scope.sort_by &mdl.sorter
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: benhoskings-hammock
 version: !ruby/object:Gem::Version 
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors: 
 - Ben Hoskings
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-27 00:00:00 -08:00
+date: 2009-03-05 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -63,6 +63,7 @@ files:
 - hammock.gemspec
 - lib/hammock.rb
 - lib/hammock/ajaxinate.rb
+- lib/hammock/callback.rb
 - lib/hammock/callbacks.rb
 - lib/hammock/canned_scopes.rb
 - lib/hammock/constants.rb
@@ -91,6 +92,8 @@ files:
 - lib/hammock/restful_support.rb
 - lib/hammock/route_drawing_hooks.rb
 - lib/hammock/route_for.rb
+- lib/hammock/route_node.rb
+- lib/hammock/route_step.rb
 - lib/hammock/scope.rb
 - lib/hammock/suggest.rb
 - lib/hammock/utils.rb
@@ -98,7 +101,6 @@ files:
 - misc/template.rb
 - tasks/hammock_tasks.rake
 - test/hammock_test.rb
-- test/rails_root/test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/benhoskings/hammock
 post_install_message: 
@@ -126,5 +128,5 @@ rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Hammock is a Rails plugin that eliminates redundant code in a very RESTful manner
-test_files: 
-- test/rails_root/test/test_helper.rb
+test_files: []
+