hobofields 0.9.0 → 0.9.100

data/Rakefile

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'activerecord'
 ActiveRecord::ActiveRecordError # hack for https://rails.lighthouseapp.com/projects/8994/tickets/2577-when-using-activerecordassociations-outside-of-rails-a-nameerror-is-thrown
 
-RUBY = ENV['RUBY'] || (defined?(JRUBY_VERSION) ? 'jruby' : 'ruby')
+RUBY = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name']).sub(/.*\s.*/m, '"\&"')
 RUBYDOCTEST = ENV['RUBYDOCTEST'] || "#{RUBY} `which rubydoctest`"
 
 $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), '/../hobofields/lib')
@@ -24,23 +24,19 @@ namespace "test" do
   end
 end
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.version      = HoboFields::VERSION
-    gemspec.name         = "hobofields"
-    gemspec.email        = "tom@tomlocke.com"
-    gemspec.summary      = "Rich field types and migration generator for Rails"
-    gemspec.homepage     = "http://hobocentral.net/"
-    gemspec.authors      = ["Tom Locke"]
-    gemspec.rubyforge_project = "hobo"
-    gemspec.add_dependency("rails", [">= 2.2.2"])
-    gemspec.add_dependency("hobosupport", ["= #{HoboFields::VERSION}"])    
-  end
-  Jeweler::GemcutterTasks.new
-  Jeweler::RubyforgeTasks.new do |rubyforge|
-    rubyforge.doc_task = false
-  end
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+require 'jeweler'
+Jeweler::Tasks.new do |gemspec|
+  gemspec.version      = HoboFields::VERSION
+  gemspec.name         = "hobofields"
+  gemspec.email        = "tom@tomlocke.com"
+  gemspec.summary      = "Rich field types and migration generator for Rails"
+  gemspec.homepage     = "http://hobocentral.net/"
+  gemspec.authors      = ["Tom Locke"]
+  gemspec.rubyforge_project = "hobo"
+  gemspec.add_dependency("rails", [">= 2.2.2"])
+  gemspec.add_dependency("hobosupport", ["= #{HoboFields::VERSION}"])    
+end
+Jeweler::GemcutterTasks.new
+Jeweler::RubyforgeTasks.new do |rubyforge|
+  rubyforge.doc_task = false
 end

data/lib/hobo_fields.rb

@@ -9,7 +9,7 @@ end
 
 module HoboFields
 
-  VERSION = "0.9.0"
+  VERSION = "0.9.100"
 
   extend self
 
@@ -60,7 +60,7 @@ module HoboFields
 
 
   def to_name(type)
-    field_types.index(type) || ALIAS_TYPES[type]
+    field_types.key(type) || ALIAS_TYPES[type]
   end
 
 
@@ -100,6 +100,15 @@ module HoboFields
     # Add the fields do declaration to ActiveRecord::Base
     ActiveRecord::Base.send(:include, HoboFields::FieldsDeclaration)
 
+    # automatically load other rich types from app/rich_types/*.rb
+    # don't assume we're in a Rails app
+    if defined?(::Rails)
+      Dir[File.join(::Rails.root, 'app', 'rich_types', '*.rb')].each do |f|
+        # TODO: should we complain if field_types doesn't get a new value? Might be useful to warn people if they're missing a register_type
+        require f
+      end
+    end
+
     # Monkey patch ActiveRecord so that the attribute read & write methods
     # automatically wrap richly-typed fields.
     ActiveRecord::AttributeMethods::ClassMethods.class_eval do

data/lib/hobo_fields/enum_string.rb

@@ -19,16 +19,40 @@ module HoboFields
 
       def with_values(*values)
         @values = values.*.to_s
+        @translated_values = Hash.new do |hash, value|
+          if name.blank? || value.blank?
+            hash[value] = value
+          else
+            hash[value] = I18n.t("#{name.tableize}.#{value}", :default => value)
+            @detranslated_values[hash[value]] = value
+            hash[value]
+          end
+        end
+            
+        @detranslated_values = Hash.new do |hash, value|
+          if name.blank?
+            hash[value] = value
+          else
+            hash[value] = @values.detect(proc { value } ) {|v|
+              @translated_values[v]==value
+            }
+          end
+        end
       end
 
       attr_accessor :values
 
+      attr_accessor :translated_values
+
+      attr_accessor :detranslated_values
+
       def for(*values)
+        options = values.extract_options!
         values = values.*.to_s
         c = Class.new(EnumString) do
           values.each do |v|
             const_name = v.upcase.gsub(/[^a-z0-9_]/i, '_').gsub(/_+/, '_')
-            const_name = "V" + const_name if const_name =~ /^[0-9_]/
+            const_name = "V" + const_name if const_name =~ /^[0-9_]/ || const_name.blank?
             const_set(const_name, self.new(v)) unless const_defined?(const_name)
 
             method_name = "is_#{v.underscore}?"
@@ -36,6 +60,7 @@ module HoboFields
           end
         end
         c.with_values(*values)
+        c.set_name(options[:name]) if options[:name]
         c
       end
 
@@ -44,12 +69,28 @@ module HoboFields
       end
       alias_method :to_s, :inspect
 
+      def set_name(name)
+        @name = name
+      end
+
+      def name
+        @name || super
+      end
+
     end
 
     COLUMN_TYPE = :string
 
+    def initialize(value)
+      super(self.class.detranslated_values.nil? ? value : self.class.detranslated_values[value.to_s])
+    end
+
     def validate
-      "must be one of #{self.class.values * ', '}" unless self.in?(self.class.values)
+      "must be one of #{self.class.values.map{|v| v.blank? ? '\'\'' : v} * ', '}" unless self.in?(self.class.values)
+    end
+
+    def to_html(xmldoctype = true)
+      self.class.translated_values[self]
     end
 
     def ==(other)

data/lib/hobo_fields/field_spec.rb

@@ -9,8 +9,9 @@ module HoboFields
       self.model = model
       self.name = name.to_sym
       self.type = type.is_a?(String) ? type.to_sym : type
+      position = options.delete(:position)
       self.options = options
-      self.position = model.field_specs.length
+      self.position = position || model.field_specs.length
     end
 
     attr_accessor :model, :name, :type, :position, :options

data/lib/hobo_fields/fields_declaration.rb

@@ -2,13 +2,15 @@ module HoboFields
 
   FieldsDeclaration = classy_module do
 
-    def self.fields(&b)
+    def self.fields(include_in_migration = true, &b)
       # Any model that calls 'fields' gets a bunch of other
-      # functionality included automatically, but make sure we only include it once
+      # functionality included automatically, but make sure we only
+      # include it once
       include HoboFields::ModelExtensions unless HoboFields::ModelExtensions.in?(included_modules)
+      @include_in_migration ||= include_in_migration
 
       if b
-        dsl = FieldDeclarationDsl.new(self)
+        dsl = HoboFields::FieldDeclarationDsl.new(self)
         if b.arity == 1
           yield dsl
         else

data/lib/hobo_fields/index_spec.rb

@@ -16,8 +16,8 @@ module HoboFields
     def self.for_model(model, old_table_name=nil)
       t = old_table_name || model.table_name
       model.connection.indexes(t).map do |i|
-        self.new(model, i.columns, :name => i.name, :unique => i.unique, :table_name => old_table_name)
-      end
+        self.new(model, i.columns, :name => i.name, :unique => i.unique, :table_name => old_table_name) unless model.ignore_indexes.include?(i.name)
+      end.compact
     end
 
     def default_name?

data/lib/hobo_fields/lifecycle_state.rb

@@ -0,0 +1,14 @@
+module HoboFields
+  class LifecycleState < String
+    
+    COLUMN_TYPE = :string
+
+    class << self
+      attr_accessor :table_name
+    end
+    
+    def to_html(xmldoctype = true)
+      I18n.t("#{self.class.table_name}.states.#{self}", :default => self)
+    end
+  end
+end

data/lib/hobo_fields/migration_generator.rb

@@ -2,6 +2,42 @@ module HoboFields
 
   class MigrationGeneratorError < RuntimeError; end
 
+  class HabtmModelShim < Struct.new(:join_table, :foreign_keys, :connection)
+
+    def self.from_reflection(refl)
+      result = self.new
+      result.join_table = refl.options[:join_table].to_s
+      result.foreign_keys = [refl.primary_key_name.to_s, refl.association_foreign_key.to_s].sort
+      # this may fail in weird ways if HABTM is running across two DB connections (assuming that's even supported)
+      # figure that anybody who sets THAT up can deal with their own migrations...
+      result.connection = refl.active_record.connection
+      result
+    end
+
+    def table_name
+      self.join_table
+    end
+
+    def field_specs
+      i = 0
+      foreign_keys.inject({}) do |h, v|
+        # some trickery to avoid an infinite loop when FieldSpec#initialize tries to call model.field_specs
+        h[v] = FieldSpec.new(self, v, :integer, :position => i)
+        i += 1
+        h
+      end
+    end
+
+    def primary_key
+      false
+    end
+
+    def index_specs
+      []
+    end
+
+  end
+
   class MigrationGenerator
 
     @ignore_models = []
@@ -40,7 +76,7 @@ module HoboFields
     # 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::") }
+      ActiveRecord::Base.send(:subclasses).reject {|c| (c.base_class != c) || c.name.starts_with?("CGI::") }
     end
 
 
@@ -65,19 +101,23 @@ module HoboFields
 
     # list habtm join tables
     def habtm_tables
+      reflections = Hash.new { |h, k| h[k] = Array.new }
       ActiveRecord::Base.send(:subclasses).map do |c|
-        c.reflect_on_all_associations(:has_and_belongs_to_many).map { |a| a.options[:join_table] }
-      end.flatten.compact.*.to_s
+        c.reflect_on_all_associations(:has_and_belongs_to_many).each do |a|
+          reflections[a.options[:join_table].to_s] << a
+        end
+      end
+      reflections
     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
+      ignore_model_names = MigrationGenerator.ignore_models.*.to_s.*.underscore
       all_models = table_model_classes
-      hobo_models = all_models.select { |m| m < HoboFields::ModelExtensions && m.name.underscore.not_in?(ignore_model_names) }
+      hobo_models = all_models.select { |m| m.try.include_in_migration && m.name.underscore.not_in?(ignore_model_names) }
       non_hobo_models = all_models - hobo_models
-      db_tables = connection.tables - MigrationGenerator.ignore_tables.*.to_s - non_hobo_models.*.table_name - habtm_tables
+      db_tables = connection.tables - MigrationGenerator.ignore_tables.*.to_s - non_hobo_models.*.table_name
       [hobo_models, db_tables]
     end
 
@@ -134,8 +174,8 @@ module HoboFields
         raise MigrationGeneratorError, "Unable to resolve migration ambiguities in table #{table_name}"
       end
     end
-    
-    
+
+
     def always_ignore_tables
       # TODO: figure out how to do this in a sane way and be compatible with 2.2 and 2.3 - class has moved
       sessions_table = CGI::Session::ActiveRecordStore::Session.table_name if
@@ -158,6 +198,10 @@ module HoboFields
           models_by_table_name[m.table_name] = m
         end
       end
+      # generate shims for HABTM models
+      habtm_tables.each do |name, refls|
+        models_by_table_name[name] = HabtmModelShim.from_reflection(refls.first)
+      end
       model_table_names = models_by_table_name.keys
 
       to_create = model_table_names - db_tables
@@ -189,25 +233,35 @@ module HoboFields
 
       changes = []
       undo_changes = []
+      index_changes = []
+      undo_index_changes = []
       to_change.each do |t|
         model = models_by_table_name[t]
-        table = to_rename.index(t) || model.table_name
+        table = to_rename.key(t) || model.table_name
         if table.in?(db_tables)
-          change, undo = change_table(model, table)
+          change, undo, index_change, undo_index = change_table(model, table)
           changes << change
           undo_changes << undo
+          index_changes << index_change
+          undo_index_changes << undo_index
         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"
+      up   = [renames, drops, creates, changes, index_changes].flatten.reject(&:blank?) * "\n\n"
+      down = [undo_changes, undo_renames, undo_drops, undo_creates, undo_index_changes].flatten.reject(&:blank?) * "\n\n"
 
       [up, down]
     end
 
     def create_table(model)
       longest_field_name = model.field_specs.values.map { |f| f.sql_type.to_s.length }.max
-      primary_key_option = ", :primary_key => :#{model.primary_key}" if model.primary_key != "id"
+      if model.primary_key != "id"
+        if model.primary_key
+          primary_key_option = ", :primary_key => :#{model.primary_key}"
+        else
+          primary_key_option = ", :id => false"
+        end
+      end
       (["create_table :#{model.table_name}#{primary_key_option} do |t|"] +
        model.field_specs.values.sort_by{|f| f.position}.map {|f| create_field(f, longest_field_name)} +
        ["end"] + (MigrationGenerator.disable_indexing ? [] : create_indexes(model))) * "\n"
@@ -226,15 +280,16 @@ module HoboFields
       new_table_name = model.table_name
 
       db_columns = model.connection.columns(current_table_name).index_by{|c|c.name}
-      key_missing = db_columns[model.primary_key].nil?
+      key_missing = db_columns[model.primary_key].nil? && model.primary_key
       db_columns -= [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_add += [model.primary_key] if key_missing
-      to_remove = db_column_names - model_column_names - [model.primary_key.to_sym]
+      to_add += [model.primary_key] if key_missing && model.primary_key
+      to_remove = db_column_names - model_column_names
+      to_remove = to_remove - [model.primary_key.to_sym] if model.primary_key
 
       to_rename = extract_column_renames!(to_add, to_remove, new_table_name)
       
@@ -292,12 +347,14 @@ module HoboFields
 
       index_changes, undo_index_changes = change_indexes(model, current_table_name)
 
-      [(renames + adds + removes + changes + index_changes) * "\n",
-       (undo_renames + undo_adds + undo_removes + undo_changes + undo_index_changes) * "\n"]
+      [(renames + adds + removes + changes) * "\n",
+       (undo_renames + undo_adds + undo_removes + undo_changes) * "\n",
+       index_changes * "\n",
+       undo_index_changes * "\n"]
     end
 
     def change_indexes(model, old_table_name)
-      return [[],[]] if MigrationGenerator.disable_indexing
+      return [[],[]] if MigrationGenerator.disable_indexing || model.is_a?(HabtmModelShim)
       new_table_name = model.table_name
       existing_indexes = IndexSpec.for_model(model, old_table_name)
       model_indexes = model.index_specs

data/lib/hobo_fields/model_extensions.rb

@@ -2,6 +2,9 @@ module HoboFields
 
   ModelExtensions = classy_module do
 
+    # ignore the model in the migration until somebody sets
+    # @include_in_migration via the fields declaration
+    inheriting_cattr_reader :include_in_migration => false
 
     # attr_types holds the type class for any attribute reader (i.e. getter
     # method) that returns rich-types
@@ -17,19 +20,26 @@ module HoboFields
 
     # index_specs holds IndexSpec objects for all the declared indexes.
     inheriting_cattr_reader :index_specs => []
+    inheriting_cattr_reader :ignore_indexes => []
 
     def self.inherited(klass)
       fields do |f|
         f.field(inheritance_column, :string)
       end
-      index(inheritance_column) unless index_specs.*.fields.include?([inheritance_column])
+      index(inheritance_column)
       super
     end
 
     def self.index(fields, options = {})
-      index_specs << IndexSpec.new(self, fields, options)
+      # don't double-index fields
+      index_specs << HoboFields::IndexSpec.new(self, fields, options) unless index_specs.*.fields.include?(Array.wrap(fields).*.to_s)
     end
 
+    # tell the migration generator to ignore the named index. Useful for existing indexes, or for indexes
+    # that can't be automatically generated (for example: an prefix index in MySQL)
+    def self.ignore_index(index_name)
+      ignore_indexes << index_name.to_s
+    end
 
     private
 
@@ -49,7 +59,9 @@ module HoboFields
       options = attrs.extract_options!
       type = options.delete(:type)
       attrs << options unless options.empty?
+      public
       attr_accessor_without_rich_types(*attrs)
+      private
 
       if type
         type = HoboFields.to_class(type)
@@ -124,7 +136,7 @@ module HoboFields
       add_validations_for_field(name, type, args)
       add_index_for_field(name, args, options)
       declare_attr_type(name, type, options) unless HoboFields.plain_type?(type)
-      field_specs[name] = FieldSpec.new(self, name, type, options)
+      field_specs[name] = HoboFields::FieldSpec.new(self, name, type, options)
       attr_order << name unless name.in?(attr_order)
     end
 
@@ -136,7 +148,7 @@ module HoboFields
       validates_uniqueness_of name, :allow_nil => !:required.in?(args) if :unique.in?(args)
 
       type_class = HoboFields.to_class(type)
-      if type_class && "validate".in?(type_class.public_instance_methods)
+      if type_class && type_class.public_method_defined?("validate")
         self.validate do |record|
           v = record.send(name)._?.validate
           record.errors.add(name, v) if v.is_a?(String)

data/rails_generators/hobo_migration/hobo_migration_generator.rb

@@ -53,7 +53,9 @@ class HoboMigrationGenerator < Rails::Generator::Base
       at_exit { rake_migrate } if action == 'm'
 
       up.gsub!("\n", "\n    ")
+      up.gsub!(/ +\n/, "\n")
       down.gsub!("\n", "\n    ")
+      down.gsub!(/ +\n/, "\n")
 
       record do |m|
         m.migration_template 'migration.rb', 'db/migrate',
@@ -73,27 +75,40 @@ class HoboMigrationGenerator < Rails::Generator::Base
     to_rename = {}
     rename_to_choices = to_create
     to_drop.dup.each do |t|
-      if rename_to_choices.empty?
-        puts "\nCONFIRM DROP! #{kind_str} #{name_prefix}#{t}"
-        resp = input("Enter 'drop #{t}' to confirm:")
-        if resp.strip != "drop " + t.to_s
-          to_drop.delete(t)
-        end
-      else
-        puts "\nDROP or RENAME?: #{kind_str} #{name_prefix}#{t}"
-        puts "Rename choices: #{to_create * ', '}"
-        resp = input("Enter either 'drop #{t}' or one of the rename choices:")
-        resp.strip!
-
-        if resp == "drop " + t
-          # Leave things as they are
+      while true
+        if rename_to_choices.empty?
+          puts "\nCONFIRM DROP! #{kind_str} #{name_prefix}#{t}"
+          resp = input("Enter 'drop #{t}' to confirm or press enter to keep:")
+          if resp.strip == "drop " + t.to_s
+            break
+          elsif resp.strip.empty?
+            to_drop.delete(t)
+            break
+          else
+            next
+          end
         else
-          resp.gsub!(' ', '_')
-          to_drop.delete(t)
-          if resp.in?(rename_to_choices)
-            to_rename[t] = resp
-            to_create.delete(resp)
-            rename_to_choices.delete(resp)
+          puts "\nDROP, RENAME or KEEP?: #{kind_str} #{name_prefix}#{t}"
+          puts "Rename choices: #{to_create * ', '}"
+          resp = input("Enter either 'drop #{t}' or one of the rename choices or press enter to keep:")
+          resp.strip!
+
+          if resp == "drop " + t
+            # Leave things as they are
+            break
+          else
+            resp.gsub!(' ', '_')
+            to_drop.delete(t)
+            if resp.in?(rename_to_choices)
+              to_rename[t] = resp
+              to_create.delete(resp)
+              rename_to_choices.delete(resp)
+              break
+            elsif resp.empty?
+              break
+            else
+              next
+            end
           end
         end
       end
@@ -132,7 +147,7 @@ class HoboMigrationGenerator < Rails::Generator::Base
       opt.separator 'Options:'
       
       opt.on("--force-drop",   "Don't prompt with 'drop or rename' - just drop everything") { |v| options[:force_drop] = true }
-      opt.on("--default-name", "Dont' prompt for a migration name - just pick one")         { |v| options[:default_name] = true }
+      opt.on("--default-name", "Don't prompt for a migration name - just pick one")         { |v| options[:default_name] = true }
       opt.on("--generate",     "Don't prompt for action - generate the migration")          { |v| options[:action] = 'g' }
       opt.on("--migrate",      "Don't prompt for action - generate and migrate")            { |v| options[:action] = 'm' }
     end

data/test/migration_generator.rdoctest

@@ -70,6 +70,9 @@ The migration generator only takes into account classes that use HoboFields, i.e
     >> HoboFields::MigrationGenerator.run
     => ["", ""]
 
+You can also tell HoboFields to ignore additional tables.  You can place this command in your environment.rb or elsewhere:
+
+    >> HoboFields::MigrationGenerator.ignore_tables = ["green_fishes"]
 
 ### Create the table
 
@@ -266,10 +269,12 @@ foreign-key field.  It also generates an index on the field.
         >> up
         => 
          "add_column :adverts, :category_id, :integer
+
          add_index :adverts, [:category_id]"
         >> down
         => 
          "remove_column :adverts, :category_id
+
          remove_index :adverts, :name => :index_adverts_on_category_id"
 
 Cleanup:
@@ -289,6 +294,7 @@ If you specify a custom foreign key, the migration generator observes that:
         >> up
         => 
          "add_column :adverts, :c_id, :integer
+
          add_index :adverts, [:c_id]"
 
 Cleanup:
@@ -325,6 +331,7 @@ You can specify the index name with :index
         >> up
         => 
          "add_column :adverts, :category_id, :integer
+
          add_index :adverts, [:category_id], :name => 'my_index'"
 
 Cleanup:
@@ -373,7 +380,7 @@ You can add an index to a field definition
            end
          end
         >> up, down = HoboFields::MigrationGenerator.run
-        >> up.split("\n")[1]
+        >> up.split("\n")[2]
         => 'add_index :adverts, [:title]'
 
 Cleanup:
@@ -391,7 +398,7 @@ You can ask for a unique index
            end
          end
         >> up, down = HoboFields::MigrationGenerator.run
-        >> up.split("\n")[1]
+        >> up.split("\n")[2]
         => 'add_index :adverts, [:title], :unique => true'
 
 Cleanup:
@@ -409,7 +416,7 @@ You can specify the name for the index
            end
          end
         >> up, down = HoboFields::MigrationGenerator.run
-        >> up.split("\n")[1]
+        >> up.split("\n")[2]
         => "add_index :adverts, [:title], :name => 'my_index'"
 
 Cleanup:
@@ -425,7 +432,7 @@ You can ask for an index outside of the fields block
            index :title
          end
         >> up, down = HoboFields::MigrationGenerator.run
-        >> up.split("\n")[1]
+        >> up.split("\n")[2]
         => "add_index :adverts, [:title]"
 
 Cleanup:
@@ -441,7 +448,7 @@ The available options for the index function are `:unique` and `:name`
            index :title, :unique => true, :name => 'my_index'
          end
         >> up, down = HoboFields::MigrationGenerator.run
-        >> up.split("\n")[1]
+        >> up.split("\n")[2]
         => "add_index :adverts, [:title], :unique => true, :name => 'my_index'"
 
 Cleanup:
@@ -457,7 +464,7 @@ You can create an index on more than one field
            index [:title, :category_id]
          end
         >> up, down = HoboFields::MigrationGenerator.run
-        >> up.split("\n")[1]
+        >> up.split("\n")[2]
         => "add_index :adverts, [:title, :category_id]"
 
 Cleanup:
@@ -466,6 +473,8 @@ Cleanup:
         >> Advert.index_specs.delete_if {|spec| spec.fields==["title", "category_id"]}
 {.hidden}
 
+Finally, you can specify that the migration generator should completely ignore an index by passing its name to ignore_index in the model. This is helpful for preserving indices that can't be automatically generated, such as prefix indices in MySQL.
+
 ### Rename a table
 
 The migration generator respects the `set_table_name` declaration, although as before, we need to explicitly tell the generator that we want a rename rather than a create and a drop.
@@ -556,10 +565,12 @@ Adding a subclass or two should introduce the 'type' column and no other changes
         >> up
         =>
          "add_column :adverts, :type, :string
+
          add_index :adverts, [:type]"
         >> down
         => 
          "remove_column :adverts, :type
+
          remove_index :adverts, :name => :index_adverts_on_type"
 
 Cleanup

data/test/rich_types.rdoctest

@@ -1,6 +1,6 @@
 # HoboFields -- Rich Types
 
-This doctest describes the rich types bundles with HoboFields, and the process by which you can create and register your own types.
+This doctest describes the rich types bundled with HoboFields, and the process by which you can create and register your own types.
 
 Our test requires rails:
 {.hidden}
@@ -41,7 +41,6 @@ Finally we can require hobofields:
         >> require 'hobosupport'
         >> require 'hobofields'
 
-
 ## `to_html` method
 
 The rich types provide a `to_html` method. If you are using the full Hobo stack you don't need to be aware of this unless you're defining your own rich types -- the `<view>` tag uses `to_html` to render a rich type. If you are not using DRYML and Rapid, you can simply call `to_html` in your views, e.g.
@@ -163,7 +162,7 @@ Provides validation of correct email address format.
 
 `HoboFields::EnumString` is not a rich type that you use directly. It's a "type generator", rather like Ruby's `Struct`. It's used for the common situation in database driven apps that you want an enumerated type, but it's not worth going to the extra bother of a separate table enumerating the values. For example you could create a type to represent the status of an article:
 
-        >> ArticleStatus = HoboFields::EnumString.for(:draft, :approved, :published)
+        >> ArticleStatus = HoboFields::EnumString.for('', :draft, :approved, :published)
         => ArticleStatus
 
 Note that, like all dynamically created classes in Ruby, the class is anonymous until assigned to a constant:
@@ -208,6 +207,13 @@ Note that every enum you create is a subclass of HoboFields::EnumString:
         >> a.is_a?(HoboFields::EnumString)
         => true
 
+EnumString's have a `validate` function defined to fit in with the
+ActiveRecord validation framework.
+
+       >> a.validate
+       => nil
+       >> ArticleStatus.new("junked").validate
+       => "must be one of '', draft, approved, published"
 
 ### Using EnumString in your models
 
@@ -228,12 +234,46 @@ Sometimes it's nice to have a proper type name. Here's one way you might go abou
          class Article < ActiveRecord::Base
            Status = HoboFields::EnumString.for(:draft, :approved, :published)
            fields do
-             status Status
+             status Article::Status
            end
          end
         >> Article.attr_type :status
         => Article::Status
 
+### Translating EnumString's
+
+Named EnumString's may be translated.   Here is an example fr.yml:
+
+    fr:
+      article/statuses:
+        draft: "esquisse"
+        approved: "approuvé"
+        published: "publiés"
+
+Alternatively, the translations may be supplied in ruby:
+
+    >> Article::Status.translated_values = { "draft"=>"esquisse", "approved"=>"approuvé", "published"=>"publiés" }
+
+EnumString's can be created with the translated values.  Internally,
+they always store the native version.
+
+    >> a=Article::Status.new("esquisse")
+    => "draft"
+    >> a.is_draft?
+    => true
+
+The translated value is available via `to_html`:
+
+    >> Article::Status::PUBLISHED.to_html
+    => "publiés"
+
+Translations only work with named EnumString's.  The recommended way of naming the EnumString is to assign it to a constant, but if you do not wish to do this, you can supply the name in an option:
+
+    >> HoboFields::EnumString.for('one', 'two', 'three', :name => "Count").inspect
+    => "Count"
+
+`tableize` will be called on your name to provide the translation key.
+
 ## Cleanup
 {.hidden}
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hobofields
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
+  version: 0.9.100
 platform: ruby
 authors: 
 - Tom Locke
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-17 00:00:00 +00:00
+date: 2009-12-01 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,7 +30,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.9.0
+        version: 0.9.100
     version: 
 description: 
 email: tom@tomlocke.com
@@ -55,6 +55,7 @@ files:
 - lib/hobo_fields/fields_declaration.rb
 - lib/hobo_fields/html_string.rb
 - lib/hobo_fields/index_spec.rb
+- lib/hobo_fields/lifecycle_state.rb
 - lib/hobo_fields/markdown_string.rb
 - lib/hobo_fields/migration_generator.rb
 - lib/hobo_fields/model_extensions.rb