hobofields 0.7.5

data/lib/hobo_fields/migration_generator.rb

@@ -0,0 +1,293 @@
+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
+        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
+      ActiveRecord::Base.connection
+    end
+    
+    
+    def native_types
+      connection.native_database_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      
+      [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)
+      if renames
+        # A hash of table renames has been provided
+
+        to_rename = {}
+        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
+            raise MigrationGeneratorError, "Invalid table rename specified: #{old_name} => #{new_name}"
+          end
+        end
+        to_rename
+        
+      elsif @ambiguity_resolver
+        @ambiguity_resolver.extract_renames!(to_create, to_drop, "table")
+
+      else
+        raise MigrationGeneratorError, "Unable to resolve migration ambiguities"
+      end
+    end
+    
+    
+    def extract_column_renames!(to_add, to_remove, table_name)
+      if renames
+        to_rename = {}
+        column_renames = renames._?[table_name.to_sym]
+        if column_renames
+          # A hash of table renames has been provided
+
+          column_renames.each_pair do |old_name, new_name|
+            if to_add.delete(new_name.to_s) && to_remove.delete(old_name.to_s)
+              to_rename[old_name.to_s] = new_name.to_s
+            else
+              raise MigrationGeneratorError, "Invalid rename specified: #{old_name} => #{new_name}"
+            end
+          end
+        end
+        to_rename
+        
+      elsif @ambiguity_resolver
+        @ambiguity_resolver.extract_renames!(to_add, to_remove, "column", "#{table_name}.")
+
+      else
+        raise MigrationGeneratorError, "Unable to resolve migration ambiguities in table #{table_name}"
+      end
+    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_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"
+      undo_renames = to_rename.map do |old_name, new_name|
+        "rename_table :#{new_name}, :#{old_name}"
+      end * "\n"
+
+      drops = to_drop.map do |t|
+        "drop_table :#{t}"
+      end * "\n"
+      undo_drops = to_drop.map do |t|
+        revert_table(t)
+      end * "\n\n"
+
+      creates = to_create.map do |t|
+        create_table(models_by_table_name[t])
+      end * "\n\n"
+      undo_creates = to_create.map do |t|
+        "drop_table :#{t}"
+      end * "\n"
+      
+      changes = []
+      undo_changes = []
+      to_change.each do |t|
+        model = models_by_table_name[t]
+        table = to_rename.index(t) || model.table_name
+        if table.in?(db_tables)
+          change, undo = change_table(model, table)
+          changes << change
+          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"
+
+      [up, down]
+    end
+
+    def create_table(model)
+      longest_field_name = model.field_specs.values.map { |f| f.sql_type.to_s.length }.max
+      (["create_table :#{model.table_name} do |t|"] +
+       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]
+
+      to_rename = extract_column_renames!(to_add, to_remove, new_table_name)
+
+      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]
+        args = [":#{spec.sql_type}"] + format_options(spec.options, spec.sql_type)
+        "add_column :#{new_table_name}, :#{c}, #{args * ', '}"
+      end
+      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 = []
+      to_change.each do |c|
+        col_name = old_names[c] || c
+        col = db_columns[col_name]
+        spec = model.field_specs[c]
+        if spec.different_to?(col)
+          change_spec = {}
+          change_spec[:limit]     = spec.limit     unless spec.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[: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(", ")
+          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)
+      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}" 
+      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))
+        # Ugly migration
+        _, type, options = *md
+      elsif (md = revert.match(/\s*t\.([a-z_]+)\s+"#{column}"(?:,\s+(.*?)$)?/m))
+        # Sexy migration
+        _, type, options = *md
+        type = ":#{type}"
+      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

data/lib/hobo_fields/model_extensions.rb

@@ -0,0 +1,172 @@
+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
+    
+    # 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
+    # type.
+    def self.attr_accessor_with_rich_types(*attrs)
+      options = attrs.extract_options!
+      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|
+          declare_attr_type attr, type
+          define_method "#{attr}=" do |val|
+            if !val.is_a?(type) && HoboFields.can_wrap?(val)
+              val = type.new(val.to_s)
+            end
+            instance_variable_set("@#{attr}", val)
+          end
+        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
+    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)
+      type_col = "#{name}_type"
+      declare_field(type_col, :string, column_options)
+      # FIXME: Before hobofields was extracted, this used to now do:
+      # 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.
+    def self.declare_attr_type(name, type)
+      attr_types[name] = HoboFields.to_class(type)
+    end
+
+
+    # Declare named field with a type and an arbitrary set of
+    # arguments. The arguments are forwarded to the #field_added
+    # callback, allowing custom metadata to be added to field
+    # declarations.
+    def self.declare_field(name, type, *args)
+      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)
+    end
+    
+    
+    # Add field validations according to arguments and options in the
+    # field declaration
+    def self.add_validations_for_field(name, type, args, options)
+      validates_presence_of   name if :required.in?(args)
+      validates_uniqueness_of name if :unique.in?(args)
+
+      type_class = HoboFields.to_class(type)
+      if type_class && "validate".in?(type_class.public_instance_methods)
+        self.validate do |record|
+          v = record.send(name)._?.validate
+          record.errors.add(name, v) if v.is_a?(String)
+        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 = {})
+      declare_field(options.fetch(:column, "position"), :integer)
+      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
+    def self.attr_type(name)
+      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])
+            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 
+    def self.column(name)
+      name = name.to_s
+      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
+    end
+
+  end
+
+end

data/lib/hobo_fields/password_string.rb

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

data/lib/hobo_fields/text.rb

@@ -0,0 +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")
+    end
+    
+    HoboFields.register_type(:text, self)
+  
+  end
+  
+end

data/lib/hobo_fields/textile_string.rb

@@ -0,0 +1,29 @@
+require 'redcloth'
+
+module HoboFields
+  
+  class TextileString < HoboFields::Text
+
+    def to_html
+      if blank?
+        ""
+      else
+        textilized = RedCloth.new(self, [ :hard_breaks ])
+        textilized.hard_breaks = true if textilized.respond_to?("hard_breaks=")
+        textilized.to_html
+      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
+

data/lib/hobo_fields.rb

@@ -0,0 +1,139 @@
+require 'hobosupport'
+
+Dependencies.load_paths |= [ File.dirname(__FILE__) ] if defined?(Dependencies)
+
+module Hobo
+  # Empty class to represent the boolean type.
+  class Boolean; end
+end
+
+module HoboFields
+  
+  VERSION = "0.7.5"
+  
+  extend self
+  
+  PLAIN_TYPES = { 
+    :boolean       => Hobo::Boolean,
+    :date          => Date,
+    :datetime      => Time,
+    :integer       => Fixnum,
+    :big_integer   => BigDecimal,
+    :float         => Float,
+    :string        => String
+  }
+  
+  # Provide a lookup for these rather than loading them all preemptively
+  STANDARD_TYPES = {
+    :html          => "HtmlString",
+    :markdown      => "MarkdownString",
+    :textile       => "TextileString",
+    :password      => "PasswordString",
+    :text          => "Text",
+    :email_address => "EmailAddress"
+  }
+  
+  @field_types   = HashWithIndifferentAccess.new(PLAIN_TYPES)
+  @never_wrap_types = Set.new([NilClass, Hobo::Boolean, TrueClass, FalseClass])
+
+  attr_reader :field_types
+  
+  def to_class(type)
+    if type.is_a?(Symbol, String)
+      type = type.to_sym
+      field_types[type] || standard_class(type)
+    else
+      type # assume it's already a class
+    end
+  end
+  
+  
+  def to_name(type)
+    field_types.index(type)
+  end
+
+  
+  def can_wrap?(val)
+    # Make sure we get the *real* class
+    klass = Object.instance_method(:class).bind(val).call
+    !@never_wrap_types.any? { |c| klass <= c }
+  end
+  
+  
+  def never_wrap(type)
+    @never_wrap_types << type
+  end
+  
+  
+  def register_type(name, klass)
+    field_types[name] = klass
+  end
+  
+  
+  def plain_type?(type_name)
+    type_name.in?(PLAIN_TYPES)
+  end
+  
+  
+  def standard_class(name)
+    class_name = STANDARD_TYPES[name]
+    "HoboFields::#{class_name}".constantize if class_name
+  end
+  
+  def enable
+    require "hobo_fields/enum_string"
+    require "hobo_fields/fields_declaration"
+
+    # Add the fields do declaration to ActiveRecord::Base
+    ActiveRecord::Base.send(:include, HoboFields::FieldsDeclaration)
+    
+    # Monkey patch ActiveRecord so that the attribute read & write methods
+    # automatically wrap richly-typed fields.
+    ActiveRecord::AttributeMethods::ClassMethods.class_eval do 
+      
+      # Define an attribute reader method.  Cope with nil column.
+      def define_read_method(symbol, attr_name, column)
+        cast_code = column.type_cast_code('v') if column
+        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}'); ")
+        end
+
+        # This is the Hobo hook - add a type wrapper around the field
+        # value if we have a special type defined
+        src = if connected? && (type_wrapper = try.attr_type(symbol)) &&
+                  type_wrapper.is_a?(Class) && type_wrapper.not_in?(HoboFields::PLAIN_TYPES.values)
+                "val = begin; #{access_code}; end; " +
+                  "if HoboFields.can_wrap?(val); self.class.attr_type(:#{attr_name}).new(val); else; val; end"
+              else
+                access_code
+              end
+        
+        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? && (type_wrapper = try.attr_type(attr_name)) &&
+                  type_wrapper.is_a?(Class) && type_wrapper.not_in?(HoboFields::PLAIN_TYPES.values)
+                "begin; wrapper_type = self.class.attr_type(:#{attr_name}); " +
+                  "if !val.is_a?(wrapper_type) && HoboFields.can_wrap?(val); wrapper_type.new(val); else; val; end; end"
+              else
+                "val"
+              end
+        evaluate_attribute_method(attr_name,
+                                  "def #{attr_name}=(val); write_attribute('#{attr_name}', #{src});end", "#{attr_name}=")
+        
+      end
+
+    end
+    
+    
+  end
+  
+end
+
+
+HoboFields.enable if defined? ActiveRecord

data/lib/hobofields.rb

@@ -0,0 +1 @@
+require 'hobo_fields'