puffer 0.0.29 → 0.0.30

data/lib/puffer/field.rb

@@ -45,9 +45,7 @@ module Puffer
     end
 
     def custom_type
-      return :select if options.key?(:select)
-      return :password if name =~ /password/
-      return reflection.macro if reflection
+      Puffer.field_type_for self
     end
 
     def reflection
@@ -59,7 +57,7 @@ module Puffer
     end
 
     def component_class
-      @component_class ||= Puffer::Component.component_for type
+      @component_class ||= Puffer.component_for self
     end
 
     def component

data/lib/puffer/field_set.rb

@@ -13,25 +13,13 @@ module Puffer
       last
     end
 
-    def searchable
-      @searchable ||= map { |f| f if f.column && [:text, :string, :integer, :decimal, :float].include?(f.column_type) }.compact
-    end
-
-    def searches query
-      searchable.map { |f| "#{f.query_column} like '%#{query}%'" if f.query_column.present? }.compact.join(' or ') if query
-    end
-
-    def boolean
-      @boolean ||= reject { |f| f.type != :boolean }
-    end
-
-    def includes
-      @includes ||= map {|f| f.path unless f.native?}.compact.to_includes
+    def columns
+      select {|f| f.column}.to_fieldset
     end
 
     def [] key
       if key.is_a?(String) || key.is_a?(Symbol)
-        detect {|f| f.to_s == key.to_s}
+        detect {|f| f.field_name == key.to_s}
       else
         super
       end

data/lib/puffer/filters.rb

@@ -0,0 +1,105 @@
+module Puffer
+  class Filters
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
+    extend ActiveModel::Translation
+    include ActiveModel::AttributeMethods
+
+    delegate :model_name, :to => 'self.class'
+
+    def initialize attributes = {}
+      attributes ||= {}
+      attributes.each do |(key, value)|
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
+    end
+
+    def read_attribute name
+      attributes[name]
+    end
+
+    def write_attribute name, value
+      attributes[name] = value.presence if attributes.key?(name)
+    end
+
+    def persisted?
+      false
+    end
+
+    def any?
+      attributes.keys.any? { |attribute| !send(attribute).nil? }
+    end
+
+    def conditions
+      attributes.except('puffer_search', 'puffer_order').keys.reduce({}) do |res, attribute|
+        value = send(attribute)
+
+        unless value.nil?
+          value = case value
+          when 'puffer_nil' then nil
+          when 'puffer_blank' then ''
+          else value
+          end
+          res[attribute] = value
+        end
+
+        res
+      end
+    end
+
+    def search
+      puffer_search
+    end
+
+    def order
+      puffer_order
+    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
+      end
+    end
+
+    extend ClassMethods
+
+  end
+end

data/lib/puffer/orm_adapter/active_record.rb

@@ -8,6 +8,39 @@ module Puffer
         end
       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
+
+        conditions = conditions.reduce({}) do |res, (name, value)|
+          field = conditions_fields[name]
+          res[field.query_column] = value if field
+          res
+        end
+
+        order = order.map {|field, direction| "#{field} #{direction}"}.join(', ')
+
+        scope.includes(includes(all_fields)).where(searches(search_fields, options[:search])).where(conditions).order(order)
+      end
+
+    private
+
+      def search_types
+        [:text, :string, :integer, :decimal, :float]
+      end
+
+      def includes fields
+        fields.map {|f| f.path unless f.native?}.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?
+      end
+
     end
   end
 end

data/lib/puffer/orm_adapter/base.rb

@@ -6,6 +6,10 @@ module Puffer
         raise NotSupportedError
       end
 
+      def filter scope, fields, options = {}
+        raise NotSupportedError
+      end
+
     end
   end
 end

data/lib/puffer/orm_adapter/mongoid.rb

@@ -8,6 +8,35 @@ module Puffer
         end
       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
+
+        conditions = conditions.reduce({}) do |res, (name, value)|
+          field = conditions_fields[name]
+          res[field.name] = value if field
+          res
+        end
+
+        scope = scope.any_of(searches(search_fields, options[:search])) if options[:search].present?
+        scope.where(conditions).order(order)
+      end
+
+    private
+
+      def search_types
+        [:string, :integer, :big_decimal, :float, :"bson/object_id", :symbol]
+      end
+
+      def searches fields, query
+        regexp = /#{Regexp.escape(query)}/i
+        fields.map {|field| {field.name => regexp}}
+      end
+
     end
   end
 end

data/lib/puffer/resource.rb

@@ -9,57 +9,25 @@ module Puffer
   class Resource
 
     include Routing
-    include Scoping
 
-    attr_reader :controller, :params, :namespace, :action, :controller_name, :model_name, :controller_class, :model
-    delegate :env, :request, :to => :controller, :allow_nil => true
+    attr_reader :resource_node, :scope, :params, :controller_instance
+    delegate :controller, :name, :plural?, :to => :resource_node, :allow_nil => true
+    delegate :model, :to => :controller, :allow_nil => true
+    delegate :env, :request, :to => :controller_instance, :allow_nil => true
 
-    def initialize params, controller = nil
+    def initialize params, controller_instance = nil
       params = ActiveSupport::HashWithIndifferentAccess.new.deep_merge params
-      @action = params.delete :action
-      @controller_class = "#{params.delete :controller}_controller".camelize.constantize
-      @controller_name = controller_class.controller_name
-      @namespace = controller_class.namespace
-      @model_name = controller_class.model_name if controller_class.puffer?
-      @model = controller_class.model if controller_class.puffer?
-      @params = params
-      @controller = controller
-    end
 
-    def plural?
-      params[:plural]
+      @resource_node = params[:puffer]
+      @scope = swallow_nil{@resource_node.scope} || params[:puffer_scope]
+      @params = params
+      @controller_instance = controller_instance
     end
 
     def human
       model.model_name.human
     end
 
-    def parent
-      @parent ||= begin
-        parent_ancestors = params[:ancestors].dup rescue []
-        parent_name = parent_ancestors.pop
-        if parent_name
-          parent_params = ActiveSupport::HashWithIndifferentAccess.new({
-            :controller => "#{namespace}/#{parent_name.to_s.pluralize}",
-            :action => 'index',
-            :plural => parent_name.plural?,
-            :ancestors => parent_ancestors,
-            :children => []
-          })
-
-          parent_ancestors.each do |ancestor|
-            key = ancestor.to_s.singularize.foreign_key
-            parent_params.merge! key => params[key] if params[key]
-          end
-          parent_params.merge! :id => params[parent_name.to_s.singularize.foreign_key]
-
-          self.class.new parent_params, controller
-        else
-          nil
-        end
-      end
-    end
-
     def ancestors
       @ancestors ||= begin
         ancestors = []
@@ -75,40 +43,73 @@ module Puffer
       @root ||= (ancestors.first || self)
     end
 
-    def children(custom_params = {})
-      @children ||= params[:children].map do |child_name|
-        child_params = ActiveSupport::HashWithIndifferentAccess.new(custom_params.deep_merge({
-          :controller => "#{namespace}/#{child_name.to_s.pluralize}",
-          :action => 'index',
-          :plural => child_name.plural?,
-          :ancestors => params[:ancestors].dup.push((plural? ? controller_name : controller_name.singularize).to_sym),
-          :children => []
-        }))
-
-        params[:ancestors].each do |ancestor|
+    def parent
+      @parent ||= begin
+        if resource_node.parent
+          parent_params = ActiveSupport::HashWithIndifferentAccess.new({:puffer => resource_node.parent})
+
+          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
+      end
+    end
+
+    def children
+      @children ||= resource_node.children.map do |child_node|
+        child_params = ActiveSupport::HashWithIndifferentAccess.new({:puffer => child_node})
+
+        resource_node.ancestors.each do |ancestor|
           key = ancestor.to_s.singularize.foreign_key
-          child_params.merge! key => params[key] if params[key]
+          child_params[key] = params[key] if params[key]
+          key = key.gsub(/_id$/, '_member')
+          child_params[key] = params[key] if params[key]
         end
-        child_params.merge! controller_name.singularize.foreign_key => params[:id] if params[:id]
 
-        self.class.new child_params, controller
+        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
+    end
+
+    def children_hash
+      @children_hash ||= children.inject(ActiveSupport::HashWithIndifferentAccess.new) do |result, child|
+        result[child.name] = child
+        result
       end
     end
 
     def collection_scope
-      parent ? parent.member.send(model_name.pluralize) : model
+      parent ? parent.member.send(name) : model
     end
 
     def collection
-      collection_scope.includes(includes).where(searches(params[:search])).order(order).page(params[:page])
+      model.to_adapter.filter collection_scope, controller.index_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(model_name.pluralize).find params[:id] if params[:id]
+          parent.member.send(name).find params[:id] if params[:id]
         else
-          parent.member.send(model_name)
+          parent.member.send(name)
         end
       else
         model.find params[:id] if params[:id]
@@ -118,9 +119,9 @@ module Puffer
     def new_member
       if parent
         if plural?
-          parent.member.send(model_name.pluralize).new attributes
+          parent.member.send(name).new attributes
         else
-          parent.member.send("build_#{model_name}", attributes)
+          parent.member.send("build_#{name}", attributes)
         end
       else
         model.new attributes
@@ -128,7 +129,7 @@ module Puffer
     end
 
     def attributes
-      params[model_name]
+      params[name.to_s.singularize]
     end
 
     def method_missing method, *args, &block

data/lib/puffer/resource/node.rb

@@ -0,0 +1,71 @@
+module Puffer
+  class Resource
+    class Node
+      attr_accessor :parent, :children, :options
+
+      def initialize *args
+        @options = args.extract_options!
+        @parent = args.first
+        @children = []
+        @parent.children.push self if parent
+      end
+
+      def name
+        options[:name]
+      end
+
+      def to_s
+        name.to_s
+      end
+
+      def scope
+        options[:scope]
+      end
+
+      def controller
+        options[:controller]
+      end
+
+      def group
+        controller.configuration.group
+      end
+
+      def singular
+        name.to_s.singularize
+      end
+
+      def singular?
+        options[:singular]
+      end
+
+      def plural
+        name.to_s.pluralize
+      end
+
+      def plural?
+        !singular?
+      end
+
+      def root?
+        parent.nil?
+      end
+
+      def ancestors
+        ancestors = []
+        resource = self
+        while resource = resource.parent do
+          ancestors.unshift resource
+        end
+        ancestors
+      end
+
+      def url_string
+        [scope, name, (:index if singular == plural)].compact.map(&:to_s).join('_')
+      end
+
+      def to_struct
+        {:scope => scope, :current => name, :children => children.map(&:name), :ancestors => ancestors.map(&:name)}
+      end
+    end
+  end
+end