resourcelogic 0.0.11

data/lib/resourcelogic/aliases.rb

@@ -0,0 +1,134 @@
+module Resourcelogic
+  # This module let's you define various aliases for your controller. For example,
+  # lets say you have the following routes:
+  #
+  #   /account/addresses        => UsersController
+  #   /admin/users/5/addresses  => UsersController
+  #
+  # Here is how your AddressesController would look:
+  #
+  #   class AddressesController < ResourceController
+  #     belongs_to :user
+  #   end
+  #
+  # The problem is that sometimes the parent object is called user, sometimes its
+  # called account. So the solution is to do:
+  #
+  #   class ResourceController < ApplicationController
+  #     route_alias :account, :user
+  #   end
+  #
+  # Now ResourceLogic knows that when it see account in the URL it will know the grab
+  # the User model.
+  #
+  # Now I know an alternative could be to do somethig like:
+  #
+  #   belongs_to :user, :alias => :account
+  #
+  # The above presents a problem. Take the following URL:
+  #
+  #   /productos/1/pictures/4/comments
+  #
+  # In order for Resourcelogic to do its magic relative URLs, it needs to know what
+  # model "productos" should be using. Which should be the Product model, yet we
+  # can't define that in the CommentsController because it's 2 levels above, and we
+  # only specify the parent.
+  #
+  # Now a lot of people say you should never nest more than 2 levels deep, and this
+  # is absolutely true 95% of the time. But what if I want to link back to the parent
+  # object from the comments controller and preserve it's context? In order to do
+  # this I have to go 3 levels deep, because maybe context for the PicturesController
+  # is really important / required. The only way to preserve context is with the URL.
+  #
+  # Sorry for rambling, this documentation is really more of an internal note for me
+  # and to hopefully clarify why I took this approach.
+  module Aliases
+    def self.included(klass)
+      klass.class_eval do
+        extend Config
+        include InstanceMethods
+      end
+    end
+    
+    module Config
+      def path_alias(alias_name, model_name)
+        current_aliases = path_aliases
+        model_name = model_name.to_sym
+        current_aliases[model_name] ||= []
+        current_aliases[model_name] << alias_name.to_sym
+        write_inheritable_attribute(:path_aliases, current_aliases)
+      end
+
+      def path_aliases
+        read_inheritable_attribute(:path_aliases) || {}
+      end
+      
+      def route_alias(alias_name, model_name)
+        current_aliases = route_aliases
+        model_name = model_name.to_sym
+        current_aliases[model_name] ||= []
+        current_aliases[model_name] << alias_name.to_sym
+        write_inheritable_attribute(:route_aliases, current_aliases)
+      end
+
+      def route_aliases
+        read_inheritable_attribute(:route_aliases) || {}
+      end
+    end
+    
+    module InstanceMethods
+      private
+        def model_name_from_route_alias(alias_name)
+          route_aliases.each do |model_name, aliases|
+            return model_name if aliases.include?(alias_name.to_sym)
+          end
+          nil
+        end
+      
+        def route_aliases
+          self.class.route_aliases
+        end
+        
+        def model_name_from_path_alias(alias_name)
+          path_aliases.each do |model_name, aliases|
+            return model_name if aliases.include?(alias_name.to_sym)
+          end
+          nil
+        end
+      
+        def path_aliases
+          self.class.path_aliases
+        end
+        
+        def possible_model_names(model_name)
+          [model_name] + (route_aliases[model_name] || []) + (path_aliases[model_name] || [])
+        end
+        
+        # The point of this method is to determine what the part of a url is really referring to.
+        # For example, let's say you did this:
+        #
+        #   map.resources :users, :as => :accounts
+        #
+        # Resource logic looks at the request.path. It's going to see "accounts" in the urls. How
+        # is it to know that by "accounts" you are referring to the "users" resource. That's the
+        # point of this method, to say "hey, accounts is mapped to users".
+        def model_name_from_path_part(part)
+          part = part.to_s.singularize
+          model_name_from_route_alias(part) || model_name_from_path_alias(part) || part.to_sym
+        end
+        
+        # The point of this method is to determine the name used in the route method. For example,
+        # let's say you did this:
+        #
+        #   map.resources :accounts, :controller => "users"
+        #
+        # You would want to use "account" in your path and url helper, not "user".
+        def route_name_from_path_part(part)
+          part = part.to_s.singularize
+          model_name = model_name_from_path_alias(part)
+          return model_name if model_name
+          part.to_sym
+        end
+    end
+  end
+end

data/lib/resourcelogic/base.rb

@@ -0,0 +1,130 @@
+module Resourcelogic # :nodoc:
+  module Base # :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
+      end
+      
+      def init_default_actions
+        index.wants.html
+        edit.wants.html
+        new_action.wants.html
+        
+        show do
+          wants.html
+          failure.wants.html { render :text => "#{model_name.to_s.singularize.humanize} not found." }
+        end
+        
+        create do
+          flash { "#{model_name.to_s.singularize.humanize} successfully created!" }
+          wants.html { redirect_to object_url }
+          failure.wants.html { render :action => "new" }
+        end
+        
+        update do
+          flash { "#{model_name.to_s.singularize.humanize} successfully updated!" }
+          wants.html { redirect_to object_url }
+          failure.wants.html { render :action => "edit" }
+        end
+        
+        destroy do
+          flash { "#{model_name.to_s.singularize.humanize} successfully removed!" }
+          wants.html { redirect_to collection_url }
+        end
+      end
+      
+      # Since this part of Authlogic deals with another class, ActiveRecord, we can't just start including things
+      # in ActiveRecord itself. A lot of these module includes need to be triggered by the acts_as_authentic method
+      # call. For example, you don't want to start adding in email validations and what not into a model that has
+      # nothing to do with Authlogic.
+      #
+      # That being said, this is your tool for extending Authlogic and "hooking" into the acts_as_authentic call.
+      def add_acts_as_resource_module(mod, action = :append)
+        modules = acts_as_resource_modules
+        case action
+        when :append
+          modules << mod
+        when :prepend
+          modules = [mod] + modules
+        end
+        modules.uniq!
+        write_inheritable_attribute(:acts_as_resource_modules, modules)
+      end
+      
+      # This is the same as add_acts_as_authentic_module, except that it removes the module from the list.
+      def remove_acts_as_resource_module(mod)
+        write_inheritable_attribute(:acts_as_resource_modules, acts_as_resource_modules - [mod])
+        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)
+          if value == read_value
+            inheritable_attributes.include?(key) ? read_inheritable_attribute(key) : default_value
+          else
+            write_inheritable_attribute(key, value)
+          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
+
+if defined?(::ActionController)
+  module ::ActionController
+    class Base
+      extend Resourcelogic::Accessors
+      include Resourcelogic::Base
+      include Resourcelogic::Actions
+      include Resourcelogic::Child
+      include Resourcelogic::Context
+      include Resourcelogic::Scope
+      include Resourcelogic::Self
+      include Resourcelogic::Sibling
+      include Resourcelogic::SubViews
+      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

@@ -0,0 +1,55 @@
+module Resourcelogic
+  module Child
+    def self.included(klass)
+      klass.class_eval do
+        add_acts_as_resource_module(Urls)
+      end
+    end
+    
+    module Urls
+      private
+        # 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]
+        end
+        
+        def child_collection_url_parts(action = nil, child_name = nil, url_params = {})
+          child_base_parts(action, url_params) + [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
+    end
+  end
+end

data/lib/resourcelogic/context.rb

@@ -0,0 +1,51 @@
+# Nested and Polymorphic Resource Helpers
+#
+module Resourcelogic
+  module Context
+    def self.included(klass)
+      klass.class_eval do
+        add_acts_as_resource_module(Methods)
+      end
+    end
+    
+    module Methods
+      def self.included(klass)
+        klass.helper_method :context, :contexts, :contexts_url_parts
+        klass.hide_action :context, :contexts
+      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)
+        end
+        @contexts
+      end
+      
+      private
+        def contexts_url_parts
+          return @contexts_url_parts if @contexts_url_parts
+          path_parts = request.path.split("/")
+          path_parts.shift
+          @contexts_url_parts = []
+          path_parts.each_with_index do |part, index|
+            break if model_name_from_path_part(part.split(".").first) == model_name
+            if part.to_i > 0
+              @contexts_url_parts << [route_name_from_path_part(@contexts_url_parts.pop), part.to_i]
+            else
+              @contexts_url_parts << part.underscore.to_sym
+            end
+          end
+          @contexts_url_parts
+        end
+    end
+  end
+end

data/lib/resourcelogic/context_options.rb

@@ -0,0 +1,5 @@
+module Resourcelogic
+  class ContextOptions
+    extend Resourcelogic::Accessors
+  end
+end

data/lib/resourcelogic/failable_action_options.rb

@@ -0,0 +1,25 @@
+module Resourcelogic
+  class FailableActionOptions
+    extend Resourcelogic::Accessors
+    
+    scoping_reader :success, :fails
+    alias_method :failure, :fails
+    
+    block_accessor :before
+    
+    def initialize
+      @success = ActionOptions.new
+      @fails   = ActionOptions.new
+    end
+    
+    delegate :flash, :flash_now, :after, :response, :wants, :to => :success
+    
+    def dup
+      returning self.class.new do |duplicate|
+        duplicate.instance_variable_set(:@success, success.dup)
+        duplicate.instance_variable_set(:@fails,   fails.dup)
+        duplicate.instance_variable_set(:@before,  before.dup) unless before.nil?
+      end
+    end
+  end
+end

data/lib/resourcelogic/parent.rb

@@ -0,0 +1,142 @@
+module Resourcelogic
+  module Parent
+    def self.included(klass)
+      klass.class_eval do
+        extend Config
+        add_acts_as_resource_module(Urls)
+        add_acts_as_resource_module(Reflection)
+      end
+    end
+    
+    module Config
+      def belongs_to(name = nil, options = {})
+        @belongs_to ||= {}
+        if name.nil?
+          @belongs_to
+        else
+          @belongs_to[name.to_sym] = options
+        end
+      end
+      
+      def require_parent(value = nil)
+        rw_config(:require_parent, value, false)
+      end
+    end
+    
+    module Urls
+      private
+        def parent_url_parts(action = nil, url_params = {})
+          [action] + contexts_url_parts + [url_params]
+        end
+        
+        def parent_collection_url_parts(*args)
+          parent_url_parts(*args)
+        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
+      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
+        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
+        end
+        
+        # Returns the type of the current parent
+        #
+        def parent_model_name
+          return @parent_model_name if defined?(@parent_model_name)
+          parent_from_path?
+          @parent_model_name
+        end
+        
+        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_path?
+          return @parent_from_path if defined?(@parent_from_path)
+          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
+            end
+          end
+          @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? && parent_id.nil?
+        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]
+        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)
+          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)
+            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
+        end
+    end
+  end
+end