extjs-mvc 0.3.4 → 0.3.5

data/README.rdoc

@@ -62,7 +62,7 @@ E.g. with the following definition:
     class User < ActiveRecord::Base
       include ExtJS::Model
 
-      extjs_fieldset :grid, [:name, :description, :company => [:name, :description]]
+      extjs_fieldset :grid, fields => [:name, :description, :company => [:name, :description]]
       extjs_fieldset :combo, [:full_name]
   
       def full_name

data/VERSION

@@ -1 +1 @@
-0.3.4
+0.3.5

data/lib/extjs-mvc.rb

@@ -16,6 +16,8 @@ module ExtJS
         require 'model/data_mapper'
       elsif defined?(MongoMapper)
         require 'model/mongo_mapper'
+      else
+        raise StandardError.new("extjs-mvc could not detect an ORM framework.  Be sure to include your ORM framework before initializing extjs-mvc Gem.")
       end
 
       # Rails-style Array#extract_options! used heavily

data/lib/model/active_record.rb

@@ -68,21 +68,17 @@ module ExtJS
       # @return {Array}
       #
       def extjs_associations
-        #if @extjs_associations.nil?
-          extjs_associations = {}
-          self.reflections.keys.each do |key|
-            assn = self.reflections[key]
-            type = (assn.macro === :has_many || assn.macro === :has_and_belongs_to_many) ? :many : assn.macro
-            extjs_associations[key.to_sym] = {
-              :name => key.to_sym, 
-              :type => type, 
-              :class => assn.options[:polymorphic] ? nil : assn.class_name.constantize,
-              :foreign_key => assn.association_foreign_key.to_sym,
-              :is_polymorphic => !!assn.options[:polymorphic]
-            }
-          end
-        #end        
-        extjs_associations
+        @extjs_associations ||= self.reflections.inject({}) do |memo, (key, assn)|
+          type = (assn.macro === :has_many || assn.macro === :has_and_belongs_to_many) ? :many : assn.macro
+          memo[key.to_sym] = {
+            :name => key.to_sym, 
+            :type => type, 
+            :class => assn.options[:polymorphic] ? nil : assn.class_name.constantize,
+            :foreign_key => assn.association_foreign_key.to_sym,
+            :is_polymorphic => !!assn.options[:polymorphic]
+          }
+          memo
+        end
       end
     end
   end

data/lib/model/base.rb

@@ -21,23 +21,40 @@ module ExtJS
       
       ##
       # Converts a model instance to a record compatible with ExtJS
-      # @params {Mixed} params A list of fields to use instead of this Class's extjs_record_fields
       #
+      # The first parameter should be the fieldset for which the record will be returned.
+      # If no parameter is provided, then the default fieldset will be choosen
+      # Alternativly the first parameter can be a Hash with a :fields member to directly specify
+      # the fields to use for the record.
+      #
+      # All these are valid calls:
+      #
+      #  user.to_record             # returns record for :default fieldset 
+      #                             # (fieldset is autmatically defined, if not set)
+      #
+      #  user.to_record :fieldset   # returns record for :fieldset fieldset
+      #                             # (fieldset is autmatically defined, if not set)
+      #
+      #  user.to_record :fields => [:id, :password]
+      #                             # returns record for the fields 'id' and 'password'
+      # 
+      # For even more valid options for this method (which all should not be neccessary to use)
+      # have a look at ExtJS::Model::Util.extract_fieldset_and_options
       def to_record(*params)
-        fieldset, params = self.class.extjs_extract_fieldset! params
+        fieldset, options = Util.extract_fieldset_and_options params
         
         fields = []
-        if params.empty?
+        if options[:fields].empty?
           fields = self.class.extjs_get_fields_for_fieldset(fieldset)
         else
-          fields = self.class.process_fields(*params)
+          fields = self.class.process_fields(*options[:fields])
         end
         
         assns   = self.class.extjs_associations
         pk      = self.class.extjs_primary_key
         
         # build the initial field data-hash
-        data    = extjs_prepare_data(pk)
+        data    = {pk => self.send(pk)}
          
         fields.each do |field|
           next if data.has_key? field[:name] # already processed (e.g. explicit mentioning of :id)
@@ -45,25 +62,34 @@ module ExtJS
           value = nil
           if association_reflection = assns[field[:name]] # if field is an association
             association = self.send(field[:name])
+            
+            # skip this association if we already visited it
+            # otherwise we could end up in a cyclic reference
+            next if options[:visited_classes].include? association.class
+            
             case association_reflection[:type]
-            when :belongs_to
+            when :belongs_to, :has_one
               if association.respond_to? :to_record
                 assn_fields = field[:fields]
                 if assn_fields.nil?
                   assn_fields = association.class.extjs_get_fields_for_fieldset(field.fetch(:fieldset, fieldset))
                 end
-                value = association.to_record *assn_fields
+                
+                value = association.to_record :fields => assn_fields,
+                  :visited_classes => options[:visited_classes] + [self.class]
               else
                 value = {}
                 (field[:fields]||[]).each do |sub_field|
                   value[sub_field[:name]] = association.send(sub_field[:name]) if association.respond_to? sub_field[:name]
                 end
               end
-              # Append associations foreign_key to data
-              data[association_reflection[:foreign_key]] = self.send(association_reflection[:foreign_key])
-              if association_reflection[:is_polymorphic]
-                foreign_type = self.class.extjs_polymorphic_type(association_reflection[:foreign_key])
-                data[foreign_type] = self.send(foreign_type)
+              if association_reflection[:type] == :belongs_to
+                # Append associations foreign_key to data
+                data[association_reflection[:foreign_key]] = self.send(association_reflection[:foreign_key])
+                if association_reflection[:is_polymorphic]
+                  foreign_type = self.class.extjs_polymorphic_type(association_reflection[:foreign_key])
+                  data[foreign_type] = self.send(foreign_type)
+                end
               end
             when :many
               value = association.collect { |r| r.to_record }  # use carefully, can get HUGE
@@ -76,15 +102,6 @@ module ExtJS
         end
         data
       end
-      
-      ##
-      # prepares the initial data-hash.  Had to implement this to fix a MongoMapper issue where pk
-      # is an Object.  Messed things up when converting to JSON.  Perhaps a better way is possible.
-      # Any adapter can override this but typical relational dbs with Integer pks won't need to.
-      #
-      def extjs_prepare_data(pk)
-        {pk => self.send(pk)}
-      end
     end
     
     ##
@@ -95,12 +112,31 @@ module ExtJS
       # render AR columns to Ext.data.Record.create format
       # eg: {name:'foo', type: 'string'}
       #
-      def extjs_record(*fields)
-        fieldset, fields = self.extjs_extract_fieldset! fields
-        if fields.empty?
+      # The first parameter should be the fieldset for which the record definition will be returned.
+      # If no parameter is provided, then the default fieldset will be choosen
+      # Alternativly the first parameter can be a Hash with a :fields member to directly specify
+      # the fields to use for the record config.
+      #
+      # All these are valid calls:
+      #
+      #  User.extjs_record             # returns record config for :default fieldset 
+      #                                # (fieldset is autmatically defined, if not set)
+      #
+      #  User.extjs_record :fieldset   # returns record config for :fieldset fieldset
+      #                                # (fieldset is autmatically defined, if not set)
+      #
+      #  User.extjs_record :fields => [:id, :password]
+      #                                # returns record config for the fields 'id' and 'password'
+      # 
+      # For even more valid options for this method (which all should not be neccessary to use)
+      # have a look at ExtJS::Model::Util.extract_fieldset_and_options
+      def extjs_record(*params)
+        fieldset, options = Util.extract_fieldset_and_options params
+        
+        if options[:fields].empty?
           fields = self.extjs_get_fields_for_fieldset(fieldset)
         else
-          fields = self.process_fields(*fields)
+          fields = self.process_fields(*options[:fields])
         end
         
         associations  = self.extjs_associations
@@ -109,17 +145,23 @@ module ExtJS
         rs            = []
         
         fields.each do |field|
+
           field = Marshal.load(Marshal.dump(field)) # making a deep copy
           
           if col = columns[field[:name]] # <-- column on this model                
             rs << self.extjs_field(field, col)      
           elsif assn = associations[field[:name]]
+            # skip this association if we already visited it
+            # otherwise we could end up in a cyclic reference
+            next if options[:visited_classes].include? assn[:class]
+            
             assn_fields = field[:fields]
             if assn[:class].respond_to?(:extjs_record)  # <-- exec extjs_record on assn Model.
               if assn_fields.nil?
                 assn_fields = assn[:class].extjs_get_fields_for_fieldset(field.fetch(:fieldset, fieldset))
               end
-              record = assn[:class].extjs_record(field.fetch(:fieldset, fieldset), assn_fields)
+              
+              record = assn[:class].extjs_record(field.fetch(:fieldset, fieldset), { :visited_classes => options[:visited_classes] + [self], :fields => assn_fields})
               rs.concat(record[:fields].collect { |assn_field| 
                 self.extjs_field(assn_field, :parent_trail => field[:name], :mapping => field[:name], :allowBlank => true) # <-- allowBlank on associated data?
               })
@@ -170,12 +212,9 @@ module ExtJS
       # end
       #
       def extjs_fieldset(*params)
-        fieldset, params = self.extjs_extract_fieldset! params
-        # creates a method storing the fieldset-to-field association
-        # using a method and not an class-level variable because the latter
-        # is bogus when we deal with inheritance
+        fieldset, options = Util.extract_fieldset_and_options params
         var_name = :"@extjs_fieldsets__#{fieldset}"
-        self.instance_variable_set( var_name, self.process_fields(*params) )
+        self.instance_variable_set( var_name, self.process_fields(*options[:fields]) )
       end
       
       def extjs_get_fields_for_fieldset(fieldset)
@@ -194,7 +233,9 @@ module ExtJS
       # shortcut to define the default fieldset. For backwards-compatibility.
       #
       def extjs_fields(*params)
-        self.extjs_fieldset(:default, params)
+        self.extjs_fieldset(:default, {
+          :fields => params
+        })
       end
       
       ##
@@ -229,9 +270,10 @@ module ExtJS
             elsif f.has_key?(:name) # already a valid Hash, just copy it over
               fields << f
             else
-              raise ArgumentError, "encountered a Hash that I don't know anyting to do with `#{f.inspect}:#{f.class}`"
+              raise ArgumentError, "encountered a Hash that I don't know anything to do with `#{f.inspect}:#{f.class}`"
             end
           else # should be a String or Symbol
+            raise ArgumentError, "encountered a fields Array that I don't understand: #{params.inspect} -- `#{f.inspect}:#{f.class}` is not a Symbol or String" unless f.is_a?(Symbol) || f.is_a?(String)
             fields << {:name => f.to_sym}
           end
         end
@@ -239,20 +281,6 @@ module ExtJS
         fields
       end
       
-      ##
-      # returns the fieldset from the arguments. 
-      # @return [{Symbol}, Array]
-      def extjs_extract_fieldset! arguments
-        fieldset = :default
-        if arguments.size > 1 && arguments[0].is_a?(Symbol) && arguments[1].is_a?(Array)
-          fieldset = arguments.shift
-          arguments = arguments[0]
-        elsif arguments.size == 1 && arguments[0].is_a?(Symbol)
-          fieldset = arguments.shift
-        end
-        [fieldset, arguments]
-      end
-      
       ##
       # Render a column-config object
       # @param {Hash/Column} field Field-configuration Hash, probably has :name already set and possibly Ext.data.Field options.
@@ -302,6 +330,39 @@ module ExtJS
       #   @extjs_used_associations
       # end
     end
+    
+    module Util
+      
+      ##
+      # returns the fieldset from the arguments and normalizes the options. 
+      # @return [{Symbol}, {Hash}]
+      def self.extract_fieldset_and_options arguments
+        orig_args = arguments
+        fieldset = :default
+        options = { # default options
+          :visited_classes => [],
+          :fields => []
+        }
+        if arguments.size > 2 || (arguments.size == 2 && !arguments[0].is_a?(Symbol))
+          raise ArgumentError, "Don't know how to handle #{arguments.inspect}"
+        elsif arguments.size == 2 && arguments[0].is_a?(Symbol)
+          fieldset = arguments.shift
+          if arguments[0].is_a?(Array)
+            options.update({
+              :fields => arguments[0]
+            })
+          elsif arguments[0].is_a?(Hash)
+            options.update(arguments[0])
+          end
+        elsif arguments.size == 1 && arguments[0].is_a?(Symbol)
+          fieldset = arguments.shift
+        elsif arguments.size == 1 && arguments[0].is_a?(Hash)
+          fieldset = arguments[0].delete(:fieldset) || :default
+          options.update(arguments[0])
+        end
+        [fieldset, options]
+      end
+    end
   end
 end
 

data/lib/model/mongo_mapper.rb

@@ -4,12 +4,6 @@
     
 module ExtJS
   module Model
-    module InstanceMethods
-      def extjs_prepare_data(pk)
-        {pk => self.send(pk).to_s}
-      end
-    end
-    
     ##
     # ClassMethods
     #
@@ -28,19 +22,16 @@ module ExtJS
       end
 
       def extjs_associations
-        if @extjs_associations.nil?
-          @extjs_associations = {}
-          self.associations.keys.each do |key|
-            @extjs_associations[key.to_sym] = {
-              :name => key,
-              :type => self.associations[key].type,
-              :class => self.associations[key].class_name.constantize,
-              :foreign_key => self.associations[key].foreign_key,
-              :is_polymorphic => false # <-- no impl. for MM is_polymorhpic yet.  Anyone care to implement this?
-            }
-          end
+        @extjs_associations ||= self.associations.inject({}) do |memo, (key, assn)|
+          memo[key.to_sym] = {
+            :name => key.to_sym,
+            :type => assn.type,
+            :class => assn.class_name.constantize,
+            :foreign_key => assn.foreign_key,
+            :is_polymorphic => false
+          }
+          memo
         end
-        @extjs_associations
       end
 
       def extjs_type(col)

data/test/model_test.rb

@@ -166,6 +166,48 @@ class ModelTest < Test::Unit::TestCase
     end
   end
   
+  context "Person with User association (has_one relationship)" do
+    setup do
+      clean_all
+      User.extjs_fields(:id, :password)
+      Person.extjs_fields(:id, :user)
+    end
+    should "produce a valid store config" do
+      fields = Person.extjs_record[:fields]
+      assert_array_has_item(fields, 'has id') {|f| f[:name] === "id" }
+      assert_array_has_item(fields, 'has user_id') {|f| f[:name] === "user_id" and f[:mapping] == 'user.id' }
+      assert_array_has_item(fields, 'has user_password') {|f| f[:name] === "user_password"and f[:mapping] == 'user.password' }
+    end
+    should "produce a valid to_record record" do
+      person = Person.create!(:first => 'first', :last => 'last', :email => 'email')
+      user = User.create!(:person_id => person.id, :password => 'password')
+      record = person.reload.to_record
+      assert_equal(person.id, record[:id])
+      assert_equal(user.id, record[:user][:id])
+      assert_equal('password', record[:user][:password])
+    end
+  end
+  
+  context "Person with User association (has_one/belongs_to relationship) cyclic reference" do
+    setup do
+      clean_all
+      User.extjs_fields(:id, :person)
+      Person.extjs_fields(:id, :user)
+    end
+    should "produce a valid store config for Person" do
+      fields = Person.extjs_record[:fields]
+      assert_array_has_item(fields, 'has id') {|f| f[:name] === "id" }
+      assert_array_has_item(fields, 'has user_id') {|f| f[:name] === "user_id" and f[:mapping] == 'user.id' }
+    end
+    should "produce a valid to_record record for Person" do
+      person = Person.create!(:first => 'first', :last => 'last', :email => 'email')
+      user = User.create!(:person_id => person.id, :password => 'password')
+      record = person.reload.to_record
+      assert_equal(person.id, record[:id])
+      assert_equal(user.id, record[:user][:id])
+    end
+  end
+  
   context "Fields should render with correct, ExtJS-compatible data-types" do
     setup do
       clean_all
@@ -204,7 +246,7 @@ class ModelTest < Test::Unit::TestCase
     end
   end
   
-  context "polymorphic assosiations" do
+  context "polymorphic associations" do
     setup do
       clean_all
     end
@@ -220,7 +262,7 @@ class ModelTest < Test::Unit::TestCase
       assert_array_has_item(fields, 'addressable_type') {|f| f[:name] === 'addressable_type' && !f[:mapping] }
     end
     
-    should "create the right store config when including members of the polymorpic association" do
+    should "create the right store config when including members of the polymorphic association" do
       Address.extjs_fields :street, :addressable => [:name]
       fields = Address.extjs_record[:fields]
       assert_array_has_item(fields, "has addressable_name") {|f| f[:name] === 'addressable_name' && f[:mapping] === 'addressable.name'}
@@ -246,13 +288,13 @@ class ModelTest < Test::Unit::TestCase
       clean_all
     end
     
-    should "fieldsets should be accessible from decendants" do
+    should "fieldsets should be accessible from descendants" do
       Location.extjs_fieldset :on_location, [:street]
       fields = House.extjs_record(:on_location)[:fields]
       assert_array_has_item(fields, 'has street') {|f| f[:name] === 'street' }
       assert_array_has_not_item(fields, 'has name') {|f| f[:name] === 'name' }
     end
-    should "fieldsets should be overrideable from decendants" do
+    should "fieldsets should be overrideable from descendants" do
       Location.extjs_fieldset :override, [:street]
       House.extjs_fieldset :override, [:name]
       fields = House.extjs_record(:override)[:fields]
@@ -261,11 +303,11 @@ class ModelTest < Test::Unit::TestCase
     end
   end
   
-  context "ExtJS::Model::ClassMethods" do
-
-    context "#extjs_extract_fieldset! default" do
+  context "ExtJS::Model::Util" do
+    context "#extract_fieldset_and_options default" do
       setup do
-        @fieldset, @fields = BogusModel.extjs_extract_fieldset! [:one, :two, :three]
+        @fieldset, @options = ExtJS::Model::Util.extract_fieldset_and_options [:fields => [:one, :two, :three]]
+        @fields = @options[:fields]
       end
       should "return :default when no fieldset provided" do
         assert_equal(:'default', @fieldset)
@@ -275,9 +317,10 @@ class ModelTest < Test::Unit::TestCase
       end
     end
 
-    context "#extjs_extract_fieldset! with explicit fieldset definition" do
+    context "#extract_fieldset_and_options with explicit fieldset definition and array with fields" do
       setup do
-        @fieldset, @fields = BogusModel.extjs_extract_fieldset! [:explicit, [:one, :two, :three]]
+        @fieldset, @options = ExtJS::Model::Util.extract_fieldset_and_options [:explicit, [:one, :two, :three]]
+        @fields = @options[:fields]
       end
       should "return :default when no fieldset provided" do
         assert_equal(:'explicit', @fieldset)
@@ -287,18 +330,55 @@ class ModelTest < Test::Unit::TestCase
       end
     end
     
-    context "#extjs_extract_fieldset! edge cases" do
+    context "#extract_fieldset_and_options with explicit fieldset definition and hash with fields" do
+      setup do
+        @fieldset, @options = ExtJS::Model::Util.extract_fieldset_and_options [:explicit, {:fields => [:one, :two, :three]}]
+        @fields = @options[:fields]
+      end
+      should "return :default when no fieldset provided" do
+        assert_equal(:'explicit', @fieldset)
+      end
+      should "not alter the fields array" do
+        assert_equal([:one, :two, :three], @fields)
+      end
+    end
+    
+    context "#extract_fieldset_and_options with only a hash" do
+      setup do
+        @fieldset, @options = ExtJS::Model::Util.extract_fieldset_and_options [{:fieldset => :explicit, :fields => [:one, :two, :three]}]
+        @fields = @options[:fields]
+      end
+      should "return :default when no fieldset provided" do
+        assert_equal(:'explicit', @fieldset)
+      end
+      should "not alter the fields array" do
+        assert_equal([:one, :two, :three], @fields)
+      end
+    end
+    
+    context "#extract_fieldset_and_options edge cases" do
       should "called without arguments" do
-        @fieldset, @fields = BogusModel.extjs_extract_fieldset! []
+        @fieldset, @options = ExtJS::Model::Util.extract_fieldset_and_options []
+        @fields = @options[:fields]
         assert_equal(:'default', @fieldset)
         assert_equal([], @fields)
       end
       should "called with only the fieldset and no field arguments" do
-        @fieldset, @fields = BogusModel.extjs_extract_fieldset! [:explicit]
+        @fieldset, @options = ExtJS::Model::Util.extract_fieldset_and_options [:explicit]
+        @fields = @options[:fields]
         assert_equal(:'explicit', @fieldset)
         assert_equal([], @fields)
       end
+      should "raise error when called with more than 2 arguments" do
+        assert_raise(ArgumentError) { ExtJS::Model::Util.extract_fieldset_and_options [:explicit, :some, {}] }
+      end
+      should "raise error when called with 2 arguments and the first one is no symbol" do
+        assert_raise(ArgumentError) { ExtJS::Model::Util.extract_fieldset_and_options [{ :fields => [] }, :explicit] }
+      end
     end
+  end
+  
+  context "ExtJS::Model::ClassMethods" do
     
     context "#process_fields" do
       should "handle a simple Array of Symbols" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: extjs-mvc
 version: !ruby/object:Gem::Version 
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors: 
 - Chris Scott
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-20 00:00:00 -05:00
+date: 2010-02-21 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency