whorm 0.4.0

data/lib/whorm/model.rb

@@ -0,0 +1,370 @@
+module Whorm
+  module Model
+    
+    def self.included(model)
+      model.send(:extend, ClassMethods)
+      model.send(:include, InstanceMethods)
+      ##
+      # @config {String} whorm_parent_trail_template This a template used to render mapped field-names.
+      # Default is Proc.new{ |field_name| "_#{field_name}" }
+      # You could also use the Rails standard
+      # Proc.new{ |field_name| "[#{field_name}]" }
+      #
+      model.cattr_accessor :whorm_parent_trail_template
+      model.whorm_parent_trail_template = Proc.new{ |field_name| "_#{field_name}" } if model.whorm_parent_trail_template.nil?
+    end
+
+    ##
+    # InstanceMethods
+    #
+    module InstanceMethods
+      
+      ##
+      # Converts a model instance to a record compatible with javascript applications
+      #
+      # 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 Whorm::Model::Util.extract_fieldset_and_options
+      def to_record(*params)
+        fieldset, options = Util.extract_fieldset_and_options params
+        
+        fields = []
+        if options[:fields].empty?
+          fields = self.class.whorm_get_fields_for_fieldset(fieldset)
+        else
+          fields = self.class.process_fields(*options[:fields])
+        end
+        
+        assns   = self.class.whorm_associations
+        pk      = self.class.whorm_primary_key
+        
+        # build the initial field data-hash
+        data    = {pk => self.send(pk)}
+         
+        fields.each do |field|
+          next if data.has_key? field[:name] # already processed (e.g. explicit mentioning of :id)
+          
+          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, :has_one
+              if association.respond_to? :to_record
+                assn_fields = field[:fields]
+                if assn_fields.nil?
+                  assn_fields = association.class.whorm_get_fields_for_fieldset(field.fetch(:fieldset, fieldset))
+                end
+                
+                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
+              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.whorm_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
+            end
+          else # not an association -> get the method's value
+            value = self.send(field[:name])
+            value = value.to_record if value.respond_to? :to_record
+          end
+          data[field[:name]] = value
+        end
+        data
+      end
+    end
+    
+    ##
+    # ClassMethods
+    #
+    module ClassMethods
+      ##
+      # render AR columns to Ext.data.Record.create format
+      # eg: {name:'foo', type: 'string'}
+      #
+      # 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.whorm_schema             # returns record config for :default fieldset 
+      #                                # (fieldset is autmatically defined, if not set)
+      #
+      #  User.whorm_schema :fieldset   # returns record config for :fieldset fieldset
+      #                                # (fieldset is autmatically defined, if not set)
+      #
+      #  User.whorm_schema :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 Whorm::Model::Util.extract_fieldset_and_options
+      def whorm_schema(*params)
+        fieldset, options = Util.extract_fieldset_and_options params
+        
+        if options[:fields].empty?
+          fields = self.whorm_get_fields_for_fieldset(fieldset)
+        else
+          fields = self.process_fields(*options[:fields])
+        end
+        
+        associations  = self.whorm_associations
+        columns       = self.whorm_columns_hash
+        pk            = self.whorm_primary_key
+        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.whorm_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?(:whorm_schema)  # <-- exec whorm_schema on assn Model.
+              if assn_fields.nil?
+                assn_fields = assn[:class].whorm_get_fields_for_fieldset(field.fetch(:fieldset, fieldset))
+              end
+              
+              record = assn[:class].whorm_schema(field.fetch(:fieldset, fieldset), { :visited_classes => options[:visited_classes] + [self], :fields => assn_fields})
+              rs.concat(record[:fields].collect { |assn_field| 
+                self.whorm_field(assn_field, :parent_trail => field[:name], :mapping => field[:name], :allowBlank => true) # <-- allowBlank on associated data?
+              })
+            elsif assn_fields  # <-- :parent => [:id, :name, :sub => [:id, :name]]
+              field_collector = Proc.new do |parent_trail, mapping, assn_field|
+                if assn_field.is_a?(Hash) && assn_field.keys.size == 1 && assn_field.keys[0].is_a?(Symbol) && assn_field.values[0].is_a?(Array)
+                  field_collector.call(parent_trail.to_s + self.whorm_parent_trail_template.call(assn_field.keys.first), "#{mapping}.#{assn_field.keys.first}", assn_field.values.first) 
+                else
+                  self.whorm_field(assn_field, :parent_trail => parent_trail, :mapping => mapping, :allowBlank => true)
+                end
+              end
+              rs.concat(assn_fields.collect { |assn_field| field_collector.call(field[:name], field[:name], assn_field) })
+            else  
+              rs << whorm_field(field)
+            end
+            
+            # attach association's foreign_key if not already included.
+            if columns.has_key?(assn[:foreign_key]) && !rs.any? { |r| r[:name] == assn[:foreign_key] }
+              rs << whorm_field({:name => assn[:foreign_key]}, columns[assn[:foreign_key]])
+            end
+            # attach association's type if polymorphic association and not alredy included
+            if assn[:is_polymorphic]
+              foreign_type = self.whorm_polymorphic_type(assn[:foreign_key])
+              if columns.has_key?(foreign_type) && !rs.any? { |r| r[:name] == foreign_type }
+                rs << whorm_field({:name => foreign_type}, columns[foreign_type])
+              end
+            end
+          else # property is a method?
+            rs << whorm_field(field)
+          end
+        end
+        
+        return {
+          :fields => rs,
+          :idProperty => pk
+        }
+      end
+      
+      ##
+      # meant to be used within a Model to define the whorm record fields.
+      # eg:
+      # class User
+      #   whorm_fieldset :grid, [:first, :last, :email => {"sortDir" => "ASC"}, :company => [:id, :name]]
+      # end
+      # or
+      # class User
+      #   whorm_fieldset :last, :email => {"sortDir" => "ASC"}, :company => [:id, :name] # => implies fieldset name :default
+      # end
+      #
+      def whorm_fieldset(*params)
+        fieldset, options = Util.extract_fieldset_and_options params
+        var_name = :"@whorm_fieldsets__#{fieldset}"
+        self.instance_variable_set( var_name, self.process_fields(*options[:fields]) )
+      end
+      
+      def whorm_get_fields_for_fieldset(fieldset)
+        var_name = :"@whorm_fieldsets__#{fieldset}"
+        super_value = nil
+        unless self.instance_variable_get( var_name )
+          if self.superclass.respond_to? :whorm_get_fields_for_fieldset
+            super_value = self.superclass.whorm_get_fields_for_fieldset(fieldset)
+          end
+          self.whorm_fieldset(fieldset, self.whorm_column_names) unless super_value
+        end
+        super_value || self.instance_variable_get( var_name )
+      end
+      
+      ##
+      # shortcut to define the default fieldset. For backwards-compatibility.
+      #
+      def whorm_fields(*params)
+        self.whorm_fieldset(:default, {
+          :fields => params
+        })
+      end
+      
+      ##
+      # Prepare a field configuration list into a normalized array of Hashes, {:name => "field_name"} 
+      # @param {Mixed} params
+      # @return {Array} of Hashes
+      #
+      def process_fields(*params)
+        fields = []
+        if params.size == 1 && params.last.is_a?(Hash) # peek into argument to see if its an option hash
+          options = params.last
+          if options.has_key?(:additional) && options[:additional].is_a?(Array)
+            return self.process_fields(*(self.whorm_column_names + options[:additional].map(&:to_sym)))
+          elsif options.has_key?(:exclude) && options[:exclude].is_a?(Array)
+            return self.process_fields(*(self.whorm_column_names - options[:exclude].map(&:to_sym)))
+          elsif options.has_key?(:only) && options[:only].is_a?(Array)
+            return self.process_fields(*options[:only])
+          end
+        end
+        
+        params = self.whorm_column_names if params.empty?
+        
+        associations = whorm_associations
+        
+        params.each do |f|
+          if f.kind_of?(Hash)
+            if f.keys.size == 1 && f.keys[0].is_a?(Symbol) && f.values[0].is_a?(Array) # {:association => [:field1, :field2]}
+              fields << {
+                :name => f.keys[0],
+                :fields => process_fields(*f.values[0])
+              }
+            elsif f.keys.size == 1 && f.keys[0].is_a?(Symbol) && f.values[0].is_a?(Hash) # {:field => {:sortDir => 'ASC'}}
+              fields << f.values[0].update(:name => f.keys[0])
+            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 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
+        
+        fields
+      end
+      
+      ##
+      # Render a column-config object
+      # @param {Hash/Column} field Field-configuration Hash, probably has :name already set and possibly Ext.data.Field options.
+      # @param {ORM Column Object from AR, DM or MM}
+      #
+      def whorm_field(field, config=nil)  
+        if config.kind_of? Hash
+          if config.has_key?(:mapping) && config.has_key?(:parent_trail)
+            field.update( # <-- We use a template for rendering mapped field-names.
+              :name => config[:parent_trail].to_s + self.whorm_parent_trail_template.call(field[:name]),
+              :mapping => "#{config[:mapping]}.#{field[:name]}"
+            )
+          end
+          field.update(config.except(:mapping, :parent_trail))
+        elsif !config.nil?  # <-- Hopfully an ORM Column object.
+          field.update(
+            :allowBlank => self.whorm_allow_blank(config),
+            :type => self.whorm_type(config),
+            :defaultValue => self.whorm_default(config)
+          )
+          field[:dateFormat] = "c" if field[:type] === "date" && field[:dateFormat].nil? # <-- ugly hack for date  
+        end  
+        field.update(:type => "auto") if field[:type].nil?
+        # convert Symbol values to String values
+        field.keys.each do |k|
+          raise ArgumentError, "whorm_field expects a Hash as first parameter with all it's keys Symbols. Found key #{k.inspect}:#{k.class.to_s}" unless k.is_a?(Symbol)
+          field[k] = field[k].to_s if field[k].is_a?(Symbol)
+        end
+        field
+      end
+
+      # ##
+      # # Returns an array of symbolized association names that will be referenced by a call to to_record
+      # # i.e. [:parent1, :parent2]
+      # #
+      # def whorm_used_associations
+      #   if @whorm_used_associations.nil?
+      #     assoc = []
+      #     self.whorm_record_fields.each do |f|
+      #       #This needs to be the first condition because the others will break if f is an Array
+      #       if whorm_associations[f[:name]]
+      #         assoc << f[:name]
+      #       end
+      #     end
+      #     @whorm_used_associations = assoc.uniq
+      #   end
+      #   @whorm_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) || arguments[0].is_a?(String))
+          fieldset = arguments.shift.to_sym
+        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/test/app/config/application.rb

@@ -0,0 +1,70 @@
+# TODO: Figure out how to iterate each ORM framework AR, DM, MM and test each.
+require 'active_record'
+require 'active_support'
+require 'whorm'
+require 'extlib/inflection'
+
+gem 'sqlite3-ruby'
+
+class Test::App
+  
+  attr_reader :models
+  
+  def initialize(orm = :active_record)
+    @orm = orm
+    @config = YAML::load(IO.read("#{ROOT}/config/database.yml"))
+    
+    # Load ORM
+    send("boot_#{orm.to_s}")
+    
+    load_models
+
+    require 'db/schema'
+    
+  end
+  
+  ##
+  # Reset a model's @whorm_fieldsets
+  #
+  def clean_all
+    @models.map { |klass| clean klass }
+  end
+  
+  
+private
+  
+  def boot_active_record
+    ActiveRecord::Base.establish_connection(@config['test'])
+  end
+  
+  def boot_mongo_mapper
+    
+  end
+  
+  def boot_data_mapper
+    
+  end
+  
+  ##
+  # Do a dir on /models and constantize each filename
+  #
+  def load_models
+    @models = []
+    # Load Models and Schema for corresponding orm
+    re = /^.*\/(.*).rb$/
+    Dir["#{ROOT}/models/#{@orm.to_s}/*"].each { |c| 
+        require c 
+        match = c.match(re)
+        @models << Extlib::Inflection.constantize(Extlib::Inflection.camelize(match[1])) if match
+    }
+  end
+  
+  def clean klass
+    klass.instance_variables.each do |var_name|
+      if /\A@whorm_fieldsets__/ =~ var_name.to_s
+        klass.instance_variable_set( var_name.to_sym, nil )
+      end
+    end
+  end
+  
+end

data/test/app/config/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: ":memory:"

data/test/app/db/schema.rb

@@ -0,0 +1,75 @@
+
+##
+# build simple database
+#
+# people
+#
+ActiveRecord::Base.connection.create_table :users, :force => true do |table|
+  table.column :id, :serial
+  table.column :person_id, :integer
+  table.column :password, :string
+  table.column :created_at, :date
+  table.column :disabled, :boolean, :default => true
+end
+##
+# people
+#
+ActiveRecord::Base.connection.create_table :people, :force => true do |table|
+  table.column :id, :serial
+  table.column :first, :string, :null => false
+  table.column :last, :string, :null => false
+  table.column :email, :string, :null => false
+end
+##
+# user_groups, join table
+#
+ActiveRecord::Base.connection.create_table :user_groups, :force => true do |table|
+  table.column :user_id, :integer
+  table.column :group_id, :integer
+end
+
+##
+# groups
+#
+ActiveRecord::Base.connection.create_table :groups, :force => true do |table|
+  table.column :id, :serial
+  table.column :title, :string
+end
+
+##
+# locations
+#
+ActiveRecord::Base.connection.create_table :locations, :force => true do |table|
+  table.column :id, :serial
+  table.column :name, :string
+  table.column :street, :string
+  table.column :type, :string
+end
+
+##
+# addresses
+#
+ActiveRecord::Base.connection.create_table :addresses, :force => true do |table|
+  table.column :id, :serial
+  table.column :addressable_type, :string
+  table.column :addressable_id, :integer
+  table.column :street, :string
+end
+
+##
+# Mock a Model for testing data-types
+#
+ActiveRecord::Base.connection.create_table :data_types, :force => true do |table|
+  table.column :id, :serial
+  table.column :string_column, :string
+  table.column :decimal_column, :decimal
+  table.column :float_column, :float
+  table.column :date_column, :date
+  table.column :datetime_column, :datetime
+  table.column :time_column, :time
+  table.column :email, :string
+  table.column :integer_column, :integer
+  table.column :notnull_column, :string, :null => false
+  table.column :default_column, :boolean, :default => true
+  table.column :boolean_column, :boolean
+end