resourcelogic 0.0.11

data/lib/resourcelogic/response_collector.rb

@@ -0,0 +1,32 @@
+module Resourcelogic
+  class ResponseCollector
+    
+    attr_reader :responses
+    
+    delegate :clear, :to => :responses
+    
+    def initialize
+      @responses = []
+    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
+    end
+    
+    def [](symbol)
+      @responses.find { |method, block| method == symbol }
+    end
+    
+    def dup
+      returning ResponseCollector.new do |duplicate|
+        duplicate.instance_variable_set(:@responses, responses.dup)
+      end
+    end
+  end
+end

data/lib/resourcelogic/scope.rb

@@ -0,0 +1,36 @@
+module Resourcelogic
+  module Scope
+    def self.included(klass)
+      klass.class_eval do
+        add_acts_as_resource_module(Methods)
+      end
+    end
+    
+    module Methods
+      def self.included(klass)
+        klass.class_eval do
+          attr_accessor :scoping, :scoping_parent
+        end
+      end
+      
+      private
+        def scope
+          return @scope if defined?(@scope)
+          
+          if parent?
+            @scope = parent_object.send(parent_scope_name)
+          else
+            @scope = model
+          end
+        end
+        
+        def parent_scope
+          parent_model
+        end
+        
+        def parent_scope_name
+          @parent_scope_name ||= model_name.to_s.pluralize
+        end
+    end
+  end
+end       

data/lib/resourcelogic/self.rb

@@ -0,0 +1,148 @@
+module Resourcelogic
+  module Self
+    def self.included(klass)
+      klass.class_eval do
+        extend Config
+        add_acts_as_resource_module(UrlParts)
+        add_acts_as_resource_module(Reflection)
+      end
+    end
+    
+    module Config
+      def model_name(value = nil)
+        rw_config(:model_name, value, model_name_from_name)
+      end
+      
+      def object_name(value = nil)
+        rw_config(:object_name, value, model_name_from_name)
+      end
+      
+      private
+        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_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_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
+            obj = object_or_params.first
+          end
+          [obj, url_params]
+        end
+    end
+    
+    module Reflection
+      def self.included(klass)
+        klass.helper_method :model_name, :collection, :object, :path_name, :route_name
+      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
+        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:
+          @collection ||= scope.all
+        end
+
+        # The current paremter than contains the object identifier.
+        def id # :doc:
+         params[:id]
+        end
+        
+        def id?
+          params.key?(:id)
+        end
+        
+        # The parameter hash that contains the object attributes.
+        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:
+          @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
+end

data/lib/resourcelogic/sibling.rb

@@ -0,0 +1,20 @@
+module Resourcelogic
+  module Sibling
+    def self.included(klass)
+      klass.class_eval do
+        add_acts_as_resource_module(Urls)
+      end
+    end
+    
+    module Urls
+      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]
+        end
+        
+        def sibling_collection_url_parts(action = nil, sibling_name = nil, url_params = {})
+          [action] + contexts_url_parts + [sibling_name, url_params]
+        end
+    end
+  end
+end

data/lib/resourcelogic/singleton.rb

@@ -0,0 +1,55 @@
+# Nested and Polymorphic Resource Helpers
+#
+module Resourcelogic
+  module Singleton
+    def self.included(klass)
+      klass.class_eval do
+        add_acts_as_resource_module(Methods)
+      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
+      end
+      
+      def build_object
+        if singleton? && parent?
+          scope.send("build_#{model_name}")
+        else
+          super
+        end
+      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/sub_views.rb

@@ -0,0 +1,98 @@
+# Nested and Polymorphic Resource Helpers
+#
+module Resourcelogic
+  module SubViews
+    def self.included(klass)
+      klass.class_eval do
+        extend Config
+        add_acts_as_resource_module(Methods)
+      end
+    end
+    
+    module Config
+      def namespace_views_by_context(value = nil)
+        rw_config(:namespace_views_by_context, value)
+      end
+
+      def namespace_views_by_context?
+        !namespace_views_by_context.blank?
+      end
+      
+      def namespace_views_by_route_alias(value = nil)
+        rw_config(:namespace_views_by_route_alias, value)
+      end
+
+      def namespace_views_by_route_alias?
+        !namespace_views_by_route_alias.blank?
+      end
+    end
+    
+    module Methods
+      def self.included(klass)
+        klass.helper_method :namespace_views_by_route_alias, :namespace_views_by_route_alias?,
+          :namespace_views_by_context, :namespace_views_by_context?, :sub_template_name
+      end
+      
+      private
+        def namespace_views_by_context?
+          self.class.namespace_views_by_context?
+        end
+        
+        def namespace_views_by_context
+          self.class.namespace_views_by_context
+        end
+        
+        def namespace_views_by_route_alias?
+          self.class.namespace_views_by_route_alias? && route_name != model_name
+        end
+        
+        def namespace_views_by_route_alias
+          self.class.namespace_views_by_route_alias
+        end
+        
+        def sub_template_name(name)
+          path_parts = [controller_name]
+          
+          if namespace_views_by_context?
+            context_folder_name = namespace_views_by_context.is_a?(Hash) && namespace_views_by_context.key?(context) ?
+              namespace_views_by_context[context] : context
+            path_parts << (context_folder_name || "root")
+          end
+          
+          if namespace_views_by_route_alias?
+            route_alias_folder_name = namespace_views_by_route_alias.is_a?(Hash) && namespace_views_by_route_alias.key?(route_name) ?
+              namespace_views_by_route_alias[route_name] : route_name
+            path_parts << (route_alias_folder_name).to_s.pluralize
+          end
+          
+          path_parts << name
+          path_parts.join("/")
+        end
+        
+        def default_template_name(action_name = self.action_name)
+          if namespace_views_by_context? || namespace_views_by_route_alias?
+            sub_template_name(action_name)
+          else
+            super
+          end
+        end
+    end
+    
+    module Partials
+      def _pick_partial_template(partial_path)
+        if respond_to?(:namespace_views_by_context?) && respond_to?(:namespace_views_by_route_alias?) &&
+          (namespace_views_by_context? || namespace_views_by_route_alias?) && !partial_path.include?("/")
+          partial_path = sub_template_name(partial_path)
+        end
+        super
+      end
+    end
+  end
+end
+
+
+module ActionView
+  class Base
+    include Resourcelogic::SubViews::Partials
+  end
+end

data/lib/resourcelogic/urligence.rb

@@ -0,0 +1,128 @@
+module Resourcelogic
+  module Urligence
+    def self.included(klass)
+      klass.helper_method :smart_url, :smart_path, :hash_for_smart_url, :hash_for_smart_path, :method_missing
+    end
+    
+    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 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_url(*url_parts)
+      urligence(*url_parts.unshift(:hash_for).push(:url).push({:type => :hash}))
+    end
+    
+    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 = method_arguments.extract_options!
+          params = {}
+          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 method_name_fragments.join("_"), params
+        end
+      end
+      
+      # The point of this method is to replace any object if a url param is passed. For example:
+      #
+      #   [:admin, [:user, user_object], {:user_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:
+      #
+      #   [:user, nil]
+      #
+      # No param was passed to replace the nil object as in the example above, so it should be:
+      #
+      #   :users
+      #
+      # This is needed for contextual development. Take modifying a resource from another, but a
+      # parent resource is not needed. For example:
+      #
+      #   payments/credit_cards
+      #
+      # You can manage and select a credit card from the credit cards resource but a payment object
+      # 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)
+            # 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
+            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_url_parts
+      end
+      
+      def extract_method_name_fragments(url_parts)
+        fragments = url_parts.collect do |obj|
+          if obj.is_a?(Symbol)
+            obj
+          elsif obj.is_a?(Array)
+            obj.first
+          elsif !obj.is_a?(Hash)
+            obj.class.name.underscore.to_sym
+          end
+        end
+        fragments.compact
+      end
+      
+      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