yodel 0.0.1

data/lib/yodel/models/core/fields/change_sensitive_hash.rb

@@ -0,0 +1,53 @@
+class ChangeSensitiveHash
+  attr_reader :hash
+  def initialize(record, field, hash)
+    @record = record
+    @field = field
+    @hash = hash
+  end
+  
+  def inspect
+    @hash.inspect
+  end
+  
+  def to_hash
+    @hash
+  end
+  
+  def merge!(other_hash)
+    notify!
+    @hash.merge!(other_hash)
+  end
+  
+  def delete(key)
+    notify!
+    @hash.delete(key)
+  end
+  
+  def clear
+    notify!
+    @hash.clear
+  end
+  
+  def []=(key, value)
+    notify!
+    @hash[key] = value
+  end
+  
+  def method_missing(name, *args, &block)
+    notify! if name.to_s.end_with?('!')
+    @hash.send(name, *args, &block)
+  end
+  
+  # See ChangeSensitiveArray#dup for an explanation of this method
+  def dup
+    copy = ChangeSensitiveHash.new(@record.dup, @field.dup, @hash.dup)
+    @record.typecast[@field] = copy
+    self
+  end
+  
+  private
+    def notify!
+      @record.try(:changed!, @field)
+    end
+end

data/lib/yodel/models/core/fields/color_field.rb

@@ -0,0 +1,4 @@
+class ColorField < StringField
+end
+
+Field::TYPES['color'] = ColorField

data/lib/yodel/models/core/fields/date_field.rb

@@ -0,0 +1,35 @@
+class DateField < Field
+  def default_input_type
+    :date
+  end
+  
+  def before_create(record)
+    return unless name == 'created_at' || name == 'updated_at'
+    record.set(name, Time.now.utc.to_date)
+  end
+
+  def before_update(record)
+    return unless name == 'updated_at'
+    record.set(name, Time.now.utc.to_date)
+  end
+  
+  def typecast(value, record)
+    value.blank? ? nil : value.to_date
+  end
+  
+  def untypecast(value, record)
+    value.blank? ? nil : Time.utc(value.year, value.month, value.day)
+  end
+  
+  def from_json(value, record)
+    return nil unless value.present? && (value.is_a?(String) || value.is_a?(Hash))
+    if value.is_a?(Hash)
+      return nil unless ['year', 'month', 'day'].all? {|field| value.key?(field) && !value[field].blank?}
+      Time.new(value['year'], value['month'], value['day'])
+    else
+      Time.parse(value)
+    end
+  end
+end
+
+Field::TYPES['date'] = DateField

data/lib/yodel/models/core/fields/decimal_field.rb

@@ -0,0 +1,19 @@
+class DecimalField < Field
+  def numeric?
+    true
+  end
+  
+  def typecast(value, record)
+    BigDecimal.new(value.to_s)
+  end
+  
+  def untypecast(value, record)
+    BigDecimal.new(value.to_s).to_s
+  end
+  
+  def from_json(value, record)
+    BigDecimal.new(value.to_s).to_s
+  end
+end
+
+Field::TYPES['decimal'] = DecimalField

data/lib/yodel/models/core/fields/email_field.rb

@@ -0,0 +1,10 @@
+class EmailField < StringField
+  
+  def validate(record, errors)
+    EmailAddressValidation.validate(nil, self, name, record.get(name), record, errors)
+    super
+  end
+  
+end
+
+Field::TYPES['email'] = EmailField

data/lib/yodel/models/core/fields/enum_field.rb

@@ -0,0 +1,33 @@
+class EnumField < StringField
+  # class << self
+  #   undef search_terms_set
+  # end
+  # 
+  # def self.to_html_field(record, field, value)
+  #   if value.nil? && !field.default.nil?
+  #     value = field.default
+  #   end
+  #   value = value.to_s
+  # 
+  #   select_options = field.values.collect do |enum_value|
+  #     options = {value: enum_value}
+  #     options[:selected] = 'selected' if value == enum_value
+  #     Hpricot::Elem.new('option', options, [Hpricot::Text.new(enum_value)])
+  #   end
+  # 
+  #   if field.show_blank || !field.required
+  #     options = {value: ''}
+  #     text = field.blank_text || 'None'
+  #     options[:selected] = 'selected' if value == ''
+  #     select_options.unshift(Hpricot::Elem.new('option', options, [Hpricot::Text.new(text)]))
+  #   end
+  # 
+  #   Hpricot::Elem.new('select', {name: field.name}, select_options)
+  # end
+  
+  def default_input_type
+    :enum
+  end
+end
+
+Field::TYPES['enum'] = EnumField

data/lib/yodel/models/core/fields/field.rb

@@ -0,0 +1,154 @@
+class Field
+  attr_accessor :name, :options
+  TYPES = {}
+  
+  def self.from_options(name, options)
+    field_from_type(options['type']).new(name, options)
+  end
+  
+  def self.field_from_type(type)
+    TYPES[type]
+  end
+  
+  # options is a hash of string keys to values as described. Type
+  # is the only required option. All others are optional.
+  #
+  # type => field type
+  # default => value (value for newly created records)
+  # display => true/false
+  # searchable => true/false
+  # protected => true/false (unable to mass assign to this field if true)
+  # section => string (nil or a section name used in admin)
+  #
+  # Some field types may have other options, such as embedded fields.
+  def initialize(name, options={})
+    @name = name
+    @options = options
+  end
+  
+  def to_str
+    "#<#{self.class.name} #{name}>"
+  end
+
+  def display?
+    @options['display'] != false
+  end
+
+  def searchable?
+    @options['searchable'] != false
+  end
+
+  def required?
+    @options['required'] == true
+  end
+
+  def unique?
+    @options['unique'] == true
+  end
+  
+  def strip_nil?
+    @options['strip_nil'] == true
+  end
+  
+  def index?
+    @options['index'] == true
+  end
+  
+  def inherited?
+    @options['inherited'] == true
+  end
+  
+  def numeric?
+    false
+  end
+  
+  def include_in_search_keywords?
+    @options.key?('include_in_search_keywords')
+  end
+
+  def method_missing(name, *args, &block)
+    @options[name.to_s]
+  end
+
+  def validate(record, errors)
+    return if @options['validations'].blank?
+    value = record.get(name)
+    field_name = name.humanize
+    @options['validations'].each do |type, params|
+      Validation.validate(type, params, self, field_name, value, record, errors)
+    end
+  end
+  
+  def default_input_type
+    :text
+  end
+  
+  # Convert from an untypecast (raw) representation of a value to a
+  # more complex version of the same value. For instance, BigDecimals
+  # are stored as strings, but are BigDecimal objects when typecast.
+  def typecast(value, record)
+    value
+  end
+  
+  # Convert from a complex (typecast) representation of a value to a
+  # simpler version of the same value. For instance, BigDecimals are
+  # BigDecimal objects when typecast, but are strings when untypecast.
+  def untypecast(value, record)
+    value
+  end
+  
+  # Example json_action implementation; only implement this method if
+  # the field type supports actions other than just 'set'
+  # def json_action(action, value, record)
+  #   record.set_raw(name, from_json(value, record))
+  # end
+  
+  # Take a raw JSON value and encode it in an untypecast (raw) value
+  # ready for storage in a mongo record. Non mongo records can still
+  # use this method since it performs complex->simple type conversion.
+  def from_json(value, record)
+    value
+  end
+  
+  # JSON converter for the field object itself; this method does not
+  # encode a field's value. Fields convert values to and from mongo
+  # (untypecast/typecast) and from json (from_json). When converting
+  # a record to JSON, the raw (untypecast) value is used. If this
+  # value needs special encoding for JSON, specify a to_json(*a)
+  # method on the class the value is an instance of. For instance,
+  # Time fields store values as Time objects in mongo. For conversion
+  # to JSON, the Time class is extended with a to_json(*a) method to
+  # perform the necessary conversion. This is done so fields can be
+  # ignored by the JSON converter, and a simple conversion done between
+  # untypecast values and JSON. Since mongo stores values in BSON (which
+  # is similar to JSON), this makes conversion much faster.
+  def to_json(*a)
+    @options.to_json(*a)
+  end
+  
+  # Record callbacks. These methods are called at various stages of a
+  # record's life cycle. Only implement them when necessary.
+  # def before_create(record)
+  # end
+  # 
+  # def before_update(record)
+  # end
+  # 
+  # def before_save(record)
+  # end
+  # 
+  # def before_destroy(record)
+  # end
+  #
+  # def after_create(record)
+  # end
+  # 
+  # def after_update(record)
+  # end
+  # 
+  # def after_save(record)
+  # end
+  # 
+  # def after_destroy(record)
+  # end
+end

data/lib/yodel/models/core/fields/fields.rb

@@ -0,0 +1,29 @@
+Dir.chdir(File.dirname(__FILE__)) do
+  require './field'
+  require './string_field'
+  require './text_field'
+  require './alias_field'
+  require './array_field'
+  require './boolean_field'
+  require './change_sensitive_array'
+  require './change_sensitive_hash'
+  require './color_field'
+  require './date_field'
+  require './decimal_field'
+  require './email_field'
+  require './enum_field'
+  require './fields_field'
+  require './filter_mixin'
+  require './filtered_string_field'
+  require './filtered_text_field'
+  require './function_field'
+  require './hash_field'
+  require './html_field'
+  require './integer_field'
+  require './password_field'
+  require './self_field'
+  require './tags_field'
+  require './time_field'
+  require './attachment_field'
+  require './image_field'
+end

data/lib/yodel/models/core/fields/fields_field.rb

@@ -0,0 +1,31 @@
+class FieldsField < Field
+  def typecast(hash, record)
+    ChangeSensitiveHash.new(record, name, fields_from_hash(hash, record))
+  end
+  
+  def untypecast(hash, record)
+    return {} unless hash.respond_to?(:to_hash)
+    hash.to_hash.each_with_object({}) do |(name, field_obj), fields|
+      next unless field_obj.is_a?(Field)
+      fields[name.to_s] = field_obj.options
+    end
+  end
+  
+  def from_json(hash, record)
+    # return {} unless hash.is_a?(Hash)
+    #       hash.each_with_object({}) do |(name, options), fields|
+    #         fields[name.to_s] = Field.from_options(name, options).options
+    #       end
+    fields_from_hash(hash, record)
+  end
+  
+  private
+    def fields_from_hash(hash, record)
+      return {} unless hash.is_a?(Hash)
+      hash.each_with_object({}) do |(name, options), fields|
+        fields[name.to_s] = Field.from_options(name, options)
+      end
+    end
+end
+
+Field::TYPES['fields'] = FieldsField

data/lib/yodel/models/core/fields/filter_mixin.rb

@@ -0,0 +1,9 @@
+module FilterMixin
+  def typecast(value, record)
+    Hpricot(value.to_s).search('text()').collect(&:to_s).collect(&:strip).join(' ').strip
+  end
+
+  def untypecast(value, record)
+    value.to_s
+  end
+end

data/lib/yodel/models/core/fields/filtered_string_field.rb

@@ -0,0 +1,5 @@
+class FilteredStringField < StringField
+  include FilterMixin
+end
+
+Field::TYPES['filtered_string'] = FilteredStringField

data/lib/yodel/models/core/fields/filtered_text_field.rb

@@ -0,0 +1,5 @@
+class FilteredTextField < TextField
+  include FilterMixin
+end
+
+Field::TYPES['filtered_text'] = FilteredTextField

data/lib/yodel/models/core/fields/function_field.rb

@@ -0,0 +1,28 @@
+class FunctionField < Field
+  def strip_nil?
+    true
+  end
+  
+  def default_input_type
+    nil
+  end
+
+  def validate(record, errors)
+    # noop
+  end
+
+  def typecast(value, record)
+    compiled_fn = Function.new(@options['fn'])
+    compiled_fn.execute(record)
+  end
+
+  def untypecast(value, record)
+    nil
+  end
+
+  def from_json(value, record)
+    nil
+  end
+end
+
+Field::TYPES['function'] = FunctionField

data/lib/yodel/models/core/fields/hash_field.rb

@@ -0,0 +1,54 @@
+class HashField < Field
+  # TODO: validate should defer to @element_type over each element
+  def initialize(name, options={})
+    @element_type = Field.from_options(name, 'type' => options['of'].to_s) if options['of']
+    super
+  end
+  
+  def json_action(action, value, record)
+    hash = record.get_raw(name)
+    
+    if action == 'remove'
+      value = [value] unless value.is_a?(Array)
+      keys = value.collect(&:to_s)
+      hash.delete_if {|key, _| keys.include?(key)}
+    else
+      raise "Set or merge actions on a hash must be passed a hash" unless value.is_a?(Hash)
+      value = process(value, record, :from_json)
+      if action == 'set'
+        hash = value
+      elsif action == 'merge'
+        hash.merge!(value)
+      end
+    end
+    
+    record.set_raw(name, hash)
+    record.changed!(name)
+  end
+
+  def typecast(value, record)
+    value = {} unless value.is_a?(Hash)
+    ChangeSensitiveHash.new(record, name, process(value, record, :typecast))
+  end
+  
+  def untypecast(value, record)
+    return {} if value.blank? || !value.respond_to?(:to_hash)
+    process(value, record, :untypecast)
+  end
+  
+  def from_json(value, record)
+    return {} if value.blank? || !value.is_a?(Hash)
+    process(value, record, :from_json)
+  end
+  
+  
+  private
+    def process(hash, record, method)
+      return hash.to_hash if @element_type.nil?
+      hash.to_hash.each do |key, value|
+        hash[key.to_s] = @element_type.send(method, value, record)
+      end
+    end
+end
+
+Field::TYPES['hash'] = HashField