puffer 0.0.29 → 0.0.30

data/lib/puffer/component.rb

@@ -56,8 +56,8 @@ module Puffer
 
       helper ComponentHelper, PufferHelper
 
-      attr_accessor :parent_controller, :field, :opts, :identifer
-      delegate :env, :request, :params, :session, :resource, :_members, :_collections, :to => :parent_controller
+      attr_accessor :parent_controller, :field, :opts, :identifer, :resource
+      delegate :env, :request, :params, :session, :_members, :_collections, :to => :parent_controller
       helper_method :params, :session, :resource, :_members, :_collections, :parent_controller, :field, :opts, :identifer, :component_id, :event_url, :event_path, :record, :records
 
       def initialize field
@@ -67,12 +67,17 @@ module Puffer
 
       def process parent_controller, context, *args
         @parent_controller = parent_controller
-        @identifer = params[:identifer] || generate_identifer
         super context, *args
       end
 
       def send_action method_name, *args
         @opts = args.extract_options!
+        if @opts[:record]
+          @resource = Puffer::Resource.new(params.merge(:member => @opts[:record]), parent_controller)
+        else
+          @resource = parent_controller.resource
+        end
+        @identifer = params[:identifer] || generate_identifer
         send method_name, *args
       end
 
@@ -104,27 +109,27 @@ module Puffer
       end
 
       def event_url name, options = {}
-        resource.collection_url :event, (options || {}).merge(event_options(name))
+        resource.collection_url (options || {}).merge(event_options(name))
       end
 
       def event_path name, options = {}
-        resource.collection_path :event, (options || {}).merge(event_options(name))
+        resource.collection_path (options || {}).merge(event_options(name))
       end
 
       def event_options name
-        {:event => name, :field => field.to_s, :fieldset => field.field_set.name, :identifer => identifer}
+        {:action => :event, :event => name, :field => field.to_s, :fieldset => field.field_set.name, :identifer => identifer}
       end
 
       def record
-        @record || instance_variable_get("@#{resource.model_name}")
+        @record || instance_variable_get("@#{resource.name.singularize}")
       end
 
       def records
-        @records || instance_variable_get("@#{resource.model_name.pluralize}")
+        @records || instance_variable_get("@#{resource.name.pluralize}")
       end
 
       def component_id
-        @component_id ||= "component_#{identifer}"
+        "component_#{identifer}"
       end
 
     private

data/lib/puffer/controller/auth.rb

@@ -1,5 +1,15 @@
 module Puffer
   module Controller
+    # Module provides authentification methods and helpers for puffer
+    # controllers. Puffer's authentification system is simple. In general, you
+    # should use different kinds of routing and controllers namespaces for
+    # partial access of different user types.
+    # 
+    # Method +has_puffer_access?+ with current namespace name as a parameter.
+    # If you want to use appication's own auth system - just redefine this
+    # method in your ApplicationController.
+    #
+    # Also see Puffer::SessionsBase.
     module Auth
       extend ActiveSupport::Concern
 
@@ -9,17 +19,46 @@ module Puffer
 
       module InstanceMethods
 
+        # Return current user instance, used for authorization. This method can
+        # be redefined in ApplicationController if you want to use application's
+        # auth system. 
+        # 
+        # ex:
+        #
+        #   class ApplicationController < ActionController::Base
+        #     def current_puffer_user
+        #       current_user
+        #     end
+        #   end
+        # 
+        # In this case returner user model instance should respond to has_role?
+        # method, or you should properly redefine +has_puffer_access?+ See
+        # +has_puffer_access?+ source and docs.
         def current_puffer_user
-          @current_puffer_user ||= super rescue PufferUser.find(session[:puffer_user_id]) if session[:puffer_user_id]
+          @current_puffer_user ||= super rescue (PufferUser.find(session[:puffer_user_id]) if session[:puffer_user_id])
         end
 
+        # Used in before_filter to prevent unauthorized access
         def require_puffer_user
-          unless has_puffer_access?(namespace)
+          unless has_puffer_access?(puffer_namespace)
             redirect_to new_admin_session_url(:return_to => request.fullpath)
             return false
           end
         end
 
+        # This method is also part of auth system and it can be redefined at the
+        # ApplicationController.
+        #
+        # ex:
+        #
+        #   class ApplicationController < ActionController::Base
+        #     # <tt>current_puffer_user.admin?</tt>
+        #     # <tt>current_puffer_user.manager?</tt>
+        #     # <tt>current_puffer_user.seo?</tt>
+        #     def has_puffer_access? namespace
+        #       current_puffer_user.send("#{namespace}?")
+        #     end
+        #   end
         def has_puffer_access? namespace
           super rescue (current_puffer_user && current_puffer_user.has_role?(namespace))
         end

data/lib/puffer/controller/config.rb

@@ -4,7 +4,7 @@ module Puffer
       extend ActiveSupport::Concern
 
       included do
-        puffer_class_attribute :group
+        puffer_class_attribute :group, :default
         puffer_class_attribute :model_name
         puffer_class_attribute :destroy, true
 

data/lib/puffer/controller/mutate.rb

@@ -6,14 +6,23 @@ module Puffer
       included do
         layout 'puffer'
         helper :puffer
-        delegate :model, :model_name, :to => 'self.class'
-        helper_method :namespace, :resource, :record, :records
+        delegate :puffer_filters_class, :model, :model_name, :to => 'self.class'
+        helper_method :puffer_filters, :puffer_namespace, :resource, :record, :records
       end
 
       module InstanceMethods
 
-        def namespace
-          params[:namespace] || self.class.namespace
+        def process_action method_name, *args
+          params[:puffer] = Rails.application.routes.resources_tree[params[:puffer]] if params[:puffer]
+          super
+        end
+
+        def puffer_filters
+          @puffer_filters ||= puffer_filters_class.new params[puffer_filters_class.model_name.param_key]
+        end
+
+        def puffer_namespace
+          resource.scope
         end
 
         def resource
@@ -36,8 +45,8 @@ module Puffer
           true
         end
 
-        def namespace
-          to_s.underscore.split('/').first
+        def puffer_filters_class
+          @puffer_filters_class ||= Puffer::Filters.controller_filters(self)
         end
 
         def model_name

data/lib/puffer/extensions/core.rb

@@ -28,6 +28,10 @@ module Puffer
     end
 
     module Array
+      def to_fieldset
+        Puffer::FieldSet.new.concat self
+      end
+
       def to_includes
         map do |field|
           sections = field.split('.').map(&:to_sym)

data/lib/puffer/extensions/directive_processor.rb

@@ -0,0 +1,36 @@
+require 'sprockets'
+
+module Puffer
+  module Extensions
+    module DirectiveProcessor
+      extend ActiveSupport::Concern
+
+      module InstanceMethods
+
+        def process_require_all_directive(path)
+          raise ArgumentError, "require_all argument must be relative" unless relative?(path)
+
+          context.environment.paths.each do |root_path|
+            root = Pathname.new(root_path).join(path).expand_path
+
+            if root.exist? && root.directory?
+              context.depend_on(root)
+
+              Dir["#{root}/*"].sort.each do |filename|
+                if filename == self.file
+                  next
+                elsif context.asset_requirable?(filename)
+                  context.require_asset(filename)
+                end
+              end
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end
+
+Sprockets::DirectiveProcessor.send :include, Puffer::Extensions::DirectiveProcessor

data/lib/puffer/extensions/form.rb

@@ -6,7 +6,7 @@ module Puffer
         field = args.first.is_a?(Puffer::Field) ? args.first : Puffer::Field.new(*args)
         field.resource = object.class
         template = instance_variable_get :@template
-        field.render template.controller, :form, :form => self
+        field.render template.controller, :form, :form => self, :record => object
       end
 
     end

data/lib/puffer/extensions/mapper.rb

@@ -1,189 +1,114 @@
 module Puffer
   module Extensions
+    # Extends rails mapper to provide resources nesting tree structure with
+    # request params. Route defaults contains <tt>:puffer</tt> key with node
+    # index in resources tree nodes array. See <tt>Puffer::Resource::Tree</tt>
+    # 
+    # Resource tree depends on routes resources nesting.
+    #
+    # ex:
+    #   
+    #   namespace :admin do
+    #     resources :users do
+    #       resource :profile
+    #       resources :articles
+    #     end
+    #     resources :orders
+    #   end
+    #
+    # will produce:
+    #
+    #   [
+    #     {:scope => 'admin', :current => :users, :children => [:profile, :articles], :ancestors => []},
+    #     {:scope => 'admin', :current => :profile, :children => [], :ancestors => [:users]},
+    #     {:scope => 'admin', :current => :articles, :children => [], :ancestors => [:users]},
+    #     {:scope => 'admin', :current => :orders, :children => [], :ancestors => []},
+    #   ]
+    # 
+    # a complete tree structure with nodes array to acces with node index
+    # (<tt>Puffer::Resource::Tree#to_struct</tt>).
+    #
+    # Also this mapper extension adds come aaditional routes for every pufer
+    # controller and namespace.
     module Mapper
       extend ActiveSupport::Concern
 
       included do
-        alias_method_chain :resource, :puffer
-        alias_method_chain :resources, :puffer
+        alias_method_chain :namespace, :puffer
+        alias_method_chain :resource_scope, :puffer
       end
 
       module InstanceMethods
 
-        def resource_with_puffer *resources, &block
-          puffer_resource(*Marshal.load(Marshal.dump(resources)), &block) || resource_without_puffer(*resources, &block)
-        end
-
-        def resources_with_puffer *resources, &block
-          puffer_resources(*Marshal.load(Marshal.dump(resources)), &block) || resources_without_puffer(*resources, &block)
-        end
-
-        def puffer_controller controller
-          if controller.configuration.group
-            puffer = ::Rails.application.routes.puffer
-            namespace = @scope[:module]
-
-            unless puffer[namespace]
-              @scope[:module] = 'admin'
-              root :to => 'dashboard#index', :namespace => namespace
-              @scope[:module] = namespace
-            end
-
-            puffer[namespace] ||= ActiveSupport::OrderedHash.new
-            puffer[namespace][controller.configuration.group] ||= []
-            puffer[namespace][controller.configuration.group] << controller
-          end
-        end
-
-        def puffer_resource(*resources, &block)
-          options = resources.extract_options!
-
-          if apply_common_behavior_for(:resource, resources, options, &block)
-            return self
-          end
-
-          resource = ActionDispatch::Routing::Mapper::Resources::SingletonResource.new(resources.pop, options)
-          controller = "#{[@scope[:module], resource.controller].compact.join("/")}_controller".camelize.constantize rescue nil
+        def namespace_with_puffer path, options = {}
+          defaults :puffer_scope => path.to_sym do
+            namespace_without_puffer path, options do
+              yield
 
-          return if controller.nil? || (controller && !controller.puffer?)
-
-          @scope[:ancestors] ||= []
-          @scope[:children] ||= []
-
-          puffer_controller controller if @scope[:ancestors] == []
-
-          resource_scope(resource) do
-            siblings = @scope[:children].dup
-            @scope[:children] = []
-            @scope[:ancestors].push resource.singular.to_sym
-
-            yield if block_given?
-
-            @scope[:ancestors].pop
-            options = {:plural => false, :ancestors => @scope[:ancestors].dup, :children => @scope[:children].dup}
-            siblings.push resource.singular.to_sym
-            @scope[:children] = siblings
-
-            collection do
-              get  '/event/:fieldset/:field/:event(/:identifer)', options.merge(:action => :event, :as => :event)
-              post :create, options
-              controller._collections.each do |action|
-                opts = action.route.extract_options!.dup
-                action.route.push options.reverse_merge(opts)
-                send *action.route
+              if ::Rails.application.routes.resources_tree.any? {|node| node.scope == @scope[:module].to_sym}
+                old, @scope[:module] = @scope[:module], 'admin'
+                root :to => 'dashboard#index'
+                @scope[:module] = old
               end
             end
-
-            new do
-              get :new, options
-            end
-
-            member do
-              get    :edit, options
-              get    :show, options
-              put    :update, options
-              delete :destroy, options
-              controller._members.each do |action|
-                opts = action.route.extract_options!.dup
-                action.route.push options.reverse_merge(opts)
-                send *action.route
-              end
-            end
-
           end
-
-          self
         end
 
-        def puffer_resources(*resources, &block)
-          options = resources.extract_options!
-
-          if apply_common_behavior_for(:resources, resources, options, &block)
-            return self
-          end
-
-          resource = ActionDispatch::Routing::Mapper::Resources::Resource.new(resources.pop, options)
-          controller = "#{[@scope[:module], resource.controller].compact.join("/")}_controller".camelize.constantize rescue nil
-
-          return if controller.nil? || (controller && !controller.puffer?)
-
-          @scope[:ancestors] ||= []
-          @scope[:children] ||= []
-
-          puffer_controller controller if @scope[:ancestors] == []
-
-          resource_scope(resource) do
-            siblings = @scope[:children].dup
-            @scope[:children] = []
-            @scope[:ancestors].push resource.plural.to_sym
-
-            yield if block_given?
-
-            @scope[:ancestors].pop
-            options = {:plural => true, :ancestors => @scope[:ancestors].dup, :children => @scope[:children].dup}
-            siblings.push resource.plural.to_sym
-            @scope[:children] = siblings
-
-
-            collection do
-              get  :index, options
-              get  '/event/:fieldset/:field/:event(/:identifer)', options.merge(:action => :event, :as => :event)
-              post :create, options
-              controller._collections.each do |action|
-                opts = action.route.extract_options!.dup
-                action.route.push options.reverse_merge(opts)
-                send *action.route
-              end
-            end
-
-            new do
-              get :new, options
-            end
-
-            member do
-              get    :edit, options
-              get    :show, options
-              put    :update, options
-              delete :destroy, options
-              controller._members.each do |action|
-                opts = action.route.extract_options!.dup
-                action.route.push options.reverse_merge(opts)
-                send *action.route
+        def resource_scope_with_puffer resource, &block
+          controller = "#{[@scope[:module], resource.controller].compact.join("/")}_controller".camelize.constantize# rescue nil
+          if controller && controller.puffer?
+            singular = resource.is_a? ActionDispatch::Routing::Mapper::Resources::SingletonResource
+            name = (singular ? resource.singular : resource.plural).to_sym
+
+            resource_node = ::Rails.application.routes.resources_tree.append_node swallow_nil{@scope[:defaults][:puffer]},
+              :name => name, :scope => @scope[:module].to_sym, :controller => controller, :singular => singular
+
+            defaults :puffer => resource_node do
+              resource_scope_without_puffer resource do
+                block.call if block
+
+                member do
+                  controller._members.each do |action|
+                    send *action.route
+                  end
+                end
+
+                collection do
+                  controller._collections.each do |action|
+                    send *action.route
+                  end
+                  get '/event/:fieldset/:field/:event(/:identifer)', :action => :event, :as => :event
+                end
               end
             end
+          else
+            resource_scope_without_puffer resource, &block
           end
-
-          self
         end
 
       end
-
     end
 
     module RouteSet
+      extend ActiveSupport::Concern
 
-      def self.included base
-        base.class_eval do
-          include InstanceMethods
-
-          alias_method_chain :clear!, :puffer
-          attr_writer :puffer
+      included do
+        alias_method_chain :clear!, :puffer
+        attr_writer :resources_tree
 
-          def puffer
-            @puffer ||= ActiveSupport::OrderedHash.new
-          end
+        def resources_tree
+          @resources_tree ||= Puffer::Resource::Tree.new
         end
       end
 
       module InstanceMethods
 
         def clear_with_puffer!
-          self.puffer = ActiveSupport::OrderedHash.new
+          @resources_tree = nil
           clear_without_puffer!
         end
 
       end
-
     end
 
   end