resourcelogic 0.9.0 → 0.10.0

data/lib/resourcelogic/child.rb

@@ -7,89 +7,49 @@ module Resourcelogic
     end
     
     module Urls
-      def self.included(klass)
-        klass.helper_method :new_child_url, :new_child_path, :edit_child_url, :edit_child_path,
-          :child_url, :child_path, :child_collection_url, :child_collection_path
-      end
-      
       private
-        def new_child_url(child_name, url_params = {})
-          smart_url *new_child_url_options(child_name, url_params)
-        end
-        
-        def new_child_path(child_name, url_params = {})
-          smart_path *new_child_url_options(child_name, url_params)
-        end
-        
-        def edit_child_url(child, url_params = {})
-          smart_url *child_url_options(child, :edit, url_params)
-        end
-        
-        def edit_child_path(child, url_params = {})
-          smart_path *child_url_options(child, :edit, url_params)
-        end
-        
-        def child_url(child, url_params = {})
-          smart_url *child_url_options(child, url_params)
-        end
-        
         # The following should work
         #
         #   child_path(obj)
         #   child_path(obj, :id => 2) # where obj is then replaced by the obj with id 2
         #   child_path(:child_name, :id => 2) # where this is a literal build of the url
-        def child_path(child, url_params = {})
-          smart_path *child_url_options(child, url_params)
-        end
-        
-        def child_collection_url(child_name, url_params = {})
-          smart_url *child_collection_url_options(child_name, url_params)
-        end
-        
-        def child_collection_path(child_name, url_params = {})
-          smart_path *child_collection_url_options(child_name, url_params)
+        def child_url_parts(action = nil, child = nil, url_params = {})
+          child_base_parts(action, url_params) + [[child.is_a?(Symbol) ? child : child.class.name.underscore.to_sym, child], url_params]
         end
         
-        def new_child_url_options(child_name, url_params = {})
-          object_url_options(:new) + [child_name, url_params]
+        def child_collection_url_parts(action = nil, child_name = nil, url_params = {})
+          child_base_parts(action, url_params) + [child_name, url_params]
         end
         
-        def child_url_options(child, *action_prefix_or_params)
-          action_prefix, url_params = identify_action_prefix_or_params(action_prefix_or_params)
-          object_url_options(action_prefix) + [[child.is_a?(Symbol) ? child : child.class.name.underscore.to_sym, child], url_params]
-        end
-        
-        def child_collection_url_options(child_name, url_params = {})
-          object_url_options + [child_name, url_params]
-        end
-        
-        def find_object_for_child(url_params = {})
-          key = "#{model_name}_id".to_sym
-          url_params.key?(key) ? end_of_association_chain.find(url_params[key]) : object
-        end
-        
-        def find_child_name(child)
-          name = args.first.class.name.underscore.to_sym
-          return name if model.reflect_on_association(name)
-          
-          name = name.to_s.pluralize
-        end
-        
-        def identify_action_prefix_or_params(action_prefix_or_params)
-          action_prefix_or_params = action_prefix_or_params.first if action_prefix_or_params.is_a?(Array) && action_prefix_or_params.size <= 1
-          action_prefix = nil
-          url_params = {}
-          case action_prefix_or_params
-          when Array
-            url_params = action_prefix_or_params.last if action_prefix_or_params.last.is_a?(Hash)
-            action_prefix = action_prefix_or_params.first
-          when Symbol
-            action_prefix = action_prefix_or_params
-          when Hash
-            url_params = action_prefix_or_params
-          end
-          [action_prefix, url_params]
-        end
+        # This determines if the child if off of an object or the collection. Most of the time,
+        # as assumed, it will be off of an object. But let's say you are at this url:
+        #
+        #   /payments
+        #
+        # And you call this path:
+        #
+        #   child_collection(:credit_cards)
+        #
+        # There is no object to be a child off, we are in the collection / index action. But
+        # we still want to call the following url:
+        #
+        #   /payments/credit_cards
+        #
+        # That's what this method does, it makes the above possible. So you can still link
+        # to the "child" credit cards resource relatively, keeping the idea of contextual
+        # development intact. Maybe you only want to use payments as a context for the
+        # credit cards resource.
+        def child_base_parts(action, url_params)
+          object_to_use = (url_params.key?("#{model_name}_id".to_sym) && url_params["#{model_name}_id".to_sym]) || (id? && object)
+          base_parts = object_to_use || singleton? ? object_url_parts(action, object_to_use) : collection_url_parts(action)
+          base_parts.pop if base_parts.last.is_a?(Hash)
+          base_parts
+        end
+        
+        #def current_object_to_use(url_params)
+        #  result = (url_params.key?("#{model_name}_id".to_sym) && url_params["#{model_name}_id".to_sym]) || (id? && object)
+        #  result ? result : nil
+        #end
     end
   end
 end

data/lib/resourcelogic/context.rb

@@ -4,85 +4,48 @@ module Resourcelogic
   module Context
     def self.included(klass)
       klass.class_eval do
-        extend Config
         add_acts_as_resource_module(Methods)
       end
     end
     
-    module Config
-      def contextual_views(value = nil)
-        config(:contextual_views, value)
-      end
-
-      def contextual_views?
-        !contextual_views.blank?
-      end
-    end
-    
     module Methods
       def self.included(klass)
-        klass.helper_method :context, :contexts, :contextual_views, :contextual_views?, :context_template_name
+        klass.helper_method :context, :contexts, :contexts_url_parts
+        klass.hide_action :context, :contexts
       end
       
-      private
-        def context
-          @context ||= (parent? && (parent_alias || parent_model_name)) || (contexts.last && (contexts.last.is_a?(Array) ? contexts.last.first : contexts.last))
+      def context
+        @context ||= contexts.last
+      end
+      
+      def contexts
+        return @contexts if defined?(@contexts)
+        path_parts = request.path.split("/")
+        path_parts.shift
+        @contexts = []
+        path_parts.each_with_index do |part, index|
+          break if model_name_from_path_part(part.split(".").first) == model_name
+          @contexts << (part.to_i > 0 ? @contexts.pop.to_s.singularize.to_sym : part.underscore.to_sym)
         end
+        @contexts
+      end
       
-        # Returns all of the current namespaces of the current controller, symbolized, in array form.
-        def contexts
-          return @contexts if @contexts
+      private
+        def contexts_url_parts
+          return @contexts_url_parts if @contexts_url_parts
           path_parts = request.path.split("/")
           path_parts.shift
-          @contexts = []
+          @contexts_url_parts = []
           path_parts.each_with_index do |part, index|
-            part = part.split(".").first if (index + 1) == path_parts.size # for formats: blah.html or blah.js
-            break if [(parent_alias || parent_model_name).to_s.pluralize, (parent_alias || parent_model_name).to_s, route_name.to_s.pluralize].include?(part.underscore)
+            break if model_name_from_path_part(part.split(".").first) == model_name
             if part.to_i > 0
-              @contexts << [@contexts.pop.to_s.singularize.to_sym, part]
+              @contexts_url_parts << [route_name_from_path_part(@contexts_url_parts.pop), part.to_i]
             else
-              @contexts << part.underscore.to_sym
+              @contexts_url_parts << part.underscore.to_sym
             end
           end
-          @contexts
-        end
-        alias_method :namespaces, :contexts
-        
-        def contextual_views?
-          self.class.contextual_views?
-        end
-        
-        def contextual_views
-          self.class.contextual_views
-        end
-        
-        def context_template_name(name)
-          sub_folder = contextual_views.is_a?(Hash) && contextual_views.key?(context) ? contextual_views[context] : context
-          sub_folder ||= "root"
-          "#{controller_name}/#{sub_folder}/#{name}"
-        end
-        
-        def default_template_name(action_name = self.action_name)
-          if contextual_views?
-            context_template_name(action_name)
-          else
-            super
-          end
+          @contexts_url_parts
         end
     end
-    
-    module Partials
-      def _pick_partial_template(partial_path)
-        partial_path = context_template_name(partial_path) if respond_to?(:contextual_views?) && contextual_views? && !partial_path.include?("/")
-        super
-      end
-    end
-  end
-end
-
-
-module ActionView
-  class Base
-    include Resourcelogic::Context::Partials
   end
 end

data/lib/resourcelogic/parent.rb

@@ -17,157 +17,125 @@ module Resourcelogic
           @belongs_to[name.to_sym] = options
         end
       end
+      
+      def require_parent(value = nil)
+        rw_config(:require_parent, value, false)
+      end
     end
     
     module Urls
-      def self.included(klass)
-        klass.helper_method :new_parent_url, :new_parent_path, :edit_parent_url, :edit_parent_path, :parent_url, :parent_path,
-          :parent_collection_url, :parent_collection_path
-      end
-      
       private
-        def new_parent_url(url_params = {})
-          smart_url *([:new] + namespaces + [parent_url_options, url_params])
-        end
-        
-        def new_parent_path(url_params = {})
-          smart_path *([:new] + namespaces + [parent_url_options, url_params])
-        end
-        
-        def edit_parent_url(url_params = {})
-          smart_url *([:edit] + namespaces + [parent_url_options, url_params])
-        end
-        
-        def edit_parent_path(url_params = {})
-          smart_path *([:edit] + namespaces + [parent_url_options, url_params])
-        end
-        
-        def parent_url(url_params = {})
-          smart_url *(namespaces + [parent_url_options, url_params])
+        def parent_url_parts(action = nil, url_params = {})
+          [action] + contexts_url_parts + [url_params]
         end
         
-        def parent_path(url_params = {})
-          smart_path *(namespaces + [parent_url_options, url_params])
-        end
-        
-        def parent_collection_url(url_params = {})
-          smart_url *(namespaces + [parent_model_name.to_s.pluralize.to_sym, url_params])
-        end
-        
-        def parent_collection_path(url_params = {})
-          smart_path *(namespaces + [parent_model_name.to_s.pluralize.to_sym, url_params])
-        end
-        
-        def parent_url_options
-          if parent?
-            parent_name = (parent_alias || parent_model_name).to_sym
-            parent_singleton? ? parent_name : [parent_name, parent_object]
-          else
-            nil
-          end
+        def parent_collection_url_parts(*args)
+          parent_url_parts(*args)
         end
     end
     
     module Reflection
       def self.included(klass)
-        klass.helper_method :parent?, :parent_model_name, :parent_object
+        klass.class_eval do
+          helper_method :parent?, :parent_model_name, :parent_object
+          before_filter :require_parent
+        end
       end
       
       private
         def belongs_to
           self.class.belongs_to
         end
-      
-        # Returns the relevant association proxy of the parent. (i.e. /posts/1/comments # => @post.comments)
-        #
-        def parent_association
-          @parent_association ||= parent_object.send(model_name.to_s.pluralize.to_sym)
+        
+        def parent_path_name
+          return @parent_path_name if defined?(@parent_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) == parent_model_name
+              return @parent_path_name = path_part.to_sym
+            end
+          end
+          @parent_path_name = nil
         end
-      
-        def parent_alias
-          return @parent_alias if @parent_alias
-          parent_from_params? || parent_from_request?
-          @parent_alias
+        
+        def parent_route_name
+          return @parent_route_name if defined?(@parent_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) == parent_model_name
+              return @parent_route_name = route_name_from_path_part(path_part)
+            end
+          end
+          @parent_route_name = parent_model_name
         end
-  
+        
         # Returns the type of the current parent
         #
         def parent_model_name
-          return @parent_model_name if @parent_model_name
-          parent_from_params? || parent_from_request?
+          return @parent_model_name if defined?(@parent_model_name)
+          parent_from_path?
           @parent_model_name
         end
-  
-        # Returns the type of the current parent extracted from params
-        #    
-        def parent_from_params?
-          return @parent_from_params if defined?(@parent_from_params)
-          belongs_to.each do |model_name, options|
-            if !params["#{model_name}_id".to_sym].nil?
-              @parent_model_name = model_name
-              @parent_alias = options[:as]
-              return @parent_from_params = true
-            end
-          end
-          @parent_from_params = false
+        
+        def parent_model
+          @parent_model ||= parent_model_name.to_s.camelize.constantize
         end
-  
+        
         # Returns the type of the current parent extracted form a request path
-        #    
-        def parent_from_request?
-          return @parent_from_request if defined?(@parent_from_request)
+        #
+        def parent_from_path?
+          return @parent_from_path if defined?(@parent_from_path)
           belongs_to.each do |model_name, options|
-            if request.path.split('/').include?((options[:as] && options[:as].to_s) || model_name.to_s)
-              @parent_model_name = model_name
-              @parent_alias = options[:as]
-              return @parent_from_request = true
+            request.path.split('/').reverse.each do |path_part|
+              possible_model_names(model_name).each_with_index do |possible_name, index|
+                if [possible_name.to_s, possible_name.to_s.pluralize].include?(path_part)
+                  @parent_model_name = model_name
+                  return @parent_from_path = true
+                end
+              end
             end
           end
-          @parent_from_request = false
+          @parent_from_path = false
         end
-  
+        
         # Returns true/false based on whether or not a parent is present.
         #
         def parent?
           !parent_model_name.nil?
         end
-  
+        
         # Returns true/false based on whether or not a parent is a singleton.
-        #    
+        #
         def parent_singleton?
-          !parent_from_params?
+          parent? && parent_id.nil?
         end
-  
+        
         # Returns the current parent param, if there is a parent. (i.e. params[:post_id])
-        def parent_param
-          params["#{parent_model_name}_id".to_sym]
+        def parent_id
+          params["#{parent_route_name}_id".to_sym]
         end
-  
-        # Like the model method, but for a parent relationship.
-        # 
-        def parent_model
-          @parent_model ||= parent_model_name.to_s.camelize.constantize
-        end
-  
+        
         # Returns the current parent object if a parent object is present.
         #
-        def parent_object
-          return @parent_object if defined?(@parent_object)
+        def parent_object(reload = false)
+          return @parent_object if !reload && defined?(@parent_object)
           if parent?
             if parent_singleton? && respond_to?("current_#{parent_model_name}", true)
               @parent_object = send("current_#{parent_model_name}")
+            elsif parent_singleton? && parent_scope.respond_to?(parent_model_name)
+              @parent_object = parent_scope.send(parent_model_name, reload)
             else
-              @parent_object = parent_model.find(parent_param)
+              @parent_object = parent_scope.find(parent_id)
             end
           else
             @parent_object = nil
           end
         end
-  
-        # If there is a parent, returns the relevant association proxy.  Otherwise returns model.
-        #
-        def end_of_association_chain
-          parent? ? parent_association : model
+        
+        def require_parent
+          raise StandardError.new("A parent is required to access this resource and no parent was found") if !parent? && self.class.require_parent == true
         end
     end
   end