netzke-basepack 0.7.0 → 0.7.1

data/CHANGELOG.rdoc

@@ -1,3 +1,11 @@
+= 0.7.1 - 2011-09-04
+* bug fix
+  * fixing the netzke_load endpoint when association fields are present
+  * dates were not displayed in date fields, and submitting a form with date fields might result in erasing those fields
+
+* Rails 3.1 compatibility
+  * no meta_where dependencies (searching and filtering done with Arel)
+
 = 0.7.0 - 2011-08-09
 * Core 0.7.0 and Ext 4 compatibility
 * API changes
@@ -6,7 +14,7 @@
 = v0.6.5 - to be released
 * enhancements
   * When columns states are saved in the persistent storage, adding/removing columns (e.g. in the code) will reset the saved states
-  * Moved features and specs to test/rails_app
+  * Moved features and specs to test/basepack_test_app
 * bug fix
   * FormPanel with multiple association fields wouldn't submit data correctly
   * GridPanel's forms take over the +text+ configuration option for columns as +fieldLabel+ for default fields

data/README.md

@@ -24,7 +24,7 @@ Embed a basepack component into a view as any other Netzke component, e.g.:
 
   <%= netzke :books, :class_name => 'Netzke::Basepack::GridPanel', :model => 'Book' %>
 
-For more examples, see http://demo.netzke.com, and look into test/rails_app.
+For more examples, see http://demo.netzke.com, and look into test/basepack_test_app.
 
 ## Testing and playing with Netzke Basepack
 
@@ -32,13 +32,9 @@ Netzke Basepack is bundled with Cucumber and RSpec tests. If you would like to c
 
 Besides, the bundled test application is a convenient [playground](https://github.com/skozlov/netzke-core/wiki/Playground) for those who search to experiment with the framework.
 
-After setting up the test application, you can access the test components (from test/rails_app/app/components) like this:
+After starting up the test app, you can see the list of functional test components on the index page (along with links to the source code):
 
-    http://localhost:3000/components/<name_of_the_test_component_class>
-
-e.g.:
-
-    http://localhost:3000/components/UserGrid
+    http://localhost:3000/
 
 ## Icons support
 Netzke Basepack can make use of FamFamFam Silk icon set (http://www.famfamfam.com/archive/silk-icons-thats-your-lot/). To enable this, download the icons and put the "icons" folder into your app's public/images folder. Then restart your application.
@@ -55,9 +51,10 @@ Official project site: http://netzke.org
 Twitter:
 
 * latest news about Netzke: http://twitter.com/netzke
-* author's rambling about osx, productivity and what not:  http://twitter.com/nomadcoder
+* author's tweets on osx, productivity and what not:  http://twitter.com/nomadcoder
 
 Many (if a bit outdated) tutorials: http://blog.writelesscode.com
 
 ---
 Copyright (c) 2008-2011 NomadCoder, released under the MIT license
+Note, that Ext JS itself is licensed [differently](http://www.sencha.com/products/extjs/license/)

data/Rakefile

@@ -10,7 +10,6 @@ begin
     gemspec.homepage = "http://netzke.org"
     gemspec.authors = ["Sergei Kozlov"]
     gemspec.add_dependency("netzke-core",   "~>0.7.0")
-    gemspec.add_dependency("meta_where",    "~>1.0.0")
     gemspec.add_dependency("will_paginate", "~>3.0.0")
     gemspec.add_dependency("acts_as_list",  "~>0.1.4")
     gemspec.post_install_message = <<-MESSAGE

data/lib/netzke/active_record/attributes.rb

@@ -104,10 +104,10 @@ module Netzke
                 c = {:name => name, :attr_type => columns_hash[name].type}
 
                 # If it's named as foreign key of some association, then it's an association column
-                assoc = reflect_on_all_associations.detect{|a| a.primary_key_name == c[:name]}
+                assoc = reflect_on_all_associations.detect { |a| foreign_key_for_assoc(a) == c[:name] }
 
                 if assoc && !assoc.options[:polymorphic]
-                  candidates = %w{name title label} << assoc.primary_key_name
+                  candidates = %w{name title label} << foreign_key_for_assoc(assoc)
                   assoc_method = candidates.detect{|m| (assoc.klass.instance_methods.map(&:to_s) + assoc.klass.column_names).include?(m) }
                   c[:name] = "#{assoc.name}__#{assoc_method}"
                   c[:attr_type] = assoc.klass.columns_hash[assoc_method].try(:type) || :string # when it's an instance method rather than a column, fall back to :string
@@ -127,6 +127,11 @@ module Netzke
             ).reject { |attr| netzke_excluded_attributes.include?(attr[:name]) }
           end
 
+          # Returns foreign key for given association (Rails >= 3.0)
+          def foreign_key_for_assoc(assoc)
+            assoc.respond_to?(:foreign_key) ? assoc.foreign_key : assoc.primary_key_name
+          end
+
           def association_attr?(attr_name)
             !!attr_name.index("__") # probably we can't do much better than this, as we don't know at this moment if the associated model has a specific attribute, and we don't really want to find it out
           end
@@ -169,7 +174,7 @@ module Netzke
               if r.respond_to?(m)
                 r.send(m)
               else
-                logger.debug "!!! Netzke::Basepack: Wrong attribute name: #{a[:name]}" unless r.nil?
+                logger.debug "Netzke::Basepack: Wrong attribute name: #{a[:name]}" unless r.nil?
                 nil
               end
             end
@@ -180,11 +185,14 @@ module Netzke
 
         # 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 v.is_a?(ActiveSupport::TimeWithZone)
+
         v
       end
 
       # Assigns new value to an (association) attribute
       def set_value_for_attribute(a, v)
+        v = v.to_time_in_current_zone if v.is_a?(Date) # convert Date to Time
+
         if a[:setter]
           a[:setter].call(self, v)
         elsif respond_to?("#{a[:name]}=")
@@ -215,10 +223,10 @@ module Netzke
                   self.send("#{assoc.options[:foreign_key] || assoc.name.to_s.foreign_key}=", v)
                 end
               else
-                logger.debug "!!! Netzke::Basepack: Association #{assoc} is not known for class #{self.class.name}"
+                logger.debug "Netzke::Basepack: Association #{assoc} is not known for class #{self.class.name}"
               end
             else
-              logger.debug "!!! Netzke::Basepack: Wrong attribute name: #{a[:name]}"
+              logger.debug "Netzke::Basepack: Wrong attribute name: #{a[:name]}"
             end
           end
         end

data/lib/netzke/basepack.rb

@@ -2,7 +2,6 @@ require 'netzke/basepack/version'
 
 if defined? ActiveRecord
   require 'netzke/active_record'
-  require 'meta_where'
 end
 
 # will_paginate supports more than just ActiveRecord

data/lib/netzke/basepack/data_accessor.rb

@@ -108,57 +108,116 @@ module Netzke
       end
 
       # An ActiveRecord::Relation instance encapsulating all the necessary conditions.
-      # Using the meta_where magic.
       def get_relation(params = {})
-        # make params coming from Ext grid filters understandable by meta_where
-        conditions = params[:filter] && convert_filters(params[:filter]) || {}
+        @arel = data_class.arel_table
 
-        relation = data_class.where(conditions)
+        relation = data_class.scoped
+
+        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
 
-        if params[:query]
+        query = params[:query] && ActiveSupport::JSON.decode(params[:query])
+
+        if query.present?
           # array of arrays of conditions that should be joined by OR
-          query = ActiveSupport::JSON.decode(params[:query])
-          meta_where = query.map do |conditions|
-            normalize_and_conditions(conditions)
+          and_predicates = query.map do |conditions|
+            predicates_for_and_conditions(conditions)
           end
 
           # join them by OR
-          meta_where = meta_where.inject(meta_where.first){ |r,c| r | c } if meta_where.present?
+          predicates = and_predicates[1..-1].inject(and_predicates.first){ |r,c| r.or(c) }
         end
 
-        relation = relation.where(meta_where)
+        relation = relation.where(predicates)
 
         relation = relation.extend_with(config[:scope]) if config[:scope]
 
         relation
       end
 
+      # Parses and applies grid column filters, calling consequent "where" methods on the passed relation.
+      # Returns the updated relation.
+      #
+      # Example column grid data:
+      #
+      #     {"0" => {
+      #       "data" => {
+      #         "type" => "numeric",
+      #         "comparison" => "gt",
+      #         "value" => 10 },
+      #       "field" => "id"
+      #     },
+      #     "1" => {
+      #       "data" => {
+      #         "type" => "string",
+      #         "value" => "pizza"
+      #       },
+      #       "field" => "food_name"
+      #     }}
+      #
+      # This will result in:
+      #
+      #      relation.where(["id > ?", 10]).where(["food_name like ?", "%pizza%"])
+      def apply_column_filters(relation, column_filter)
+        res = relation
+        operator_map = {"lt" => "<", "gt" => ">"}
+
+        # these are still JSON-encoded due to the migration to Ext.direct
+        column_filter=JSON.parse(column_filter)
+        column_filter.each do |v|
+          assoc, method = v["field"].split('__')
+          if method
+            assoc = data_class.reflect_on_association(assoc.to_sym)
+            field = [assoc.klass.table_name, method].join('.').to_sym
+          else
+            field = assoc.to_sym
+          end
+
+          value = v["value"]
+
+          op = operator_map[v['comparison']]
+
+          case v["type"]
+          when "string"
+            res = res.where(["#{field} like ?", "%#{value}%"])
+          when "numeric", "date"
+            res = res.where(["#{field} #{op} ?", value])
+          else
+            res = res.where(["#{field} = ?", value])
+          end
+        end
+
+        res
+      end
+
+
       protected
 
-        def normalize_and_conditions(conditions)
-          and_conditions = conditions.map do |q|
+        def predicates_for_and_conditions(conditions)
+          return nil if conditions.empty?
+
+          predicates = conditions.map do |q|
             value = q["value"]
             case q["operator"]
             when "contains"
-              q["attr"].to_sym.matches % %Q{%#{value}%}
+              @arel[q["attr"]].matches "%#{value}%"
             else
               if value == false || value == true
-                q["attr"].to_sym.eq % (value ? 1 : 0)
+                @arel[q["attr"]].eq(value ? 1 : 0)
               else
-                q["attr"].to_sym.send(q["operator"]) % value
+                @arel[q["attr"]].send(q["operator"], value)
               end
             end
           end
 
           # join them by AND
-          and_conditions.inject(and_conditions.first){ |r,c| r & c } if and_conditions.present?
+          predicates[1..-1].inject(predicates.first){ |r,p| r.and(p)  }
         end
 
     end
   end
-end
+end

data/lib/netzke/basepack/form_panel.rb

@@ -6,7 +6,8 @@ module Netzke
   module Basepack
     # Ext.form.Panel-based component
     #
-    # == Configuration
+    # == Netzke-specific config options
+    #
     # * +model+ - name of the ActiveRecord model that provides data to this GridPanel.
     # * +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+
@@ -14,10 +15,20 @@ module Netzke
     # * +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
-    # Besides, FormPanel can accept any meaninful :
     #
     # === 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). FormPanel will expand fields by looking at their names (unless +no_binding+ set to +true+ is specified for a specific field).
+    #
+    # == Endpoints
+    # FormPanel implements the following endpoints:
+    #
+    # * +netzke_load+ - loads a record with a given id from the server, e.g.:
+    #
+    #     someFormPanel.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 FormPanel < Netzke::Base
 
       js_base_class "Ext.form.Panel"
@@ -94,44 +105,22 @@ module Netzke
 
       # A hash of record data including the meta field
       def js_record_data
-        record.to_hash(fields).merge(:_meta => meta_field).literalize_keys
+        hsh = record.to_hash(fields).merge(:_meta => meta_field).literalize_keys
+
+        # HACK: a dirty hack cutting off the time part from the datetime string to please the form's datefield - until we have a real datetimefield
+        hsh.each_pair do |k,v|
+          if v && [:datetime, :date].include?(fields[k.to_sym].try(:fetch, :attr_type, nil))
+            hsh[k] = v.split.first
+          end
+        end
+
+        hsh
       end
 
       def record
         @record ||= config[:record] || config[:record_id] && data_class && data_class.where(data_class.primary_key => config[:record_id]).first
       end
 
-      # def configuration_components
-      #   res = []
-      #
-      #   res << {
-      #     :name              => 'fields',
-      #     :class_name => "FieldsConfigurator",
-      #     :active            => true,
-      #     :owner             => self,
-      #     :persistent_config => true
-      #   }
-      #
-      #   res << {
-      #     :name               => 'general',
-      #     :class_name  => "PropertyEditor",
-      #     :component             => self,
-      #     :title => false
-      #   }
-      #
-      #   res
-      # end
-
-      def self.property_fields
-        res = [
-          {:name => "ext_config__title",               :attr_type => :string},
-          {:name => "ext_config__header",              :attr_type => :boolean, :default => true},
-          {:name => "ext_config__bbar",              :attr_type => :json}
-        ]
-
-        res
-      end
-
       private
 
         def self.server_side_config_options

data/lib/netzke/basepack/form_panel/fields.rb

@@ -100,6 +100,12 @@ module Netzke
             set_default_field_xtype(field) if field[:xtype].nil?
             set_default_read_only(field)
 
+            # temporal datetime setup, while we don't have real datetime field
+            if field[:attr_type] == :datetime || field[:attr_type] == :date
+              field[:format] ||= "Y-m-d" # needed for
+              field[:submit_format] = "Y-m-d"
+            end
+
             # provide our special combobox with our id
             field[:parent_id] = self.global_id if field[:xtype] == :netzkeremotecombo
 
@@ -183,6 +189,7 @@ module Netzke
               :date => :datefield,
               # WIP: waiting for datetime.js implementation for ExtJS 4
               # :datetime => :datetimefield,
+              :datetime => :datefield,
 
               :text => :textarea,
               :json => :jsonfield,

data/lib/netzke/basepack/form_panel/services.rb

@@ -8,14 +8,18 @@ module Netzke
 
           #
           # Endpoints
-          #
+
+          # Called when the form gets submitted (e.g. by pressing the Apply button)
           endpoint :netzke_submit, :pre => true do |params|
             netzke_submit(params)
           end
 
+          # Can be called when the form needs to load a record with given ID. E.g.:
+          #
+          #     someForm.netzkeLoad({id: 100});
           endpoint :netzke_load do |params|
             @record = data_class && data_class.find_by_id(params[:id])
-            {:set_form_values => @record.to_hash(fields)}
+            {:set_form_values => js_record_data}
           end
 
           # Returns options for a combobox
@@ -98,7 +102,6 @@ module Netzke
 
           # Creates/updates a record from hash
           def create_or_update_record(hsh)
-
             hsh.merge!(config[:strong_default_attrs]) if config[:strong_default_attrs]
             @record ||= data_class.find(:first, :conditions => {data_class.primary_key => hsh.delete(data_class.primary_key)}) # only pick up the record specified in the params if it was not provided in the configuration
             success = true

data/lib/netzke/basepack/grid_panel/services.rb

@@ -214,10 +214,10 @@ module Netzke
                 relation = relation.send(column[:sorting_scope].to_sym, dir.to_sym)
               else
                 relation = if method.nil?
-                  relation.order(assoc.to_sym.send(dir))
+                  relation.order("#{assoc} #{dir}")
                 else
                   assoc = data_class.reflect_on_association(assoc.to_sym)
-                  relation.order(assoc.klass.table_name.to_sym => method.to_sym.send(dir)).joins(assoc.name)
+                  relation.joins(assoc.name).order("#{assoc.klass.table_name}.#{method} #{dir}")
                 end
               end
             end
@@ -298,53 +298,6 @@ module Netzke
             mod_records
           end
 
-          # Converts Ext.ux.grid.GridFilters filters to searchlogic conditions, e.g.
-          #     {"0" => {
-          #       "data" => {
-          #         "type" => "numeric",
-          #         "comparison" => "gt",
-          #         "value" => 10 },
-          #       "field" => "id"
-          #     },
-          #     "1" => {
-          #       "data" => {
-          #         "type" => "string",
-          #         "value" => "pizza"
-          #       },
-          #       "field" => "food_name"
-          #     }}
-          #
-          #      =>
-          #
-          #  metawhere:   :id.gt => 100, :food_name.matches => '%pizza%'
-          def convert_filters(column_filter)
-            # these are still JSON-encoded due to the migration to Ext.direct
-            column_filter=JSON.parse(column_filter)
-            res = {}
-            column_filter.each do |v|
-              assoc, method = v["field"].split('__')
-              if method
-                assoc = data_class.reflect_on_association(assoc.to_sym)
-                field = [assoc.klass.table_name, method].join('.').to_sym
-              else
-                field = assoc.to_sym
-              end
-
-              value = v["value"]
-
-              case v["type"]
-              when "string"
-                op = v['comparison'] && (v['comparison'] == 'like' ? :matches : :does_not_match) || :matches
-                field = field.send(op)
-                value = "%#{value}%"
-              when "numeric", "date"
-                field = field.send :"#{v['comparison']}"
-              end
-              res.merge!({field => value})
-            end
-            res
-          end
-
           def normalize_extra_conditions(conditions)
             conditions.each_pair do |k,v|
               conditions[k] = "%#{v}%" if ["like", "matches"].include?(k.to_s.split("__").last)