extjs-mvc 0.2.5 → 0.2.6

data/README.rdoc

@@ -1,5 +1,6 @@
 = mvc
 
+
 A collection of helpers, MVC mixins and PORs (plain-old-ruby-object) to assist with auto-generating ExtJS javascript component definitions.
 
 
@@ -23,6 +24,11 @@ fields with will be used to render the <tt>Ext.data.Record.create</tt> field-def
       include ExtJS::Model
 
       extjs_fields :exclude => [:password, :password_confirmation]
+      # OR
+      extjs_fields :name, :description
+      # OR
+      extjs_fields :name, :description, :parent => [:name, :date]
+      # this would configure associated columns with names like "parent__name" and "parent__date")
     end
 
 In script/console

data/VERSION

@@ -1 +1 @@
-0.2.5
+0.2.6

data/lib/extjs/component.rb

@@ -55,7 +55,7 @@ class ExtJS::Component
     end
   end
 
-  def to_json(*args)
+  def to_json
     config.to_json
   end
 

data/lib/extjs/data/store.rb

@@ -57,7 +57,7 @@ module ExtJS::Data
       if @writer  # <-- ugly hack because 3.0.1 can't deal with Writer as config-param
         json = @config.to_json
         json[json.length-1] = ','
-        json += "writer:new Ext.data.#{@format.capitalize}Writer(#{@writer.to_json})}"
+        json += "\"writer\":new Ext.data.#{@format.capitalize}Writer(#{@writer.to_json})}"
         "<script>new #{@type}(#{json});#{script}</script>"
       else
         "<script>new #{@type}(#{@config.to_json});#{script}</script>"

data/lib/extjs-mvc.rb

@@ -7,14 +7,15 @@ module ExtJS
       cattr_accessor :message_property
       cattr_accessor :root
       
+      require 'model/base'
       
       # Detect orm, include appropriate mixin.
       if defined?(ActiveRecord)
-        require 'model/active_record/model'
+        require 'model/active_record'
       elsif defined?(DataMapper)
-        require 'model/dm/model'
+        require 'model/data_mapper'
       elsif defined?(MongoMapper)
-        require 'model/mongo_mapper/model'
+        require 'model/mongo_mapper'
       end
 
       # Rails-style Array#extract_options! used heavily

data/lib/model/active_record.rb

@@ -0,0 +1,44 @@
+module ExtJS
+  module Model
+    module ClassMethods
+      
+      def extjs_primary_key
+        self.primary_key
+      end
+      
+      def extjs_column_names
+        self.column_names
+      end
+      
+      def extjs_columns_hash
+        self.columns_hash
+      end
+      
+      def extjs_render_column(col)
+        type = col.type
+        case type
+          when :datetime || :date || :time || :timestamp
+            type = :date
+          when :text
+            type = :string
+          when :integer
+            type = :int
+        end
+        {:name => col.name, :allowBlank => (col.primary) ? true : col.null, :type => type}        
+      end
+      
+      def extjs_associations
+        if @extjs_associations.nil?
+          @extjs_associations = {}
+          self.reflections.keys.each do |key|
+            assn = self.reflections[key]
+            type = (assn.macro === :has_many) ? :many : assn.macro
+            @extjs_associations[key.to_sym] = {:name => key, :type => type}
+          end
+        end        
+        @extjs_associations
+      end
+    end
+  end
+end
+

data/lib/model/base.rb

@@ -0,0 +1,118 @@
+module ExtJS
+  module Model
+    
+    def self.included(model)
+      model.send(:extend, ClassMethods)
+      model.send(:include, InstanceMethods)
+      model.class_eval do
+        cattr_accessor :extjs_record_fields
+      end
+      model.extjs_record_fields = []
+    end
+
+    ##
+    # InstanceMethods
+    #
+    module InstanceMethods
+      
+      def to_record
+        pk = self.class.extjs_primary_key
+        assns = self.class.extjs_associations
+        
+        data = {pk => self.send(pk)}
+        self.class.extjs_record_fields.each do |f|
+          if refl = assns[f]
+            if refl[:type] === :belongs_to
+              assn = self.send(f)
+              data[f] = (assn) ? assn.to_record : {} # <-- a thing was requested, give emtpy thing.
+            elsif refl[:type] === :many
+              data[f] = self.send(f).collect {|r| r.to_record}  #CAREFUL!!!!!!!!!!!!1
+            end
+          elsif f.is_a? Array
+            value = self
+            f.each do |method|
+              value = value.send(method)
+              break if value.nil?
+            end
+            data[f.join('__')] = value
+          else
+            data[f] = self.send(f)
+          end
+        end
+        data
+      end
+    end
+    
+    ##
+    # ClassMethods
+    #
+    module ClassMethods
+      ##
+      # render AR columns to Ext.data.Record.create format
+      # eg: {name:'foo', type: 'string'}
+      #
+      def extjs_record
+        
+        if self.extjs_record_fields.empty?
+          self.extjs_record_fields = self.extjs_column_names
+        end
+
+        pk = self.extjs_primary_key
+        columns = self.extjs_columns_hash
+        associations = self.extjs_associations
+        
+        return {
+          "fields" => self.extjs_record_fields.collect {|f|
+            if columns[f.to_sym] || columns[f.to_s]
+              field = self.extjs_render_column(columns[f.to_sym] || columns[f.to_s])
+              field[:dateFormat] = "c" if field[:type] === :date  # <-- ugly hack for date
+              field
+            elsif assn = associations[f]
+              field = {:name => f, :allowBlank => true, :type => 'auto'}
+            elsif f.is_a? Array
+              field = {:name => f.join('__'), :type => 'auto'}
+            else # property is a method?
+              field = {:name => f, :allowBlank => true, :type => 'auto'}
+            end
+          },
+          "idProperty" => pk
+        }
+      end
+      
+      def extjs_fields(*params)
+        options = params.extract_options!
+        if !options.keys.empty?
+          if excludes = options.delete(:exclude)
+            self.extjs_record_fields = self.extjs_column_names.reject {|c| excludes.find {|ex| c === ex.to_s}}.collect {|c| c}
+          elsif only = options.delete(:only)
+            self.extjs_record_fields = only
+          end
+          self.extjs_record_fields.concat(process_association_fields(options))
+        elsif params.empty?
+          return self.extjs_record_fields
+        end
+
+        self.extjs_record_fields.concat(params) if !params.empty?
+
+        #Append primary key if it's not included
+        # I don't think we want to automatically include :id
+        # Chris
+        #self.extjs_record_fields << self.primary_key.to_sym if !self.extjs_record_fields.include?(self.primary_key.to_sym)
+      end
+      
+      ##
+      # Prepare the config for fields with '.' in their names
+      #
+      def process_association_fields(options)
+        results = []
+        options.each do |assoc, fields|
+          fields.each do |field|
+            results << [assoc, field]
+          end
+        end
+        results
+      end
+    end
+  end
+end
+

data/lib/model/data_mapper.rb

@@ -0,0 +1,55 @@
+module ExtJS
+  module Model
+    module ClassMethods
+      
+      def extjs_primary_key
+        self.key.first.name
+      end
+      
+      def extjs_column_names
+        self.properties.collect {|p| p.name.to_s }
+      end
+      
+      def extjs_columns_hash
+        if @extjs_columns_hash.nil?
+          @extjs_columns_hash = {}
+          self.properties.each do |p|
+            @extjs_columns_hash[p.name] = p
+          end
+        end
+        @extjs_columns_hash
+      end
+      
+      def extjs_render_column(col)
+        pk = self.key.first
+        type = ((col.type.respond_to?(:primitive)) ? col.type.primitive : col.type).to_s
+        case type
+          when "DateTime", "Date", "Time"
+            type = :date
+          when "String"
+            type = :string
+          when "Float"
+            type = :float
+          when "Integer", "BigDecimal"
+            type = :int
+          else
+            type = "auto"
+        end 
+        {:name => col.name.to_s, :type => type, :allowBlank => (col === pk) ? true : col.nullable? }
+      end
+      
+      def extjs_associations
+        if @extjs_associations.nil?  
+          @extjs_associations = {}
+          self.relationships.keys.each do |key|
+            assn = self.relationships[key]
+            type = (assn.options[:max].nil? && assn.options[:min].nil?) ? :belongs_to : (assn.options[:max] > 1) ? :many : nil 
+            @extjs_associations[key.to_sym] = {:name => key, :type => type}
+          end
+        end
+        @extjs_associations
+      end
+    end
+  end
+end
+

data/lib/model/mongo_mapper.rb

@@ -0,0 +1,49 @@
+module ExtJS
+  module Model
+    ##
+    # ClassMethods
+    #
+    module ClassMethods
+      
+      def extjs_primary_key
+        "id"
+      end
+      
+      def extjs_column_names
+        self.column_names
+      end
+      
+      def extjs_columns_hash
+        self.keys
+      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}
+          end
+        end
+        @extjs_associations
+      end
+      
+      def extjs_render_column(col)
+        type = col.type.to_s
+        case type
+          when "DateTime", "Date", "Time"
+            type = :date
+          when "String"
+            type = :string
+          when "Float"
+            type = :float
+          when "Integer", "BigDecimal"
+            type = :int
+          else
+            type = "auto"
+        end 
+        {:name => col.name, :type => type, :allowBlank => (col.name === '_id') ? true : (col.options[:required] === true) ? false : true }
+      end
+    end
+  end
+end
+

data/test/model_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class TestParent < ActiveRecord::Base
+
+end
+
+class TestModel < ActiveRecord::Base
+  include ExtJS::Model
+  belongs_to :test_parent
+
+  #for the EXT Store configuration
+  extjs_fields :name, :test_parent => [:name]
+end
+
+class ModelTest < Test::Unit::TestCase
+  def test_field_list_for_associations
+    assert_equal [[:test_parent, :name], :name, :id], TestModel.extjs_fields
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: extjs-mvc
 version: !ruby/object:Gem::Version 
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors: 
 - Chris Scott
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-25 00:00:00 -04:00
+date: 2009-11-17 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,9 +45,10 @@ files:
 - lib/extjs/data/store.rb
 - lib/helpers/component.rb
 - lib/helpers/store.rb
-- lib/model/active_record/model.rb
-- lib/model/dm/model.rb
-- lib/model/mongo_mapper/model.rb
+- lib/model/active_record.rb
+- lib/model/base.rb
+- lib/model/data_mapper.rb
+- lib/model/mongo_mapper.rb
 - test/component_test.rb
 - test/controller_test.rb
 - test/model_test.rb

data/lib/model/active_record/model.rb

@@ -1,90 +0,0 @@
-module ExtJS
-  module Model
-    def self.included(model)
-      model.send(:extend, ClassMethods)
-      model.send(:include, InstanceMethods)
-      model.class_eval do
-        cattr_accessor :extjs_record_fields
-      end
-      model.extjs_record_fields = []
-    end
-
-    ##
-    # InstanceMethods
-    #
-    module InstanceMethods
-      def to_record
-        data = {self.class.primary_key => self.send(self.class.primary_key)}
-        self.class.extjs_record_fields.each do |f|
-          if refl = self.class.reflections[f]
-            if refl.macro === :belongs_to
-	      assn = self.send(f)
-              data[f] = (assn) ? assn.to_record : {} # <-- a thing was requested, give emtpy thing.
-            elsif refl.macro === :has_many
-	      #data[f] = self.send(f).collect {|r| r.to_record}  CAREFUL!!!!!!!!!!!!1
-            end
-          else
-            data[f] = self.send(f)
-          end
-        end
-        data
-      end
-    end
-    ##
-    # ClassMethods
-    #
-    module ClassMethods
-      ##
-      # Defines the subset of AR columns used to create Ext.data.Record def'n.
-      # @param {Array/Hash} list-of-fields to include, :only, or :exclude
-      #
-      def extjs_fields(*params)
-        options = params.extract_options!
-        if !options.keys.empty?
-          if options[:exclude]
-            self.extjs_record_fields = self.columns.reject {|c| options[:exclude].find {|ex| c.name.to_sym === ex}}.collect {|c| c.name.to_sym}
-          end
-        elsif !params.empty?
-          self.extjs_record_fields = params
-        else
-          self.extjs_record_fields
-        end
-      end
-
-      ##
-      # render AR columns to Ext.data.Record.create format
-      # eg: {name:'foo', type: 'string'}
-      #
-      def extjs_record
-        if self.extjs_record_fields.empty?
-          self.extjs_record_fields = self.columns.collect {|c| c.name.to_sym }
-          self.extjs_record_fields.concat(self.reflect_on_all_associations.collect {|assn| assn.name})
-        end
-
-        return {
-          "fields" => self.extjs_record_fields.collect {|f|
-            if col = self.columns_hash[f.to_s]
-              type = col.type
-              case col.type
-                when :datetime || :date || :time || :timestamp
-                  type = :date
-                when :text
-                  type = :string
-                when :integer
-                  type = :int
-              end
-              field = {:name => col.name, :allowBlank => (col.primary) ? true : col.null, :type => type}
-              field[:dateFormat] = "c" if col.type === :datetime || col.type === :date  # <-- ugly hack for date
-              field
-            elsif self.reflections[f]
-              assn = self.reflections[f]
-              field = {:name => assn.name, :allowBlank => true, :type => 'auto'}
-            end
-          },
-          "idProperty" => self.primary_key
-        }
-      end
-    end
-  end
-end
-

data/lib/model/dm/model.rb

@@ -1,98 +0,0 @@
-module ExtJS
-  module Model
-    def self.included(model)
-      model.send(:extend, ClassMethods)
-      model.send(:include, InstanceMethods)
-      model.class_eval do
-        cattr_accessor :extjs_record_fields
-      end
-      model.extjs_record_fields = []
-    end
-
-    ##
-    # InstanceMethods
-    #
-    module InstanceMethods
-      def to_record
-        properties = self.class.properties
-        pk = self.class.key.first.name
-        
-        data = {pk => self.send(pk)}
-        self.class.extjs_record_fields.each do |f|
-          if refl = self.class.relationships[f]
-            if refl.options[:max].nil? && refl.options[:min].nil? # belongs_to
-              assn = self.send(f)
-              data[f] = (assn) ? assn.to_record : {} # <-- a thing was requested, give emtpy thing.
-            elsif refl.options[:max] > 1
-              data[f] = self.send(f).collect {|r| r.to_record}  #CAREFUL!!!!!!!!!!!!1
-            end
-          else
-            data[f] = self.send(f)
-          end
-        end
-        data
-      end
-    end
-    ##
-    # ClassMethods
-    #
-    module ClassMethods
-      ##
-      # Defines the subset of AR columns used to create Ext.data.Record def'n.
-      # @param {Array/Hash} list-of-fields to include, :only, or :exclude
-      #
-      def extjs_fields(*params)
-        options = params.extract_options!
-        if !options.keys.empty?
-          if options[:exclude]
-            self.extjs_record_fields = self.properties.reject {|p| options[:exclude].find {|ex| p.name === ex}}.collect {|p| p.name}
-          end
-        elsif !params.empty?
-          self.extjs_record_fields = params
-        else
-          self.extjs_record_fields
-        end
-      end
-
-      ##
-      # render AR columns to Ext.data.Record.create format
-      # eg: {name:'foo', type: 'string'}
-      #
-      def extjs_record
-        if self.extjs_record_fields.empty?
-          self.extjs_record_fields = self.properties.collect {|p| p.name}
-        end
-
-        pk = self.key.first
-
-        return {
-          "fields" => self.extjs_record_fields.collect {|f|
-            if self.properties.has_property?(f)
-              col = self.properties[f]
-              type = ((col.type.respond_to?(:primitive)) ? col.type.primitive : col.type).to_s
-              case type
-                when "DateTime", "Date", "Time"
-                  type = :date
-                when "String"
-                  type = :string
-                when "Float"
-                  type = :float
-                when "Integer", "BigDecimal"
-                  type = :int
-              end
-              field = {:name => col.name, :allowBlank => (col === pk) ? true : col.nullable?, :type => type}
-              field[:dateFormat] = "c" if type === :date  # <-- ugly hack for date
-              field
-            elsif assn = self.relationships[f]
-              field = {:name => f, :allowBlank => true, :type => 'auto'}
-            else # property is a method?
-              field = {:name => f, :allowBlank => true, :type => 'auto'}
-            end
-          },
-          "idProperty" => pk.name
-        }
-      end
-    end
-  end
-end
-

data/lib/model/mongo_mapper/model.rb

@@ -1,102 +0,0 @@
-module ExtJS
-  module Model
-    
-    def self.included(model)
-      model.send(:extend, ClassMethods)
-      model.send(:include, InstanceMethods)
-      model.class_eval do
-        cattr_accessor :extjs_record_fields
-      end
-      model.extjs_record_fields = []
-    end
-
-    ##
-    # InstanceMethods
-    #
-    module InstanceMethods
-      def to_record
-        properties = self.class.column_names
-        pk = "id"
-        
-        data = {pk => self.send(pk)}
-        self.class.extjs_record_fields.each do |f|
-          if refl = self.class.associations[f]
-            if refl.type === :belongs_to
-              assn = self.send(f)
-              data[f] = (assn) ? assn.to_record : {} # <-- a thing was requested, give emtpy thing.
-            elsif refl.type === :many
-              data[f] = self.send(f).collect {|r| r.to_record}  #CAREFUL!!!!!!!!!!!!1
-            end
-          else
-            data[f] = self.send(f)
-          end
-        end
-        data
-      end
-    end
-    ##
-    # ClassMethods
-    #
-    module ClassMethods
-      ##
-      # Defines the subset of AR columns used to create Ext.data.Record def'n.
-      # @param {Array/Hash} list-of-fields to include, :only, or :exclude
-      #
-      def extjs_fields(*params)
-        options = params.extract_options!
-        if !options.keys.empty?
-          if options[:exclude]
-            self.extjs_record_fields = self.column_names.reject {|p| options[:exclude].find {|ex| p === ex.to_s}}.collect {|p| p}
-          end
-        elsif !params.empty?
-          self.extjs_record_fields = params
-        else
-          self.extjs_record_fields
-        end
-      end
-
-      ##
-      # render AR columns to Ext.data.Record.create format
-      # eg: {name:'foo', type: 'string'}
-      #
-      def extjs_record
-        if self.extjs_record_fields.empty?
-          self.extjs_record_fields = self.column_names
-        end
-
-        pk = "_id"
-
-        return {
-          "fields" => self.extjs_record_fields.collect {|f|
-            if self.keys[f]
-            
-              col = self.keys[f]
-              type = col.type.to_s
-              case type
-                when "DateTime", "Date", "Time"
-                  type = :date
-                when "String"
-                  type = :string
-                when "Float"
-                  type = :float
-                when "Integer", "BigDecimal"
-                  type = :int
-                else
-                  type = "auto"
-              end
-              field = {:name => col.name, :allowBlank => (col.name === pk) ? true : !col.options[:required] === true, :type => type}
-              field[:dateFormat] = "c" if type === :date  # <-- ugly hack for date
-              field
-            elsif assn = self.associations[f.to_sym]
-              field = {:name => f, :allowBlank => true, :type => 'auto'}
-            else # property is a method?
-              field = {:name => f, :allowBlank => true, :type => 'auto'}
-            end
-          },
-          "idProperty" => "id"
-        }
-      end
-    end
-  end
-end
-