yodel 0.0.1

data/lib/yodel/models/core/associations/store/store_association.rb

@@ -0,0 +1,51 @@
+module StoreAssociation
+  include RecordAssociation
+  
+  def associate(associated_record, store, record)
+    if store.is_a?(Array)
+      store << associated_record.id
+    else
+      record.set_raw(name, associated_record.id)
+    end
+  end
+  
+  def validate(record, errors)
+    # noop
+  end
+  
+  def unassociate(associated_record, store, record)
+    if store.is_a?(Array)
+      store.delete(associated_record.id)
+    else
+      record.set_raw(name, nil)
+    end
+  end
+  
+  def record_options(record)
+    query = model(record).where()
+    query = query.sort(@options['order'].to_s) if @options['order']
+    query.all
+  end
+  
+  
+  private
+    def clear(store, record)
+      if store.is_a?(Array)
+        store.clear
+      else
+        record.set_raw(name, nil)
+        return nil
+      end
+    end
+    
+    def all(store, record)
+      query = model(record).where(_id: store)
+      query = query.sort(@options['sort']) if @options['sort']
+      query.all
+    end
+    
+    def associated(store, record)
+      return nil if store.nil?
+      model(record).first(_id: store)
+    end
+end

data/lib/yodel/models/core/attachments/attachment.rb

@@ -0,0 +1,73 @@
+class Attachment
+  attr_accessor :field, :record, :name, :mime
+  
+  def initialize(value, record, field)
+    @field = field
+    @record = record
+    value ||= {}
+    @name = value['name']
+    @mime = value['mime']
+  end
+  
+  def to_hash
+    {'name' => name, 'mime' => mime}
+  end
+    
+  def url
+    @url ||= Pathname.new('/').join(Yodel::ATTACHMENTS_DIRECTORY_NAME, relative_path)
+  end
+  
+  def relative_path
+    @relative_path ||= File.join(relative_directory_path, @name)
+  end
+  
+  def relative_directory_path
+    @relative_directory_path ||= File.join(@field.name, @record.id.to_s)
+  end
+  
+  def path
+    @path ||= File.join(@record.site.attachments_directory, relative_path)
+  end
+  
+  def directory_path
+    @directory_path ||= File.join(@record.site.attachments_directory, relative_directory_path)
+  end
+  
+  def exist?
+    return false if @name.nil?
+    File.exist?(path)
+  end
+  
+  def remove_files
+    FileUtils.rm_r directory_path if exist?
+  end
+  
+  def reset_memoised_values
+    @url = @relative_path = @relative_directory_path = @path = @directory_path = nil
+  end
+  
+  def set_file(file)
+    # delete the old file and reset memoised paths
+    unless @record.new?
+      remove_files
+      reset_memoised_values
+    end
+
+    # reset the name and mime type of the attachment
+    @name = file[:filename]
+    @mime = file[:type]
+    temp  = file[:tempfile]
+    temp_path = temp.path
+    temp.close
+    
+    # for simplicity we move the uploaded file (from /tmp) rather than copying
+    FileUtils.mkpath directory_path
+    FileUtils.mv(temp_path, path)
+    FileUtils.chmod(0664, path) # (owner: rw, group: rw, other: r)
+  end
+  
+  def length
+    return 0 unless self.exist?
+    return File.size(path)
+  end
+end

data/lib/yodel/models/core/attachments/image.rb

@@ -0,0 +1,38 @@
+class Image < Attachment
+  def set_file(file)
+    super(file)
+    crop_image
+  end
+
+  def crop_image
+    sizes = @field.options['sizes'].to_hash.merge('admin_thumb' => '100x100')
+    return unless exist?    
+    sizes.each do |size_name, size|
+      image = MiniMagick::Image.open(path.to_s)
+      image.resize("#{size}^")
+      image.format('jpeg')
+      image.write(resized_image_path(size_name, false).to_s)
+    end
+  end
+
+  # TODO: shouldn't always be .jpg; have image extension as an option
+  def resized_image_path(size, crop_if_required=true)
+    return path if size.nil? || size == :original
+    sized_path = File.join(@record.site.attachments_directory, relative_directory_path, "#{size}.jpg")
+    crop_image unless File.exist?(sized_path) || !crop_if_required
+    sized_path
+  end
+
+  # TODO: relative path from is quite a complex method; we should optimise the whole path system here somehow
+  def relative_resized_image_path(name, crop_if_required=true)
+    Pathname.new(resized_image_path(name, crop_if_required)).relative_path_from(Pathname.new(@record.site.attachments_directory))
+  end
+
+  def url(size=:original, crop_if_required=true)
+    if size == :original
+      super()
+    else
+      Pathname.new('/').join(relative_resized_image_path(size, crop_if_required))
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+Dir.chdir(File.dirname(__FILE__)) do
+  require './attachments/attachment'
+  require './attachments/image'
+  require './fields/fields'
+  require './validations/validations'
+  require './associations/associations'
+  require './mongo/mongo'
+  require './record/record'
+  require './model/model'
+  require './functions/functions'
+  require './log/log'
+  require './site/migration'
+  require './site/remote'
+  require './site/site'
+end

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

@@ -0,0 +1,32 @@
+class AliasField < Field    
+  # FIXME: assignments don't work; alias = val won't be saved
+  # FIXME: changes to the original value aren't observed;
+  # original = val_1, alias => val_1; original = val_2; alias => val_1
+  def strip_nil?
+    true
+  end
+  
+  def default_input_type
+    nil
+  end
+
+  def validate(record, errors)
+    # noop
+  end
+
+  def typecast(value, record)
+    field_name = @options['of'].to_s
+    raise InvalidField, "Alias fields must have a from property" if field_name.blank?
+    record.get(field_name)
+  end
+
+  def untypecast(value, record)
+    nil
+  end
+
+  def from_json(value, record)
+    nil
+  end
+end
+
+Field::TYPES['alias'] = AliasField

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

@@ -0,0 +1,64 @@
+class ArrayField < 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.singularize) if options['of']
+    super
+  end
+  
+  def json_action(action, value, record)
+    array = record.get_raw(name)
+    value = process(value, record, :from_json)
+    value = [value] unless value.is_a?(Array)
+    
+    case action
+    when 'set'
+      array = value
+    when 'add'
+      array += value
+    when 'add_unique'
+      array |= value
+    when 'remove'
+      array -= value
+    when 'clear'
+      array = []
+    end
+    
+    record.set_raw(name, array)
+    record.changed!(name)
+  end
+
+  def typecast(value, record)
+    value = [] unless value.is_a?(Array)
+    ChangeSensitiveArray.new(record, name, process(value, record, :typecast))
+  end
+  
+  def untypecast(value, record)
+    return [] if value.blank?
+    process(value.to_a, record, :untypecast)
+  end
+  
+  def from_json(value, record)
+    return [] if value.blank?
+    if value.is_a?(String)
+      if value.include?(',')
+        value = value.split(',')
+      else
+        value = value.split(' ')
+      end
+    end
+    process(value.to_a, record, :from_json)
+  end
+  
+  
+  private
+    def process(values, record, method)
+      return values if @element_type.nil?
+      if values.is_a?(Array)
+        values.collect {|element| @element_type.send(method, element, record)}
+      else
+        @element_type.send(method, values, record)
+      end
+    end
+end
+
+Field::TYPES['array'] = ArrayField

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

@@ -0,0 +1,42 @@
+class AttachmentField < Field
+  def default_input_type
+    :file
+  end
+  
+  def untypecast(value, record)
+    # expecting an Attachment object, or a hash of the original data
+    value.to_hash
+  end
+  
+  def typecast(value, record)
+    Attachment.new(value, record, self)
+  end
+
+  def json_action(action, value, record)
+    original = record.get(name)
+    case action
+    when 'set'
+      return if value.nil?
+      original.set_file(value)
+      record.set_raw(name, original.to_hash)
+    when 'clear'
+      original.remove_files
+      record.set_raw(name, nil)
+    end
+    record.changed!(name)
+  end
+  
+  def from_json(value, record)
+    original = record.get(name)
+    original.set_file(value)
+    original
+  end
+  
+  def after_destroy(record)
+    if record.get(name).is_a?(Attachment)
+      record.get(name).remove_files
+    end
+  end
+end
+
+Field::TYPES['attachment'] = AttachmentField

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

@@ -0,0 +1,28 @@
+class BooleanField < Field
+  def default_input_type
+    :radio
+  end
+  
+  def json_action(action, value, record)
+    case action
+    when 'set'
+      record.set_raw(name, !!value)
+    when 'toggle'
+      record.set_raw(name, !record.get(name))
+    end
+    
+    record.changed!(name)
+  end
+
+  def from_json(value, record)
+    if value == 'true'
+      true
+    elsif value == 'false'
+      false
+    else
+      !!value
+    end
+  end
+end
+
+Field::TYPES['boolean'] = BooleanField

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

@@ -0,0 +1,96 @@
+# Notify the record owning this value whenever the underlying array
+# changes. Records rely on assignment to determine when a value has
+# changed, so mutable objects need to notify the record when they are
+# updated. This is not an exhaustive list of ways to mutate an array,
+# just some common methods used in Yodel already.
+class ChangeSensitiveArray
+  attr_reader :array
+  def initialize(record, field, array)
+    @record = record
+    @field = field
+    @array = array
+  end
+  
+  def inspect
+    @array.inspect
+  end
+  
+  def to_a
+    @array
+  end
+  
+  def to_s
+    @array.collect(&:to_s).join(', ')
+  end
+  
+  def push(value)
+    notify!
+    @array.push(value)
+  end
+  
+  def clear
+    notify!
+    @array.clear
+  end
+  
+  def pop
+    notify!
+    @array.pop
+  end
+  
+  def <<(value)
+    notify!
+    @array << value
+  end
+  
+  def delete(value)
+    notify!
+    @array.delete(value)
+  end
+  
+  def []=(index, value)
+    notify!
+    @array[index] = value
+  end
+  
+  def each(&block)
+    @array.each(&block)
+  end
+  
+  def collect(&block)
+    @array.collect(&block)
+  end
+  
+  def count(*item, &block)
+    @array.count(*item, &block)
+  end
+  
+  def size
+    @array.size
+  end
+  
+  def include?(item)
+    @array.include?(item)
+  end
+  
+  def method_missing(name, *args, &block)
+    notify! if name.to_s.end_with?('!')
+    @array.send(name, *args, &block)
+  end
+  
+  # Calling changed! on @record will call dup on this array before any mutating
+  # operation has been performed. We need to store the original unedited version
+  # in typecast (the 'was' value), then return this array since the mutating
+  # operation is being performed on it. Since dup returns self, the array being
+  # operated on will be stored in @record.changed, and be modified by the op.
+  def dup
+    copy = ChangeSensitiveArray.new(@record.dup, @field.dup, @array.dup)
+    @record.typecast[@field] = copy
+    self
+  end
+  
+  private
+    def notify!
+      @record.try(:changed!, @field)
+    end
+end