netzke-basepack 0.7.7 → 0.8.0

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

@@ -1,4 +1,5 @@
 module Netzke::Basepack::DataAdapters
+  # Implementation of Netzke::Basepack::DataAdapters::AbstractAdapter
   class ActiveRecordAdapter < AbstractAdapter
     def self.for_class?(model_class)
       model_class <= ActiveRecord::Base
@@ -8,19 +9,15 @@ module Netzke::Basepack::DataAdapters
       @model_class.primary_key.to_s
     end
 
-    def attr_type(attr_name)
-      @model_class.association_attr?(attr_name) ? :integer : (@model_class.columns_hash[attr_name.to_s].try(:type) || :string)
-    end
-
     def model_attributes
       @model_class.column_names.map do |column_name|
-        {:name => column_name, :attr_type => @model_class.columns_hash[column_name].type}.tap do |c|
+        {name: column_name, attr_type: @model_class.columns_hash[column_name].type}.tap do |c|
 
           # 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| foreign_key_for_assoc(a) == c[:name] }
+          assoc = @model_class.reflect_on_all_associations.detect { |a| a.foreign_key == c[:name] }
 
           if assoc && !assoc.options[:polymorphic]
-            candidates = %w{name title label} << foreign_key_for_assoc(assoc)
+            candidates = %w{name title label} << assoc.foreign_key
             assoc_method = candidates.detect{|m| (assoc.klass.instance_methods.map(&:to_s) + assoc.klass.column_names).include?(m) }
             c[:name] = "#{assoc.name}__#{assoc_method}"
           end
@@ -33,6 +30,28 @@ module Netzke::Basepack::DataAdapters
       end
     end
 
+    # WIP
+    def attribute_names
+      @model_class.column_names
+    end
+
+    def primary_key_attr?(a)
+      a[:name].to_s == @model_class.primary_key.to_s
+    end
+
+    def human_attribute_name(attr_name)
+      @model_class.human_attribute_name(attr_name)
+    end
+
+    def primary_key
+      @model_class.primary_key
+    end
+    ## E_WIP
+
+    def attr_type(attr_name)
+      association_attr?(attr_name) ? :integer : (@model_class.columns_hash[attr_name.to_s].try(:type) || :string)
+    end
+
     def get_records(params, columns=[])
       # build initial relation based on passed params
       relation = get_relation(params)
@@ -90,7 +109,7 @@ module Netzke::Basepack::DataAdapters
       end
     end
 
-    def column_virtual? c
+    def virtual_attribute?(c)
       assoc_name, asso = c[:name].split('__')
       assoc, assoc_method = assoc_and_assoc_method_for_attr(c[:name])
 
@@ -101,50 +120,35 @@ module Netzke::Basepack::DataAdapters
       end
     end
 
-    # Returns options for comboboxes in grids/forms
-    def combobox_options_for_column(column, method_options = {})
-      query = method_options[:query]
+    def combo_data(attr, query = "")
+      assoc, assoc_method = assoc_and_assoc_method_for_attr(attr[:name])
 
-      # First, check if we have options for this column defined in persistent storage
-      options = column[:combobox_options] && column[:combobox_options].split("\n")
-      if options
-        query ? options.select{ |o| o.index(/^#{query}/) }.map{ |el| [el] } : options
-      else
-        assoc, assoc_method = assoc_and_assoc_method_for_attr(column[:name])
-
-        if assoc
-          # Options for an asssociation attribute
-
-          relation = assoc.klass.scoped
+      if assoc
+        # Options for an asssociation attribute
 
-          relation = relation.extend_with(method_options[:scope]) if method_options[:scope]
-
-          if assoc.klass.column_names.include?(assoc_method)
-            # apply query
-            relation = relation.where(["#{assoc_method} like ?", "%#{query}%"]) if query.present?
-            relation.all.map{ |r| [r.id, r.send(assoc_method)] }
-          else
-            relation.all.map{ |r| [r.id, r.send(assoc_method)] }.select{ |id,value| value =~ /^#{query}/ }
-          end
+        relation = assoc.klass.scoped
+        relation = relation.extend_with(attr[:scope]) if attr[:scope]
 
+        if assoc.klass.column_names.include?(assoc_method)
+          # apply query
+          relation = relation.where(["#{assoc_method} like ?", "%#{query}%"]) if query.present?
+          relation.all.map{ |r| [r.id, r.send(assoc_method)] }
         else
-          # Options for a non-association attribute
-          res=@model_class.netzke_combo_options_for(column[:name], method_options)
-
-          # ensure it is an array-in-array, as Ext will fail otherwise
-          raise RuntimeError, "netzke_combo_options_for should return an Array" unless res.kind_of? Array
-          return [[]] if res.empty?
-
-          unless res.first.kind_of? Array
-            res=res.map do |v|
-              [v]
-            end
-          end
-          return res
+          # an expensive search!
+          relation.all.map{ |r| [r.id, r.send(assoc_method)] }.select{ |id,value| value =~ /^#{query}/ }
         end
+
+      else
+        distinct_combo_values(attr, query)
       end
     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.map{|r| [r.send(attr[:name]), r.send(attr[:name])]}
+    end
+    protected :distinct_combo_values
+
     def foreign_key_for assoc_name
       @model_class.reflect_on_association(assoc_name.to_sym).foreign_key
     end
@@ -184,12 +188,110 @@ module Netzke::Basepack::DataAdapters
       end
     end
 
+    def record_to_array(r, attrs)
+      [].tap do |res|
+        attrs.each do |a|
+          res << record_value_for_attribute(r, a, a[:nested_attribute]) if a[:included] != false # :included ever used?..
+        end
+      end
+    end
+
+    def record_to_hash(r, attrs)
+      {}.tap do |res|
+        attrs.each do |a|
+          res[a[:name].to_sym] = record_value_for_attribute(r, a, a[:nested_attribute]) if a[:included] != false
+        end
+      end
+    end
+
+    # def assoc_values(r, attr_hash) #:nodoc:
+    #   @_assoc_values ||= {}.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
+
+    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)
+        split = a[:name].to_s.split(/\.|__/)
+        assoc = @model_class.reflect_on_association(split.first.to_sym)
+        if through_association
+          split.inject(r) do |r,m| # TODO: do we really need to descend deeper than 1 level?
+            if r.respond_to?(m)
+              r.send(m)
+            else
+              logger.debug "Netzke::Basepack: Wrong attribute name: #{a[:name]}" unless r.nil?
+              nil
+            end
+          end
+        else
+          r.send("#{assoc.options[:foreign_key] || assoc.name.to_s.foreign_key}")
+        end
+      end
+
+      # a work-around for to_json not taking the current timezone into account when serializing ActiveSupport::TimeWithZone
+      v = v.to_datetime.to_s(:db) if [ActiveSupport::TimeWithZone].include?(v.class)
+
+      v
+    end
+
+    def set_record_value_for_attribute(r, a, v, role = :default)
+      v = v.to_time_in_current_zone if v.is_a?(Date) # convert Date to Time
+
+      if a[:setter]
+        a[:setter].call(r, v)
+      elsif r.respond_to?("#{a[:name]}=") && attribute_mass_assignable?(a[:name], role)
+        r.send("#{a[:name]}=", v)
+      elsif association_attr?(a)
+        split = a[:name].to_s.split(/\.|__/)
+        if a[:nested_attribute]
+          # We want:
+          #     set_value_for_attribute({:name => :assoc_1__assoc_2__method, :nested_attribute => true}, 100)
+          # =>
+          #     r.assoc_1.assoc_2.method = 100
+          split.inject(r) { |r,m| m == split.last ? (r && r.send("#{m}=", v) && 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_method = split.last
+            if assoc
+              if assoc.macro == :has_one
+                assoc_instance = r.send(assoc.name)
+                if assoc_instance
+                  assoc_instance.send("#{assoc_method}=", v)
+                  assoc_instance.save # what should we do when this fails?..
+                else
+                  # what should we do in this case?
+                end
+              else
+
+                # set the foreign key to the passed value
+                # not that if a negative value is passed, we reset the association (set it to nil)
+                r.send("#{assoc.foreign_key}=", v.to_i < 0 ? nil : v) if attribute_mass_assignable?(assoc.foreign_key, role)
+              end
+            else
+              logger.debug "Netzke::Basepack: Association #{assoc} is not known for class #{@data_class}"
+            end
+          else
+            logger.debug "Netzke::Basepack: Wrong attribute name: #{a[:name]}"
+          end
+        end
+      end
+    end
+
     # Returns association and association method for a column
     def assoc_and_assoc_method_for_attr(column_name)
       assoc_name, assoc_method = column_name.split('__')
       assoc = @model_class.reflect_on_association(assoc_name.to_sym) if assoc_method
       [assoc, assoc_method]
     end
+    protected :assoc_and_assoc_method_for_attr
 
 
     # An ActiveRecord::Relation instance encapsulating all the necessary conditions.
@@ -200,11 +302,6 @@ module Netzke::Basepack::DataAdapters
 
       relation = apply_column_filters(relation, params[:filter]) if params[:filter]
 
-      if params[:extra_conditions]
-        extra_conditions = normalize_extra_conditions(ActiveSupport::JSON.decode(params[:extra_conditions]))
-        relation = relation.extend_with_netzke_conditions(extra_conditions) if params[:extra_conditions]
-      end
-
       query = params[:query] && ActiveSupport::JSON.decode(params[:query])
 
       if query.present?
@@ -223,6 +320,7 @@ module Netzke::Basepack::DataAdapters
 
       relation
     end
+    protected :get_relation
 
     # Parses and applies grid column filters, calling consequent "where" methods on the passed relation.
     # Returns the updated relation.
@@ -282,6 +380,7 @@ module Netzke::Basepack::DataAdapters
 
       res
     end
+    protected :apply_column_filters
 
     def predicates_for_and_conditions(conditions)
       return nil if conditions.empty?
@@ -303,6 +402,12 @@ module Netzke::Basepack::DataAdapters
       # join them by AND
       predicates[1..-1].inject(predicates.first){ |r,p| r.and(p)  }
     end
+    protected :predicates_for_and_conditions
 
+    # Whether an attribute is mass assignable. As second argument optionally takes the role.
+    def attribute_mass_assignable?(attr_name, role = :default)
+      @model_class.accessible_attributes(role).empty? ? !@model_class.protected_attributes(role).include?(attr_name.to_s) : @model_class.accessible_attributes(role).include?(attr_name.to_s)
+    end
+    protected :attribute_mass_assignable?
   end
 end

data/lib/netzke/basepack/fields.rb

@@ -0,0 +1,162 @@
+module Netzke
+  module Basepack
+    # Because Form allows for arbitrary layout of fields, we need to have all fields configured in one place (the +fields+ method), and then have references to those fields from +items+.
+    module Fields
+      extend ActiveSupport::Concern
+
+      # Items with normalized fields (i.e. containing all the necessary attributes needed by Ext.form.Form to render a field)
+      def items
+        config.items || data_class && data_adapter.model_attributes || []
+      end
+
+      # Hash of fully configured fields, that are referenced in the items. E.g.:
+      #   {
+      #     :role__name => {:xtype => 'netzkeremotecombo', :disabled => true, :value => "admin"},
+      #     :created_at => {:xtype => 'datetime', :disabled => true, :value => "2010-10-10 10:10"}
+      #   }
+      def fields
+        @fields ||= begin
+          # extract incomplete field configs from +config+
+          flds = fields_from_config
+
+          primary_key = data_adapter.primary_key_name
+          flds[primary_key.to_sym] ||= {name: primary_key}
+
+          # and merged them with fields from the model
+          deep_merge_existing_fields(flds, fields_from_model) if data_adapter
+          flds
+        end
+      end
+
+      # The array of fields as specified on the model level (using +netzke_attribute+ and alike)
+      def fields_array_from_model
+        data_adapter && data_adapter.model_attributes
+      end
+
+      # Hash of fields as specified on the model level
+      def fields_from_model
+        @fields_from_model ||= fields_array_from_model && fields_array_from_model.inject({}){ |hsh, f| hsh.merge(f[:name].to_sym => f) }
+      end
+
+      # Hash of normalized field configs extracted from :items, e.g.:
+      #
+      #     {:role__name => {:xtype => "netzkeremotecombo"}, :password => {:xtype => "passwordfield"}}
+      def fields_from_config
+        @fields_from_config || (normalize_config || true) && @fields_from_config
+      end
+
+    protected
+
+      # This is where we expand our basic field config with all the defaults
+      def extend_item(field)
+        field = super
+
+        if is_field_config?(field)
+          # field can only be a string, a symbol, or a hash
+          if field.is_a?(Hash)
+            field = field.dup # we don't want to modify original hash
+            return field if field[:no_binding] # stop here if no normalization is needed
+            field[:name] = field[:name].to_s if field[:name] # all names should be strings
+          else
+            field = {:name => field.to_s}
+          end
+
+          # right place?
+          @fields_from_config[field[:name].to_sym] = field
+
+          field_from_model = fields_from_model && fields_from_model[field[:name].to_sym]
+
+          field_from_model && field.merge!(field_from_model)
+
+          detect_association_with_method(field) # xtype for an association field
+          set_default_field_label(field)
+          set_default_field_xtype(field) if field[:xtype].nil?
+          set_default_read_only(field)
+
+          # provide our special combobox with our id
+          field[:parent_id] = self.js_id if field[:xtype] == :netzkeremotecombo
+
+          field[:hidden] = field[:hide_label] = true if field[:hidden].nil? && data_adapter.try(:primary_key_attr?, field)
+
+          # checkbox setup
+          if field[:attr_type] == :boolean
+            field[:checked] = field[:value]
+            field[:unchecked_value] = false
+            field[:input_value] = true if field[:attr_type] == :boolean
+          end
+
+          # date field format
+          if field[:attr_type] = :date
+            field[:submit_format] = "Y-m-d"
+            field[:format] ||= "Y-m-d"
+          end
+        end
+
+        field
+      end
+
+      # Sets the proper xtype of an asociation field
+      def detect_association_with_method(c)
+        if c[:name].index('__')
+          assoc_name, method = c[:name].split('__').map(&:to_sym)
+          assoc_method_type = data_adapter.get_assoc_property_type(assoc_name, method)
+          if c[:nested_attribute]
+            c[:xtype] ||= xtype_for_attr_type(assoc_method_type)
+          else
+            c[:xtype] ||= assoc_method_type == :boolean ? xtype_for_attr_type(assoc_method_type) : xtype_for_association
+          end
+        end
+      end
+
+      def is_field_config?(item)
+        item.is_a?(Symbol) || (item.is_a?(Hash) && item[:name]) # && !is_component_config?(item)
+      end
+
+      # Deeply merges only those key/values at the top level that are already there
+      def deep_merge_existing_fields(dest, src)
+        dest.each_pair do |k,v|
+          v.deep_merge!(src[k] || {})
+        end
+      end
+
+      def set_default_field_label(c)
+        # multiple spaces (in case of association attrs) get replaced with one
+        c[:field_label] ||= data_class ? data_class.human_attribute_name(c[:name]) : c[:name].humanize
+        c[:field_label].gsub!(/\s+/, " ")
+      end
+
+      def set_default_field_xtype(field)
+        field[:xtype] = xtype_for_attr_type(field[:attr_type]) unless xtype_for_attr_type(field[:attr_type]).nil?
+      end
+
+      def set_default_read_only(field)
+        enabled_if = !data_adapter || data_adapter.attribute_names.include?(field[:name])
+        enabled_if ||= data_class.instance_methods.map(&:to_s).include?("#{field[:name]}=")
+        enabled_if ||= record && record.respond_to?("#{field[:name]}=")
+        enabled_if ||= association_attr?(field[:name])
+
+        field[:read_only] = !enabled_if if field[:read_only].nil?
+      end
+
+      def attr_type_to_xtype_map
+        {
+          :integer => :numberfield,
+          :boolean => config[:multi_edit] ? :tricheckbox : :checkboxfield,
+          :date => :datefield,
+          :datetime => :xdatetime,
+          :text => :textarea,
+          :json => :jsonfield,
+          :string => :textfield
+        }
+      end
+
+      def xtype_for_attr_type(type)
+        attr_type_to_xtype_map[type] || :textfield
+      end
+
+      def xtype_for_association
+        :netzkeremotecombo
+      end
+    end
+  end
+end

data/lib/netzke/basepack/form.rb

@@ -0,0 +1,136 @@
+require "netzke/basepack/form/services"
+
+module Netzke
+  module Basepack
+    # Ext.form.Panel-based component
+    #
+    # == Netzke-specific config options
+    #
+    # * +model+ - name of the ActiveRecord model that provides data to this Grid.
+    # * +record+ - record to be displayd in the form. Takes precedence over +:record_id+
+    # * +record_id+ - id of the record to be displayd in the form. Also see +:record+
+    # * +items+ - the layout of the fields as an array. See "Layout configuration".
+    # * +mode+ - render mode, accepted options:
+    # * +lockable+ - makes the form panel load initially in "display mode", then lets "unlock" it, change the values, and "lock" it again, while updating the values on the server
+    # * +updateMask+ - +Ext.LoadMask+ config options for the mask shown while the form is submitting its values
+    #
+    # === Layout configuration
+    #
+    # The layout of the form is configured by supplying the +item+ config option, same way it would be configured in Ext (thus allowing for complex form layouts). Form will expand fields by looking at their names (unless +no_binding+ set to +true+ is specified for a specific field).
+    #
+    # == Endpoints
+    # Form implements the following endpoints:
+    #
+    # * +netzke_load+ - loads a record with a given id from the server, e.g.:
+    #
+    #     someForm.netzkeLoad({id: 100});
+    #
+    # * +netzke_submit+ - gets called when the form gets submitted (e.g. by pressing the Apply button, or by calling onApply)
+    # * +get_combobox_options+ - gets called when a 'remote' combobox field gets expanded
+    class Form < Netzke::Base
+      include self::Services
+      include Fields
+      include DataAccessor
+      include Netzke::Core::ConfigToDslDelegator
+
+      js_configure do |c|
+        c.extend = "Ext.form.Panel"
+        c.mixin
+        c.require :comma_list_cbg, :n_radio_group, :readonly_mode
+      end
+
+      delegates_to_dsl :model, :record_id
+
+      def js_configure(c)
+        super
+
+        configure_locked(c)
+        configure_bbar(c)
+
+        # prepend the primary key field if not present
+        if data_adapter
+          c.items = [extend_item(data_adapter.primary_key_name.to_sym), *c.items] if !includes_primary_key_field?(c.items)
+          c.pri = data_adapter.primary_key_name
+        end
+
+        if !c.multi_edit
+          c.record = js_record_data if record
+        else
+          c.record_id = c.record = nil if c.multi_edit # never set record_id in multi-edit mode
+        end
+      end
+
+      action :apply do |a|
+        a.icon = :tick
+      end
+
+      action :edit do |a|
+        a.icon = :pencil
+      end
+
+      action :cancel do |a|
+        a.icon = :cancel
+      end
+
+      def configure_locked(c)
+        c[:locked] = c[:locked].nil? ? (c[:mode] == :lockable) : c[:locked]
+      end
+
+      def configure_bbar(c)
+        c[:bbar] = [:apply] if c[:bbar].nil? && !c[:read_only]
+      end
+
+
+      # Extra JavaScripts and stylesheets
+      css_configure do |c|
+        c.require :readonly_mode
+      end
+
+      # A hash of record data including the meta field
+      def js_record_data
+        data_adapter.record_to_hash(record, fields.values).merge(:meta => meta_field).literalize_keys
+      end
+
+      def record
+        @record ||= config[:record] || config[:record_id] && data_adapter && data_adapter.find_record(config[:record_id])
+      end
+
+    protected
+
+      def includes_primary_key_field?(items)
+        !!items.detect do |item|
+          (item.is_a?(Hash) ? item[:name] : item.to_s) == data_adapter.primary_key_name
+        end
+      end
+
+      def normalize_config
+        config.items = items
+        @fields_from_config = {}
+        super
+      end
+
+      def self.server_side_config_options
+        super + [:scope]
+      end
+
+      def meta_field
+        {}.tap do |res|
+          assoc_values = get_association_values
+          res[:association_values] = assoc_values.literalize_keys if record && !assoc_values.empty?
+        end
+      end
+
+      def get_association_values
+        fields_that_need_associated_values = fields.select{ |k,v| k.to_s.index("__") && !fields[k][:nested_attribute] }
+        # Take care of Ruby 1.8.7
+        if fields_that_need_associated_values.is_a?(Array)
+          fields_that_need_associated_values = fields_that_need_associated_values.inject({}){|r,(k,v)| r.merge(k => v)}
+        end
+
+        fields_that_need_associated_values.each_pair.inject({}) do |r,(k,v)|
+          r.merge(k => data_adapter.record_value_for_attribute(record, fields_that_need_associated_values[k], true))
+        end
+      end
+    end
+  end
+end