netzke-basepack 0.7.7 → 0.8.0

data/lib/netzke/basepack/active_record.rb

@@ -0,0 +1,12 @@
+require 'netzke/basepack/active_record/relation_extensions'
+
+module Netzke
+  module Basepack
+    module ActiveRecord
+    end
+  end
+end
+
+::ActiveRecord::Relation.class_eval do
+  include ::Netzke::Basepack::ActiveRecord::RelationExtensions
+end

data/lib/netzke/basepack/active_record/relation_extensions.rb

@@ -0,0 +1,27 @@
+module Netzke
+  module Basepack
+    module ActiveRecord
+      module RelationExtensions
+        def extend_with(*params)
+          scope = params.shift
+          case scope.class.name
+          when "Symbol" # model's scope
+            self.send(scope, *params)
+          when "String" # SQL query or SQL query with params (e.g. ["created_at < ?", 1.day.ago])
+            params.empty? ? self.where(scope) : self.where([scope, *params])
+          when "Array"
+            self.extend_with(*scope)
+          when "Hash"  # conditions hash
+            self.where(scope)
+          when "ActiveSupport::HashWithIndifferentAccess" # conditions hash
+            self.where(scope)
+          when "Proc"   # receives a relation, must return a relation
+            scope.call(self)
+          else
+            raise ArgumentError, "Wrong parameter type for ActiveRecord::Relation#extend_with"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/netzke/basepack/columns.rb

@@ -0,0 +1,309 @@
+module Netzke
+  module Basepack
+    module Columns
+      extend ActiveSupport::Concern
+
+      COLUMN_METHOD_NAME = "%s_column"
+
+      module ClassMethods
+        # Overrides a column config, e.g.:
+        #
+        #     column :title do |c|
+        #       c.flex = 1
+        #     end
+        def column(name, &block)
+          method_name = COLUMN_METHOD_NAME % name
+          define_method(method_name, &block)
+        end
+      end
+
+      # Returns the list of (non-normalized) columns to be used. By default returns the list of model column names.
+      # Can be overridden.
+      def columns
+        config.columns || data_adapter.model_attributes
+      end
+
+      # An array of complete columns configs ready to be passed to the JS side.
+      # The +options+ hash can have the following keys:
+      #   * :with_excluded - when true, include the columns that are marked as excluded
+      #   * :with_meta - when true, include the meta column
+      def final_columns(options = {})
+        @_final_columns ||= {}
+        @_final_columns[options] ||= [].tap do |cols|
+          initial_columns(true).each do |c|
+            name = c.name
+
+            # merge with column declaration
+            send(:"#{name}_column", c) if respond_to?(:"#{name}_column")
+
+            # set the defaults as lowest priority
+            augment_column_config(c)
+
+            cols << c if options[:with_excluded] || !c.excluded
+          end
+
+          append_meta_column(cols) if options[:with_meta]
+        end
+      end
+
+      # Columns as a hash, for easier access to a specific column
+      def final_columns_hash
+        @_final_columns_hash ||= final_columns.inject({}){|r,c| r.merge(c[:name].to_sym => c)}
+      end
+
+      # Columns from config.columns or the `columns` method, after normalization
+      def initial_columns(with_excluded = false)
+        @_initial_columns ||= {}
+        @_initial_columns[with_excluded] ||= [].tap do |cols|
+          has_primary_column = false
+
+          columns.each do |c|
+            # normalize:
+            # * :title => {name: 'title'}
+            # * {name: :some_column} => {name: 'some_column'}
+            c = ActiveSupport::OrderedOptions.new.replace(c.is_a?(Symbol) ? {name: c.to_s} : c.merge(name: c[:name].to_s))
+
+            cols << c if with_excluded || !c.excluded
+
+            # detect primary key column
+            has_primary_column ||= c.name == data_adapter.primary_key_name
+          end
+
+          # automatically add a column that reflects the primary key
+          cols.insert(0, ActiveSupport::OrderedOptions.new.replace(:name => data_adapter.primary_key_name)) unless has_primary_column
+        end
+      end
+
+      def append_meta_column(cols)
+        cols << {}.tap do |c|
+          c.merge!(
+            :name => "meta",
+            :meta => true,
+            :getter => lambda do |r|
+              meta_data(r)
+            end
+          )
+          c[:default_value] = meta_default_data if meta_default_data.present?
+        end
+      end
+
+      # default_value for the meta column; used when a new record is being created in the grid
+      def meta_default_data
+        default_association_values(final_columns_hash).present? ? { :association_values => default_association_values(final_columns_hash).literalize_keys } : {}
+      end
+
+      # Override it when you need extra meta data to be passed through the meta column
+      def meta_data(r)
+        { :association_values => data_adapter.assoc_values(r, final_columns_hash).literalize_keys }
+      end
+
+    private
+
+      # Based on initial column config, e.g.:
+      #
+      #   {:name=>"author__name", :attr_type=>:string}
+      #
+      # augment it with additional configuration params, e.g.:
+      #
+      #   {:name=>"author__name", :attr_type=>:string, :editor=>{:xtype=>:netzkeremotecombo}, :assoc=>true, :virtual=>true, :header=>"Author  name", :editable=>true, :sortable=>false, :filterable=>false}
+      #
+      # It may be handy to override it.
+      def augment_column_config(c)
+        set_default_attr_type(c)
+        set_default_xtype(c)
+        set_default_virtual(c)
+        set_default_text(c)
+        set_default_editable(c)
+        set_default_editor(c)
+        set_default_width(c)
+        set_default_hidden(c)
+        set_default_sortable(c)
+        set_default_filterable(c)
+        c[:assoc] = association_attr?(c) # needed on the JS side
+      end
+
+      def set_default_attr_type(c)
+        c[:attr_type] ||= association_attr?(c) ? :integer : data_adapter.attr_type(c.name)
+      end
+
+      def set_default_xtype(c)
+        return if c[:renderer] || c[:editor] # if user set those manually, we don't mess with column xtype
+        c[:xtype] ||= attr_type_to_xtype_map[c[:attr_type]]
+      end
+
+      def set_default_text(c)
+        c[:text] ||= c[:label] || data_adapter.human_attribute_name(c[:name])
+      end
+
+      def set_default_editor(c)
+        # if shouldn't be editable, don't set any default editor; also, specifying xtype takes care of the editor
+        return if c[:read_only] || c[:editable] == false
+
+        if association_attr?(c)
+          set_default_association_editor(c)
+        else
+          c[:editor] ||= editor_for_attr_type(c[:attr_type])
+        end
+
+      end
+
+      def set_default_width(c)
+        c[:width] ||= 50 if c[:attr_type] == :boolean
+        c[:width] ||= 150 if c[:attr_type] == :datetime
+      end
+
+      def set_default_hidden(c)
+        c[:hidden] = true if data_adapter.primary_key_attr?(c) && c[:hidden].nil?
+      end
+
+      def set_default_editable(c)
+        if c[:editable].nil?
+          c[:editable] = is_editable_column?(c)
+        end
+      end
+
+      def set_default_sortable(c)
+        # this *has* to be set to false if we don't want the column to be sortable (it's sortable by default in Ext)
+        c[:sortable] = !(c[:virtual] && !c[:sorting_scope]) if c[:sortable].nil?
+      end
+
+      def set_default_filterable(c)
+        c[:filterable] = !c[:virtual] if c[:filterable].nil?
+      end
+
+
+      # Detects an association column and sets up the proper editor.
+      def set_default_association_editor(c)
+        assoc, assoc_method =  c[:name].split('__')
+        return unless assoc
+
+        assoc_method_type = data_adapter.get_assoc_property_type assoc, assoc_method
+
+        # if association column is boolean, display a checkbox (or alike), otherwise - a combobox (or alike)
+        if c[:nested_attribute]
+          c[:editor] ||= editor_for_attr_type(assoc_method_type)
+        else
+          c[:editor] ||= assoc_method_type == :boolean ? editor_for_attr_type(:boolean) : editor_for_association
+        end
+      end
+
+      # If the column should be editable
+      def is_editable_column?(c)
+        not_editable_if = data_adapter.primary_key_attr?(c)
+        not_editable_if ||= c[:virtual] && !association_attr?(c[:name])
+        not_editable_if ||= c[:read_only]
+
+        editable_if = data_adapter.attribute_names.include?(c[:name])
+        editable_if ||= data_class.instance_methods.map(&:to_s).include?("#{c[:name]}=")
+        editable_if ||= association_attr?(c[:name])
+
+        editable_if && !not_editable_if
+      end
+
+      def initial_columns_order
+        final_columns.map do |c|
+          # copy the values that are not null
+          {name: c[:name]}.tap do |r|
+            r[:width] = c[:width] if c[:width]
+            r[:hidden] = c[:hidden] if c[:hidden]
+          end
+        end
+      end
+
+      def columns_order
+        if config[:persistence]
+          state[:columns_order] = initial_columns_order if columns_have_changed?
+          state[:columns_order] || initial_columns_order
+        else
+          initial_columns_order
+        end
+      end
+
+      def columns_have_changed?
+        init_column_names = initial_columns_order.map{ |c| c[:name].to_s }.sort
+        stored_column_names = (state[:columns_order] || initial_columns_order).map{ |c| c[:name].to_s }.sort
+        init_column_names != stored_column_names
+      end
+
+      # Column editor config for attribute type.
+      def editor_for_attr_type(type)
+        {:xtype => attr_type_to_editor_xtype_map[type] || :textfield}
+      end
+
+      # Column editor config for one-to-many association
+      def editor_for_association
+        {:xtype => :netzkeremotecombo}
+      end
+
+      # Hash that maps a column type to the editor xtype. Override if you want different editors.
+      def attr_type_to_editor_xtype_map
+        {
+          :integer => :numberfield,
+          :boolean => :checkbox,
+          :date => :datefield,
+          :datetime => :xdatetime,
+          :text => :textarea,
+          :string => :textfield
+        }
+      end
+
+      def attr_type_to_xtype_map
+        {
+          # :integer  => :numbercolumn, # don't like the default formatter
+          :boolean  => :checkcolumn,
+          :date     => :datecolumn,
+          #:datetime => :datecolumn # TODO: replace with datetimepicker
+        }
+      end
+
+      # Default fields that will be displayed in the Add/Edit/Search forms
+      # When overriding this method, keep in mind that the fields inside the layout must be expanded (each field represented by a hash, not just a symbol)
+      def default_fields_for_forms
+        selected_columns = final_columns.select do |c|
+          data_adapter.attribute_names.include?(c[:name]) ||
+          data_class.instance_methods.include?("#{c[:name]}=") ||
+          association_attr?(c[:name])
+        end
+
+        selected_columns.map do |c|
+          field_config = {
+            :name => c[:name],
+            :field_label => c[:text] || c[:header]
+          }
+
+          # scopes for combobox options
+          field_config[:scopes] = c[:editor][:scopes] if c[:editor].is_a?(Hash)
+
+          field_config.merge!(c[:editor] || {})
+
+          field_config
+        end
+      end
+
+      def columns_default_values
+        final_columns.inject({}) do |r,c|
+          assoc_name, assoc_method = c[:name].split '__'
+          if c[:default_value].nil?
+            r
+          else
+            if assoc_method
+              r.merge(data_adapter.foreign_key_for(assoc_name) || data_adapter.foreign_key_for(assoc_name) => c[:default_value])
+            else
+              r.merge(c[:name] => c[:default_value])
+            end
+          end
+        end
+      end
+
+      # Recursively traversess items (an array) and yields each found field (a hash with :name set)
+      def each_attr_in(items)
+        items.each do |item|
+          if item.is_a?(Hash)
+            each_attr_in(item[:items]) if item[:items].is_a?(Array)
+            yield(item) if item[:name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/netzke/basepack/data_accessor.rb

@@ -1,18 +1,14 @@
 module Netzke
   module Basepack
-    # This module is included into such data-driven components as GridPanel, FormPanel, PagingFormPanel, etc.
+    # 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"}]
+      #     [:col1, "col2", {:name => :col3}] #=> [{:name => "col1"}, {:name => "col2"}, {:name => "col3"}]
       def normalize_attrs(attrs)
         attrs.map{ |a| normalize_attr(a) }
       end
@@ -35,19 +31,33 @@ module Netzke
 
       # Data adapter responsible for all DB-related operations
       def data_adapter
-        @data_adapter ||= Netzke::Basepack::DataAdapters::AbstractAdapter.adapter_class(data_class).new(data_class)
+        @data_adapter ||= data_class && Netzke::Basepack::DataAdapters::AbstractAdapter.adapter_class(data_class).new(data_class)
       end
 
-      # whether a column is bound to the primary_key
-      def primary_key_attr?(a)
-        data_class && a[:name].to_s == data_class.primary_key.to_s
-      end
+      # whether a column/field is bound to the primary_key
+      # def primary_key_attr?(a)
+      #   data_class && a[:name].to_s == data_class.primary_key.to_s
+      # 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.column_virtual?(c) if c[:virtual].nil?
+        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
+      end
     end
   end
 end

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

@@ -2,6 +2,23 @@ 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
 
+    # Returns primary key name of the model
+    def primary_key_name
+      "id"
+    end
+
+    # Returns a list of model attribute hashes, each containing `name`, `attr_type` and `default_value` (if set in the schema).
+    # 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
+      raise NotImplementedError
+    end
+
+    # Returns attribute type (as Symbol) given its name.
+    def attr_type(attr_name)
+      raise NotImplementedError
+    end
+
     # Returns records based on passed params. Implements:
     # * pagination
     # * filtering
@@ -14,7 +31,7 @@ module Netzke::Basepack::DataAdapters
     #   * :direction - "asc" or "desc"
     # * :limit - rows per page in pagination
     # * :start - page number in pagination
-    # * :scope - the scope as described in Netzke::Basepack::GridPanel
+    # * :scope - the scope as described in Netzke::Basepack::Grid
     # * :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
@@ -33,7 +50,7 @@ module Netzke::Basepack::DataAdapters
     #
     # `params` is a hash that contains the following keys:
     #
-    # * :scope - the scope as described in Netzke::Basepack::GridPanel
+    # * :scope - the scope as described in Netzke::Basepack::Grid
     # * :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
@@ -74,14 +91,18 @@ module Netzke::Basepack::DataAdapters
     def get_property_type column
       column.type
     end
- 
+
     # should return true if column is virtual
-    def column_virtual? c
+    def virtual_attribute? c
       raise NotImplementedError
     end
 
     # Returns options for comboboxes in grids/forms
-    def combobox_options_for_column(column, method_options = {})
+    # +attr+ - column/field configuration; note that it will in its turn provide:
+    # * +name+ - attribute name
+    # * +scope+ - searching scope (optional)
+    # +query+ - whatever is entered in the combobox
+    def combo_data(attr, query = "")
       raise NotImplementedError
     end
 
@@ -99,6 +120,16 @@ module Netzke::Basepack::DataAdapters
     def destroy(ids)
     end
 
+    # Finds a record by id, return nil if not found
+    def find_record(id)
+      @model_class.find(id)
+    end
+
+    # Build a hash of foreign keys and the associated model
+    def hash_fk_model
+      raise NotImplementedError
+    end
+
     # Changes records position (e.g. when acts_as_list is used in ActiveRecord).
     #
     # `params` is a hash with the following keys:
@@ -125,22 +156,55 @@ module Netzke::Basepack::DataAdapters
       record.errors.to_a
     end
 
-    # Finds a record by id, return nil if not found
-    def find_record(id)
-      @model_class.find(id)
+    # Whether an attribute is mass assignable. As second argument optionally takes the role.
+    def attribute_mass_assignable?(attr_name, role = :default)
+      true
     end
 
-    # Build a hash of foreign keys and the associated model
-    def hash_fk_model
-      raise NotImplementedError
+    # Whether an attribute (by name) is an association one
+    def association_attr?(attr_name)
+      !!attr_name.to_s.index("__")
+    end
+
+    # Transforms a record to an array of values according to the passed attributes
+    # +attrs+ - array of attribute config hashes
+    def record_to_array(r, attrs)
+      []
     end
 
+    # Transforms a record to a hash of values according to the passed attributes
+    # +attrs+ - array of attribute config hashes
+    def record_to_hash(r, attrs)
+      {}
+    end
 
+    # Returns a hash of association values for given record, e.g.:
+    #
+    #     {author__first_name: "Michael"}
+    def assoc_values(r, attr_hash) #:nodoc:
+      {}.tap do |values|
+        attr_hash.each_pair do |name,c|
+          values[name] = record_value_for_attribute(r, c, true) if association_attr?(c)
+        end
+      end
+    end
+
+    # Fetches the value specified by an (association) attribute
+    # If +through_association+ is true, get the value of the association by provided method, *not* the associated record's id
+    # E.g., author__name with through_association set to true may return "Vladimir Nabokov", while with through_association set to false, it'll return author_id for the current record
+    def record_value_for_attribute(r, a, through_association = false)
+    end
+
+    # Assigns new value to an (association) attribute in a given record
+    # +role+ - role provided for mass assignment protection
+    def set_record_value_for_attribute(record, attr, value, role = :default)
+    end
 
     # -- End of overridable methods
 
     # Abstract-adapter specifics
     #
+    #
 
     # Used to determine if the given adapter should be used for the passed in class.
     def self.for_class?(member_class)