netzke-basepack 0.12.9 → 1.0.0.0.pre

data/lib/netzke/basepack/active_record.rb

@@ -1,12 +1,6 @@
-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/attr_config.rb

@@ -1,41 +1,50 @@
 module Netzke
   module Basepack
-    # Common parts of FieldConfig and ColumnConfig
+    # Base for FieldConfig and ColumnConfig
     class AttrConfig < ActiveSupport::OrderedOptions
-      def initialize(c, data_adapter)
+      def initialize(c, model_adapter)
         c = {name: c.to_s} if c.is_a?(Symbol) || c.is_a?(String)
         c[:name] = c[:name].to_s
         self.replace(c)
 
-        @data_adapter = data_adapter || NullDataAdapter.new(nil)
+        @model_adapter = model_adapter
       end
 
       def primary?
-        @data_adapter.primary_key_attr?(self)
+        @model_adapter.primary_key_attr?(self)
       end
 
       def association?
-        @data_adapter.association_attr?(self)
+        @model_adapter.association_attr?(self)
       end
 
-      def set_defaults!
-        set_read_only! if read_only.nil?
+      def set_defaults
+        set_read_only if read_only.nil?
       end
 
-      def set_read_only!
+      def set_read_only
         self.read_only = primary? ||
           !responded_to_by_model? &&
           !association?
+        self.delete(:read_only) if read_only == false
       end
 
     private
 
+      def default_label
+        if association?
+          @model_adapter.human_attribute_name(name.split("__").first)
+        else
+          @model_adapter.human_attribute_name(name)
+        end
+      end
+
       def responded_to_by_model?
         # if no model class is provided, assume the attribute is being responded to
-        @data_adapter.model_class.nil? ||
+        @model_adapter.model.nil? ||
           !setter.nil? ||
-          @data_adapter.model_class.instance_methods.include?(:"#{name}=") ||
-          @data_adapter.model_class.attribute_names.include?(name)
+          @model_adapter.model.instance_methods.include?(:"#{name}=") ||
+          @model_adapter.model.attribute_names.include?(name)
       end
     end
   end

data/lib/netzke/basepack/attribute_config.rb

@@ -0,0 +1,10 @@
+module Netzke
+  module Basepack
+    # TODO get rid
+    class AttributeConfig < ActiveSupport::OrderedOptions
+      def initialize(name)
+        self.name = name.to_s
+      end
+    end
+  end
+end

data/lib/netzke/basepack/attributes.rb

@@ -0,0 +1,196 @@
+module Netzke
+  module Basepack
+    # This module is encluded in +Grid+, +Form+, and +Tree+. It allows configuring specific model attributes.
+    #
+    # To override default configuration for a model attribute (e.g. to change its label or read-only property) use the
+    # +attribute_overrides+ configuration option for the component, or the +attribute+ DSL method. This will have effect
+    # on both columns and form fields.
+    #
+    # For example, to make the address attribute read-only:
+    #
+    #      class Users < Netzke::Grid::Base
+    #        def configure(c)
+    #          super
+    #          c.model = User
+    #        end
+    #
+    #        attribute :address do |c|
+    #          c.read_only = true
+    #        end
+    #      end
+    #
+    # Using the +attribute_overrides+ config option may be handy when building composite components. E.g. in a tab panel
+    # nesting multiple grids, you may want to override specific attributes for a specific grid:
+    #
+    #      class ManagmentPanel < Netzke::Base
+    #        client_class do |c|
+    #          c.extend = "Ext.tab.Panel"
+    #        end
+    #
+    #        def configure(c)
+    #          super
+    #          c.items = [:users, :roles]
+    #        end
+    #
+    #        component :users do |c|
+    #          c.attribute_overrides = {
+    #            birth_date: {
+    #              excluded: true # exclude this column from the grid and forms
+    #            }
+    #          }
+    #        end
+    #
+    #        component :roles
+    #      end
+    #
+    # The following attribute config options are available:
+    #
+    # [read_only]
+    #
+    #   A boolean that defines whether the attribute should be editable via grid/form.
+    #
+    # [getter]
+    #
+    #   A lambda that receives a record as a parameter, and is expected to return the value used in the grid cell or
+    #   form field, e.g.:
+    #
+    #     getter: lambda {|r| [r.first_name, r.last_name].join }
+    #
+    #   In case of relation used in relation, passes the last record to lambda, e.g.:
+    #
+    #     name: author__books__first__name, getter: lambda {|r| r.title }
+    #     r #=> author.books.first
+    #
+    # [setter]
+    #
+    #   A lambda that receives a record as first parameter, and the value passed from the cell/field as the second parameter,
+    #   and is expected to modify the record accordingly, e.g.:
+    #
+    #     setter: lambda {|r,v| r.first_name, r.last_name = v.split(" ") }
+    #
+    # [scope]
+    #
+    #   The scope for association attribute. Same syntax applies as for scoping out records for the grid.
+    #
+    # [filter_association_with]
+    #
+    #   A Proc object that receives the relation and the value to filter by. Example:
+    #
+    #     column :author__name do |c|
+    #       c.filter_association_with = lambda {|rel, value| rel.where("first_name like ? or last_name like ?", "%#{value}%", "%#{value}%" ) }
+    #     end
+    #
+    # [format]
+    #
+    #   The format to display data in case of date and datetime attributes, e.g. 'Y-m-d g:i:s'.
+    #
+    # [excluded]
+    #
+    #   When true, this attribute will not be used
+    #
+    # [meta]
+    #
+    #   When set to +true+, the data for this column will be available in the grid store, but the actual column won't be
+    #   created (as if +excluded+ were set to +true+).
+    #
+    # [type]
+    #
+    #   When adding a virtual attribute to the grid, it may be useful to specify its type, so the column editor (and the
+    #   form field) are configured properly.
+    #
+    # [column_config]
+    #
+    #   Configuration specific for the corresponding grid column. For example:
+    #
+    #        attribute :address do |c|
+    #          c.column_config = { width: 200 }
+    #        end
+    #
+    # [field_config]
+    #
+    #   Configuration for the corresponding form field. For example:
+    #
+    #        attribute :address do |c|
+    #          c.field_config = { xtype: :displayfield }
+    #        end
+    #
+    # [editor_config]
+    #
+    #   Additional configuration for column editor and form field (which are usually represented by the same Ext field
+    #   component). Any common Ext config option like `min_chars` and `format` are accepted. Besides, Netzke extends it
+    #   with some extras:
+    #
+    #   [blank_line]
+    #
+    #     The blank line for one-to-many association columns, defaults to "---". Set to false to exclude completely.
+    #
+    #   [date_format]
+    #
+    #     In case of datetime type, the format date must be entered in the editor.
+    #
+    #   [time_format]
+    #
+    #     In case of datetime type, the format time must be entered in the editor.
+    module Attributes
+      extend ActiveSupport::Concern
+
+      ATTRIBUTE_METHOD_NAME = "%s_attribute"
+
+      included do
+        class_attribute :declared_attribute_names
+        self.declared_attribute_names = []
+      end
+
+      module ClassMethods
+        # Adds/overrides an attribute config, e.g.:
+        #
+        #     attribute :price do |c|
+        #       c.read_only = true
+        #     end
+        def attribute(name, &block)
+          method_name = ATTRIBUTE_METHOD_NAME % name
+          define_method(method_name, &block)
+
+          # we *must* use a writer here
+          self.declared_attribute_names = declared_attribute_names + [name]
+        end
+      end
+
+      def attribute_overrides
+        return @attribute_overrides if @attribute_overrides
+
+        declared = self.class.declared_attribute_names.reduce({}) do |res, name|
+          c = AttributeConfig.new(name)
+          augment_attribute_config(c)
+          res.merge!(name => c)
+        end
+
+        @attribute_overrides = (config.attribute_overrides || {}).deep_merge(declared)
+      end
+
+      def augment_attribute_config(c)
+        send(ATTRIBUTE_METHOD_NAME % c.name, c)
+      end
+
+      def association_attr?(attr)
+        !!attr[:name].to_s.index("__")
+      end
+
+      # Returns a hash of association attribute default values. Used when creating new records with association attributes that have a default value.
+      def association_value_defaults(cols)
+        @_default_association_values ||= {}.tap do |values|
+          cols.each do |c|
+            next unless association_attr?(c) && c[:default_value]
+
+            assoc_name, assoc_method = c[:name].split '__'
+            assoc_class = model_adapter.class_for(assoc_name)
+            assoc_data_adapter = Netzke::Basepack::DataAdapters::AbstractAdapter.adapter_class(assoc_class).new(assoc_class)
+            ::Rails.logger.debug "\n!!! assoc_data_adapter.class: #{assoc_data_adapter.class.inspect}\n"
+            assoc_instance = assoc_data_adapter.find_record c[:default_value]
+            values[c[:name]] = assoc_instance.send(assoc_method)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/netzke/basepack/column_config.rb

@@ -1,6 +1,6 @@
 module Netzke
   module Basepack
-    # Takes care of automatic column configuration in {Basepack::Grid}
+    # Takes care of automatic column configuration in {Grid::Base}
     class ColumnConfig < AttrConfig
       # These config options can be ommitted from config, as they are assumed by default at the JS side
       COMMON_DEFAULTS = {
@@ -12,20 +12,30 @@ module Netzke
         assoc: false
       }
 
-      def set_defaults!
+      def merge_attribute(attr)
+        self.merge!(attr)
+
+        self.text = delete(:label) if self.has_key?(:label)
+
+        self.merge!(delete(:column_config)) if self.has_key?(:column_config)
+
+        self.delete(:field_config) if self.has_key?(:field_config)
+      end
+
+      def set_defaults
         super
 
-        self.attr_type ||= @data_adapter.attr_type(name)
+        self.type ||= @model_adapter.attr_type(name)
 
-        set_xtype! if xtype.nil?
+        set_xtype if xtype.nil?
 
-        self.virtual = @data_adapter.virtual_attribute?(self)
+        self.virtual = @model_adapter.virtual_attribute?(self)
 
-        self.text ||= label || @data_adapter.human_attribute_name(name)
+        self.text ||= label || default_label
 
-        set_editor!
+        set_editor
 
-        set_width! if width.nil?
+        set_width if width.nil?
 
         self.hidden = primary? if hidden.nil?
 
@@ -35,81 +45,79 @@ module Netzke
 
         self.assoc = association? # used at the JS side
 
-        remove_defaults! # options that are implied by Ext JS by default, thus don't have to be passed
+        remove_defaults # options that are implied by Ext JS by default, thus don't have to be passed
       end
 
-      def set_xtype!
+      def set_xtype
         # if user set those manually, we don't mess with column xtype
         return if renderer || editor
-        xtype = xtype_for_attr_type(attr_type)
+        xtype = xtype_for_type(type)
         self.xtype = xtype unless xtype.nil?
       end
 
-      def xtype_for_attr_type(type)
+      def xtype_for_type(type)
         { :boolean  => :checkcolumn,
           :date     => :datecolumn
         }[type]
       end
 
-      def set_editor!
+      def set_editor
         # if shouldn't be editable, don't set any default editor
         return if read_only
 
         passed_editor = editor
 
         if association?
-          set_default_association_editor!
+          set_default_association_editor
         else
-          self.editor = editor_for_attr_type(attr_type)
+          self.editor = editor_for_type(type)
         end
 
         self.editor.merge!(passed_editor) if passed_editor
       end
 
       # Detects an association column and sets up the proper editor.
-      def set_default_association_editor!
+      def set_default_association_editor
         assoc, assoc_method = name.split('__')
 
-        assoc_method_type = @data_adapter.get_assoc_property_type assoc, assoc_method
+        assoc_method_type = @model_adapter.get_assoc_property_type assoc, assoc_method
 
         # if association column is boolean, display a checkbox (or alike), otherwise - a combobox (or alike)
         if nested_attribute
-          self.editor = editor_for_attr_type(assoc_method_type)
+          self.editor = editor_for_type(assoc_method_type)
         else
-          self.editor = assoc_method_type == :boolean ? editor_for_attr_type(:boolean) : {xtype: :netzkeremotecombo}
+          self.editor = assoc_method_type == :boolean ? editor_for_type(:boolean) : {xtype: :netzkeremotecombo}
         end
       end
 
       # Column editor config for attribute type.
-      def editor_for_attr_type(type)
-        {xtype: attr_type_to_editor_xtype_map(type)}
+      def editor_for_type(type)
+        {xtype: type_to_editor_xtype(type)}
+      end
+
+      def type_to_editor_xtype(type)
+        type_to_editor_xtype_map[type] || :textfield
       end
 
       # Hash that maps a column type to the editor xtype. Override if you want different editors.
-      def attr_type_to_editor_xtype_map(type)
-        { :integer => :numberfield,
-          :boolean => :checkbox,
-          :date => :datefield,
-          :datetime => :xdatetime,
-          :text => :textarea,
-          :string => :textfield
-        }[type] || :textfield
+      def type_to_editor_xtype_map
+        {
+          integer: :numberfield,
+          boolean: :checkbox,
+          date: :datefield,
+          datetime: :xdatetime,
+          text: :textarea,
+          string: :textfield
+        }
       end
 
-      def set_width!
-        self.width = case attr_type
-        when :boolean
-          50
-        when :datetime
-          150
-        else
-          120
-        end
+      def set_width
+        self.width = 150 if type == :datetime
       end
 
       ##
       # @return self
-      def remove_defaults!
+      def remove_defaults
         COMMON_DEFAULTS.each_pair {|k,v| self.delete(k) if v == self[k]}
         self
       end

data/lib/netzke/basepack/columns.rb

@@ -1,7 +1,48 @@
 module Netzke
   module Basepack
     # Takes care of grid column configuration, as well as the grid's default form fields
-    # TODO: refactor using Netzke::Core::DslSupport
+    # +Grid::Base+ extends common Ext JS column options with the following ones:
+    #
+    # [sorting_scope]
+    #
+    #   A Proc object used for sorting by the column. This can be useful for sorting by a virtual column. The Proc
+    #   object will get the relation as the first parameter, and the sorting direction as the second. Example:
+    #
+    #     columns => [{ name: "complete_user_name", sorting_scope: lambda {|rel, dir| order("users.first_name #{dir.to_s}, users.last_name #{dir.to_s}") }, ...]
+    #
+    # [filter_with]
+    #
+    #   A Proc object that receives the relation, the value to filter by and the operator. This allows for more flexible
+    #   handling of basic filters and enables filtering of virtual columns. Example:
+    #
+    #     columns => [{ name: "complete_user_name", filter_with: lambda{|rel, value, op| rel.where("first_name like ? or last_name like ?", "%#{value}%", "%#{value}%" ) } }, ...]
+    #
+    # [filterable]
+    #
+    #   Set to false to disable filtering on this column
+    #
+    # [editor]
+    #
+    #   A hash that will override the automatic editor configuration. For example, for one-to-many association column
+    #   you may set it to +{min_chars: 1}+, which will be passed to the combobox and make it query its remote data after
+    #   entering 1 character (instead of default 4).
+    #
+    # === Configuring default filters on grid columns
+    #
+    # Default Filters can either be configured on the grid itself
+    #
+    #     def configure(c)
+    #       super
+    #       c.default_filters = [{name: "Mark"}, {age: {gt: 10}}]
+    #     end
+    #
+    # or as a component configuration
+    #
+    #      component :tasks |c|
+    #        c.klass = TaskGrid
+    #        c.default_filters = [{due_date: {before: Time.now}}]
+    #      end
+    #
     module Columns
       extend ActiveSupport::Concern
 
@@ -13,11 +54,6 @@ module Netzke
       end
 
       module ClassMethods
-        def inherited(klass)
-          klass.class_attribute :declared_columns
-          klass.declared_columns = []
-        end
-
         # Adds/overrides a column config, e.g.:
         #
         #     column :title do |c|
@@ -28,53 +64,47 @@ module Netzke
         def column(name, &block)
           method_name = COLUMN_METHOD_NAME % name
           define_method(method_name, &block)
-          self.declared_columns << name
+          self.declared_columns = [*declared_columns, name]
         end
       end
 
       # Returns the list of (non-normalized) columns to be used. By default returns the list of model column names and declared columns.
       # Can be overridden.
       def columns
-        config.columns || default_columns
-      end
-
-      # Columns from model + columns declared with DSL
-      def default_columns
-        (data_adapter.model_attributes + self.class.declared_columns).uniq
+        config.columns || model_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 = {})
-        # memoize
-        @_final_columns ||= {}
-        @_final_columns[options] ||= [].tap do |cols|
+      def final_columns
+        @final_columns ||= [].tap do |cols|
           has_primary_column = false
 
           columns.each do |c|
-            c = Netzke::Basepack::ColumnConfig.new(c, data_adapter)
-
-            # merge with column declaration
-            send(:"#{c.name}_column", c) if respond_to?(:"#{c.name}_column")
+            c = build_column_config(c)
+            next if c.excluded
 
-            # detect primary key column
             has_primary_column ||= c.primary?
-
-            if (!c.excluded || options[:with_excluded]) && (!c.meta || options[:with_meta])
-              # set the defaults as lowest priority
-              augment_column_config(c)
-
-              cols << c # if options[:with_excluded] || !c.excluded
-            end
+            cols << c
           end
 
-          insert_primary_column(cols) if !has_primary_column
-          append_meta_column(cols) if options[:with_meta]
+          insert_primary_column(cols) unless has_primary_column
+          append_association_values_column(cols)
+        end
+      end
+
+      def build_column_config(c)
+        Netzke::Basepack::ColumnConfig.new(c, model_adapter).tap do |c|
+          attribute_config = attribute_overrides[c.name.to_sym]
+          c.merge_attribute(attribute_config) if attribute_config
+          augment_column_config(c)
         end
       end
 
+      # Array of complete config hashes for non-meta columns
+      def non_meta_columns
+        @non_meta_columns ||= final_columns.reject{|c| c[:meta]}
+      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)}
@@ -82,89 +112,107 @@ module Netzke
 
       # Columns that have to be used by the JS side of the grid
       def js_columns
-        final_columns(with_meta: true).map do |c|
+        final_columns.map do |c|
           # we are removing the editor on this last step, so that the editor config is still being passed from the
           # column config to the form editor; refactor!
-          c.delete(:editor) if !config.enable_edit_inline
+          c.delete(:editor) unless config.edit_inline
           c
         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?
+      def append_association_values_column(cols)
+        cols << Netzke::Basepack::AttrConfig.new("association_values", model_adapter).tap do |c|
+          c.meta = true
+          c.getter = lambda do |r|
+            model_adapter.assoc_values(r, final_columns_hash).netzke_literalize_keys
+          end
+          defaults = association_value_defaults(cols).netzke_literalize_keys
+          c.default_value = defaults if defaults.present?
         end
       end
 
       def insert_primary_column(cols)
-        primary_key = data_adapter.primary_key
-        raise "Model #{data_adapter.model_class.name} does not have a primary column" if primary_key.blank?
-        c = Netzke::Basepack::ColumnConfig.new(data_adapter.primary_key, data_adapter)
-        send(:"#{c.name}_column", c) if respond_to?(:"#{c.name}_column")
+        primary_key = model_adapter.primary_key
+        raise "Model #{model_adapter.model.name} does not have a primary column" if primary_key.blank?
+        c = Netzke::Basepack::ColumnConfig.new(model_adapter.primary_key, model_adapter)
+        c.merge_attribute(attribute_overrides[c.name.to_sym]) if attribute_overrides.has_key?(c.name.to_sym)
         augment_column_config(c)
         cols.insert(0, c)
       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).netzke_literalize_keys } : {}
+      # Default form items (non-normalized) that will be displayed in the Add/Edit forms
+      def default_form_items
+        non_meta_columns.map{|c| c.name.to_sym}
       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).netzke_literalize_keys }
+      # ATM the same attributes are used as in forms
+      def attributes_for_search
+        non_meta_columns.map do |c|
+          {name: c.name, text: c.text, type: c.type}.tap do |a|
+            if c[:assoc]
+              a[:text].sub!("  ", " ")
+            end
+          end
+        end
       end
 
-    protected
+      # Form items that will be used by the Add/Edit forms. May be useful overriding it.
+      def form_items
+        config.form_items || default_form_items
+      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
-        columns_taken_over_to_forms.map do |c|
-          (c[:editor] || {}).tap do |f|
-            %w(name read_only setter getter scope format).each do |key|
-              f[key.to_sym] = c[key.to_sym]
+      private
+
+      def populate_columns_with_filters(c)
+        c.default_filters.each do |filter|
+          c.columns[:items].each do |column|
+            if column[:name].to_sym == filter[:column].to_sym
+              extend_column_with_filter(column, filter)
             end
-            f[:field_label] = c.text || c.header
           end
         end
+        c.delete(:default_filters)
       end
 
-      # ATM the same attributes are used as in forms
-      def attributes_for_search
-        columns_taken_over_to_forms.map do |c|
-          {name: c.name, text: c.text, attr_type: c.attr_type}.tap do |a|
-            if c[:assoc]
-              a[:text].sub!("  ", " ")
-            end
+      def extend_column_with_filter(column, filter)
+        if filter[:value].is_a?(Hash)
+          val = {}
+          filter[:value].each do |k,v|
+            val[k] = (v.is_a?(Time) || v.is_a?(Date) || v.is_a?(ActiveSupport::TimeWithZone)) ? Netzke::Core::JsonLiteral.new("new Date('#{v.strftime("%m/%d/%Y")}')") : v
           end
+        else
+          val = filter[:value]
+        end
+        new_filter = {value: val, active: true}
+        if column[:filter]
+          column[:filter].merge! new_filter
+        else
+          column[:filter] = new_filter
         end
       end
 
-    private
+      # Extends passed column config with DSL declaration for this column
+      def apply_column_dsl(c)
+        method_name = COLUMN_METHOD_NAME % c.name
+        send(method_name, c) if respond_to?(method_name)
+      end
 
       # Based on initial column config, e.g.:
       #
-      #   {:name=>"author__name", :attr_type=>:string}
+      #   {:name=>"author__name", :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", :sortable=>false, :filterable=>false}
+      #   {:name=>"author__name", :type=>:string, :editor=>{:xtype=>:netzkeremotecombo}, :assoc=>true, :virtual=>true, :header=>"Author", :sortable=>false, :filterable=>false}
       #
       # It may be handy to override it.
       def augment_column_config(c)
-        c.set_defaults!
+        apply_column_dsl(c)
+        c.set_defaults
       end
 
       def initial_columns_order
-        final_columns.map do |c|
+        non_meta_columns.map do |c|
           # copy the values that are not null
           {name: c[:name]}.tap do |r|
             r[:width] = c[:width] if c[:width]
@@ -188,32 +236,14 @@ module Netzke
         init_column_names != stored_column_names
       end
 
-      # Selects those columns that make sense to be shown in forms
-      def columns_taken_over_to_forms
-        final_columns.select {|c| include_in_forms?(c) && !exclude_from_forms?(c)}
-      end
-
-      def include_in_forms?(c)
-        !c.getter.nil? ||
-        !c.setter.nil? ||
-        data_adapter.attribute_names.include?(c[:name]) ||
-        data_class.instance_methods.include?(c[:name].to_sym) ||
-        data_class.instance_methods.include?(:"#{c[:name]}=") ||
-        association_attr?(c)
-      end
-
-      def exclude_from_forms?(c)
-        c[:type] == :action
-      end
-
       def columns_default_values
-        final_columns.inject({}) do |r,c|
+        non_meta_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])
+              r.merge(model_adapter.foreign_key_for(assoc_name) || model_adapter.foreign_key_for(assoc_name) => c[:default_value])
             else
               r.merge(c[:name] => c[:default_value])
             end