resourcelogic 0.0.12 → 0.9.0

data/lib/resourcelogic/base.rb

@@ -3,13 +3,11 @@ module Resourcelogic # :nodoc:
     def self.included(klass)
       klass.class_eval do
         extend ClassMethods
-        include InstanceMethods
       end
     end
     
     module ClassMethods
       def acts_as_resource(&block)
-        resourceful(true)
         yield self if block_given?
         acts_as_resource_modules.each { |mod| include mod }
         init_default_actions
@@ -67,21 +65,13 @@ module Resourcelogic # :nodoc:
         acts_as_resource_modules
       end
       
-      def resourceful(value = nil)
-        rw_config(:resourceful, value, false)
-      end
-      
-      def resourceful?
-        resourceful == true
-      end
-      
       private
         def acts_as_resource_modules
           key = :acts_as_resource_modules
           inheritable_attributes.include?(key) ? read_inheritable_attribute(key) : []
         end
         
-        def rw_config(key, value, default_value = nil, read_value = nil)
+        def config(key, value, default_value = nil, read_value = nil)
           if value == read_value
             inheritable_attributes.include?(key) ? read_inheritable_attribute(key) : default_value
           else
@@ -89,21 +79,6 @@ module Resourcelogic # :nodoc:
           end
         end
     end
-    
-    module InstanceMethods
-      def self.included(klass)
-        klass.helper_method :resourceful?, :section
-      end
-      
-      def resourceful?
-        self.class.resourceful?
-      end
-      
-      def section
-        section = request.path.split("/")[1]
-        section && section.to_sym
-      end
-    end
   end
 end
 
@@ -115,16 +90,11 @@ if defined?(::ActionController)
       include Resourcelogic::Actions
       include Resourcelogic::Child
       include Resourcelogic::Context
-      include Resourcelogic::Scope
+      include Resourcelogic::Parent
       include Resourcelogic::Self
       include Resourcelogic::Sibling
-      include Resourcelogic::SubViews
+      include Resourcelogic::Singleton
       include Resourcelogic::Urligence
-      
-      # Need to be loaded last to override methods
-      include Resourcelogic::Parent
-      include Resourcelogic::Aliases
-       include Resourcelogic::Singleton
     end
   end
 end

data/lib/resourcelogic/child.rb

@@ -7,49 +7,89 @@ 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_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]
+        def child_path(child, url_params = {})
+          smart_path *child_url_options(child, url_params)
         end
         
-        def child_collection_url_parts(action = nil, child_name = nil, url_params = {})
-          child_base_parts(action, url_params) + [child_name, url_params]
+        def child_collection_url(child_name, url_params = {})
+          smart_url *child_collection_url_options(child_name, 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
+        def child_collection_path(child_name, url_params = {})
+          smart_path *child_collection_url_options(child_name, url_params)
+        end
+        
+        def new_child_url_options(child_name, url_params = {})
+          object_url_options(:new) + [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
     end
   end
 end

data/lib/resourcelogic/context.rb

@@ -4,48 +4,85 @@ 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, :contexts_url_parts
-        klass.hide_action :context, :contexts
+        klass.helper_method :context, :contexts, :contextual_views, :contextual_views?, :context_template_name
       end
       
-      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)
+      private
+        def context
+          @context ||= (parent? && (parent_alias || parent_model_name)) || (contexts.last && (contexts.last.is_a?(Array) ? contexts.last.first : contexts.last))
         end
-        @contexts
-      end
       
-      private
-        def contexts_url_parts
-          return @contexts_url_parts if @contexts_url_parts
+        # Returns all of the current namespaces of the current controller, symbolized, in array form.
+        def contexts
+          return @contexts if @contexts
           path_parts = request.path.split("/")
           path_parts.shift
-          @contexts_url_parts = []
+          @contexts = []
           path_parts.each_with_index do |part, index|
-            break if model_name_from_path_part(part.split(".").first) == model_name
+            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)
             if part.to_i > 0
-              @contexts_url_parts << [route_name_from_path_part(@contexts_url_parts.pop), part.to_i]
+              @contexts << [@contexts.pop.to_s.singularize.to_sym, part]
             else
-              @contexts_url_parts << part.underscore.to_sym
+              @contexts << part.underscore.to_sym
             end
           end
-          @contexts_url_parts
+          @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
         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,125 +17,157 @@ 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 parent_url_parts(action = nil, url_params = {})
-          [action] + contexts_url_parts + [url_params]
+        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])
         end
         
-        def parent_collection_url_parts(*args)
-          parent_url_parts(*args)
+        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
         end
     end
     
     module Reflection
       def self.included(klass)
-        klass.class_eval do
-          helper_method :parent?, :parent_model_name, :parent_object
-          before_filter :require_parent
-        end
+        klass.helper_method :parent?, :parent_model_name, :parent_object
       end
       
       private
         def belongs_to
           self.class.belongs_to
         end
-        
-        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
+      
+        # 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)
         end
-        
-        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
+      
+        def parent_alias
+          return @parent_alias if @parent_alias
+          parent_from_params? || parent_from_request?
+          @parent_alias
         end
-        
+  
         # Returns the type of the current parent
         #
         def parent_model_name
-          return @parent_model_name if defined?(@parent_model_name)
-          parent_from_path?
+          return @parent_model_name if @parent_model_name
+          parent_from_params? || parent_from_request?
           @parent_model_name
         end
-        
-        def parent_model
-          @parent_model ||= parent_model_name.to_s.camelize.constantize
+  
+        # 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
         end
-        
+  
         # Returns the type of the current parent extracted form a request path
-        #
-        def parent_from_path?
-          return @parent_from_path if defined?(@parent_from_path)
+        #    
+        def parent_from_request?
+          return @parent_from_request if defined?(@parent_from_request)
           belongs_to.each do |model_name, options|
-            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
+            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
             end
           end
-          @parent_from_path = false
+          @parent_from_request = 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? && parent_id.nil?
+          !parent_from_params?
         end
-        
+  
         # Returns the current parent param, if there is a parent. (i.e. params[:post_id])
-        def parent_id
-          params["#{parent_route_name}_id".to_sym]
+        def parent_param
+          params["#{parent_model_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(reload = false)
-          return @parent_object if !reload && defined?(@parent_object)
+        def parent_object
+          return @parent_object if 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_scope.find(parent_id)
+              @parent_object = parent_model.find(parent_param)
             end
           else
             @parent_object = nil
           end
         end
-        
-        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
+  
+        # If there is a parent, returns the relevant association proxy.  Otherwise returns model.
+        #
+        def end_of_association_chain
+          parent? ? parent_association : model
         end
     end
   end