netzke-basepack 0.7.4 → 0.7.5

data/.travis.yml

@@ -0,0 +1,11 @@
+rvm:
+  - 1.9.2
+
+env:
+  - ORM=ar
+  - ORM=dm
+  - ORM=sq
+
+bundler_args: "--without development production profiling"
+before_script: "./config/ci/before-travis.sh"
+script: "cd test/basepack_test_app ; bundle exec rake travis"

data/CHANGELOG.rdoc

@@ -1,3 +1,13 @@
+= 0.7.5 - ?
+* improvements
+  * data-related operations in grids and forms are moved to data adapters; implemented (partial) support for DataMapper and Sequel (see updated README)
+  * afterApply event in forms and grids (pschyska)
+  * apply event fired before apply button is processed in FormPanel (pschyska)
+
+* bug fix
+  * advanced search panel works again (pididi)
+  * fixed a problem with session and GridPanel
+
 = 0.7.4 - 2012-03-05
 * bug fix
   * :enable_pagination is now respected in GridPanel

data/README.md

@@ -5,7 +5,7 @@ A pack of pre-built [Netzke](http://netzke.org) components - such as grid, form,
 ## Requirements
 
 * Ruby 1.9.2 (1.8.7 may work, too)
-* Rails >= 3.0.0
+* Rails ~> 3.1.0
 * Ext JS = 4.0.2a
 
 ## Installation
@@ -36,6 +36,40 @@ After starting up the test app, you can see the list of functional test componen
 
     http://localhost:3000/
 
+## Note on testing with DataMapper/Sequel Support
+To install the test app with DataMapper or Sequel, put ORM=dm or ORM=sq
+into your environment.
+For example to set-up DataMapper support run
+
+    # in test/basepack_test_app
+    ORM=dm bundle install
+
+To run the test app in DataMapper-Mode (will use DataMapper models instead of ActiveRecord models)
+
+    # in test/basepack_test_app
+    ORM=dm rails s
+
+To run the test suite
+
+    # in test/basepack_test_app
+    ORM=dm bundle exec rake
+
+etc.
+
+NOTE: netzke-basepack is not dependant on neither DataMapper nor Sequel.  It will pick the right DataAdapter for your models automatically.
+ActiveRecord is still included in Gemfile of the test app, as netzke-persistance is used which uses ActiveRecord.
+If you don't use netzke-persistence, then you don't need to include ActiveRecord.
+
+## DataMapper support
+DataMapper support is *incomplete*, as I didn't find a good way to sort by an association's column when the association needs a LEFT OUTER JOIN (i.e. nullable foreign key in many_to_one).
+
+## Sequel support
+
+CAVEATS:
+  - you can't use polymorphic associations for the time being, as the sequel_polymorphic plugin is not supported by netzke-basepack
+  - SearchPanel is broken atm. When it's fixed, Sequel support for
+    SearchPanel triggered queries should be implemented.
+
 ## 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.
 
@@ -57,4 +91,4 @@ 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/)
+Note, that Ext JS itself is licensed [differently](http://www.sencha.com/products/extjs/license/)

data/Rakefile

@@ -10,8 +10,6 @@ begin
     gemspec.homepage = "http://netzke.org"
     gemspec.authors = ["Sergei Kozlov"]
     gemspec.add_dependency("netzke-core",   "~>0.7.4")
-    gemspec.add_dependency("will_paginate", "~>3.0.0")
-    gemspec.add_dependency("acts_as_list",  "~>0.1.4")
     gemspec.post_install_message = <<-MESSAGE
 
 ========================================================================
@@ -60,4 +58,4 @@ namespace :rdoc do
   task :publish => :rdoc do
     `scp -r rdoc/* fl:www/api.netzke.org/basepack`
   end
-end
+end

data/config/ci/before-travis.sh

@@ -0,0 +1,28 @@
+# Start xvfb in preparation for cucumber
+sh -e /etc/init.d/xvfb start
+
+# fetch extjs
+wget http://extjs.cachefly.net/ext-4.0.2a-gpl.zip
+unzip -q -d test/basepack_test_app/public/ -n ext-4.0.2a-gpl.zip
+mv test/basepack_test_app/public/ext-4.0.2a test/basepack_test_app/public/extjs
+
+# cp db configuration
+cp test/basepack_test_app/config/database.yml.travis  test/basepack_test_app/config/database.yml
+
+# create mysql database
+mysql -e 'create database nbt_test;'
+
+# clone netzke-core and netzke-persistence gems into test project
+mkdir -p test/basepack_test_app/vendor/gems
+cd test/basepack_test_app/vendor/gems
+git clone git://github.com/skozlov/netzke-core.git
+cd netzke-core
+git checkout tags/v0.7.4
+cd ..
+git clone git://github.com/skozlov/netzke-persistence.git
+cd netzke-persistence
+git checkout tags/v0.1.0
+cd ../../..
+bundle install
+bundle exec rake db:migrate RAILS_ENV=test
+cd ../..

data/lib/netzke/active_record.rb

@@ -7,12 +7,14 @@ module Netzke
   end
 end
 
-# Extend ActiveRecord
-ActiveRecord::Base.class_eval do
-  include ::Netzke::ActiveRecord::Attributes
-  include ::Netzke::ActiveRecord::ComboboxOptions
-end
+if defined? ActiveRecord
+  # Extend ActiveRecord
+  ActiveRecord::Base.class_eval do
+    include ::Netzke::ActiveRecord::Attributes
+    include ::Netzke::ActiveRecord::ComboboxOptions
+  end
 
-ActiveRecord::Relation.class_eval do
-  include ::Netzke::ActiveRecord::RelationExtensions
-end
+  ActiveRecord::Relation.class_eval do
+    include ::Netzke::ActiveRecord::RelationExtensions
+  end
+end

data/lib/netzke/active_record/attributes.rb

@@ -3,14 +3,28 @@ module Netzke
     module Attributes
       extend ActiveSupport::Concern
 
+      included do
+        class_attribute :netzke_declared_attr
+        self.netzke_declared_attr = []
+
+        class_attribute :netzke_excluded_attr
+        self.netzke_excluded_attr = []
+
+        class_attribute :netzke_exposed_attr
+      end
+
       module ClassMethods
+        def data_adapter
+          @data_adapter = Netzke::Basepack::DataAdapters::AbstractAdapter.adapter_class(self).new(self)
+        end
+
         # Define or configure an attribute.
         # Example:
         #   netzke_attribute :recent, :type => :boolean, :read_only => true
         def netzke_attribute(name, options = {})
           name = name.to_s
           options[:attr_type] = options.delete(:type) || options.delete(:attr_type) || :string
-          declared_attrs = read_inheritable_attribute(:netzke_declared_attributes) || []
+          declared_attrs = self.netzke_declared_attr.dup
           # if the attr was declared already, simply merge it with the new options
           existing = declared_attrs.detect{ |va| va[:name] == name }
           if existing
@@ -24,7 +38,7 @@ module Netzke
               declared_attrs << {:name => name}.merge(options)
             end
           end
-          write_inheritable_attribute(:netzke_declared_attributes, declared_attrs)
+          self.netzke_declared_attr = declared_attrs
         end
 
         # Exclude attributes from being picked up by grids and forms.
@@ -32,7 +46,7 @@ module Netzke
         # Example:
         #   netzke_expose_attributes :created_at, :updated_at, :crypted_password
         def netzke_exclude_attributes(*args)
-          write_inheritable_attribute(:netzke_excluded_attributes, args.map(&:to_s))
+          self.netzke_excluded_attr = args.map(&:to_s)
         end
 
         # Explicitly expose attributes that should be picked up by grids and forms.
@@ -41,7 +55,7 @@ module Netzke
         # Example:
         #   netzke_expose_attributes :name, :role__name
         def netzke_expose_attributes(*args)
-          write_inheritable_attribute(:netzke_exposed_attributes, args.map(&:to_s))
+          self.netzke_exposed_attr = args.map(&:to_s)
         end
 
         # Returns the attributes that will be picked up by grids and forms.
@@ -55,7 +69,7 @@ module Netzke
         end
 
         def netzke_exposed_attributes
-          exposed = read_inheritable_attribute(:netzke_exposed_attributes)
+          exposed = self.netzke_exposed_attr
           if exposed && !exposed.include?(self.primary_key)
             # automatically declare primary key as a netzke attribute
             netzke_attribute(self.primary_key)
@@ -65,17 +79,10 @@ module Netzke
         end
 
         private
-          def netzke_declared_attributes
-            read_inheritable_attribute(:netzke_declared_attributes) || []
-          end
-
-          def netzke_excluded_attributes
-            read_inheritable_attribute(:netzke_excluded_attributes) || []
-          end
 
           def netzke_attrs_in_forced_order(attrs)
             attrs.collect do |attr_name|
-              declared = netzke_declared_attributes.detect { |va| va[:name] == attr_name } || {}
+              declared = self.netzke_declared_attr.detect { |va| va[:name] == attr_name } || {}
               in_columns_hash = columns_hash[attr_name] && {:name => attr_name, :attr_type => columns_hash[attr_name].type, :default_value => columns_hash[attr_name].default} || {} # {:virtual => true} # if nothing found in columns, mark it as "virtual" or not?
               if in_columns_hash.empty?
                 # If not among the model columns, it's either virtual, or an association
@@ -98,7 +105,7 @@ module Netzke
           #   role_id => role__name
           def netzke_attrs_in_natural_order
             (
-              declared_attrs = netzke_declared_attributes
+              declared_attrs = self.netzke_declared_attr
 
               column_names.map do |name|
                 c = {:name => name, :attr_type => columns_hash[name].type}
@@ -124,7 +131,7 @@ module Netzke
                 c
               end +
               declared_attrs
-            ).reject { |attr| netzke_excluded_attributes.include?(attr[:name]) }
+            ).reject { |attr| self.netzke_excluded_attr.include?(attr[:name]) }
           end
 
           # Returns foreign key for given association (Rails >= 3.0)
@@ -139,7 +146,7 @@ module Netzke
       end
 
       # Transforms a record to array of values according to the passed attributes
-      def to_array(attributes)
+      def netzke_array(attributes = self.class.netzke_attributes)
         res = []
         for a in attributes
           next if a[:included] == false
@@ -148,8 +155,12 @@ module Netzke
         res
       end
 
+      def netzke_json
+        netzke_hash.to_nifty_json
+      end
+
       # Accepts both hash and array of attributes
-      def to_hash(attributes)
+      def netzke_hash(attributes = self.class.netzke_attributes)
         res = {}
         for a in (attributes.is_a?(Hash) ? attributes.values : attributes)
           next if a[:included] == false

data/lib/netzke/active_record/relation_extensions.rb

@@ -11,7 +11,9 @@ module Netzke
           params.empty? ? self.where(scope) : self.where([scope, *params])
         when "Array"
           self.extend_with(*scope)
-        when "Hash"   # conditions hash
+        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)

data/lib/netzke/basepack.rb

@@ -3,9 +3,17 @@ require 'netzke/basepack/version'
 if defined? ActiveRecord
   require 'netzke/active_record'
 end
+if defined? DataMapper
+  require 'netzke/data_mapper'
+end
+if defined? Sequel
+  require 'netzke/sequel'
+end
 
-# will_paginate supports more than just ActiveRecord
-require 'will_paginate'
+require 'netzke/basepack/data_adapters/abstract_adapter'
+require 'netzke/basepack/data_adapters/active_record_adapter' if defined? ActiveRecord
+require 'netzke/basepack/data_adapters/data_mapper_adapter' if defined? DataMapper
+require 'netzke/basepack/data_adapters/sequel_adapter' if defined? Sequel
 
 module Netzke
   module Basepack

data/lib/netzke/basepack/action_column.rb

@@ -4,20 +4,18 @@ module Netzke
       extend ActiveSupport::Concern
 
       included do |base|
+
+        # Returns registered actions
+        class_attribute :registered_column_actions
+        self.registered_column_actions = []
+
         js_include :action_column
       end
 
       module ClassMethods
         # Register an action
         def register_column_action(name)
-          current_column_actions = read_inheritable_attribute(:column_actions) || []
-          current_column_actions << name
-          write_inheritable_attribute(:column_actions, current_column_actions.uniq)
-        end
-
-        # Returns registered actions
-        def registered_column_actions
-          read_inheritable_attribute(:column_actions) || []
+          self.registered_column_actions |= [name]
         end
 
         # Use this method to define column actions in your component, e.g.:

data/lib/netzke/basepack/data_accessor.rb

@@ -3,48 +3,11 @@ module Netzke
     # This module is included into such data-driven components as GridPanel, FormPanel, PagingFormPanel, etc.
     module DataAccessor
 
-      # Returns options for comboboxes in grids/forms
-      def combobox_options_for_column(column, method_options = {})
-        query = method_options[:query]
-
-        # 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)
-
-          if assoc
-            # Options for an asssociation attribute
-
-            relation = assoc.klass.scoped
 
-            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
-
-          else
-            # Options for a non-association attribute
-            res=data_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
-          end
-        end
+      # 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
@@ -61,156 +24,30 @@ module Netzke
         a.is_a?(Symbol) || a.is_a?(String) ? {:name => a.to_s} : a.merge(:name => a[:name].to_s)
       end
 
-      # Returns association and association method for a column
-      def assoc_and_assoc_method_for_attr(c)
-        assoc_name, assoc_method = c[:name].split('__')
-        assoc = data_class.reflect_on_association(assoc_name.to_sym) if assoc_method
-        [assoc, assoc_method]
-      end
-
       def association_attr?(name)
         !!name.to_s.index("__")
       end
 
       # Model class
       def data_class
-        @data_class ||= config[:model] && config[:model].constantize
+        @data_class ||= config[:model].is_a?(String) ? config[:model].constantize : config[:model]
+      end
+
+      # Data adapter responsible for all DB-related operations
+      def data_adapter
+        @data_adapter ||= 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
+        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)
-        if c[:virtual].nil? # sometimes at maybe handy to mark a column as non-virtual forcefully
-          assoc, assoc_method = assoc_and_assoc_method_for_attr(c)
-          if assoc
-            c[:virtual] = true if !assoc.klass.column_names.map(&:to_sym).include?(assoc_method.to_sym)
-          else
-            c[:virtual] = true if !data_class.column_names.map(&:to_sym).include?(c[:name].to_sym)
-          end
-        end
-      end
-
-      # An ActiveRecord::Relation instance encapsulating all the necessary conditions.
-      def get_relation(params = {})
-        @arel = data_class.arel_table
-
-        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
-
-        query = params[:query] && ActiveSupport::JSON.decode(params[:query])
-
-        if query.present?
-          # array of arrays of conditions that should be joined by OR
-          and_predicates = query.map do |conditions|
-            predicates_for_and_conditions(conditions)
-          end
-
-          # join them by OR
-          predicates = and_predicates[1..-1].inject(and_predicates.first){ |r,c| r.or(c) }
-        end
-
-        relation = relation.where(predicates)
-
-        relation = relation.extend_with(config[:scope]) if config[:scope]
-
-        relation
+        c[:virtual] = data_adapter.column_virtual?(c) if c[:virtual].nil?
       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" => ">", "eq" => "="}
-
-        table_name = data_class.table_name
-
-        # 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('.')
-          else
-            field = [table_name, assoc].join('.')
-          end
-
-          value = v["value"]
-
-          op = operator_map[v['comparison']]
-
-          case v["type"]
-          when "string"
-            res = res.where(["#{field} like ?", "%#{value}%"])
-          when "date"
-            # convert value to the DB date
-            value.match /(\d\d)\/(\d\d)\/(\d\d\d\d)/
-            res = res.where("#{field} #{op} ?", "#{$3}-#{$1}-#{$2}")
-          when "numeric"
-            res = res.where(["#{field} #{op} ?", value])
-          else
-            res = res.where(["#{field} = ?", value])
-          end
-        end
-
-        res
-      end
-
-
-      protected
-
-        def predicates_for_and_conditions(conditions)
-          return nil if conditions.empty?
-
-          predicates = conditions.map do |q|
-            value = q["value"]
-            case q["operator"]
-            when "contains"
-              @arel[q["attr"]].matches "%#{value}%"
-            else
-              if value == false || value == true
-                @arel[q["attr"]].eq(value ? 1 : 0)
-              else
-                @arel[q["attr"]].send(q["operator"], value)
-              end
-            end
-          end
-
-          # join them by AND
-          predicates[1..-1].inject(predicates.first){ |r,p| r.and(p)  }
-        end
-
     end
   end
 end