puffer 0.0.32 → 0.1.0

data/lib/puffer/filters.rb

@@ -1,40 +1,103 @@
 module Puffer
   class Filters
+    class Diapason < Struct.new(:from, :till)
+      def empty?
+        from.blank? && till.blank?
+      end
+
+      def persisted?
+        false
+      end
+
+      def to_query(key)
+        {:from => from, :till => till}.to_query(key)
+      end
+    end
+
     include ActiveModel::Conversion
     extend ActiveModel::Naming
     extend ActiveModel::Translation
     include ActiveModel::AttributeMethods
 
-    delegate :model_name, :to => 'self.class'
+    delegate :model_name, :special_attributes, :to => 'self.class'
 
-    def initialize attributes = {}
-      attributes ||= {}
-      attributes.each do |(key, value)|
-        send("#{key}=", value) if respond_to?("#{key}=")
+    def self.special_attributes
+      %w(puffer_search puffer_order)
+    end
+
+    special_attributes.each do |attribute|
+      define_method attribute do
+        read_attribute attribute
+      end
+      define_method "#{attribute}=" do |value|
+        write_attribute attribute, value
       end
     end
 
+    attr_reader :fieldset
+
+    def initialize fieldset, attributes = {}
+      @attributes = {}
+      @fieldset = fieldset
+      generate_attribute_methods
+
+      self.attributes = attributes
+    end
+
     def read_attribute name
-      attributes[name]
+      @attributes[name.to_s]
     end
 
     def write_attribute name, value
-      attributes[name] = value.presence if attributes.key?(name)
+      if value.is_a? Hash
+        value.each do |key, subvalue|
+          @attributes[name.to_s][key] = subvalue if subvalue.present?
+        end
+      else
+        @attributes[name.to_s] = value
+      end if value.present?
     end
 
-    def persisted?
-      false
+    def any?
+      attributes.values.any?
     end
 
-    def any?
-      attributes.keys.any? { |attribute| !send(attribute).nil? }
+    def attributes
+      (fieldset.map(&:field_name) + special_attributes).reduce(ActiveSupport::HashWithIndifferentAccess.new()) do |res, attribute|
+        res.merge attribute => send(attribute)
+      end
+    end
+
+    def attributes= attributes = {}
+      attributes.each do |(key, value)|
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
+    end
+
+    def generate_attribute_methods
+      fieldset.each do |field|
+        define_singleton_method :"#{field}" do
+          read_attribute field
+        end
+        define_singleton_method :"#{field}=" do |value|
+          write_attribute field, value
+        end
+
+        if %(date, time, datetime, date_time, timestamp).include?(field.type.to_s)
+          @attributes[field.to_s] = Puffer::Filters::Diapason.new
+
+          define_singleton_method :"#{field}_attributes=" do |value|
+            write_attribute field, value
+          end
+        end
+      end
     end
 
     def conditions
-      attributes.except('puffer_search', 'puffer_order').keys.reduce({}) do |res, attribute|
+      fieldset.map(&:field_name).reduce(ActiveSupport::HashWithIndifferentAccess.new()) do |res, attribute|
         value = send(attribute)
 
-        unless value.nil?
+        unless value.blank?
           value = case value
           when 'puffer_nil' then nil
           when 'puffer_blank' then ''
@@ -52,54 +115,21 @@ module Puffer
     end
 
     def order
-      puffer_order
+      puffer_order.to_s.split(' ').map(&:to_sym)
     end
 
-    module ClassMethods
-      def model_name
-        @model_name ||= begin
-          name = super
-          name.instance_variable_set :@param_key, 'filters'
-          name
-        end
-      end
-
-      def controller_filters controller
-        scope = "#{controller}Filters".split('::')[0..-2].join('::').constantize rescue Kernel
-        name = "#{controller}Filters".demodulize
-
-        if scope.const_defined?(name)
-          scope.const_get(name)
-        else
-          attributes_from_controller = controller.index_fields.reduce({}) do |res, field|
-            res[field.field_name] = nil
-            res
-          end
-
-          attributes_from_controller.merge!('puffer_search' => nil, 'puffer_order' => nil)
-
-          klass = Class.new(self)
-
-          attributes_from_controller.keys.each do |name|
-            klass.send :define_method, name do
-              read_attribute name
-            end
-            klass.send :define_method, "#{name}=" do |value|
-              write_attribute name, value
-            end
-          end
-
-          klass.send :define_method, :attributes do
-            attributes_from_controller
-          end
-          
-
-          scope.const_set(name, klass)
-        end
+    def query
+      (fieldset.map(&:field_name) + special_attributes).reduce(ActiveSupport::HashWithIndifferentAccess.new()) do |res, attribute|
+        value = send(attribute)
+        attribute = "#{attribute}_attributes" if respond_to?("#{attribute}_attributes=")
+        res[attribute] = value if value.present?
+        res
       end
     end
 
-    extend ClassMethods
+    def persisted?
+      false
+    end
 
   end
 end

data/lib/puffer/helpers/component_helper.rb

@@ -0,0 +1,24 @@
+module Puffer
+  module Helpers
+    module ComponentHelper
+
+      def component_wrap name = :span, options = {}, &block
+        content_tag name, options.merge(:id => component_id), &block
+      end
+
+      def paginate(scope, options = {}, &block)
+        paginator = Kaminari::Helpers::Paginator.new parent_controller.view_context, options.reverse_merge(:current_page => scope.current_page, :num_pages => scope.num_pages, :per_page => scope.limit_value, :param_name => Kaminari.config.param_name, :remote => false)
+        paginator.to_s
+      end
+
+      def component_fields_for record, &block
+        if opts[:builder]
+          capture opts[:builder], &block
+        else
+          fields_for record, &block
+        end
+      end
+      
+    end
+  end
+end

data/lib/puffer/helpers/puffer_helper.rb

@@ -0,0 +1,65 @@
+# coding: utf-8
+
+module Puffer
+  module Helpers
+    module PufferHelper
+
+      def puffer_scopes_navigation
+        Rails.application.routes.resources_tree.map(&:scope).uniq.each do |scope|
+          yield scope, send("#{scope}_root_path"), scope == puffer_namespace
+        end
+      end
+
+      def puffer_groups_navigation namespace = puffer_namespace
+        Rails.application.routes.resources_tree.roots.select {|node| node.scope == namespace}.uniq_by(&:group).each do |resource_node|
+          if resource_node.group
+            path = send("#{resource_node.scope}_#{resource_node.url_segment}_path")
+            current = resource.resource_node ? resource.root.resource_node.group == resource_node.group : false
+
+            yield resource_node.group, path, current
+          end
+        end
+      end
+
+      def puffer_resources_navigation namespace = puffer_namespace, group = configuration.group
+        Rails.application.routes.resources_tree.roots.select {|node| node.scope == namespace && node.group == group}.each do |resource_node|
+          title = resource_node.controller.model.model_name.human
+          path = send("#{resource_node.scope}_#{resource_node.url_segment}_path")
+          current = resource.resource_node ? resource.root.resource_node == resource_node : false
+
+          yield title, path, current
+        end
+      end
+
+      def render_head field
+        head = []
+        if field.column
+          head.push link_to_unless(puffer_filters.puffer_order == field.to_s, "▼", resource.collection_path(:page => params[:page], Puffer::Filters.model_name.param_key => puffer_filters.query.merge(:puffer_order => field)))
+          head.push link_to_unless(puffer_filters.puffer_order == [field, :desc].join(' '), "▲", resource.collection_path(:page => params[:page], Puffer::Filters.model_name.param_key => puffer_filters.query.merge(:puffer_order => [field, :desc].join(' '))))
+        end
+        head.push field.human
+        head.join(' ').html_safe
+      end
+
+      def render_field field, record
+        if field.options[:render]
+          case field.options[:render]
+          when Symbol then
+            res = send(field.options[:render], record)
+          when Proc then
+            res = field.options[:render].bind(self).call(record)
+          else ''
+          end
+        else
+          res = record.call_chain(field.to_s)
+        end
+        unless field.native?
+          url = edit_polymorphic_path [resource.scope, record.call_chain(field.path)] rescue nil
+          res = link_to res, url if url
+        end
+        res
+      end
+
+    end
+  end
+end

data/lib/puffer/helpers/puffer_tree_helper.rb

@@ -0,0 +1,19 @@
+module Puffer
+  module Helpers
+    module PufferTreeHelper
+
+      def puffer_tree hash, options = {}, &block
+        content_tag :ul, options do
+          puffer_tree_node hash, &block
+        end if hash.present?
+      end
+
+      def puffer_tree_node hash, &block
+        hash.keys.each do |node|
+          block.call node, render_tree(hash[node], &block)
+        end if hash.present?
+      end
+
+    end
+  end
+end

data/lib/puffer/orm_adapter/active_record.rb

@@ -8,23 +8,40 @@ module Puffer
         end
       end
 
+      def reflection name
+        reflection = klass.reflect_on_association(name.to_sym)
+        Reflection.new(
+          :klass => reflection.klass,
+          :macro => reflection.macro,
+          :through? => !!reflection.through_reflection
+        ) if reflection
+      end
+
       def filter scope, fields, options = {}
-        fields = fields.columns
         conditions, order = extract_conditions_and_order!(options)
 
-        conditions_fields = fields.select {|f| conditions.keys.include?(f.field_name)}.to_fieldset
-        search_fields = fields.select {|f| !conditions_fields.include?(f) && search_types.include?(f.column_type)}
-        all_fields = conditions_fields + search_fields
+        order = order.map { |name, dir| field = fields[name]; "#{query_order(field)} #{dir}" if field && field.column }.compact.join(', ')
+
+        conditions_fields = fields.select {|f| f.column && conditions.keys.include?(f.field_name)}.to_fieldset
+        search_fields = fields.select {|f| f.column && !conditions_fields.include?(f) && search_types.include?(f.column_type)}
+        all_fields = conditions_fields + search_fields        
 
-        conditions = conditions.reduce({}) do |res, (name, value)|
+        scope = scope.includes(includes(all_fields)).includes(reflection_includes(fields)).where(searches(search_fields, options[:search])).order(order)
+
+        conditions.each do |name, value|
           field = conditions_fields[name]
-          res[field.query_column] = value if field
-          res
+          scope = if value.is_a?(Puffer::Filters::Diapason)
+            case
+            when value.from.blank? then scope.where(["#{query_column(field)} < ?", value.till])
+            when value.till.blank? then scope.where(["#{query_column(field)} > ?", value.from])
+            else scope.where(name => Range.new(value.from, value.till))
+            end
+          else
+            scope.where(name => value)
+          end if field
         end
 
-        order = order.map {|field, direction| "#{field} #{direction}"}.join(', ')
-
-        scope.includes(includes(all_fields)).where(searches(search_fields, options[:search])).where(conditions).order(order)
+        scope
       end
 
     private
@@ -37,8 +54,20 @@ module Puffer
         fields.map {|f| f.path unless f.native?}.compact.to_includes
       end
 
+      def reflection_includes fields
+        fields.map {|f| f.field_name if f.reflection}.compact.to_includes
+      end
+
       def searches fields, query
-        [fields.map {|f| "#{f.query_column} like ?"}.compact.join(' or '), *(Array.wrap("%#{query}%") * fields.count)] if query.present?
+        [fields.map {|f| "#{query_column(f)} like ?"}.compact.join(' or '), *(Array.wrap("%#{query}%") * fields.count)] if query.present?
+      end
+
+      def query_column field
+        "#{field.model.table_name}.#{field.name}" if field.column
+      end
+
+      def query_order field
+        field.options[:order] || query_column(field)
       end
 
     end

data/lib/puffer/orm_adapter/base.rb

@@ -11,6 +11,15 @@ module Puffer
       end
 
     end
+
+    class Reflection < ActiveSupport::OrderedOptions
+
+      def initialize hash
+        super
+        hash.each { |(key, value)| self[key] = value }
+      end
+
+    end
   end
 end
 

data/lib/puffer/orm_adapter/mongoid.rb

@@ -8,22 +8,41 @@ module Puffer
         end
       end
 
+      def reflection name
+        reflection = klass.reflect_on_association(name.to_sym)
+        Reflection.new(
+          :klass => reflection.klass,
+          :macro => reflection.macro,
+          :through? => false
+        ) if reflection
+      end
+
       def filter scope, fields, options = {}
-        fields = fields.columns
         conditions, order = extract_conditions_and_order!(options)
 
-        conditions_fields = fields.select {|f| conditions.keys.include?(f.field_name)}.to_fieldset
-        search_fields = fields.select {|f| !conditions_fields.include?(f) && search_types.include?(f.column_type)}
+        order = order.map { |o| f = fields[o.first]; [query_order(f), o.last] if f && f.column }.compact
+
+        conditions_fields = fields.select {|f| f.column && conditions.keys.include?(f.field_name)}.to_fieldset
+        search_fields = fields.select {|f| f.column && !conditions_fields.include?(f) && search_types.include?(f.column_type)}
         all_fields = conditions_fields + search_fields
+        
+        scope = scope.any_of(searches(search_fields, options[:search])) if options[:search].present?
+        scope = scope.order_by(order)
 
-        conditions = conditions.reduce({}) do |res, (name, value)|
+        conditions.each do |name, value|
           field = conditions_fields[name]
-          res[field.name] = value if field
-          res
+          scope = if value.is_a?(Puffer::Filters::Diapason)
+            case
+            when value.from.blank? then scope.where(name.to_sym.lt => value.till)
+            when value.till.blank? then scope.where(name.to_sym.gt => value.from)
+            else scope.where(name => Range.new(value.from, value.till))
+            end
+          else
+            scope.where(name => value)
+          end if field
         end
 
-        scope = scope.any_of(searches(search_fields, options[:search])) if options[:search].present?
-        scope.where(conditions).order(order)
+        scope
       end
 
     private
@@ -34,7 +53,11 @@ module Puffer
 
       def searches fields, query
         regexp = /#{Regexp.escape(query)}/i
-        fields.map {|field| {field.name => regexp}}
+        fields.map {|field| {field.to_s => regexp}}
+      end
+
+      def query_order field
+        field.options[:order] || field.name
       end
 
     end

data/lib/puffer/resource/node.rb

@@ -59,8 +59,8 @@ module Puffer
         ancestors
       end
 
-      def url_string
-        [scope, name, (:index if singular == plural)].compact.map(&:to_s).join('_')
+      def url_segment
+        [name, (:index if singular == plural)].compact.map(&:to_s).join('_')
       end
 
       def to_struct

data/lib/puffer/resource/routing.rb

@@ -5,38 +5,52 @@ module Puffer
       include ActionController::UrlFor
       include Rails.application.routes.url_helpers
 
-      def collection_url *args
-        polymorphic_url *route_args(route_member(model), *args)
+      def collection_method routing_type, options = {}
+        send url_method_name(routing_type, url_segment, options.delete(:action)), *url_arguments, options
       end
 
-      def member_url *args
-        suggest = args.shift if args.first.respond_to? :to_key
-        polymorphic_url *route_args(route_member(suggest), *args)
+      def member_method routing_type, *args
+        options = args.extract_options!
+        send url_method_name(routing_type, singular, options.delete(:action)), *url_arguments(use_resource_id(args.first) || member_id), options
       end
 
-      def new_url *args
-        new_polymorphic_url *route_args(name.to_s.singularize, *args)
+      def new_method routing_type, options = {}
+        send url_method_name(routing_type, singular, :new), *url_arguments, options
       end
 
-      def edit_url *args
-        suggest = args.shift if args.first.respond_to? :to_key
-        edit_polymorphic_url *route_args(route_member(suggest), *args)
+      def edit_method routing_type, *args
+        options = args.extract_options!
+        member_method routing_type, *args, options.merge(:action => :edit)
       end
 
-      def route_args *args
-        options = args.extract_options!
-        resource = Array.wrap(args)
-        return [scope] + ancestors.map(&:route_member) + resource, options
+      def url_method_name routing_type, current, action = nil
+        [action, scope, *ancestors.map(&:singular), current, routing_type].compact.join('_')
       end
 
-      def route_member suggest = nil
-        plural? ? (suggest || member) : name.to_s.singularize
+      def url_arguments current = nil
+        ancestors.map(&:member_id).push(current).compact
+      end
+
+      %w(url path).each do |routing_type|
+        %w(collection member new edit).each do |method|
+          define_method "#{method}_#{routing_type}" do |*args|
+            send "#{method}_method", routing_type, *args
+          end
+        end
       end
 
       def default_url_options *args
         Puffer::Base.default_url_options(*args)
       end
 
+      def use_resource_id(resource)
+        if resource and resource.respond_to?(:id)
+          resource.id
+        else
+          resource
+        end
+      end
+
     end
   end
 end

data/lib/puffer/resource.rb

@@ -11,7 +11,7 @@ module Puffer
     include Routing
 
     attr_reader :resource_node, :scope, :params, :controller_instance
-    delegate :controller, :name, :plural?, :to => :resource_node, :allow_nil => true
+    delegate :controller, :name, :plural?, :singular, :plural, :url_segment, :to => :resource_node, :allow_nil => true
     delegate :model, :to => :controller, :allow_nil => true
     delegate :env, :request, :to => :controller_instance, :allow_nil => true
 
@@ -51,14 +51,10 @@ module Puffer
           resource_node.ancestors[0..-2].each do |ancestor|
             key = ancestor.to_s.singularize.foreign_key
             parent_params[key] = params[key] if params[key]
-            key = key.gsub(/_id$/, '_member')
-            parent_params[key] = params[key] if params[key]
           end
 
           key = resource_node.parent.to_s.singularize.foreign_key
           parent_params[:id] = params[key] if params[key]
-          key = key.gsub(/_id$/, '_member')
-          parent_params[:member] = params[key] if params[key]
 
           self.class.new parent_params, controller_instance
         end
@@ -72,14 +68,10 @@ module Puffer
         resource_node.ancestors.each do |ancestor|
           key = ancestor.to_s.singularize.foreign_key
           child_params[key] = params[key] if params[key]
-          key = key.gsub(/_id$/, '_member')
-          child_params[key] = params[key] if params[key]
         end
 
         key = resource_node.to_s.singularize.foreign_key
         child_params[key] = params[:id] if params[:id]
-        key = key.gsub(/_id$/, '_member')
-        child_params[key] = params[:member] if params[:member]
 
         self.class.new child_params, controller_instance
       end
@@ -92,31 +84,40 @@ module Puffer
       end
     end
 
+    def member_id
+      params[:id]
+    end
+
     def collection_scope
       parent ? parent.member.send(name) : model
     end
 
+    def adapter
+      model.to_adapter
+    end
+
     def collection
-      model.to_adapter.filter collection_scope, controller.index_fields,
+      scope = collection_scope
+      scope = scope.send controller.configuration.scope if controller.configuration.scope
+      adapter.filter scope, controller.filter_fields,
         :conditions => controller_instance.puffer_filters.conditions,
         :search => controller_instance.puffer_filters.search,
         :order => controller_instance.puffer_filters.order
     end
 
     def member
-      return params[:member] if params[:member]
       if parent
         if plural?
-          parent.member.send(name).find params[:id] if params[:id]
+          parent.member.send(name).find member_id if member_id
         else
           parent.member.send(name)
         end
       else
-        model.find params[:id] if params[:id]
+        adapter.get member_id if member_id
       end
     end
 
-    def new_member
+    def new_member attributes = attributes
       if parent
         if plural?
           parent.member.send(name).new attributes
@@ -129,15 +130,14 @@ module Puffer
     end
 
     def attributes
-      params[name.to_s.singularize]
+      params[attributes_key] || {}
+    end
+
+    def attributes_key
+      model.model_name.param_key
     end
 
     def method_missing method, *args, &block
-      method = method.to_s
-      if method.match(/path$/) && respond_to?(method.gsub(/path$/, 'url'))
-        options = args.extract_options!
-        return send method.gsub(/path$/, 'url'), *(args << options.merge(:routing_type => :path))
-      end
       model.send method, *args, &block if model.respond_to? method
     end
 

data/lib/puffer/version.rb

@@ -0,0 +1,3 @@
+module Puffer
+  VERSION = "0.1.0"
+end