hobo 0.6.2 → 0.6.3

data/hobo_files/plugin/lib/hobo/dryml/template_environment.rb

@@ -19,6 +19,8 @@ module Hobo::Dryml
         @tag_attrs ||= {}
       end
       
+      alias_method :_alias_tag_chain, :alias_tag_chain
+      
     end
 
     for mod in ActionView::Helpers.constants.grep(/Helper$/).map {|m| ActionView::Helpers.const_get(m)}
@@ -218,8 +220,7 @@ module Hobo::Dryml
              end
         parent, field, obj = Hobo.get_field_path(tag_this || this, path)
 
-        type = if (obj.nil? or obj.respond_to?(:proxy_reflection)) and
-                   parent.class.respond_to?(:field_type) and field_type = parent.class.field_type(field)
+        type = if parent.class.respond_to?(:field_type) && field_type = parent.class.field_type(field)
                  field_type
                elsif obj == false
                  # In dryml, TrueClass is the 'boolean' class
@@ -305,27 +306,27 @@ module Hobo::Dryml
     end
     
     
-    def call_block_tag_parameter(the_tag, attributes, overriding_proc, &b)
+    def call_block_tag_parameter(the_tag, attributes, overriding_proc, &default_tagbody)
       if overriding_proc && overriding_proc.arity == 1
         # This is a 'replace' parameter
         
         template_default = proc do |attrs, body_block|
-          tagbody_proc = body_block && proc {|_| new_context { body_block.call(b) } }
-          call_block_tag_parameter(the_tag, attributes, proc { attrs.update(:tagbody => tagbody_proc) }, &b)
+          tagbody_proc = body_block && proc {|_| new_context { body_block.call(default_tagbody) } }
+          call_block_tag_parameter(the_tag, attributes, proc { attrs.update(:tagbody => tagbody_proc) }, &default_tagbody)
         end
         overriding_proc.call(template_default)
       else
         if overriding_proc
           overriding_attributes = overriding_proc.call
-          tagbody = overriding_attributes.delete(:tagbody)
+          overriding_tagbody = overriding_attributes.delete(:tagbody)
           attributes = merge_attrs(attributes, overriding_attributes)
         end
       
         if the_tag.is_a?(String, Symbol) && the_tag.to_s.in?(Hobo.static_tags)
-          body = if tagbody
-                   new_context { tagbody.call(proc {b.call(nil)}) }
-                 elsif b
-                   new_context { b.call(nil) }
+          body = if overriding_tagbody
+                   new_context { overriding_tagbody.call(proc { default_tagbody.call(nil) }) }
+                 elsif default_tagbody
+                   new_context { default_tagbody.call(nil) }
                  else
                    nil
                  end
@@ -337,17 +338,17 @@ module Hobo::Dryml
         else
           if the_tag.is_a?(String, Symbol)
             body = proc do |default| 
-              if tagbody
-                tagbody.call(proc { b ? b.call(default) : "" })
+              if overriding_tagbody
+                overriding_tagbody.call(proc { default_tagbody ? default_tagbody.call(default) : "" })
               else
-                b ? b.call(default) : ""
+                default_tagbody ? default_tagbody.call(default) : ""
               end
             end
             
             send(the_tag, attributes, &body)
           else
             # It's a proc - a template default
-            the_tag.call(attributes, tagbody || b)
+            the_tag.call(attributes, overriding_tagbody || default_tagbody)
           end
         end
       end
@@ -376,11 +377,31 @@ module Hobo::Dryml
     # Takes two procs that each returh hashes and returns a single
     # proc that calls these in turn and merges the results into a
     # single hash
-    def merge_option_procs(general_proc, overriding_proc)
-      if overriding_proc
-        proc { merge_attrs(general_proc.call, overriding_proc.call) }
-      else
+    def merge_block_tag_parameter(general_proc, overriding_proc)
+      if overriding_proc.nil?
         general_proc
+      else
+        if overriding_proc.arity == 1
+          # The override is a replace parameter - just pass it on
+          overriding_proc
+        else
+          proc do 
+            overriding_attrs = overriding_proc.call
+            defined_attrs = general_proc.call
+            
+            attrs = merge_attrs(defined_attrs, overriding_attrs)
+            
+            # The overrider should provide its tagbody as the new
+            # <default_tagbody/>
+            if overriding_attrs[:tagbody] && defined_attrs[:tagbody]
+              attrs[:tagbody] = proc do |default|
+                overriding_attrs[:tagbody].call(proc { _output(defined_attrs[:tagbody].call(default)) })
+              end
+            end
+
+            attrs
+          end
+        end
       end
     end
     
@@ -388,7 +409,7 @@ module Hobo::Dryml
     # hashes rather than a single hash. The first hash is the tag
     # attributes, the second is a hash of procs -- the template
     # parameters.
-    def merge_template_parameter_procs(general_proc, overriding_proc)
+    def merge_template_parameter(general_proc, overriding_proc)
       proc do
         general_attributes, general_template_procs = general_proc.call
         overriding_attributes, overriding_template_procs = overriding_proc.call
@@ -399,7 +420,7 @@ module Hobo::Dryml
     
     def part_contexts_storage_tag
       storage = part_contexts_storage
-      storage.blank? ? "" : "<script>\nvar hoboParts = {}\n#{storage}</script>\n"
+      storage.blank? ? "" : "<script>\n#{storage}</script>\n"
     end
     
     

data/hobo_files/plugin/lib/hobo/email_address.rb

@@ -3,7 +3,10 @@ class Hobo::EmailAddress < String
   COLUMN_TYPE = :string
   
   def validate
-    "is not a valid email address" unless self.blank? || self =~ /^\s*([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\s*$/i
+    "is not a valid email address" unless 
+      self.blank? || self =~ /^\s*([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\s*$/i
   end
 
 end
+
+Hobo.field_types[:email_address] = Hobo::EmailAddress

data/hobo_files/plugin/lib/hobo/enum_string.rb

@@ -0,0 +1,50 @@
+module Hobo
+  
+  class EnumString < String
+    
+    module Helper
+      
+      def enum_string(*values)
+        EnumString.for(*values)
+      end
+      
+    end
+    
+    class << self 
+      
+      def with_values(*values)
+        @values = values.every(:to_s)
+      end
+      
+      attr_accessor :values
+      
+      def for(*values)
+        values = values.every(:to_s)
+        c = Class.new(EnumString) do
+          values.each do |v|
+            define_method("#{v.underscore}?") { self == v }
+            meta_def("#{v.underscore}") { v }
+          end
+        end
+        c.with_values(*values)
+        c
+      end
+      
+      def inspect
+        "#<EnumString #{(values || []) * ' '}>"
+      end
+      alias_method :to_s, :inspect
+      
+    end
+
+    COLUMN_TYPE = :string
+    
+    def validate
+      "must be one of #{self.class.values * ', '}" unless self.in?(self.class.values)
+    end
+    
+  end
+  
+end
+
+Hobo::FieldDeclarationsDsl.send(:include, Hobo::EnumString::Helper)

data/hobo_files/plugin/lib/hobo/field_declaration_dsl.rb

@@ -0,0 +1,36 @@
+module Hobo
+  
+  class FieldDeclarationsDsl
+    
+    def initialize(model)
+      @model = model
+    end
+    
+    attr_reader :model
+    
+    def timestamps
+      field(:created_at, :datetime)
+      field(:updated_at, :datetime)
+    end
+    
+    def field(name, *args)
+      type = args.shift
+      options = args.extract_options!
+      @model.send(:set_field_type, name => type) unless
+        type.in?(@model.connection.native_database_types.keys - [:text])
+      @model.field_specs[name] = FieldSpec.new(@model, name, type, options)
+      
+      @model.send(:validates_presence_of, name)   if :required.in?(args)
+      @model.send(:validates_uniqueness_of, name) if :unique.in?(args)
+    end
+    
+    def method_missing(name, *args)
+      field(name, *args)
+    end
+    
+    undef_method :type
+    
+    
+  end
+  
+end

data/hobo_files/plugin/lib/hobo/field_spec.rb

@@ -8,7 +8,7 @@ module Hobo
       raise ArgumentError, "you cannot provide a field spec for the primary key" if name == model.primary_key
       self.model = model
       self.name = name.to_sym
-      self.type = type.to_sym
+      self.type = type.is_a?(String) ? type.to_sym : type
       self.options = options
       self.position = model.field_specs.length
     end
@@ -17,13 +17,11 @@ module Hobo
     
     def sql_type
       options[:sql_type] or begin
-                              sql_types = model.connection.native_database_types.keys - [:primary_key]
-                              if type.in?(sql_types)
+                              native_types = model.connection.native_database_types.keys - [:primary_key]
+                              if type.in?(native_types)
                                 type
-                              elsif options[:length]
-                                :string
                               else
-                                field_type = Hobo.field_types[type]
+                                field_type = type.is_a?(Class) ? type : Hobo.field_types[type]
                                 field_type && field_type::COLUMN_TYPE or raise UnknownSqlTypeError, [model, name, type]
                               end
                             end
@@ -51,7 +49,6 @@ module Hobo
     
     def different_to?(col_spec)
       [:limit, :precision, :scale, :null, :default].any? do |k|
-        # puts "#{col_spec.send(k).inspect} --- #{self.send(k).inspect} : #{col_spec.send(k) != self.send(k)}"
         col_spec.send(k) != self.send(k)
       end || sql_type != col_spec.type
     end

data/hobo_files/plugin/lib/hobo/hobo_helper.rb

@@ -11,12 +11,10 @@ module Hobo
      
     def current_user
       # simple one-hit-per-request cache
-      @current_user or
-        @current_user = if session and id = session[:user]
-                          Hobo.object_from_dom_id(id)
-                        else 
-                          ::Guest.new
-                        end 
+      @current_user ||= begin
+                          id = session._?[:user]
+                          (id && Hobo.object_from_dom_id(id) rescue nil) || ::Guest.new
+                        end
     end
      
      
@@ -37,22 +35,33 @@ module Hobo
         obj.class.name.underscore.pluralize
       end
     end
+    
+    
+    def subsite
+      params[:controller].match(/([^\/]+)\//)._?[1]
+    end
      
      
-    def object_url(obj, action=nil, *param_hashes)
+    def object_url(*args)
+      params = args.extract_options!
+      obj, action = args
+      
       action &&= action.to_s
       
       controller_name = controller_for(obj)
       
+      subsite = params[:subsite] || self.subsite
+      base = subsite ? "/#{subsite}#{base_url}" : base_url
+      
       parts = if obj.is_a? Class
-                [base_url, controller_name]
+                [base, controller_name]
                 
               elsif obj.is_a? Hobo::CompositeModel
-                [base_url, controller_name, obj.id]
+                [base, controller_name, obj.to_param]
                 
               elsif obj.is_a? ActiveRecord::Base
                 if obj.new_record?
-                  [base_url, controller_name]
+                  [base, controller_name]
                 else
                   raise HoboError.new("invalid object url: new for existing object") if action == "new"
      
@@ -60,10 +69,10 @@ module Hobo
                   id = if klass.id_name?
                          obj.id_name(true)
                        else
-                         obj.id
+                         obj.to_param
                        end
                   
-                  [base_url, controller_name, id]
+                  [base, controller_name, id]
                 end
                 
               elsif obj.is_a? Array    # warning - this breaks if we use `case/when Array`
@@ -74,23 +83,17 @@ module Hobo
               else
                 raise HoboError.new("cannot create url for #{obj.inspect} (#{obj.class})")
               end
-      basic = parts.join("/")
-      
-      controller = (controller_name.camelize + "Controller").constantize rescue nil
-      url = case action
-            when "new"
-              basic + "/new"
-            when "destroy"
-              basic + "?_method=DELETE"
-            when "update"
-              basic + "?_method=PUT"
-            when nil
-              basic
-            else
-              basic + "/" + action
-            end
-      params = make_params(*param_hashes)
-      params.blank? ? url : url + "?" + params
+      url = parts.join("/")
+
+      case action
+      when nil       # do nothing
+      when "destroy" then params["_method"] = "DELETE"
+      when "update"  then params["_method"] = "PUT"
+      else url += "/#{action}" 
+      end
+
+      params = make_params(params - [:subsite])
+      params.blank? ? url : "#{url}?#{params}"
     end
      
      
@@ -125,6 +128,8 @@ module Hobo
       else
         Hobo.dom_id(*args)
       end
+    rescue ArgumentError
+      ""
     end
     
     
@@ -146,8 +151,13 @@ module Hobo
      
     def map_this
       res = []
-      this.each_index {|i| new_field_context(i) { res << yield } }
-      Dryml.last_if = !this.empty?
+      empty = true
+      if this.respond_to?(:each_index)
+        this.each_index {|i| empty = false; new_field_context(i) { res << yield } }
+      else
+        this.map {|e| empty = false; new_object_context(e) { res << yield } }
+      end
+      Dryml.last_if = !empty
       res
     end
     alias_method :collect_this, :map_this
@@ -238,17 +248,6 @@ module Hobo
     end
      
      
-    def render_params(*args)
-      parts = args.map{|x| x.split(/, */) if x}.compact.flatten
-      { :part_page => view_name,
-        :render => parts.map do |part_id|
-          { :object => Hobo::RawJs.new("hoboParts.#{part_id}"),
-            :part => part_id }
-        end
-      }
-    end
-     
-     
     def nl_to_br(s)
       s.to_s.gsub("\n", "<br/>") if s
     end
@@ -332,6 +331,10 @@ module Hobo
       c = user_or_class.is_a?(Class) ? user_or_class : user_or_class.class
       send("#{c.name.underscore}_signup_url") rescue nil
     end
+    
+    def current_page_url
+      request.request_uri.match(/^([^?]*)/)._?[1]
+    end
 
     def query_params
       query = request.request_uri.match(/(?:\?(.+))/)._?[1]
@@ -341,9 +344,9 @@ module Hobo
           pair = param.split('=')
           pair.length == 1 ? pair + [''] : pair
         end
-        Hash[*pairs.flatten]
+        HashWithIndifferentAccess[*pairs.flatten]
       else
-        {}
+        HashWithIndifferentAccess.new
       end
     end
   

data/hobo_files/plugin/lib/hobo/html_string.rb

@@ -3,3 +3,5 @@ class Hobo::HtmlString < String
   COLUMN_TYPE = :text
 
 end
+
+Hobo.field_types[:html] = Hobo::HtmlString

data/hobo_files/plugin/lib/hobo/markdown_string.rb

@@ -7,3 +7,5 @@ class Hobo::MarkdownString < String
   end
 
 end
+
+Hobo.field_types[:markdown] = Hobo::MarkdownString

data/hobo_files/plugin/lib/hobo/model.rb

@@ -2,20 +2,16 @@ module Hobo
 
   module Model
     
-    Hobo.field_types.update({ :html          => HtmlString,
-                              :markdown      => MarkdownString,
-                              :textile       => TextileString,
-                              :password      => PasswordString,
-                              :text          => Hobo::Text,
-                              :boolean       => TrueClass,
-                              :date          => Date,
-                              :datetime      => Time,
-                              :integer       => Fixnum,
-                              :big_integer   => BigDecimal,
-                              :float         => Float,
-                              :string        => String,
-                              :email_address => EmailAddress
-                            })
+    PLAIN_TYPES = { :boolean       => TrueClass,
+                    :date          => Date,
+                    :datetime      => Time,
+                    :integer       => Fixnum,
+                    :big_integer   => BigDecimal,
+                    :float         => Float,
+                    :string        => String
+                  }
+    
+    Hobo.field_types.update(PLAIN_TYPES)
     
     def self.included(base)
       Hobo.register_model(base)
@@ -23,13 +19,12 @@ module Hobo
       base.class_eval do
         @field_specs  = HashWithIndifferentAccess.new
         set_field_type({})
+        alias_method_chain :attributes=, :hobo_type_conversion
       end
       class << base
         alias_method_chain :has_many, :defined_scopes
         alias_method_chain :belongs_to, :foreign_key_declaration
       end
-      # respond_to? is slow on AR objects, use this instead where possible
-      base.send(:alias_method, :has_hobo_method?, :respond_to_without_attributes?)
     end
 
     module ClassMethods
@@ -51,50 +46,27 @@ module Hobo
       end
       
       
-      class FieldDeclarationsDsl
-        
-        def initialize(model)
-          @model = model
-        end
-        
-        attr_reader :model
-        
-        def timestamps
-          field(:created_at, :datetime)
-          field(:updated_at, :datetime)
-        end
-        
-        def field(name, *args)
-          type = args.shift
-          options = args.extract_options!
-          @model.send(:set_field_type, name => type) unless
-            type.in?(@model.connection.native_database_types.keys - [:text])
-          @model.field_specs[name] = FieldSpec.new(@model, name, type, options)
-          
-          @model.send(:validates_presence_of, name) if :required.in?(args)
-          @model.send(:validates_uniqueness_of, name) if :unique.in?(args)
-        end
-        
-        def method_missing(name, *args)
-          field(name, *args)
-        end
-        
-      end
-      
-      
       def fields(&b)
-        FieldDeclarationsDsl.new(self).instance_eval(&b)
+        dsl = FieldDeclarationsDsl.new(self)
+        if b.arity == 1
+          yield dsl
+        else
+          dsl.instance_eval(&b)
+        end
       end
       
       
       def belongs_to_with_foreign_key_declaration(name, *args, &block)
-        res = belongs_to_without_foreign_key_declaration(name, *args, &block)
+        options = args.extract_options!
+        res = belongs_to_without_foreign_key_declaration(name, *args + [options], &block)
         refl = reflections[name]
         fkey = refl.primary_key_name
-        field_specs[fkey] ||= FieldSpec.new(self, fkey, :integer)
+        column_options = {}
+        column_options[:null] = options[:null] if options.has_key?(:null)
+        field_specs[fkey] ||= FieldSpec.new(self, fkey, :integer, column_options)
         if refl.options[:polymorphic]
           type_col = "#{name}_type"
-          field_specs[type_col] ||= FieldSpec.new(self, type_col, :string)
+          field_specs[type_col] ||= FieldSpec.new(self, type_col, :string, column_options)
         end
         res
       end
@@ -108,9 +80,9 @@ module Hobo
           type_class = Hobo.field_types[type] || type
           field_types[field] = type_class
           
-          if "validate".in?(type_class.instance_methods)
+          if type_class && "validate".in?(type_class.instance_methods)
             self.validate do |record|
-              v = record.send(field).validate
+              v = record.send(field)._?.validate
               record.errors.add(field, v) if v.is_a?(String)
             end
           end
@@ -136,7 +108,7 @@ module Hobo
       end
 
       def never_show?(field)
-        @hobo_never_show and field.to_sym.in?(@hobo_never_show)
+        @hobo_never_show && field.to_sym.in?(@hobo_never_show)
       end
       public :never_show?
 
@@ -176,20 +148,20 @@ module Hobo
             end
           }
         end
-
+        
         key = "id_name#{if underscore; ".gsub('_', ' ')"; end}"
         finder = if insenstive
-          "find(:first, :conditions => ['lower(#{id_name_field}) = ?', #{key}.downcase])"
+          "find(:first, options.merge(:conditions => ['lower(#{id_name_field}) = ?', #{key}.downcase]))"
         else
-          "find_by_#{id_name_field}(#{key})"
+          "find_by_#{id_name_field}(#{key}, options)"
         end
 
         class_eval %{
-          def self.find_by_id_name(id_name)
+          def self.find_by_id_name(id_name, options)
             #{finder}
           end
         }
-
+        
         model = self
         validate do
           erros.add id_name_field, "is taken" if model.find_by_id_name(name)
@@ -207,12 +179,11 @@ module Hobo
       attr_reader :id_name_column
 
       
-      
       def field_type(name)
         name = name.to_sym
         field_types[name] or
           reflections[name] or begin
-                                 col = columns.find {|c| c.name == name.to_s} rescue nil
+                                 col = column(name)
                                  return nil if col.nil?
                                  case col.type
                                  when :boolean
@@ -224,19 +195,18 @@ module Hobo
                                  end
                                end
       end
-
       
-      def nilable_field?(name)
-        col = columns.find {|c| c.name == name.to_s} rescue nil
-        col.nil? || col.null
+      
+      def column(name)
+        columns.find {|c| c.name == name.to_s} rescue nil
       end
       
       
       def conditions(*args, &b)
         if args.empty?
-          ModelQueries.new(self).instance_eval(&b).to_sql
+          ModelQueries.new(self).instance_eval(&b)._?.to_sql
         else
-          ModelQueries.new(self).instance_exec(*args, &b).to_sql
+          ModelQueries.new(self).instance_exec(*args, &b)._?.to_sql
         end
       end
       
@@ -251,16 +221,28 @@ module Hobo
                     end
         end
           
-        if b && !(block_conditions = conditions(&b)).blank?
-          c = if !options[:conditions].blank?
-                "(#{options[:conditons]}) and (#{block_conditions})"
+        res = if b && !(block_conditions = conditions(&b)).blank?
+                c = if !options[:conditions].blank?
+                      "(#{sanitize_sql options[:conditions]}) AND (#{sanitize_sql block_conditions})"
+                    else
+                      block_conditions
+                    end
+                super(args.first, options.merge(:conditions => c))
               else
-                block_conditions
+                super(*args + [options])
               end
-          super(args.first, options.merge(:conditions => c))
-        else
-          super(*args + [options])
+        if args.first == :all
+          def res.member_class
+            @member_class
+          end
+          res.instance_variable_set("@member_class", self)
         end
+        res
+      end
+      
+      
+      def all(options={})
+        find(:all, options.reverse_merge(:order => :default))
       end
       
       
@@ -314,7 +296,7 @@ module Hobo
       
       
       class ScopedProxy
-        def initialize(klass, scope={})
+        def initialize(klass, scope)
           @klass = klass
           
           # If there's no :find, or :create specified, assume it's a find scope
@@ -325,9 +307,14 @@ module Hobo
                    end
         end
         
+        
         def method_missing(name, *args, &block)
-          @klass.send(:with_scope, @scope) do
-            @klass.send(name, *args, &block)
+          if name.to_sym.in?(@klass.defined_scopes.keys)
+            proxy = @klass.send(name, *args)
+            proxy.instance_variable_set("@parent_scope", self)
+            proxy
+          else
+            _apply_scope { @klass.send(name, *args, &block) }
           end
         end
         
@@ -338,12 +325,28 @@ module Hobo
         def first
           self.find(:first)
         end
+        
+        def member_class
+          @klass
+        end
+        
+        private
+        def _apply_scope
+          if @parent_scope
+            @parent_scope.send(:_apply_scope) do
+              @scope ? @klass.send(:with_scope, @scope) { yield } : yield
+            end
+          else
+            @scope ? @klass.send(:with_scope, @scope) { yield } : yield
+          end
+        end
+        
       end
       (Object.instance_methods + 
        Object.private_instance_methods +
        Object.protected_instance_methods).each do |m|
         ScopedProxy.send(:undef_method, m) unless
-          m.in?(%w{initialize method_missing send}) || m.starts_with?('_')
+          m.in?(%w{initialize method_missing send instance_variable_set instance_variable_get puts}) || m.starts_with?('_')
       end
       
       attr_accessor :defined_scopes
@@ -384,18 +387,20 @@ module Hobo
             
             unless assoc
               options = proxy_reflection.options
-              has_many_conditions = options.has_key?(:conditions)
+              has_many_conditions = options[:conditions]
+              has_many_conditions = nil if has_many_conditions.blank?
               source = proxy_reflection.source_reflection
               scope_conditions = find_scope[:conditions]
+              scope_conditions = nil if scope_conditions.blank?
               conditions = if has_many_conditions && scope_conditions
-                             "(#{scope_conditions}) AND (#{has_many_conditions})"
+                             "(#{sanitize_sql scope_conditions}) AND (#{sanitize_sql has_many_conditions})"
                            else
                              scope_conditions || has_many_conditions
                            end
               
-              options = options.merge(find_scope).update(:conditions => conditions,
-                                                         :class_name => proxy_reflection.klass.name,
+              options = options.merge(find_scope).update(:class_name => proxy_reflection.klass.name,
                                                          :foreign_key => proxy_reflection.primary_key_name)
+              options[:conditions] = conditions unless conditions.blank?
               options[:source] = source.name if source
 
               r = ActiveRecord::Reflection::AssociationReflection.new(:has_many,
@@ -437,6 +442,13 @@ module Hobo
     end
     
     
+    def attributes_with_hobo_type_conversion=(attributes)
+      converted = attributes.map_hash { |k, v| convert_type_for_mass_assignment(self.class.field_type(k), v) }
+      self.attributes_without_hobo_type_conversion = converted
+    end
+      
+
+    
     def set_creator(user)
       self.send("#{self.class.creator_attr}=", user) if (t = self.class.creator_type) && user.is_a?(t)
     end
@@ -460,11 +472,14 @@ module Hobo
 
 
     def same_fields?(other, *fields)
+      fields = fields.flatten
       fields.all?{|f| self.send(f) == other.send(f)}
     end
     
-    def changed_fields?(other, *fields)
-      fields.all?{|f| self.send(f) != other.send(f)}
+    def only_changed_fields?(other, *changed_fields)
+      changed_fields = changed_fields.flatten.every(:to_s)
+      all_cols = self.class.columns.every(:name) - []
+      all_cols.all?{|c| c.in?(changed_fields) || self.send(c) == other.send(c) }
     end
     
     def compose_with(object, use=nil)
@@ -493,6 +508,42 @@ module Hobo
       end
     end
     
+    private
+    
+    def parse_datetime(s)
+      defined?(Chronic) ? Chronic.parse(s) : Time.parse(s)
+    end
+
+    def convert_type_for_mass_assignment(field_type, value)
+      if field_type.is_a?(ActiveRecord::Reflection::AssociationReflection) and field_type.macro.in?([:belongs_to, :has_one])
+        if value.is_a?(String) && value.starts_with?('@')
+          Hobo.object_from_dom_id(value[1..-1])
+        else
+          value
+        end
+      elsif !field_type.is_a?(Class)
+        value
+      elsif field_type <= Date
+        if value.is_a? Hash
+          Date.new(*(%w{year month day}.map{|s| value[s].to_i}))
+        elsif value.is_a? String
+          dt = parse_datetime(value)
+          dt && dt.to_date
+        end
+      elsif field_type <= Time
+        if value.is_a? Hash
+          Time.local(*(%w{year month day hour minute}.map{|s| value[s].to_i}))
+        elsif value.is_a? String
+          parse_datetime(value)
+        end
+      elsif field_type <= TrueClass
+        (value.is_a?(String) && value.strip.downcase.in?(['0', 'false']) || value.blank?) ? false : true
+      else
+        # primitive field
+        value
+      end
+    end
+    
   end
 end
 
@@ -507,17 +558,17 @@ module ActiveRecord::AttributeMethods::ClassMethods
     access_code = cast_code ? "(v=@attributes['#{attr_name}']) && #{cast_code}" : "@attributes['#{attr_name}']"
 
     unless attr_name.to_s == self.primary_key.to_s
-      access_code = access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
+      access_code = access_code.insert(0, "missing_attribute('#{attr_name}', caller) " +
+                                       "unless @attributes.has_key?('#{attr_name}'); ")
     end
 
     # This is the Hobo hook - add a type wrapper around the field
     # value if we have a special type defined
     src = if connected? && respond_to?(:field_type) && (type_wrapper = field_type(symbol)) &&
-              type_wrapper.is_a?(Class) && type_wrapper < String
+              type_wrapper.is_a?(Class) && type_wrapper.not_in?(Hobo::Model::PLAIN_TYPES.values)
             "val = begin; #{access_code}; end; " +
-              "if val.nil?; nil; " +
-              "elsif val.respond_to?(:hobo_undefined?) && val.hobo_undefined?; val; " + 
-              "else; #{type_wrapper}.new(val); end"
+              "if val.nil? || (val.respond_to?(:hobo_undefined?) && val.hobo_undefined?); val; " + 
+              "else; self.class.field_type(:#{attr_name}).new(val); end"
           else
             access_code
           end
@@ -525,4 +576,22 @@ module ActiveRecord::AttributeMethods::ClassMethods
     evaluate_attribute_method(attr_name, 
                               "def #{symbol}; @attributes_cache['#{attr_name}'] ||= begin; #{src}; end; end")
   end
+  
+  def define_write_method(attr_name)
+    src = if connected? && respond_to?(:field_type) && (type_wrapper = field_type(attr_name)) &&
+              type_wrapper.is_a?(Class) && type_wrapper.not_in?(Hobo::Model::PLAIN_TYPES.values)
+            "if val.nil? || (val.respond_to?(:hobo_undefined?) && val.hobo_undefined?); val; " + 
+              "else; self.class.field_type(:#{attr_name}).new(val); end"
+          else
+            "val"
+          end
+    evaluate_attribute_method(attr_name, "def #{attr_name}=(val); " + 
+                              "write_attribute('#{attr_name}', #{src});end", "#{attr_name}=")
+    
+  end
+
+end
+
+class ActiveRecord::Base
+  alias_method :has_hobo_method?, :respond_to_without_attributes?
 end