netzke-basepack 0.12.9 → 1.0.0.0.pre

data/lib/netzke/basepack/data_accessor.rb

@@ -2,57 +2,16 @@ module Netzke
   module Basepack
     # This module is included into such data-driven components as Grid, Form, PagingForm, etc.
     module DataAccessor
-      # Returns options for comboboxes in grids/forms
-      def combobox_options_for_column(column, method_options = {})
-        data_adapter.combobox_options_for_column column, method_options
-      end
-
-      # Normalize array of attributes
-      #     [:col1, "col2", {:name => :col3}] #=> [{:name => "col1"}, {:name => "col2"}, {:name => "col3"}]
-      def normalize_attrs(attrs)
-        attrs.map{ |a| normalize_attr(a) }
-      end
-
-      # Normalize an attribute, e.g.:
-      # :first_name =>
-      #   {:name => "first_name"}
-      def normalize_attr(a)
-        a.is_a?(Symbol) || a.is_a?(String) ? {:name => a.to_s} : a.merge(:name => a[:name].to_s)
-      end
-
-      def association_attr?(attr)
-        !!attr[:name].to_s.index("__")
-      end
-
-      # Model class
-      def data_class
-        @data_class ||= config[:model].is_a?(String) ? config[:model].constantize : config[:model]
+      # Model class as specified in configuration. May be handy to override.
+      # Returns ORM model class.
+      def model
+        @model ||= config[:model].is_a?(String) ? config[:model].constantize : config[:model]
       end
 
       # Data adapter responsible for all DB-related operations.
-      # Note that if data_class is nil, AbstractAdapter will used.
-      def data_adapter
-        @data_adapter ||= Netzke::Basepack::DataAdapters::AbstractAdapter.adapter_class(data_class).new(data_class)
-      end
-
-      # Mark an attribute as "virtual" by default, when it doesn't reflect a model column, or a model column of an association
-      def set_default_virtual(c)
-        c[:virtual] = data_adapter.virtual_attribute?(c) if c[:virtual].nil?
-      end
-
-      # Returns a hash of association attribute default values. Used when creating new records with association attributes that have a default value
-      def default_association_values(attr_hash) #:nodoc:
-        @_default_association_values ||= {}.tap do |values|
-          attr_hash.each_pair do |name,c|
-            next unless association_attr?(c) && c[:default_value]
-
-            assoc_name, assoc_method = c[:name].split '__'
-            assoc_class = data_adapter.class_for(assoc_name)
-            assoc_data_adapter = Netzke::Basepack::DataAdapters::AbstractAdapter.adapter_class(assoc_class).new(assoc_class)
-            assoc_instance = assoc_data_adapter.find_record c[:default_value]
-            values[name] = assoc_instance.send(assoc_method)
-          end
-        end
+      # Note that if model is nil, AbstractAdapter will used.
+      def model_adapter
+        @model_adapter ||= Netzke::Basepack::DataAdapters::AbstractAdapter.adapter_class(model).new(model)
       end
     end
   end

data/lib/netzke/basepack/data_adapters/abstract_adapter.rb

@@ -1,7 +1,7 @@
 module Netzke::Basepack::DataAdapters
   # A concrete adapter should implement all the public instance methods of this adapter in order to support all the functionality of Basepack components.
   class AbstractAdapter
-    attr_accessor :model_class
+    attr_accessor :model
 
     # Returns primary key name of the model
     def primary_key
@@ -18,7 +18,7 @@ module Netzke::Basepack::DataAdapters
       []
     end
 
-    # Returns a list of model attribute hashes, each containing `name`, `attr_type` and `default_value` (if set in the schema).
+    # Returns a list of model attribute names.
     # For association columns the name can have the double-underscore format, e.g.: `author__first_name`.
     # These attributes will be used by grids and forms to display default columns/fields.
     def model_attributes
@@ -48,7 +48,7 @@ module Netzke::Basepack::DataAdapters
     # [start]
     #   page number in pagination
     # [scope]
-    #   the scope as described in Netzke::Basepack::Grid
+    #   the scope as described in Netzke::Grid::Base
     # [filters]
     #   an array of hashes representing a filter query, where the hashes have the following keys:
     #   [attr]
@@ -75,7 +75,7 @@ module Netzke::Basepack::DataAdapters
     #
     # `params` is a hash that contains the following keys:
     #
-    # * :scope - the scope as described in Netzke::Basepack::Grid
+    # * :scope - the scope as described in Netzke::Grid::Base
     # * :filter - Ext filters
     #
     # The `columns` parameter may be used to use joins to address the n+1 query problem, and receives an array of column configurations
@@ -225,24 +225,22 @@ module Netzke::Basepack::DataAdapters
       name.to_s.humanize
     end
 
-    # Returns root record for tree-like data
+    # Return root record for tree-like data
     def root
-      model_class.root
+      model.root
     end
 
-    # Children records for given record in the tree; extra scope (lambda/proc) is optional
-    def find_record_children(r, scope = nil)
-      r.children.extend_with(scope)
+    def find_record_children(r)
+      r.children
     end
 
-    # All root records in the tree
-    def find_root_records(scope)
-      model_class.where(parent_id: nil).extend_with(scope)
+    def find_root_records
+      model.where(parent_id: nil)
     end
 
     # Does record respond to given method?
     def model_respond_to?(method)
-      @model_class.instance_methods.include?(method)
+      @model.instance_methods.include?(method)
     end
 
     # -- End of overridable methods
@@ -261,12 +259,12 @@ module Netzke::Basepack::DataAdapters
       @subclasses << subclass
     end
 
-    def self.adapter_class(model_class)
-      @subclasses.detect { |subclass| subclass.for_class?(model_class) } || AbstractAdapter
+    def self.adapter_class(model)
+      @subclasses.detect { |subclass| subclass.for_class?(model) } || AbstractAdapter
     end
 
-    def initialize(model_class)
-      @model_class = model_class
+    def initialize(model)
+      @model = model
     end
   end
 end

data/lib/netzke/basepack/data_adapters/active_record_adapter.rb

@@ -1,22 +1,22 @@
 module Netzke::Basepack::DataAdapters
   # Implementation of {Netzke::Basepack::DataAdapters::AbstractAdapter}
   class ActiveRecordAdapter < AbstractAdapter
-    def self.for_class?(model_class)
-      model_class && model_class <= ActiveRecord::Base
+    def self.for_class?(model)
+      model && model <= ActiveRecord::Base
     end
 
     def new_record(params = {})
-      @model_class.new(params)
+      @model.new(params)
     end
 
     def primary_key
-      @model_class.primary_key.to_s
+      @model.primary_key.to_s
     end
 
     def model_attributes
-      @_model_attributes ||= attribute_names.map do |column_name|
+      @model_attributes ||= attribute_names.map do |column_name|
         # If it's named as foreign key of some association, then it's an association column
-        assoc = @model_class.reflect_on_all_associations.detect { |a| a.foreign_key == column_name }
+        assoc = @model.reflect_on_all_associations.detect { |a| a.foreign_key == column_name }
 
         if assoc && !assoc.options[:polymorphic]
           candidates = %w{name title label} << assoc.klass.primary_key
@@ -26,71 +26,29 @@ module Netzke::Basepack::DataAdapters
           column_name.to_sym
         end
         # auto set up the default value from the column settings
-        # c[:default_value] = @model_class.columns_hash[column_name].default if @model_class.columns_hash[column_name].default
+        # c[:default_value] = @model.columns_hash[column_name].default if @model.columns_hash[column_name].default
       end
     end
 
     def attribute_names
-      @model_class.column_names
-    end
-
-    def human_attribute_name(attr_name)
-      @model_class.human_attribute_name(attr_name)
+      @model.column_names
     end
 
     def attr_type(attr_name)
       method, assoc = method_and_assoc(attr_name)
-      klass = assoc.nil? ? @model_class : assoc.klass
+      klass = assoc.nil? ? @model : assoc.klass
       klass.columns_hash[method].try(:type) || :string
     end
 
     # Implementation for {AbstractAdapter#get_records}
     def get_records(params, columns=[])
-      # build initial relation based on passed params
       relation = get_relation(params)
 
-      # addressing the n+1 query problem
-      columns.each do |c|
-        assoc, method = c[:name].split('__')
-        relation = relation.includes(assoc.to_sym).references(assoc.to_sym) if method
-      end
-
-      # apply sorting if needed
-      if params[:sorters]
-        sorters = Array.new(params[:sorters])
-        sorters.each do |sorter|
-          sorter["direction"] ||= 'ASC'
-          dir = sorter["direction"].downcase
-          column = columns.detect { |c| c[:name] == sorter["property"] }
-          column ||= {name: sorter["property"]} # stub column, as we may want to sort by a column that's not in the grid
-          relation = apply_sorting(relation, column, dir)
-        end
-      end
-
-      #page = params[:limit] ? params[:start].to_i/params[:limit].to_i + 1 : 1
-      if params[:limit]
-        relation.offset(params[:start]).limit(params[:limit])
-      else
-        relation
-      end
-    end
-
-    def apply_sorting(relation, column, dir)
-      assoc, method = column[:name].split('__')
+      relation = fix_nplus1_problem(relation, columns)
 
-      # if a sorting scope is set, call the scope with the given direction
-      if column.has_key?(:sorting_scope)
-        relation = relation.send(column[:sorting_scope].to_sym, dir.to_sym)
-      else
-        relation = if method.nil?
-          relation.order("#{@model_class.table_name}.#{assoc} #{dir}")
-        else
-          assoc = @model_class.reflect_on_association(assoc.to_sym)
-          relation.includes(assoc.name).references(assoc.klass.table_name.to_sym).order("#{assoc.klass.table_name}.#{method} #{dir}")
-        end
-      end
+      relation = apply_sorting(relation, columns, params[:sorters])
 
-      relation
+      relation = apply_offset(relation, params)
     end
 
     def count_records(params, columns=[])
@@ -107,7 +65,7 @@ module Netzke::Basepack::DataAdapters
     end
 
     def get_assoc_property_type assoc_name, prop_name
-      if prop_name && assoc = @model_class.reflect_on_association(assoc_name)
+      if prop_name && assoc = @model.reflect_on_association(assoc_name)
         assoc_column = assoc.klass.columns_hash[prop_name.to_s]
         assoc_column.try(:type)
       end
@@ -120,7 +78,7 @@ module Netzke::Basepack::DataAdapters
       if assoc
         return !assoc.klass.column_names.include?(method)
       else
-        return !@model_class.column_names.include?(c[:name])
+        return !@model.column_names.include?(c[:name])
       end
     end
 
@@ -131,9 +89,16 @@ module Netzke::Basepack::DataAdapters
         # Options for an asssociation attribute
 
         relation = assoc.klass.all
-        relation = relation.extend_with(attr[:scope]) if attr[:scope]
+        relation = attr[:scope].call(relation) if attr[:scope].is_a?(Proc)
 
-        if assoc.klass.column_names.include?(method)
+        if attr[:filter_association_with]
+          relation = attr[:filter_association_with].call(relation, query).to_a
+          if attr[:getter]
+            relation.map{ |r| [r.id, attr[:getter].call(r)] }
+          else
+            relation.map{ |r| [r.id, r.send(method)] }
+          end
+        elsif assoc.klass.column_names.include?(method)
           # apply query
           assoc_arel_table = assoc.klass.arel_table
 
@@ -151,35 +116,37 @@ module Netzke::Basepack::DataAdapters
     end
 
     def distinct_combo_values(attr, query)
-      records = query.empty? ? @model_class.find_by_sql("select distinct #{attr[:name]} from #{@model_class.table_name}") : @model_class.find_by_sql("select distinct #{attr[:name]} from #{@model_class.table_name} where #{attr[:name]} like '#{query}%'")
+      records = query.empty? ? @model.find_by_sql("select distinct #{attr[:name]} from #{@model.table_name}") : @model.find_by_sql("select distinct #{attr[:name]} from #{@model.table_name} where #{attr[:name]} like '#{query}%'")
       records.map{|r| [r.send(attr[:name]), r.send(attr[:name])]}
     end
 
     def foreign_key_for assoc_name
-      @model_class.reflect_on_association(assoc_name.to_sym).foreign_key
+      @model.reflect_on_association(assoc_name.to_sym).foreign_key
     end
 
     # Returns the model class for association columns
     def class_for assoc_name
-      @model_class.reflect_on_association(assoc_name.to_sym).klass
+      @model.reflect_on_association(assoc_name.to_sym).klass
     end
 
     def destroy(ids)
-      @model_class.destroy(ids)
+      @model.destroy(ids)
     end
 
     # Returns a record by id.
     # Respects the following options:
     # * scope - will only return a record if it falls into the provided scope
     def find_record(id, options = {})
-      scope = options[:scope] || {}
-      @model_class.where(primary_key => id).extend_with(scope).first
+      # scope = options[:scope] || {}
+      relation = @model.where(primary_key => id)
+      relation = options[:scope].call(relation) if options[:scope].is_a?(Proc)
+      relation.first
     end
 
     # Build a hash of foreign keys and the associated model
     def hash_fk_model
       foreign_keys = {}
-      @model_class.reflect_on_all_associations(:belongs_to).map{ |r|
+      @model.reflect_on_all_associations(:belongs_to).map{ |r|
         foreign_keys[r.association_foreign_key.to_sym] = r.name
       }
       foreign_keys
@@ -187,10 +154,10 @@ module Netzke::Basepack::DataAdapters
 
     # FIXME
     def move_records(params)
-      if defined?(ActsAsList) && @model_class.ancestors.include?(ActsAsList::InstanceMethods)
+      if defined?(ActsAsList) && @model.ancestors.include?(ActsAsList::InstanceMethods)
         ids = JSON.parse(params[:ids]).reverse
         ids.each_with_index do |id, i|
-          r = @model_class.find(id)
+          r = @model.find(id)
           r.insert_at(params[:new_index].to_i + i + 1)
         end
         on_data_changed # copypaste nonsense
@@ -216,21 +183,21 @@ module Netzke::Basepack::DataAdapters
     end
 
     def human_attribute_name(name)
-      @model_class.human_attribute_name(name)
+      @model.human_attribute_name(name)
     end
 
     def record_value_for_attribute(r, a, through_association = false)
-      v = if a[:getter]
-        a[:getter].call(r)
-      elsif r.respond_to?("#{a[:name]}")
-        r.send("#{a[:name]}")
-      elsif association_attr?(a)
+      v = if association_attr?(a)
         split = a[:name].to_s.split(/\.|__/)
-        assoc = @model_class.reflect_on_association(split.first.to_sym)
+        assoc = @model.reflect_on_association(split.first.to_sym)
         if through_association
-          split.inject(r) do |r,m| # Do we *really* need to descend deeper than 1 level?
+          split.inject(r) do |r, m| # Do we *really* need to descend deeper than 1 level?
             return nil if r.nil?
-            if r.respond_to?(m)
+
+            # On the last iteration call the getter block
+            if a[:getter] && split.last.equal?(m)
+              a[:getter].call(r)
+            elsif r.respond_to?(m)
               r.send(m)
             else
               logger.warn "Netzke: Wrong attribute name: #{a[:name]}" unless r.nil?
@@ -240,6 +207,11 @@ module Netzke::Basepack::DataAdapters
         else
           r.send("#{assoc.options[:foreign_key] || assoc.name.to_s.foreign_key}")
         end
+      elsif a[:getter]
+        a[:getter].call(r)
+      elsif r.respond_to?("#{a[:name]}")
+        r.send("#{a[:name]}")
+
       # the composite_primary_keys gem produces [Key1,Key2...] and [Value1,Value2...]
       # on primary_key and id requests. Basepack::AttrConfig converts the keys-array to an String.
       elsif primary_key.try(:to_s) == a[:name]
@@ -253,13 +225,11 @@ module Netzke::Basepack::DataAdapters
     end
 
     def set_record_value_for_attribute(record, attr, value)
-      ::Rails.logger.debug "\n!!! attr: #{attr.inspect}\n"
       value = value.to_time_in_current_zone if value.is_a?(Date) # convert Date to Time
       unless attr[:read_only]
         if attr[:setter]
           attr[:setter].call(record, value)
         elsif record.respond_to?("#{attr[:name]}=")
-          ::Rails.logger.debug "\n!!! value: #{value.inspect}\n"
           record.send("#{attr[:name]}=", value)
         elsif association_attr?(attr)
           split = attr[:name].to_s.split(/\.|__/)
@@ -268,11 +238,11 @@ module Netzke::Basepack::DataAdapters
             #     set_value_for_attribute({:name => :assoc_1__assoc_2__method, :nested_attribute => true}, 100)
             # =>
             #     record.assoc_1.assoc_2.method = 100
-            split.inject(record) { |r,m| m == split.last ? (r && r.send("#{m}=", v) && r.save) : r.send(m) }
+            split.inject(record) { |r,m| m == split.last ? (r && r.send("#{m}=", value) && r.save) : r.send(m) }
           else
             if split.size == 2
               # search for association and assign it to r
-              assoc = @model_class.reflect_on_association(split.first.to_sym)
+              assoc = @model.reflect_on_association(split.first.to_sym)
               assoc_method = split.last
               if assoc
                 if assoc.macro == :has_one
@@ -290,7 +260,7 @@ module Netzke::Basepack::DataAdapters
                   record.send("#{assoc.foreign_key}=", value.to_i < 0 ? nil : value)
                 end
               else
-                logger.warn "Netzke: Association #{assoc} is not known for class #{@data_class}"
+                logger.warn "Netzke: Association #{assoc} is not known for class #{@model}"
               end
             else
               logger.warn "Netzke: Wrong attribute name: #{attr[:name]}"
@@ -304,13 +274,13 @@ module Netzke::Basepack::DataAdapters
     # Else returns [attr_name]
     def method_and_assoc(attr_name)
       assoc_name, method = attr_name.to_s.split('__')
-      assoc = @model_class.reflect_on_association(assoc_name.to_sym) if method
+      assoc = @model.reflect_on_association(assoc_name.to_sym) if method
       assoc.nil? ? [attr_name] : [method, assoc]
     end
 
     # An ActiveRecord::Relation instance encapsulating all the necessary conditions.
     def get_relation(params = {})
-      relation = @model_class.all
+      relation = @model.all
 
       query = params[:query]
 
@@ -337,17 +307,20 @@ module Netzke::Basepack::DataAdapters
       if params[:filters]
         and_query = params[:filters]
         and_query.each do |q|
-          if prok = q.delete(:proc)
-            relation = prok.call(relation, q[:value], q[:operator])
-            and_query.delete(q)
-          end
+          relation = q[:proc].call(relation, q[:value], q[:operator]) if q[:proc]
         end
 
+        and_query.delete_if{|q| q[:proc] }
+
         # apply other, non-Proc filters
         relation = relation.where(predicates_for_and_conditions(and_query))
       end
 
-      relation = relation.extend_with(params[:scope]) if params[:scope]
+      if params[:scope].is_a?(Proc)
+        relation = params[:scope].call(relation)
+      else
+        raise ArgumentError, "Expected scope to be a Proc, got #{params[:scope].class}" unless params[:scope].nil?
+      end
 
       @relation = relation
     end
@@ -361,7 +334,7 @@ module Netzke::Basepack::DataAdapters
         attr = q[:attr]
         method, assoc = method_and_assoc(attr)
 
-        arel_table = assoc ? Arel::Table.new(assoc.klass.table_name.to_sym) : @model_class.arel_table
+        arel_table = assoc ? Arel::Table.new(assoc.klass.table_name.to_sym) : @model.arel_table
 
         value = q["value"]
         op = q["operator"]
@@ -420,7 +393,55 @@ module Netzke::Basepack::DataAdapters
       end
     end
 
-  private
+    protected
+
+    # Addresses the n+1 query problem
+    # Returns updated relation
+    def fix_nplus1_problem(relation, columns)
+      columns.reduce(relation) do |rel, c|
+        assoc, method = c[:name].split('__')
+        method ? rel.includes(assoc.to_sym).references(assoc.to_sym) : rel
+      end
+    end
+
+    def apply_sorting(relation, columns, sorters)
+      return relation if sorters.blank?
+
+      sorters = Array.new(sorters)
+
+      relation = relation.reorder("") # reset eventual default_scope ordering
+
+      sorters.reduce(relation) do |rel, sorter|
+        sorter["direction"] ||= 'ASC'
+        dir = sorter["direction"].downcase
+        column = columns.detect { |c| c[:name] == sorter["property"] }
+        column ||= {name: sorter["property"]} # stub column, as we may want to sort by a column that's not in the grid
+        apply_column_sorting(rel, column, dir)
+      end
+    end
+
+    def apply_column_sorting(relation, column, dir)
+      assoc, method = column[:name].split('__')
+
+      # if a sorting scope is set, call the scope with the given direction
+      if column[:sorting_scope].is_a?(Proc)
+        column[:sorting_scope].call(relation, dir.to_sym)
+      else
+        if method.nil?
+          relation.order("#{@model.table_name}.#{assoc} #{dir}")
+        else
+          assoc = @model.reflect_on_association(assoc.to_sym)
+          relation.includes(assoc.name).references(assoc.klass.table_name.to_sym).order("#{assoc.klass.table_name}.#{method} #{dir}")
+        end
+      end
+    end
+
+    def apply_offset(relation, params)
+      return relation if params[:limit].blank?
+      relation.offset(params[:start]).limit(params[:limit])
+    end
+
+    private
 
     def logger
       Netzke::Base.logger