hobo_fields 1.3.0.RC

data/lib/hobo_fields/model/field_spec.rb

@@ -0,0 +1,121 @@
+module HoboFields
+  module Model
+
+    class FieldSpec
+
+      class UnknownSqlTypeError < RuntimeError; end
+
+      def initialize(model, name, type, options={})
+        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.is_a?(String) ? type.to_sym : type
+        position = options.delete(:position)
+        self.options = options
+        self.position = position || model.field_specs.length
+      end
+
+      attr_accessor :model, :name, :type, :position, :options
+
+      TYPE_SYNONYMS = [[:timestamp, :datetime]]
+
+      begin
+        MYSQL_COLUMN_CLASS = ActiveRecord::ConnectionAdapters::MysqlColumn
+      rescue NameError
+        MYSQL_COLUMN_CLASS = NilClass
+      end
+
+      begin
+        SQLITE_COLUMN_CLASS = ActiveRecord::ConnectionAdapters::SQLiteColumn
+      rescue NameError
+        SQLITE_COLUMN_CLASS = NilClass
+      end
+
+      def sql_type
+        options[:sql_type] or begin
+                                if native_type?(type)
+                                  type
+                                else
+                                  field_class = HoboFields.to_class(type)
+                                  field_class && field_class::COLUMN_TYPE or raise UnknownSqlTypeError, "#{type.inspect} for #{model}.#{name}"
+                                end
+                              end
+      end
+
+      def limit
+        options[:limit] || native_types[sql_type][:limit]
+      end
+
+      def precision
+        options[:precision]
+      end
+
+      def scale
+        options[:scale]
+      end
+
+      def null
+        :null.in?(options) ? options[:null] : true
+      end
+
+      def default
+        options[:default]
+      end
+
+      def comment
+        options[:comment]
+      end
+
+      def same_type?(col_spec)
+        t = sql_type
+        TYPE_SYNONYMS.each do |synonyms|
+          if t.in? synonyms
+            return col_spec.type.in?(synonyms)
+          end
+        end
+        t == col_spec.type
+      end
+
+
+      def different_to?(col_spec)
+        !same_type?(col_spec) ||
+          # we should be able to use col_spec.comment, but col_spec has
+          # a nil table_name for some strange reason.
+          begin
+            if model.table_exists?
+              col_comment = ActiveRecord::Base.try.column_comment(col_spec.name, model.table_name)
+              col_comment != nil && col_comment != comment
+            else
+              false
+            end
+          end ||
+          begin
+            check_attributes = [:null, :default]
+            check_attributes += [:precision, :scale] if sql_type == :decimal && !col_spec.is_a?(SQLITE_COLUMN_CLASS)  # remove when rails fixes https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/2872
+            check_attributes -= [:default] if sql_type == :text && col_spec.is_a?(MYSQL_COLUMN_CLASS)
+            check_attributes << :limit if sql_type.in?([:string, :text, :binary, :integer])
+            check_attributes.any? do |k|
+              if k==:default && sql_type==:datetime
+                col_spec.default.try.to_datetime != default.try.to_datetime
+              else
+                col_spec.send(k) != self.send(k)
+              end
+            end
+          end
+      end
+
+
+      private
+
+      def native_type?(type)
+        type.in?(native_types.keys - [:primary_key])
+      end
+
+      def native_types
+        Generators::Hobo::Migration::Migrator.native_types
+      end
+
+    end
+
+  end
+end

data/lib/hobo_fields/model/index_spec.rb

@@ -0,0 +1,47 @@
+module HoboFields
+  module Model
+
+    class IndexSpec
+
+      def initialize(model, fields, options={})
+        @model = model
+        self.table = options.delete(:table_name) || model.table_name
+        self.fields = Array.wrap(fields).*.to_s
+        self.name = options.delete(:name) || model.connection.index_name(self.table, :column => self.fields)
+        self.unique = options.delete(:unique) || false
+      end
+
+      attr_accessor :table, :fields, :name, :unique
+
+      # extract IndexSpecs from an existing table
+      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) unless model.ignore_indexes.include?(i.name)
+        end.compact
+      end
+
+      def default_name?
+        name == @model.connection.index_name(table, :column => fields)
+      end
+
+      def to_add_statement(new_table_name)
+        r = "add_index :#{new_table_name}, #{fields.*.to_sym.inspect}"
+        r += ", :unique => true" if unique
+        r += ", :name => '#{name}'" unless default_name?
+        r
+      end
+
+      def hash
+        [table, fields, name, unique].hash
+      end
+
+      def ==(v)
+        v.hash == hash
+      end
+      alias_method :eql?, :==
+
+    end
+
+  end
+end

data/lib/hobo_fields/model.rb

@@ -0,0 +1,226 @@
+module HoboFields
+
+  Model = 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
+    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
+
+    # index_specs holds IndexSpec objects for all the declared indexes.
+    inheriting_cattr_reader :index_specs => []
+    inheriting_cattr_reader :ignore_indexes => []
+
+    # eval avoids the ruby 1.9.2 "super from singleton method ..." error
+    eval %(
+      def self.inherited(klass)
+        fields do |f|
+          f.field(inheritance_column, :string)
+        end
+        index(inheritance_column)
+        super
+      end
+    )
+
+    def self.index(fields, options = {})
+      # don't double-index fields
+      index_specs << HoboFields::Model::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
+
+    # 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?
+      public
+      attr_accessor_without_rich_types(*attrs)
+      private
+
+      if type
+        type = HoboFields.to_class(type)
+        attrs.each do |attr|
+          declare_attr_type attr, type, options
+          type_wrapper = attr_type(attr)
+          define_method "#{attr}=" do |val|
+            if type_wrapper.not_in?(HoboFields::PLAIN_TYPES.values) && !val.is_a?(type) && HoboFields.can_wrap?(type, 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)
+      column_options = {}
+      column_options[:null] = options.delete(:null) if options.has_key?(:null)
+      column_options[:comment] = options.delete(:comment) if options.has_key?(:comment)
+
+      index_options = {}
+      index_options[:name] = options.delete(:index) if options.has_key?(:index)
+      bt = belongs_to_without_field_declarations(name, options, &block)
+      refl = reflections[name.to_sym]
+      fkey = refl.primary_key_name
+      declare_field(fkey.to_sym, :integer, column_options)
+      if refl.options[:polymorphic]
+        declare_polymorphic_type_field(name, column_options)
+        index(["#{name}_type", fkey], index_options) if index_options[:name]!=false
+      else
+        index(fkey, index_options) if index_options[:name]!=false
+      end
+      bt
+    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 hobo_fields 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, options={})
+      klass = HoboFields.to_class(type)
+      attr_types[name] = HoboFields.to_class(type)
+      klass.try.declared(self, name, options)
+    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_formatting_for_field(name, type, args)
+      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] = HoboFields::Model::FieldSpec.new(self, name, type, options)
+      attr_order << name unless name.in?(attr_order)
+    end
+
+
+    # Add field validations according to arguments in the
+    # field declaration
+    def self.add_validations_for_field(name, type, args)
+      validates_presence_of   name if :required.in?(args)
+      validates_uniqueness_of name, :allow_nil => !:required.in?(args) if :unique.in?(args)
+
+      type_class = HoboFields.to_class(type)
+      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)
+        end
+      end
+    end
+
+    def self.add_formatting_for_field(name, type, args)
+      type_class = HoboFields.to_class(type)
+      if type_class && "format".in?(type_class.instance_methods)
+        self.before_validation do |record|
+          record.send("#{name}=", record.send(name)._?.format)
+        end
+      end
+    end
+
+    def self.add_index_for_field(name, args, options)
+      to_name = options.delete(:index)
+      return unless to_name
+      index_opts = {}
+      index_opts[:unique] = :unique.in?(args) || options.delete(:unique)
+      # support :index => true declaration
+      index_opts[:name] = to_name unless to_name == true
+      index(name, index_opts)
+    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 references to classes"
+      end
+
+      attr_types[name] or
+
+        if (refl = reflections[name.to_sym])
+          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
+    def self.column(name)
+      return unless (@table_exists ||= table_exists?)
+      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/railtie.rb

@@ -0,0 +1,13 @@
+require 'hobo_fields'
+require 'rails'
+
+module HoboFields
+  class Railtie < Rails::Railtie
+
+    ActiveSupport.on_load(:active_record) do
+      require 'hobo_fields/extensions/active_record/attribute_methods'
+      require 'hobo_fields/extensions/active_record/fields_declaration'
+    end
+
+  end
+end

data/lib/hobo_fields/sanitize_html.rb

@@ -0,0 +1,23 @@
+module HoboFields
+
+  module SanitizeHtml
+
+    PERMITTED_TAGS       = %w(a abbr acronym address b bdo big blockquote br caption center cite code colgroup dd del dfn dir
+                              div dl dt em fieldset font h1 h2 h3 h4 h5 h6 i img ins kbd label legend li map menu ol optgroup
+                              option p pre q s samp select small span strike strong sub sup table tbody td textarea tfoot
+                              th thead tr tt u ul var)
+
+    PERMITTED_ATTRIBUTES = %w(href title class style align name src label target border)
+
+    class Helper
+      include ActionView::Helpers::SanitizeHelper
+      extend ActionView::Helpers::SanitizeHelper::ClassMethods
+    end
+
+    def self.sanitize(s)
+      Helper.new.sanitize(s, :tags => PERMITTED_TAGS, :attributes => PERMITTED_ATTRIBUTES)
+    end
+
+  end
+
+end

data/lib/hobo_fields/types/email_address.rb

@@ -0,0 +1,26 @@
+require 'active_support/core_ext/string/output_safety'
+
+module HoboFields
+  module Types
+    class EmailAddress < String
+
+      COLUMN_TYPE = :string
+
+      def validate
+        I18n.t("errors.messages.invalid") unless valid? || blank?
+      end
+
+      def valid?
+        self =~ /^\s*([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\s*$/i
+      end
+
+      def to_html(xmldoctype = true)
+        ERB::Util.html_escape(self).sub('@', " at ").gsub('.', ' dot ')
+      end
+
+      HoboFields.register_type(:email_address, self)
+
+    end
+  end
+end
+

data/lib/hobo_fields/types/enum_string.rb

@@ -0,0 +1,101 @@
+module HoboFields
+  module Types
+    class EnumString < String
+
+      module DeclarationHelper
+
+        def enum_string(*values)
+          EnumString.for(*values)
+        end
+
+      end
+
+      class << self
+
+        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.blank?
+              const_set(const_name, self.new(v)) unless const_defined?(const_name)
+
+              method_name = "is_#{v.underscore}?"
+              define_method(method_name) { self == v } unless self.respond_to?(method_name)
+            end
+          end
+          c.with_values(*values)
+          c.set_name(options[:name]) if options[:name]
+          c
+        end
+
+        def inspect
+          name.blank? ? "#<EnumString #{(values || []) * ' '}>" : name
+        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.map{|v| v.blank? ? '\'\'' : v} * ', '}" unless self.in?(self.class.values)
+      end
+
+      def to_html(xmldoctype = true)
+        self.class.translated_values[self].html_safe
+      end
+
+      def ==(other)
+        if other.is_a?(Symbol)
+          super(other.to_s)
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/hobo_fields/types/html_string.rb

@@ -0,0 +1,15 @@
+module HoboFields
+  module Types
+    class HtmlString < RawHtmlString
+
+      include SanitizeHtml
+
+      def self.declared(model, name, options)
+        model.before_save { |record| record[name] = HoboFields::SanitizeHtml.sanitize(record[name]) }
+      end
+
+      HoboFields.register_type(:html, self)
+    end
+
+  end
+end

data/lib/hobo_fields/types/lifecycle_state.rb

@@ -0,0 +1,16 @@
+module HoboFields
+  module Types
+    class LifecycleState < String
+
+      COLUMN_TYPE = :string
+
+      class << self
+        attr_accessor :model_name
+      end
+
+      def to_html(xmldoctype = true)
+        I18n.t("activerecord.attributes.#{self.class.model_name.underscore}.lifecycle.states.#{self}", :default => self).html_safe
+      end
+    end
+  end
+end

data/lib/hobo_fields/types/markdown_string.rb

@@ -0,0 +1,15 @@
+module HoboFields
+  module Types
+    class MarkdownString < RawMarkdownString
+
+      include SanitizeHtml
+
+      HoboFields.register_type(:markdown, self)
+
+      def to_html(xmldoctype = true)
+        blank? ? "" : HoboFields::SanitizeHtml.sanitize(Markdown.new(self).to_html)
+      end
+
+    end
+  end
+end

data/lib/hobo_fields/types/password_string.rb

@@ -0,0 +1,15 @@
+module HoboFields
+  module Types
+    class PasswordString < String
+
+      COLUMN_TYPE = :string
+
+      HoboFields.register_type(:password, self)
+
+      def to_html(xmldoctype = true)
+        I18n.t("hobo.password_hidden", :default => "[password hidden]").html_safe
+      end
+
+    end
+  end
+end

data/lib/hobo_fields/types/raw_html_string.rb

@@ -0,0 +1,13 @@
+module HoboFields
+  module Types
+    class RawHtmlString < HoboFields::Types::Text
+
+      def to_html(xmldoctype = true)
+        self.html_safe
+      end
+
+      HoboFields.register_type(:raw_html, self)
+
+    end
+  end
+end

data/lib/hobo_fields/types/raw_markdown_string.rb

@@ -0,0 +1,13 @@
+module HoboFields
+  module Types
+    class RawMarkdownString < HoboFields::Types::Text
+
+      HoboFields.register_type(:raw_markdown, self)
+
+      def to_html(xmldoctype = true)
+        blank? ? "" : Markdown.new(self).to_html.html_safe
+      end
+
+    end
+  end
+end

data/lib/hobo_fields/types/serialized_object.rb

@@ -0,0 +1,15 @@
+module HoboFields
+  module Types
+    class SerializedObject < Object
+
+      COLUMN_TYPE = :text
+
+      def self.declared(model, name, options)
+        model.serialize name, options.delete(:class) || Object
+      end
+
+      HoboFields.register_type(:serialized, self)
+
+    end
+  end
+end

data/lib/hobo_fields/types/text.rb

@@ -0,0 +1,16 @@
+require 'active_support/core_ext/string/output_safety'
+module HoboFields
+  module Types
+    class Text < String
+
+      COLUMN_TYPE = :text
+
+      def to_html(xmldoctype = true)
+        ERB::Util.html_escape(self).gsub("\n", "<br#{xmldoctype ? ' /' : ''}>\n")
+      end
+
+      HoboFields.register_type(:text, self)
+
+    end
+  end
+end