resourcelogic 0.0.12 → 0.9.0

data/lib/resourcelogic/response_collector.rb

@@ -10,13 +10,8 @@ module Resourcelogic
     end
     
     def method_missing(method_name, &block)
-      existing = self[method_name]
-      if existing
-        existing[0] = method_name
-        existing[1] = block || nil
-      else
-        @responses << [method_name, block || nil]
-      end
+      @responses.delete self[method_name]
+      @responses << [method_name, block || nil]
     end
     
     def [](symbol)

data/lib/resourcelogic/self.rb

@@ -3,145 +3,181 @@ module Resourcelogic
     def self.included(klass)
       klass.class_eval do
         extend Config
-        add_acts_as_resource_module(UrlParts)
+        add_acts_as_resource_module(Urls)
         add_acts_as_resource_module(Reflection)
       end
     end
     
     module Config
       def model_name(value = nil)
-        rw_config(:model_name, value, model_name_from_name)
+        config(:model_name, value, controller_name.singularize.underscore)
       end
       
       def object_name(value = nil)
-        rw_config(:object_name, value, model_name_from_name)
+        config(:object_name, value, controller_name.singularize.underscore)
       end
       
-      private
-        def model_name_from_name
-          name.underscore.split("/").first.gsub(/_controller/, "").singularize.underscore.to_sym
-        end
+      def route_name(value = nil)
+        config(:route_name, value, controller_name.singularize.underscore)
+      end
     end
     
-    module UrlParts
+    module Urls
+      def self.included(klass)
+        klass.helper_method :object_url, :object_path, :hash_for_object_url, :hash_for_object_path, :edit_object_url, :edit_object_path, :hash_for_edit_object_url,
+          :hash_for_edit_object_path, :new_object_url, :new_object_path, :hash_for_new_object_url, :hash_for_new_object_path, :collection_url, :collection_path,
+          :hash_for_collection_url, :hash_for_collection_path
+      end
+      
       private
-        # Used internally to provide the options to smart_url from Urligence.
-        #
-        def collection_url_parts(action = nil, url_params = {})
-          [action] + contexts_url_parts + [route_name.to_s.pluralize.to_sym, url_params]
+        def object_url(*objects) # :doc:
+          smart_url *object_url_options(nil, objects)
+        end
+        
+        def object_path(*objects)
+          smart_path *object_url_options(nil, objects)
+        end
+        
+        def hash_for_object_url(*objects)
+          hash_for_smart_url *object_url_options(nil, objects)
+        end
+        
+        def hash_for_object_path(*objects)
+          hash_for_smart_path *object_url_options(nil, objects)
+        end
+        
+        def edit_object_url(*objects)
+          smart_url *object_url_options(:edit, objects)
+        end
+        
+        def edit_object_path(*objects)
+          smart_path *object_url_options(:edit, objects)
         end
         
+        def hash_for_edit_object_url(*objects)
+          hash_for_smart_url *object_url_options(:edit, objects)
+        end
+        
+        def hash_for_edit_object_path(*objects)
+          hash_for_smart_path *object_url_options(:edit, objects)
+        end
+    
+        def new_object_url(url_params = {})
+          smart_url *new_object_url_options(url_params)
+        end
+    
+        def new_object_path(url_params = {})
+          smart_path *new_object_url_options(url_params)
+        end
+    
+        def hash_for_new_object_url(url_params = {})
+          hash_for_smart_url *new_object_url_options(url_params)
+        end
+    
+        def hash_for_new_object_path(url_params = {})
+          hash_for_smart_path *new_object_url_options(url_params)
+        end
+    
+        def collection_url(url_params = {})
+          smart_url *collection_url_options(url_params)
+        end
+    
+        def collection_path(url_params = {})
+          smart_path *collection_url_options(url_params)
+        end
+    
+        def hash_for_collection_url(url_params = {})
+          hash_for_smart_url *collection_url_options(url_params)
+        end
+    
+        def hash_for_collection_path(url_params = {})
+          hash_for_smart_path *collection_url_options(url_params)
+        end
+    
         # Used internally to provide the options to smart_url from Urligence.
         #
-        def object_url_parts(action = nil, *alternate_object_or_params)
-          alternate_object, url_params = identify_object_or_params(alternate_object_or_params)
-          url_object = alternate_object
-          url_object = object if url_object.nil? && object && !object.new_record?
-          object_parts = url_object ?
-            [route_name, url_object] :
-            (action == :new || singleton? ? route_name : route_name.to_s.pluralize.to_sym)
-          [action] + contexts_url_parts + [object_parts, url_params]
+        def collection_url_options(url_params = {})
+          namespaces + [parent_url_options, route_name.to_s.pluralize.to_sym, url_params]
         end
-        
-        def identify_object_or_params(object_or_params)
-          obj = nil
-          url_params = {}
-          if object_or_params.size > 1
-            url_params = object_or_params.last if object_or_params.last.is_a?(Hash)
-            obj = object_or_params.first
-          elsif object_or_params.first.is_a?(Hash)
-            url_params = object_or_params.first
+    
+        # Used internally to provide the options to smart_url from Urligence.
+        #
+        def object_url_options(action_prefix = nil, alternate_object_or_params = nil)
+          alternate_object = nil
+          url_params = nil
+          case alternate_object_or_params
+          when Array
+            url_params = alternate_object_or_params.last if alternate_object_or_params.last.is_a?(Hash)
+            alternate_object = alternate_object_or_params.first
+          when Hash
+            url_params = alternate_object_or_params
           else
-            obj = object_or_params.first
+            alternate_object = alternate_object_or_params
           end
-          [obj, url_params]
+          
+          [action_prefix] + namespaces + [parent_url_options, [route_name.to_sym, alternate_object || (param ? object : nil)], url_params]
+        end
+    
+        # Used internally to provide the options to smart_url from Urligence.
+        #
+        def new_object_url_options(url_params = {})
+          [:new] + namespaces + [parent_url_options, route_name.to_sym, url_params]
         end
     end
     
     module Reflection
       def self.included(klass)
-        klass.helper_method :model_name, :collection, :object, :path_name, :route_name
+        klass.helper_method :model_name, :collection, :object
       end
       
       private
-        def path_name
-          return @path_name if defined?(@path_name)
-          path_parts = request.path.split("/")
-          path_parts.reverse.each do |path_part|
-            next if path_part.blank?
-            if model_name_from_path_part(path_part) == model_name
-              return @path_name = path_part.to_sym
-            end
-          end
-          @path_name = nil
-        end
-        
-        def route_name
-          return @route_name if defined?(@route_name)
-          path_parts = request.path.split("/")
-          path_parts.reverse.each do |path_part|
-            next if path_part.blank?
-            if model_name_from_path_part(path_part) == model_name
-              return @route_name = route_name_from_path_part(path_part)
-            end
-          end
-          @route_name = model_name
-        end
-        
         # Convenience method for the class level model_name method
         def model_name
-          @model_name ||= self.class.model_name.to_sym
-        end
-        
-        def model
-          @model ||= model_name.to_s.camelize.constantize
+          self.class.model_name
         end
         
         # Convenience method for the class level object_name method
         def object_name
-          @object_name ||= self.class.object_name.to_sym
+          self.class.object_name
+        end
+        
+        # Convenience method for the class level route_name method
+        def route_name
+          self.class.route_name
+        end
+        
+        # The current model for the resource.
+        def model # :doc:
+          model_name.to_s.camelize.constantize
         end
         
         # The collection for the resource.
         def collection # :doc:
-          @collection ||= scope.all
+          end_of_association_chain.all
         end
 
         # The current paremter than contains the object identifier.
-        def id # :doc:
-         params[:id]
-        end
-        
-        def id?
-          params.key?(:id)
+        def param # :doc:
+          params[:id]
         end
         
         # The parameter hash that contains the object attributes.
-        def attributes
-          params[object_name]
-        end
-        
-        def attributes?
-          params.key?(object_name)
+        def object_params
+          params["#{object_name}"]
         end
-        
+
         # The current member being used. If no param is present, it will look for
         # a current_#{object_name} method. For example, if you have a UsersController
         # and its a singleton controller, meaning no identifier is needed, this will
         # look for a current_user method. If this is not the behavioru you want, simply
         # overwrite this method.
         def object # :doc:
-          @object ||= id? ? find_object : build_object
-        end
-        
-        def build_object
-          obj = scope.respond_to?(:build) ? scope.build : scope.new
-          obj.attributes = attributes
-          obj
-        end
-        
-        def find_object
-          scope.find(id)
+          return @object if defined?(@object)
+          if param.nil? && respond_to?("current_#{object_name}", true)
+            @object = send("current_#{object_name}")
+          else
+            @object = end_of_association_chain.find(param)
+          end
         end
     end
   end

data/lib/resourcelogic/sibling.rb

@@ -7,13 +7,55 @@ module Resourcelogic
     end
     
     module Urls
+      def self.included(klass)
+        klass.helper_method :new_sibling_url, :new_sibling_path, :edit_sibling_url, :edit_sibling_path,
+          :sibling_url, :sibling_path, :sibling_collection_url, :sibling_collection_path
+      end
+      
       private
-        def sibling_url_parts(action = nil, sibling = nil, url_params = {})
-          [action] + contexts_url_parts + [sibling.is_a?(Symbol) ? sibling : [sibling.class.name.underscore.to_sym, sibling], url_params]
+        def new_sibling_url(sibling_name, url_params = {})
+          smart_url *new_sibling_url_options(sibling_name, url_params)
+        end
+        
+        def new_sibling_path(sibling_name, url_params = {})
+          smart_path *new_sibling_url_options(sibling_name, url_params)
+        end
+        
+        def edit_sibling_url(sibling, url_params = {})
+          smart_url *sibling_url_options(sibling, :edit, url_params)
+        end
+        
+        def edit_sibling_path(sibling, url_params = {})
+          smart_path *sibling_url_options(sibling, :edit, url_params)
+        end
+        
+        def sibling_url(sibling, url_params = {})
+          smart_url *sibling_url_options(sibling, url_params)
+        end
+        
+        def sibling_path(sibling, url_params = {})
+          smart_path *sibling_url_options(sibling, url_params)
+        end
+        
+        def sibling_collection_url(sibling_name, url_params = {})
+          smart_url *sibling_collection_url_options(sibling_name, url_params)
+        end
+        
+        def sibling_collection_path(sibling_name, url_params = {})
+          smart_path *sibling_collection_url_options(sibling_name, url_params)
+        end
+        
+        def new_sibling_url_options(sibling_name, url_params = {})
+          [:new] + namespaces + [parent_url_options, sibling_name, url_params]
+        end
+        
+        def sibling_url_options(sibling, *action_prefix_or_params)
+          action_prefix, url_params = identify_action_prefix_or_params(action_prefix_or_params)
+          [action_prefix] + namespaces + [parent_url_options, [sibling.class.name.underscore.to_sym, sibling], url_params]
         end
         
-        def sibling_collection_url_parts(action = nil, sibling_name = nil, url_params = {})
-          [action] + contexts_url_parts + [sibling_name, url_params]
+        def sibling_collection_url_options(sibling_name, url_params = {})
+          namespaces + [parent_url_options, sibling_name, url_params]
         end
     end
   end

data/lib/resourcelogic/singleton.rb

@@ -4,52 +4,70 @@ module Resourcelogic
   module Singleton
     def self.included(klass)
       klass.class_eval do
-        add_acts_as_resource_module(Methods)
+        extend Config
       end
     end
     
-    module Methods
-      def object
-        return @object if defined?(@object)
-        
-        if singleton?
-          if !parent? && respond_to?("current_#{model_name}", true)
-            @object = send("current_#{model_name}")
-          elsif parent? && parent_object.send(model_name)
-            @object = parent_object.send(model_name)
-          else
-            super
-          end
-        else
-          super
-        end
+    module Config
+      def singleton(value = nil)
+        include Methods if value == true
+        config(:singleton, value)
       end
       
-      def build_object
-        if singleton? && parent?
-          scope.send("build_#{model_name}")
-        else
-          super
-        end
+      def singleton?
+        singleton == true
       end
-      
-      def scope
-        if singleton? && parent?
-          parent_object
-        else
-          super
+    end
+    
+    module Methods
+      def self.included(klass)
+        klass.class_eval do  
+          methods_to_undefine = [:index, :collection, :load_collection, :collection_url, 
+            :collection_path, :hash_for_collection_url, :hash_for_collection_path]
+          methods_to_undefine.each { |method| undef_method(method) if method_defined?(method) }
         end
       end
       
-      # Route alises can only be used for singleton, like account => user. Otherwise the urligence wont work because there is no account model.
-      def object_url_parts(action = nil, *alternate_object_or_params)
-        singleton? ? ([action] + contexts_url_parts + [route_name]) : super
-      end
-      
-      # Override me with true to make singleton
-      def singleton?
-        false
-      end
+      private
+        # Used to fetch the current object in a singleton controller.
+        #
+        # By defult this method is able to fetch the current object for resources nested with the :has_one association only. (i.e. /users/1/image # => @user.image)
+        # In other cases you should override this method and provide your custom code to fetch a singleton resource object, like using a session hash.
+        #
+        # class AccountsController < ResourceController::Singleton
+        #   private
+        #     def object
+        #       @object ||= Account.find(session[:account_id])
+        #     end
+        #   end
+        #  
+        def object
+          @object ||= parent? ? end_of_association_chain : nil
+        end
+
+        # Returns the :has_one association proxy of the parent. (i.e. /users/1/image # => @user.image)
+        #  
+        def parent_association
+          @parent_association ||= parent_object.send(model_name.to_sym)
+        end
+  
+        # Used internally to provide the options to smart_url in a singleton controller.
+        #  
+        def object_url_options(action_prefix = nil, alternate_object = nil)
+          [action_prefix] + namespaces + [parent_url_options, route_name.to_sym]
+        end
+  
+        # Builds the object, but doesn't save it, during the new, and create action.
+        #
+        def build_object
+          @object ||= singleton_build_object_base.send parent? ? "build_#{model_name}".to_sym : :new, object_params
+        end
+    
+        # Singleton controllers don't build off of association proxy, so we can't use end_of_association_chain here
+        #
+        def singleton_build_object_base
+          parent? ? parent_object : model
+        end
     end
   end
 end