hobofields 0.7.5 → 0.8

data/lib/hobo_fields/migration_generator.rb

@@ -1,67 +1,78 @@
 module HoboFields
-  
+
   class MigrationGeneratorError < RuntimeError; end
-  
+
   class MigrationGenerator
-    
+
     @ignore_models = []
     @ignore_tables = []
-    
+
     class << self
       attr_accessor :ignore_models, :ignore_tables
     end
-    
+
     def self.run(renames={})
       g = MigrationGenerator.new
       g.renames = renames
       g.generate
     end
-    
+
     def initialize(ambiguity_resolver=nil)
       @ambiguity_resolver = ambiguity_resolver
       @drops = []
       @renames = nil
     end
-    
+
     attr_accessor :renames
-    
+
+
     def load_rails_models
       if defined? RAILS_ROOT
-        Dir.entries("#{RAILS_ROOT}/app/models/").each do |f|
-          f =~ /^[a-zA-Z_][a-zA-Z0-9_]*\.rb$/ and f.sub(/.rb$/, '').camelize.constantize
+        Dir["#{RAILS_ROOT}/app/models/**/[a-z0-9_]*.rb"].each do |f|
+          _, filename = *f.match(%r{/app/models/([_a-z0-9/]*).rb$})
+          filename.camelize.constantize
         end
       end
     end
-    
-    
+
+
     # Returns an array of model classes that *directly* extend
     # ActiveRecord::Base, excluding anything in the CGI module
     def table_model_classes
       load_rails_models
       ActiveRecord::Base.send(:subclasses).where.descends_from_active_record?.reject {|c| c.name.starts_with?("CGI::") }
-    end 
-    
-    
-    def connection
+    end
+
+
+    def self.connection
       ActiveRecord::Base.connection
     end
-    
-    
-    def native_types
-      connection.native_database_types
+    def connection; self.class.connection; end
+
+
+    def self.fix_native_types(types)
+      case connection.class.name
+      when /mysql/i
+        types[:integer][:limit] = 11
+      end
+      types
     end
-    
-    
+
+    def self.native_types
+      @native_types ||= fix_native_types connection.native_database_types
+    end
+    def native_types; self.class.native_types; end
+
     # Returns an array of model classes and an array of table names
     # that generation needs to take into account
     def models_and_tables
       ignore_model_names = MigrationGenerator.ignore_models.map &it.to_s.underscore
       models = table_model_classes.select { |m| m < HoboFields::ModelExtensions && m.name.underscore.not_in?(ignore_model_names) }
-      db_tables = connection.tables - MigrationGenerator.ignore_tables.*.to_s      
+      db_tables = connection.tables - MigrationGenerator.ignore_tables.*.to_s
       [models, db_tables]
     end
-    
-    
+
+
     # return a hash of table renames and modifies the passed arrays so
     # that renamed tables are no longer listed as to_create or to_drop
     def extract_table_renames!(to_create, to_drop)
@@ -72,7 +83,7 @@ module HoboFields
         renames.each_pair do |old_name, new_name|
           new_name = new_name[:table_name] if new_name.is_a?(Hash)
           next unless new_name
-          
+
           if to_create.delete(new_name.to_s) && to_drop.delete(old_name.to_s)
             to_rename[old_name.to_s] = new_name.to_s
           else
@@ -80,7 +91,7 @@ module HoboFields
           end
         end
         to_rename
-        
+
       elsif @ambiguity_resolver
         @ambiguity_resolver.extract_renames!(to_create, to_drop, "table")
 
@@ -88,8 +99,8 @@ module HoboFields
         raise MigrationGeneratorError, "Unable to resolve migration ambiguities"
       end
     end
-    
-    
+
+
     def extract_column_renames!(to_add, to_remove, table_name)
       if renames
         to_rename = {}
@@ -106,7 +117,7 @@ module HoboFields
           end
         end
         to_rename
-        
+
       elsif @ambiguity_resolver
         @ambiguity_resolver.extract_renames!(to_add, to_remove, "column", "#{table_name}.")
 
@@ -114,19 +125,26 @@ module HoboFields
         raise MigrationGeneratorError, "Unable to resolve migration ambiguities in table #{table_name}"
       end
     end
-
     
+    
+    def always_ignore_tables
+      sessions_table = CGI::Session::ActiveRecordStore::Session.table_name if
+        ActionController::Base.session_store == CGI::Session::ActiveRecordStore
+      ['schema_info', 'schema_migrations',  sessions_table].compact
+    end
+
+
     def generate
       models, db_tables = models_and_tables
       models_by_table_name = models.index_by {|m| m.table_name}
       model_table_names = models.*.table_name
 
       to_create = model_table_names - db_tables
-      to_drop = db_tables - model_table_names - ['schema_info']
+      to_drop = db_tables - model_table_names - always_ignore_tables
       to_change = model_table_names
-      
+
       to_rename = extract_table_renames!(to_create, to_drop)
-      
+
       renames = to_rename.map do |old_name, new_name|
         "rename_table :#{old_name}, :#{new_name}"
       end * "\n"
@@ -147,7 +165,7 @@ module HoboFields
       undo_creates = to_create.map do |t|
         "drop_table :#{t}"
       end * "\n"
-      
+
       changes = []
       undo_changes = []
       to_change.each do |t|
@@ -159,7 +177,7 @@ module HoboFields
           undo_changes << undo
         end
       end
-      
+
       up   = [renames, drops, creates, changes].flatten.reject(&:blank?) * "\n\n"
       down = [undo_changes, undo_renames, undo_drops, undo_creates].flatten.reject(&:blank?) * "\n\n"
 
@@ -172,19 +190,19 @@ module HoboFields
        model.field_specs.values.sort_by{|f| f.position}.map {|f| create_field(f, longest_field_name)} +
        ["end"]) * "\n"
     end
-    
+
     def create_field(field_spec, field_name_width)
       args = [field_spec.name.inspect] + format_options(field_spec.options, field_spec.sql_type)
       "  t.%-*s %s" % [field_name_width, field_spec.sql_type, args.join(', ')]
     end
-    
+
     def change_table(model, current_table_name)
       new_table_name = model.table_name
-      
+
       db_columns = model.connection.columns(current_table_name).index_by{|c|c.name} - [model.primary_key]
       model_column_names = model.field_specs.keys.*.to_s
       db_column_names = db_columns.keys.*.to_s
-      
+
       to_add = model_column_names - db_column_names
       to_remove = db_column_names - model_column_names - [model.primary_key.to_sym]
 
@@ -193,14 +211,14 @@ module HoboFields
       db_column_names -= to_rename.keys
       db_column_names |= to_rename.values
       to_change = db_column_names & model_column_names
-      
+
       renames = to_rename.map do |old_name, new_name|
         "rename_column :#{new_table_name}, :#{old_name}, :#{new_name}"
       end
       undo_renames = to_rename.map do |old_name, new_name|
         "rename_column :#{new_table_name}, :#{new_name}, :#{old_name}"
       end
-      
+
       to_add = to_add.sort_by {|c| model.field_specs[c].position }
       adds = to_add.map do |c|
         spec = model.field_specs[c]
@@ -210,14 +228,14 @@ module HoboFields
       undo_adds = to_add.map do |c|
         "remove_column :#{new_table_name}, :#{c}"
       end
-      
+
       removes = to_remove.map do |c|
         "remove_column :#{new_table_name}, :#{c}"
       end
       undo_removes = to_remove.map do |c|
         revert_column(current_table_name, c)
       end
-      
+
       old_names = to_rename.invert
       changes = []
       undo_changes = []
@@ -227,42 +245,44 @@ module HoboFields
         spec = model.field_specs[c]
         if spec.different_to?(col)
           change_spec = {}
-          change_spec[:limit]     = spec.limit     unless spec.limit.nil?
+          change_spec[:limit]     = spec.limit     unless spec.limit.nil? && col.limit.nil?
           change_spec[:precision] = spec.precision unless spec.precision.nil?
           change_spec[:scale]     = spec.scale     unless spec.scale.nil?
-          change_spec[:null]      = false          unless spec.null
+          change_spec[:null]      = spec.null      unless spec.null && col.null
           change_spec[:default]   = spec.default   unless spec.default.nil? && col.default.nil?
-          
-          changes << "change_column :#{new_table_name}, :#{c}, " + 
-            ([":#{spec.sql_type}"] + format_options(change_spec, spec.sql_type)).join(", ")
+
+          changes << "change_column :#{new_table_name}, :#{c}, " +
+            ([":#{spec.sql_type}"] + format_options(change_spec, spec.sql_type, true)).join(", ")
           back = change_column_back(current_table_name, col_name)
           undo_changes << back unless back.blank?
         else
           nil
         end
       end.compact
-      
+
       [(renames + adds + removes + changes) * "\n",
        (undo_renames + undo_adds + undo_removes + undo_changes) * "\n"]
     end
-    
-    
-    def format_options(options, type)
+
+
+    def format_options(options, type, changing=false)
       options.map do |k, v|
-        next if k == :limit && (type == :decimal || v == native_types[type][:limit])
-        next if k == :null && v == true
-        "#{k.inspect} => #{v.inspect}" 
+        unless changing
+          next if k == :limit && (type == :decimal || v == native_types[type][:limit])
+          next if k == :null && v == true
+        end
+        "#{k.inspect} => #{v.inspect}"
       end.compact
     end
-    
-    
+
+
     def revert_table(table)
       res = StringIO.new
       ActiveRecord::SchemaDumper.send(:new, ActiveRecord::Base.connection).send(:table, table, res)
       res.string.strip.gsub("\n  ", "\n")
     end
-    
-    
+
+
     def column_options_from_reverted_table(table, column)
       revert = revert_table(table)
       if (md = revert.match(/\s*t\.column\s+"#{column}",\s+(:[a-zA-Z0-9_]+)(?:,\s+(.*?)$)?/m))
@@ -275,19 +295,19 @@ module HoboFields
       end
       [type, options]
     end
-    
-    
+
+
     def change_column_back(table, column)
       type, options = column_options_from_reverted_table(table, column)
       "change_column :#{table}, :#{column}, #{type}#{', ' + options.strip if options}"
     end
-    
+
 
     def revert_column(table, column)
       type, options = column_options_from_reverted_table(table, column)
       "add_column :#{table}, :#{column}, #{type}#{', ' + options.strip if options}"
-    end  
-  
+    end
+
   end
-  
+
 end

data/lib/hobo_fields/model_extensions.rb

@@ -1,42 +1,43 @@
 module HoboFields
-  
+
   ModelExtensions = classy_module do
-  
-   
+
+
     # attr_types holds the type class for any attribute reader (i.e. getter
     # method) that returns rich-types
     inheriting_cattr_reader :attr_types => HashWithIndifferentAccess.new
-    
+    inheriting_cattr_reader :attr_order => []
+
     # field_specs holds FieldSpec objects for every declared
     # field. Note that attribute readers are created (by ActiveRecord)
     # for all fields, so there is also an entry for the field in
     # attr_types. This is redundant but simplifies the implementation
     # and speeds things up a little.
     inheriting_cattr_reader :field_specs => HashWithIndifferentAccess.new
-    
-    
+
+
     def self.inherited(klass)
       fields do |f|
         f.field(inheritance_column, :string)
       end
     end
-    
+
 
     def self.field_specs
       @field_specs ||= HashWithIndifferentAccess.new
     end
 
-    
+
     private
-   
+
     # Declares that a virtual field that has a rich type (e.g. created
     # by attr_accessor :foo, :type => :email_address) should be subject
     # to validation (note that the rich types know how to validate themselves)
     def self.validate_virtual_field(*args)
       validates_each(*args) {|record, field, value| msg = value.validate and record.errors.add(field, msg) if value.respond_to?(:validate) }
     end
-    
-    
+
+
     # This adds a ":type => t" option to attr_accessor, where t is
     # either a class or a symbolic name of a rich type. If this option
     # is given, the setter will wrap values that are not of the right
@@ -46,7 +47,7 @@ module HoboFields
       type = options.delete(:type)
       attrs << options unless options.empty?
       attr_accessor_without_rich_types(*attrs)
-      
+
       if type
         type = HoboFields.to_class(type)
         attrs.each do |attr|
@@ -60,24 +61,25 @@ module HoboFields
         end
       end
     end
-    
-    
+
+
     # Extend belongs_to so that it creates a FieldSpec for the foreign key
     def self.belongs_to_with_field_declarations(name, options={}, &block)
-      res = belongs_to_without_field_declarations(name, options, &block)
-      refl = reflections[name.to_sym]
-      fkey = refl.primary_key_name
       column_options = {}
-      column_options[:null] = options[:null] if options.has_key?(:null)
-      declare_field(fkey, :integer, column_options)
-      declare_polymorphic_type_field(name, column_options) if refl.options[:polymorphic]
-      res
+      column_options[:null] = options.delete(:null) if options.has_key?(:null)
+
+      returning belongs_to_without_field_declarations(name, options, &block) do
+        refl = reflections[name.to_sym]
+        fkey = refl.primary_key_name
+        declare_field(fkey.to_sym, :integer, column_options)
+        declare_polymorphic_type_field(name, column_options) if refl.options[:polymorphic]
+      end
     end
     class << self
       alias_method_chain :belongs_to, :field_declarations
     end
-    
-    
+
+
     # Declares the "foo_type" field that accompanies the "foo_id"
     # field for a polyorphic belongs_to
     def self.declare_polymorphic_type_field(name, column_options)
@@ -87,8 +89,8 @@ module HoboFields
       # never_show(type_col)
       # That needs doing somewhere
     end
-    
-    
+
+
     # Declare a rich-type for any attribute (i.e. getter method). This
     # does not effect the attribute in any way - it just records the
     # metadata.
@@ -102,14 +104,15 @@ module HoboFields
     # callback, allowing custom metadata to be added to field
     # declarations.
     def self.declare_field(name, type, *args)
-      options = args.extract_options!      
+      options = args.extract_options!
       try.field_added(name, type, args, options)
       add_validations_for_field(name, type, args, options)
       declare_attr_type(name, type) unless HoboFields.plain_type?(type)
       field_specs[name] = FieldSpec.new(self, name, type, options)
+      attr_order << name unless name.in?(attr_order)
     end
-    
-    
+
+
     # Add field validations according to arguments and options in the
     # field declaration
     def self.add_validations_for_field(name, type, args, options)
@@ -124,8 +127,8 @@ module HoboFields
         end
       end
     end
-    
-    
+
+
     # Extended version of the acts_as_list declaration that
     # automatically delcares the 'position' field
     def self.acts_as_list_with_field_declaration(options = {})
@@ -133,7 +136,7 @@ module HoboFields
       acts_as_list_without_field_declaration(options)
     end
 
-  
+
     # Returns the type (a class) for a given field or association. If
     # the association is a collection (has_many or habtm) return the
     # AssociationReflection instead
@@ -141,27 +144,27 @@ module HoboFields
       if attr_types.nil? && self != self.name.constantize
         raise RuntimeError, "attr_types called on a stale class object (#{self.name}). Avoid storing persistent refereces to classes"
       end
-      
+
       attr_types[name] or
-        
+
         if (refl = reflections[name.to_sym])
-          if refl.macro.in?([:has_one, :belongs_to])
+          if refl.macro.in?([:has_one, :belongs_to]) && !refl.options[:polymorphic]
             refl.klass
           else
             refl
           end
         end or
-        
+
         (col = column(name.to_s) and HoboFields::PLAIN_TYPES[col.type] || col.klass)
     end
-    
-    
-    # Return the entry from #columns for the named column 
+
+
+    # Return the entry from #columns for the named column
     def self.column(name)
       name = name.to_s
-      columns.find {|c| c.name == name } 
+      columns.find {|c| c.name == name }
     end
-    
+
     class << self
       alias_method_chain :acts_as_list,  :field_declaration if defined?(ActiveRecord::Acts::List)
       alias_method_chain :attr_accessor, :rich_types

data/lib/hobo_fields/password_string.rb

@@ -1,12 +1,12 @@
 module HoboFields
-  
+
   class PasswordString < String
-    
+
     COLUMN_TYPE = :string
-    
+
     HoboFields.register_type(:password, self)
-    
-    def to_html
+
+    def to_html(xmldoctype = true)
       "[password hidden]"
     end
 

data/lib/hobo_fields/text.rb

@@ -1,17 +1,17 @@
 module HoboFields
-  
+
   class Text < String
-    
+
     HTML_ESCAPE = { '&' => '&amp;', '"' => '&quot;', '>' => '&gt;', '<' => '&lt;' }
-    
+
     COLUMN_TYPE = :text
-    
-    def to_html
-      gsub(/[&"><]/) { |special| HTML_ESCAPE[special] }.gsub("\n", "<br />\n")
+
+    def to_html(xmldoctype = true)
+      gsub(/[&"><]/) { |special| HTML_ESCAPE[special] }.gsub("\n", "<br#{xmldoctype ? ' /' : ''}>\n")
     end
-    
+
     HoboFields.register_type(:text, self)
-  
+
   end
-  
+
 end

data/lib/hobo_fields/textile_string.rb

@@ -1,10 +1,10 @@
 require 'redcloth'
 
 module HoboFields
-  
+
   class TextileString < HoboFields::Text
 
-    def to_html
+    def to_html(xmldoctype = true)
       if blank?
         ""
       else
@@ -12,18 +12,9 @@ module HoboFields
         textilized.hard_breaks = true if textilized.respond_to?("hard_breaks=")
         textilized.to_html
       end
-    end  
+    end
 
     HoboFields.register_type(:textile, self)
   end
 
 end
-
-class RedCloth
-  # Patch for RedCloth.  Fixed in RedCloth r128 but _why hasn't released it yet.
-  # http://code.whytheluckystiff.net/redcloth/changeset/128
-  def hard_break( text ) 
-    text.gsub!( /(.)\n(?!\n|\Z| *([#*=]+(\s|$)|[{|]))/, "\\1<br />" ) if hard_breaks && RedCloth::VERSION == "3.0.4"
-  end 
-end
-