hookercookerman-merb-resource-scope 0.1.0

data/lib/merb-resource-scope/controller/helpers.rb

@@ -0,0 +1,252 @@
+module MerbResourceScope
+  module Controller
+    module Helpers
+      
+      class UrlGenerator
+        attr_accessor :resources, :name_prefixes, :resources_with_specs, :named_route
+
+        def initialize(name_prefixes, resources_with_specs, &block)
+          @resources = []
+          @name_prefixes, @resources_with_specs =  name_prefixes, resources_with_specs
+          yield self if block_given?
+          @named_route  = generate_named_route
+        end
+        
+        # this is so we can extend out current name_route
+        # will be used in congunction of the url helpers
+        # enclosing_resource_url{|route| route.add(:comments)}
+        # 
+        # @param args<VarArgs> :  this takes 3 parameter really, first one
+        #    is a symbol of the named_route you want to add, so lets
+        #    say we had enclosing_resource_url of /users/1/
+        #    and we wanted to add tags on to this url we can simple
+        #    enclosing_resource_url{|route| route.add(:tags)}
+        #    and this will be /users/1/tags
+        #    You can also add  custom routes as well then as well
+        #    add(:tags, :pending)
+        #    Also add a resource as well, add(:tag, @tag)
+        #    Also do a new this way as well add(:tag, :new)
+        #    And finally add(:tag, :edit, @tag) Where the @tag
+        #    has to be the last option
+        #
+        # @examples
+        #    enclosing_resource_url{|route| route.add(:comments)}
+        #    resource_url(current_resource){|route| route.add(:tag, @tag)}
+        #    enclosing_resource_url{|route| route.add(:post, :edit, @post)}
+        #   
+        #
+        def add(*args)
+          name_prefixes.flatten!
+          name_prefixes << args.shift
+          args.each do |arg|
+            if arg.is_a?(Symbol)
+              name_prefixes.unshift(arg.to_s)
+            else
+              resources << arg
+            end
+          end
+          self
+        end
+        
+        alias_method :with, :add
+
+        def generate_named_route
+          if resources_with_specs
+            none_singletons = resources_with_specs.reject{|rs| rs[1].singleton}
+            resources << none_singletons.map{|rs| rs[0]}
+          end
+          generated_named_route = name_prefixes.flatten.compact.join('_').intern
+        end
+      end
+      
+      # TODO tidy refactor these methods pretty please
+      # if you want the current resources url then use this method its the way forward
+      # url is generated from building up a named route and then parsing the named
+      # route to the url method, so remember this url is buit using named routes!!
+      # 
+      # so if we have a path of /users/1/posts/2
+      # the current_resources_url would be /users/1/posts
+      # remeber the url generated will be already scoped
+      # You can pass a custom route to generate a custom route
+      # and the params just like the url method
+      # 
+      # @example
+      #  current_resources_url(:pending, {:q => "cool"})
+      #  current_resources_url(:notpending, {:lots => "yes", :lot => "ofparams"})
+      #  current_resources_url
+      # 
+      #
+      # @param<*args> : pass in a list of custom named routes, and param hash
+      #
+      # @return<String> : the generate url
+      def current_resources_url(*args, &block)
+        options = extract_options_from_args!(args) || {}
+        name_prefixes = []
+        name_prefixes <<  _current_specification.name_prefix
+        name_prefixes << Extlib::Inflection.pluralize(_current_specification.resource_name)
+        name_prefixes.unshift(args)
+        generator = UrlGenerator.new(name_prefixes, _enclosing_resources_with_spec, &block)
+        url(generator.named_route, *[generator.resources, options].flatten)
+      end
+      alias_method :resources_url, :current_resources_url
+      
+      
+      # generates a new resource url that is automatically scoped where you are
+      #
+      # 
+      # lets just say we were at this url users/1/posts
+      # by using new_current_resource_url we would basically generate
+      # new_user_post named route 
+      # which inturn would generate /users/1/posts/new
+      #
+      # 
+      # @example
+      #  new_current_resource_url({:awantaparam=> "yesyoucan"})
+      #  new_current_resource_url
+      # 
+      #
+      # @param options<Hash> : Pass in a hash of params
+      #
+      # @return<String> : the generate url
+      def new_current_resource_url(options = {}, &block)
+        name_prefixes = []
+        name_prefixes <<  _current_specification.name_prefix
+        name_prefixes <<  _current_specification.resource_name
+        name_prefixes.unshift("new")
+        generator = UrlGenerator.new(name_prefixes, _enclosing_resources_with_spec, &block)
+        url(generator.named_route, *[generator.resources, options].flatten)
+      end
+      alias_method :new_resource_url, :new_current_resource_url
+      
+      
+      # generates the current_resource_url cool
+      #
+      # 
+      # lets just say we were at this url users/1/posts/1
+      # then via to using the current_resource_url we would do
+      # current_resource_url(@post) for singleton resources
+      # just pass in the resource_name ie. for /myhome/proile_image
+      # we would have current_resource_url(:myhome)
+      #
+      # 
+      # @example
+      #  current_resource_url(@post)
+      #  current_resource_url(@post, :my => "params")
+      #  current_resource_url(:myhome)
+      #
+      # @param options<Hash> : Pass in a hash of params
+      #
+      # @return<String> : the generate url
+      def current_resource_url(current_resource, *args, &block)
+        name_prefixes = []
+        options = extract_options_from_args!(args) || {}
+        resource_specs = _resources_with_specs.dup
+        name_prefixes <<  _current_specification.name_prefix
+        unless current_resource.is_a?(Symbol) && _current_specification.singleton
+          resource_specs << [current_resource, _current_specification]
+          name_prefixes << _current_specification.resource_name
+        else
+          name_prefixes <<  current_resource
+        end
+        name_prefixes.unshift(args)
+        generator = UrlGenerator.new(name_prefixes, resource_specs, &block)
+        url(generator.named_route, *[generator.resources, options].flatten)
+      end
+      alias_method :resource_url, :current_resource_url
+      
+      
+      
+      # generates the enclosing_resource_url cool
+      #
+      # 
+      # lets just say we were at this url users/1/posts/1
+      # then via to using the current_resource_url we would do
+      # current_resource_url(@post) for singleton resources
+      # just pass in the resource_name ie. for /myhome/proile_image
+      # we would have current_resource_url(:myhome)
+      #
+      # 
+      # @example
+      #  enclosing_resource_url(:edit)
+      #  enclosing_resource_url(:edit, :my => "param")
+      #  enclosing_resource_url(:whatever)
+      #  enclosing_resource_url(:my => "params")
+      #  enclosing_resource_url(:myhome)
+      #
+      # @param args<Var> : Pass in custom route, then params basically
+      #
+      # @return<String> : the generate url
+      def enclosing_resource_url(*args, &block)
+        if _enclosing_specification
+          options = extract_options_from_args!(args) || {}
+          name_prefixes = []
+          name_prefixes <<  _enclosing_specification.name_prefix
+          name_prefixes <<  _enclosing_specification.resource_name
+          name_prefixes.unshift(args)
+          generator = UrlGenerator.new(name_prefixes, _resources_with_specs, &block)
+          url(generator.named_route, *[generator.resources, options].flatten)
+        end
+      end
+      
+      
+      # generates the enclosing_resources_url cool
+      #
+      # 
+      # lets just say we were at this url users/1/posts/1
+      # then via to using the enclosing_resources_url
+      # we would get the url of /users
+      # which inturn would be using :users  named_route
+      #
+      # 
+      # @example
+      #  enclosing_resources_url
+      #  enclosing_resources_url(:pending)
+      #  enclosing_resources_url(:pending, :my => "param")
+      # @param args<Var> : Pass in custom route, then params basically
+      #
+      # @return<String> : the generate url
+      def enclosing_resources_url(*args, &block)
+        if _enclosing_specification
+          options = extract_options_from_args!(args) || {}
+          name_prefixes = []
+          name_prefixes <<  _enclosing_specification.name_prefix
+          name_prefixes <<  Extlib::Inflection.pluralize(_enclosing_specification.resource_name)
+          name_prefixes.unshift(args)
+          generator = UrlGenerator.new(name_prefixes, _enclosing_resources_with_spec, &block)
+          url(generator.named_route, *[generator.resources, options].flatten)
+        end
+      end
+
+      # generates the new_enclosing_resource_url cool
+      #
+      # 
+      # lets just say we were at this url users/1/posts/1
+      # then via to using the new_enclosing_resource_url
+      # we would get the url of /users/new
+      # which inturn would be using :new_user  named_route
+      #
+      # 
+      # @example
+      #  new_enclosing_resource_url(:edit)
+      #  new_enclosing_resource_url(:edit, :my => "param")
+      #  new_enclosing_resource_url(:whatever)
+      #  new_enclosing_resource_url(:my => "params")
+      #  new_enclosing_resource_url(:myhome)
+      #
+      # @param args<Var> : Pass in custom route, then params basically
+      #
+      # @return<String> : the generate url
+      def new_enclosing_resource_url(options = {}, &block)
+        if _enclosing_specification
+          name_prefixes = []
+          name_prefixes <<  _enclosing_specification.name_prefix
+          name_prefixes <<  _enclosing_specification.resource_name
+          name_prefixes.unshift("new")
+          generator = UrlGenerator.new(name_prefixes, _enclosing_resources_with_spec, &block)
+          url(generator.named_route, *[generator.resources, options].flatten)
+        end
+      end
+            
+    end
+  end
+end

data/lib/merb-resource-scope/controller/scoped_resource_mixin.rb

@@ -0,0 +1,300 @@
+module MerbResourceScope
+  module Controller
+    
+    module ScopedResourceMixin
+      def self.included(base)
+        base.class_eval do
+          attr_accessor  :_enclosing_scope, :_enclosing_specifications, :_resources_with_specs, :_enclosing_resources_with_spec, :_current_specification, :_enclosing_specification
+          attr_accessor  :current_resources, :current_resource, :resource_scope
+          extend  ScopedResourceMixin::ClassMethods
+        end
+      end
+  
+      module ClassMethods
+        def build_resource_scope(options = {})
+          include InstanceMethods
+          options.only(:build_scope, :singleton, :actions)
+          filter_options = options.delete(:build_scope)
+          add_filter(_before_filters, :_build_resource_scope, filter_options || {}) 
+        
+          unless options[:actions] == false
+            actions ||= options[:singleton] ? Merb::Plugins.config[:merb_resource_scope][:singleton_actions] : Merb::Plugins.config[:merb_resource_scope][:actions]
+            include_actions actions, options.delete(:actions) || {}
+          end
+        end
+    
+        private
+        # we only want to include actions that we want!
+        def include_actions(mixin, options = {})
+          mixin = mixin.dup
+          if only = options[:only]
+            only = Array(options[:only])
+            mixin.instance_methods.each {|m| mixin.send(:undef_method, m) unless only.include?(m.intern)}
+          elsif except = options[:exclude]
+            except = Array(options[:exclude])
+            mixin.instance_methods.each {|m| mixin.send(:undef_method, m) if except.include?(m.intern)}
+          end
+          include mixin
+        end
+      end
+      
+      # Proxy class to provide a consistent API for resource_scope. passing all method calls
+      # to the current_scope
+      class ResourceScope
+        instance_methods.each { |m| undef_method m unless %w[ __id__ __send__ class kind_of? respond_to? should should_not instance_variable_set instance_variable_get instance_eval].include?(m) }
+        attr_reader :controller
+      
+        def initialize(controller)
+          @controller = controller
+        end
+        
+        def _enclosing_resource
+          @_enclosing_resource ||= controller.enclosing_resource
+        end
+        
+        def _current_specification
+          @_current_specification ||= controller._current_specification
+        end
+        
+        def respond_to?(method)
+          super || current_scope.respond_to?(method)
+        end
+        
+        def current_scope
+          @current_scope ||= _enclosing_resource ? _enclosing_resource.send(_current_specification.association_method) : _current_specification.klass
+        end
+    
+        def method_missing(method, *args, &block)
+          if current_scope.respond_to?(method)
+            current_scope.send(method, *args, &block)
+          else
+            super
+          end
+        end
+      end
+        
+      module InstanceMethods
+        
+        # the before filter, when this before filter is run; it will build the resource_scope
+        def _build_resource_scope
+          if specifications = request.resource_specifications
+            @_current_specification = specifications.pop
+            @_enclosing_specifications = specifications
+            @_resources_with_specs = []
+          
+            # if we dont want to load all the enclosing resource and resources
+            # we can specify a depth to which build the the scope from 
+            if scope_depth = @_current_specification.scope_depth
+              @_enclosing_specifications.slice!(0..scope_depth-1)
+            end
+          
+            _generate_enclosing_scope
+            @resource_scope ||= MerbResourceScope::Controller::ScopedResourceMixin::ResourceScope.new(self)
+          end
+        end
+        
+        def enclosing_resource
+          return nil if @_enclosing_specifications.size == 0
+          if @_resources_with_specs.size == @_enclosing_specifications.size+1
+            @_resources_with_specs.slice(-2)[0]
+          else
+            @_resources_with_specs.last && @_resources_with_specs.last[0]      
+          end
+        end
+              
+        # When we find the current_resource we want its resource with its specification
+        # to be added; essentially so we can know what the correct enclosing resource is
+        # but we dont want to add it if its a new_record as its not a resource just yet
+        # TODO need looking AT basically!! as create and destroy actions show not hold
+        # the resource OR put into the resource as they are essentiall not correct
+        # as it should be current_resource_url(@new_resource) Basically YEAH!
+      
+        # if you want to find resources in another way just override this in your
+        # controller; 
+        #
+        # @example
+        #   def find_resources
+        #     @resource_scope.all :conditions => {:pending => true}
+        #   end
+        #
+        # @api overwritable  
+        def find_resources
+          @resource_scope.all
+        end
+        
+        # if you want to find a resource in another then this default way
+        # then you can override in the controller,
+        #
+        # @example
+        #   def find_resource
+        #     @resource_scope.first :conditions => {:user_id => 1, :pending => false}
+        #   end
+        # 
+        # @param id<String>|<Integer> the params to use to find a resource could be permalink  
+        #
+        # @api overwritable     
+        def find_resource(id = params[@_current_specification.permalink])
+          if find_method = @_current_specification.find_method
+            find_method.is_a?(Proc) ? self.instance_eval(&find_method) : self.send(find_method)
+          else
+            @_current_specification.singleton ? @resource_scope : @resource_scope.first(:conditions => {@_current_specification.permalink => id})
+          end
+        end
+        
+        # if you have other requirments on how you would like to create a new resource
+        # then you can override this at the controller level, using the @resource_scope
+        # Also if you wish to have different attributes set you can just add them  as well
+        # dont really want to go into it but I cannot use the proxy here as a send then a 
+        # method call basically stops the dependent attributes from being set! strange but
+        # true
+        # @example
+        #    def new_resource
+        #       @resource_scope.different_new {:whatever => :egg}
+        #    end
+        #
+        # @api overwritable     
+        def new_resource(attributes = (params[@_current_specification.resource_name] || {}))
+          if enclosing_resource
+            if @_current_specification.singleton
+              return @_current_specification.klass.new attributes.merge!(_enclosing_specification.association_method.to_sym => enclosing_resource)
+            end
+            enclosing_resource.send(@_current_specification.association_method).build attributes
+          else
+            @_current_specification.klass.new attributes
+          end
+        end
+        # 
+        # we set the current_resource to have the current specification resource_name method
+        def current_resource=(resource)
+          instance_variable_set("@#{@_current_specification.resource_name}", resource)
+          @current_resource = resource
+        end
+        
+        # we set the current_resource to have the current specification resource_name method
+        def current_resources=(resources)
+          instance_variable_set("@#{@_current_specification.association_method}", resources)
+          @current_resources = resources
+        end
+             
+        private
+        # this is the work horse of how the enclosing_scope is built,
+        # it will use all the enclosing enclosing_specifications to work out what the 
+        # enclosing scope is. 
+        # 
+        # On its first run it will determine whether
+        # it should just use the singleton method or the find_method of the specification,
+        # or just go with the standand User.get(params[:id])
+        #
+        # Futher iterations will just try to find the resource via method calls
+        # and if the key of the specification is in the params then that resource
+        # will also be found
+        #
+        # so for a typical url say users/1/posts/1/comments
+        # it would go something like this, setting the enclosing_scope as it goes
+        # 1. enclosing_scope = User - via enclosing_specifications.first.klass_name
+        # 2. enclosing_scope = User.get(params[:user_id]) - via collect_resource_via_params(@enclosing_scope, specification)
+        # 3. enclosing_scope = User.get(params[:user_id]).posts.get(params[:post_id]) - via collect_resource_via_params(@enclosing_scope, specification)
+        # 4. thats it! now our enclosing_scope is where we want it
+        #
+        # This will also handle enclosing depth witch can default to the number of
+        # enclosing specification but can get it from current
+        # specification and if its been set to say 1 then my inclosing_specifications
+        # will only be set to just that COOL
+        def _generate_enclosing_scope
+          @_enclosing_specifications.each_with_index do |specification, index|
+            if specification.singleton || specification.find_method
+              @_enclosing_scope = _collect_resource_via_method(@_enclosing_scope, specification)
+            else
+              @_enclosing_scope = _collect_resource_via_params(@_enclosing_scope, specification)
+            end
+          end
+        end
+        
+        # collect a resource either with the specification.find_method or the association method
+        # we also want to store the found resource or resources along with the specification 
+        # that was used to find them for later use; mainly in route generation
+        #
+        # @param enclosing_scope<Object>|<Objects> aka ur orm object 
+        # @param specification<Specification>
+        #
+        # @return <Object>|<Objects> aka ur orm object 
+        def _collect_resource_via_method(enclosing_scope, specification)
+          if specification.find_method
+            return _collect_resource_via_find_method(specification)
+          else
+             resource_or_resources = enclosing_scope.send(specification.association_method)
+             @_resources_with_specs << [resource_or_resources, specification]
+             instance_variable_set("@#{specification.association_method}", resource_or_resources)
+          end
+          resource_or_resources
+        end
+        
+        
+        # collect a resource either with the specification.find_method
+        # we also want to store the found resource or resources along with the specification 
+        # that was used to find them for later use; mainly in route generation and to find 
+        # enclosing resources or resource
+        #
+        # @param specification<Specification>
+        #
+        # @return <Object>|<Objects> aka ur orm object
+        def _collect_resource_via_find_method(specification)
+          resource_or_resources = if specification.find_method.is_a?(Proc)
+            self.instance_eval(&specification.find_method)
+          else
+            self.send(specification.find_method)
+          end
+          
+          unless _resource_is_a_collection?(specification, resource_or_resources)
+            @_resources_with_specs << [resource_or_resources, specification]
+            instance_variable_set("@#{specification.resource_name}", resource_or_resources)
+          end
+          
+          resource_or_resources
+        end
+        
+        # collect a resource with the specification using the params and the resource_name
+        # we also want to store the found resource along with the specification 
+        #
+        # @param enclosing_scope<Object>|<Objects> aka ur orm object 
+        # @param specification<Specification>
+        #
+        # @return <Object>|<Objects>|enclosing_scope aka ur orm object
+        def _collect_resource_via_params(enclosing_scope, specification)
+          if !params.keys.include?(specification.foreign_key.to_s)
+            return enclosing_scope
+          else
+           
+           resource = if enclosing_scope
+             enclosing_scope.send(specification.association_method).first(:conditions => {specification.permalink => params[specification.foreign_key]})
+           else
+             specification.klass.first(:conditions => {specification.permalink => params[specification.foreign_key]})
+           end
+          
+            @_resources_with_specs << [resource, specification]
+            instance_variable_set("@#{specification.resource_name}", resource)
+            resource
+          end
+        end
+      
+        # This is by default set to use datamapper
+        # You can override this at the application controller level
+        # then it will use this for all controllers; or if you have 
+        # specific requirement on a controller;then just change it in there
+        # 
+        # @api overwritable
+        def _resource_is_a_collection?(specification, resource_or_resources)
+          resource_or_resources.kind_of?(::DataMapper::Collection)
+        end
+        
+        def _enclosing_resources_with_specs
+          @_resources_with_specs.slice(0..-2)
+        end
+        
+        def _enclosing_specification
+          @_enclosing_specifications.last     
+        end
+      end
+    end
+  end
+end