resourcelogic 0.9.0 → 0.10.0

data/lib/resourcelogic/self.rb

@@ -3,181 +3,145 @@ module Resourcelogic
     def self.included(klass)
       klass.class_eval do
         extend Config
-        add_acts_as_resource_module(Urls)
+        add_acts_as_resource_module(UrlParts)
         add_acts_as_resource_module(Reflection)
       end
     end
     
     module Config
       def model_name(value = nil)
-        config(:model_name, value, controller_name.singularize.underscore)
+        rw_config(:model_name, value, model_name_from_name)
       end
       
       def object_name(value = nil)
-        config(:object_name, value, controller_name.singularize.underscore)
-      end
-      
-      def route_name(value = nil)
-        config(:route_name, value, controller_name.singularize.underscore)
-      end
-    end
-    
-    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
+        rw_config(:object_name, value, model_name_from_name)
       end
       
       private
-        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)
+        def model_name_from_name
+          name.underscore.split("/").first.gsub(/_controller/, "").singularize.underscore.to_sym
         end
+    end
     
+    module UrlParts
+      private
         # Used internally to provide the options to smart_url from Urligence.
         #
-        def collection_url_options(url_params = {})
-          namespaces + [parent_url_options, route_name.to_s.pluralize.to_sym, url_params]
+        def collection_url_parts(action = nil, url_params = {})
+          [action] + contexts_url_parts + [route_name.to_s.pluralize.to_sym, url_params]
         end
-    
+        
         # 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
+        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]
+        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
           else
-            alternate_object = alternate_object_or_params
+            obj = object_or_params.first
           end
-          
-          [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]
+          [obj, url_params]
         end
     end
     
     module Reflection
       def self.included(klass)
-        klass.helper_method :model_name, :collection, :object
+        klass.helper_method :model_name, :collection, :object, :path_name, :route_name
       end
       
       private
-        # Convenience method for the class level model_name method
-        def model_name
-          self.class.model_name
+        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
         
-        # Convenience method for the class level object_name method
-        def object_name
-          self.class.object_name
+        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 route_name method
-        def route_name
-          self.class.route_name
+        # Convenience method for the class level model_name method
+        def model_name
+          @model_name ||= self.class.model_name.to_sym
         end
         
-        # The current model for the resource.
-        def model # :doc:
-          model_name.to_s.camelize.constantize
+        def model
+          @model ||= model_name.to_s.camelize.constantize
+        end
+        
+        # Convenience method for the class level object_name method
+        def object_name
+          @object_name ||= self.class.object_name.to_sym
         end
         
         # The collection for the resource.
         def collection # :doc:
-          end_of_association_chain.all
+          @collection ||= scope.all
         end
 
         # The current paremter than contains the object identifier.
-        def param # :doc:
-          params[:id]
+        def id # :doc:
+         params[:id]
+        end
+        
+        def id?
+          params.key?(:id)
         end
         
         # The parameter hash that contains the object attributes.
-        def object_params
-          params["#{object_name}"]
+        def attributes
+          params[object_name]
         end
-
+        
+        def attributes?
+          params.key?(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:
-          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
+          @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)
         end
     end
   end

data/lib/resourcelogic/sibling.rb

@@ -7,55 +7,13 @@ 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 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]
+        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]
         end
         
-        def sibling_collection_url_options(sibling_name, url_params = {})
-          namespaces + [parent_url_options, sibling_name, url_params]
+        def sibling_collection_url_parts(action = nil, sibling_name = nil, url_params = {})
+          [action] + contexts_url_parts + [sibling_name, url_params]
         end
     end
   end

data/lib/resourcelogic/singleton.rb

@@ -4,70 +4,52 @@ module Resourcelogic
   module Singleton
     def self.included(klass)
       klass.class_eval do
-        extend Config
-      end
-    end
-    
-    module Config
-      def singleton(value = nil)
-        include Methods if value == true
-        config(:singleton, value)
-      end
-      
-      def singleton?
-        singleton == true
+        add_acts_as_resource_module(Methods)
       end
     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) }
+      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
       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
+      def build_object
+        if singleton? && parent?
+          scope.send("build_#{model_name}")
+        else
+          super
         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
+      
+      def scope
+        if singleton? && parent?
+          parent_object
+        else
+          super
         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
     end
   end
 end

data/lib/resourcelogic/urligence.rb

@@ -1,57 +1,60 @@
 module Resourcelogic
   module Urligence
-    def smart_url(*objects)
-      url_params = objects.extract_options!
-      objects.push(:url)
-      objects.push(url_params)
-      urligence(*objects)
+    def self.included(klass)
+      klass.helper_method :smart_url, :smart_path, :hash_for_smart_url, :hash_for_smart_path, :method_missing
     end
-  
-    def smart_path(*objects)
-      url_params = objects.extract_options!
-      objects.push(:path)
-      objects.push(url_params)
-      urligence(*objects)
+    
+    def smart_url(*url_parts)
+      url_params = url_parts.extract_options!
+      url_parts.push(:url)
+      url_parts.push(url_params)
+      urligence(*url_parts)
     end
-  
-    def hash_for_smart_url(*objects)
-      urligence(*objects.unshift(:hash_for).push(:url).push({:type => :hash}))
+    
+    def smart_path(*url_parts)
+      url_params = url_parts.extract_options!
+      url_parts.push(:path)
+      url_parts.push(url_params)
+      urligence(*url_parts)
     end
-  
-    def hash_for_smart_path(*objects)
-      urligence(*objects.unshift(:hash_for).push(:path).push({:type => :hash}))
+    
+    def hash_for_smart_url(*url_parts)
+      urligence(*url_parts.unshift(:hash_for).push(:url).push({:type => :hash}))
     end
-  
-    def urligence(*objects)
-      objects = cleanup_url_objects(objects)
-      url_fragments = extract_url_fragments(objects)
-      url_objects = extract_url_objects(objects)
     
-      begin
-        if objects.first != :hash_for
-          send url_fragments.join("_"), *url_objects
+    def hash_for_smart_path(*url_parts)
+      urligence(*url_parts.unshift(:hash_for).push(:path).push({:type => :hash}))
+    end
+    
+    private
+      def urligence(*url_parts)
+        url_parts = cleanup_url_parts(url_parts)
+        method_name_fragments = extract_method_name_fragments(url_parts)
+        method_arguments = extract_method_arguments(url_parts)
+        
+        if url_parts.first != :hash_for
+          send method_name_fragments.join("_"), *method_arguments
         else
-          url_params = url_objects.extract_options!
+          url_params = method_arguments.extract_options!
           params = {}
-          url_objects.each_with_index do |obj, i|
-            key = i == (url_objects.size - 1) ? :id : (obj.is_a?(Array) ? "#{obj.first}_id".to_sym : "#{obj.class.name.underscore}_id".to_sym)
+          method_arguments.each_with_index do |obj, i|
+            key = i == (method_arguments.size - 1) ?
+              :id :
+              (obj.is_a?(Array) ? "#{obj.first}_id".to_sym : "#{obj.class.name.underscore}_id".to_sym)
             params.merge!((obj.is_a?(Array)) ? {key => obj[1].to_param} : {key => obj.to_param})
           end
-    
+          
           params.merge!(url_params)
-          send url_fragments.join("_"), params
+          send method_name_fragments.join("_"), params
         end
-      rescue NoMethodError
-        raise objects.inspect
       end
-    end
-  
-    private
+      
       # The point of this method is to replace any object if a url param is passed. For example:
       #
-      #   [:user, user_object], {:user_id => 4}
+      #   [:admin, [:user, user_object], {:user_id => 4}]
       #
-      # The "user_object" should be replaced by user with id 4.
+      # The "user_object" should be replaced by user with id 4, since we are explicitly saying we want to use User.find(4).
+      # The last part is the url_params.
       #
       # This also pluralizes path names if the obj is nil. Example:
       #
@@ -67,31 +70,35 @@ module Resourcelogic
       #   payments/credit_cards
       #
       # You can manage and select a credit card from the credit cards resource but a payment object
-      # is not needed.
-      def cleanup_url_objects(objects)
-        objects = objects.compact
-        url_params = objects.last.is_a?(Hash) ? objects.last : {}
-        non_symbol_object_total = objects.select { |object| !object.is_a?(Symbol) }.size - 1
-        non_symbol_object_count = 0
-        new_objects = []
-        objects.each do |object|
-          non_symbol_object_count += 1 if !object.is_a?(Symbol)
+      # is not needed. In a sense you are just creating a "payments" context.
+      def cleanup_url_parts(url_parts)
+        url_parts = url_parts.compact
+        url_params = url_parts.last.is_a?(Hash) ? url_parts.last : {}
+        new_url_parts = []
+        
+        url_parts.each do |object|
           if !object.is_a?(Array)
-            new_objects << object
+            # It's not an array, just copy it over
+            new_url_parts << object
           else
+            # Let's try to 
             klass = object.first.to_s.camelize.constantize rescue nil
-            klass_name = klass ? klass.name.underscore : nil
-            key = (non_symbol_object_count == non_symbol_object_total) ? :id : "#{object.first}_id".to_sym
-            obj = (url_params.key?(key) ? ((!klass && url_params[key]) || (url_params[key] && klass.find(url_params.delete(key)))) : object[1])
-            new_objects << (obj.nil? ? object.first.to_s.pluralize.to_sym : [object.first, obj])
+            #klass_name = klass ? klass.name.underscore : nil
+            params_key = "#{object.first}_id".to_sym
+            obj = if url_params.key?(params_key)
+              (!klass && url_params[params_key]) || (url_params[params_key] && klass.find(url_params.delete(params_key)))
+            else
+              object[1]
+            end
+            new_url_parts << [object.first, obj]
+            #new_url_parts << (obj.nil? ? object.first.to_s.pluralize.to_sym : [object.first, obj])
           end
         end
-        new_objects
+        new_url_parts
       end
-  
-  
-      def extract_url_fragments(objects)
-        fragments = objects.collect do |obj|
+      
+      def extract_method_name_fragments(url_parts)
+        fragments = url_parts.collect do |obj|
           if obj.is_a?(Symbol)
             obj
           elsif obj.is_a?(Array)
@@ -102,9 +109,20 @@ module Resourcelogic
         end
         fragments.compact
       end
-    
-      def extract_url_objects(objects)
-        objects.flatten.select { |obj| !obj.is_a?(Symbol) }
+      
+      def extract_method_arguments(url_parts)
+        url_parts.flatten.select { |obj| !obj.is_a?(Symbol) }
+      end
+      
+      def method_missing(method, *args, &block)
+        if method.to_s =~ /^((.*)_)?(child_collection|parent_collection|sibling|sibling_collection)_(path|url)$/ || method.to_s =~ /^((.*)_)?(child|collection|object|parent)_(path|url)$/
+          action = $2.blank? ? nil : $2.to_sym
+          target = $3
+          url_type = $4
+          send("smart_#{url_type}", *send("#{target}_url_parts", action, *args))
+        else
+          super
+        end
       end
   end
 end