yodel 0.0.1

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

@@ -0,0 +1,37 @@
+class Association < Field
+  def json_action(action, value, record)
+    store = record.get_raw(name)
+    
+    case action
+    when 'set'
+      clear(store, record)
+      process_json_items(value, record, store, :associate)
+    when 'add'
+      process_json_items(value, record, store, :associate)
+    when 'remove'
+      process_json_items(value, record, store, :unassociate)
+    when 'clear'
+      clear(store, record)
+    end
+    
+    record.changed!(name)
+  end
+  
+  def from_json(value, record)
+    store = record.get_raw(name)
+    clear(store, record)
+    process_json_items(value, record, store, :associate)
+    record.get(name)
+  end
+  
+  
+  private
+    def process_json_items(items, record, store, method)
+      items = [items] unless items.is_a?(Array)
+      items.each do |raw_item|
+        item = process_json_item(raw_item, store, record)
+        next if item.nil?
+        send(method, item, store, record)
+      end
+    end
+end

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

@@ -0,0 +1,22 @@
+require './model/abstract_model'
+
+Dir.chdir(File.dirname(__FILE__)) do
+  require './association'
+  require './record_association'
+  
+  require './counts/many_association'
+  require './counts/one_association'
+  
+  require './query/query_association'
+  require './query/many_query_association'
+  require './query/one_query_association'
+  
+  require './store/store_association'
+  require './store/many_store_association'
+  require './store/one_store_association'
+  
+  require './embedded/embedded_record_array'
+  require './embedded/embedded_association'
+  require './embedded/many_embedded_association'
+  require './embedded/one_embedded_association'
+end

data/lib/yodel/models/core/associations/counts/many_association.rb

@@ -0,0 +1,18 @@
+module ManyAssociation
+  def search_terms_set(record)
+    return [] unless include_in_search_keywords?
+    record.get(name).collect do |embedded_record|
+      embedded_record.search_terms
+    end.flatten
+  end
+  
+  def before_destroy(record)
+    if @options['destroy'] == true
+      record.get(name).each(&:destroy)
+    end
+  end
+  
+  def typecast(value, record)
+    ChangeSensitiveArray.new(record, name, all(value, record))
+  end
+end

data/lib/yodel/models/core/associations/counts/one_association.rb

@@ -0,0 +1,22 @@
+module OneAssociation
+  def search_terms_set(record)
+    return [] unless include_in_search_keywords?
+    record.get(name).try(:search_terms) || []
+  end
+  
+  def before_destroy(record)
+    if @options['destroy'] == true
+      record.get(name).try(:destroy)
+    end
+  end
+  
+  def typecast(value, record)
+    return default if value.blank?
+    associated(value, record)
+  end
+  
+  private
+    def clear(store, record)
+      unassociate(associated(store, record), store, record)
+    end
+end

data/lib/yodel/models/core/associations/embedded/embedded_association.rb

@@ -0,0 +1,47 @@
+module EmbeddedAssociation
+  include AbstractModel
+  
+  def fields_field
+    @fields_field ||= FieldsField.new(name)
+  end
+  
+  def fields
+    @fields ||= fields_field.typecast(@options['fields'], nil)
+  end
+  
+  def options
+    @options.merge({'fields' => fields_field.untypecast(fields, nil)})
+  end
+  
+  def validate(record, errors)
+    EmbeddedRecordsValidation.validate(self, record.get(name), record, errors)
+    super(record, errors)
+  end
+  
+  def default_input_type
+    :embedded
+  end
+  
+  private
+    def process_json_item(embedded_record, store, record)
+      return unless embedded_record.respond_to?(:to_hash)
+      EmbeddedRecord.new(self, record, {}).tap {|new_record| new_record.from_json(embedded_record)}
+    end
+    
+    def clear(store, record)
+      if store.is_a?(Array)
+        store.clear
+      else
+        record.set_raw(name, {})
+        return {}
+      end
+    end
+  
+    def all(store, record)
+      return [] if store.blank?
+      store = [store] unless store.respond_to?(:collect)
+      store.collect do |values|
+        EmbeddedRecord.new(self, record, values, false)
+      end
+    end
+end

data/lib/yodel/models/core/associations/embedded/embedded_record_array.rb

@@ -0,0 +1,12 @@
+class EmbeddedRecordArray < ChangeSensitiveArray
+  def new(values={})
+    EmbeddedRecord.new(@field, @record).tap {|record| record.update(values, false)}
+  end
+  
+  private
+    def notify!
+      return if @notified
+      @record.try(:changed!, @field.name)
+      @notified = true
+    end
+end

data/lib/yodel/models/core/associations/embedded/many_embedded_association.rb

@@ -0,0 +1,62 @@
+class ManyEmbeddedAssociation < Association
+  include EmbeddedAssociation
+  include ManyAssociation
+  
+  # remove ManyAssociation's destroy behaviour since embedded
+  # records are destroyed as part of the parent anyway
+  undef :before_destroy
+  
+  def search_terms_set(record)
+    record.get(name).collect do |embedded_record|
+      embedded_record.search_terms
+    end.flatten
+  end
+  
+  def options
+    super.merge({'type' => 'many_embedded'})
+  end
+  
+  def save(embedded_record, parent_record)
+    if embedded_record.new?
+      parent_record.get(name) << embedded_record
+    end
+  end
+
+  def destroy(embedded_record, parent_record)
+    parent_record.get(name).delete(embedded_record)
+  end
+  
+  def associate(embedded_record, store, record)
+    raise "Associated record must be an Embedded Record" unless embedded_record.is_a?(EmbeddedRecord)
+    embedded_record.save
+    store << embedded_record.values
+  end
+  
+  def unassociate(embedded_record, store, record)
+    store.delete(embedded_record)
+  end
+  
+  def untypecast(value, record)
+    return nil if value.blank?
+    raise "ManyEmbeddedAssociation values must be enumerable (#{name})" unless value.respond_to?(:each)
+    
+    store = record.get_raw(name)
+    clear(store, record)
+    value.each do |associated_record|
+      associate(associated_record, store, record)
+    end
+    store
+  end
+  
+  def default
+    @options['default'] || []
+  end
+  
+  def typecast(value, record)
+    return EmbeddedRecordArray.new(record, self, []) if value.blank?
+    raise "ManyEmbedded values must be enumerable (#{name})" unless value.respond_to?(:each)
+    EmbeddedRecordArray.new(record, self, all(value, record))
+  end
+end
+
+Field::TYPES['many_embedded'] = ManyEmbeddedAssociation

data/lib/yodel/models/core/associations/embedded/one_embedded_association.rb

@@ -0,0 +1,49 @@
+class OneEmbeddedAssociation < Association
+  include EmbeddedAssociation
+  include OneAssociation
+  
+  # remove OneAssociation's destroy behaviour since embedded
+  # records are destroyed as part of the parent anyway
+  undef :before_destroy
+  
+  def search_terms_set(record)
+    record.get(name).search_terms
+  end
+  
+  def default
+    @options['default'] || EmbeddedRecord.new(self, nil).default_values
+  end
+  
+  def options
+    super.merge({'type' => 'one_embedded'})
+  end
+  
+  def save(embedded_record, parent_record)
+    # noop
+  end
+
+  def destroy(embedded_record, parent_record)
+    embedded_record.initialize(self, parent_record)
+    parent_record.changed!(name)
+  end
+  
+  def untypecast(value, record)
+    return {} unless value.is_a?(EmbeddedRecord)
+    value.save
+    value.values
+  end
+  
+  private
+    def associated(store, record)
+      store = {} unless store.is_a?(Hash)
+      EmbeddedRecord.new(self, record, store, false)
+    end
+    
+    def associate(embedded_record, store, record)
+      raise "Associated record must be an Embedded Record" unless embedded_record.is_a?(EmbeddedRecord)
+      embedded_record.save
+      record.set(name, embedded_record)
+    end
+end
+
+Field::TYPES['one_embedded'] = OneEmbeddedAssociation

data/lib/yodel/models/core/associations/query/many_query_association.rb

@@ -0,0 +1,10 @@
+class ManyQueryAssociation < Association
+  include QueryAssociation
+  include ManyAssociation
+  
+  def untypecast(value, record)
+    nil
+  end
+end
+
+Field::TYPES['many_query'] = ManyQueryAssociation

data/lib/yodel/models/core/associations/query/one_query_association.rb

@@ -0,0 +1,10 @@
+class OneQueryAssociation < Association
+  include QueryAssociation
+  include OneAssociation
+  
+  def untypecast(value, record)
+    nil
+  end
+end
+
+Field::TYPES['one_query'] = OneQueryAssociation

data/lib/yodel/models/core/associations/query/query_association.rb

@@ -0,0 +1,64 @@
+module QueryAssociation
+  include RecordAssociation
+  
+  def initialize(name, options={})
+    super
+    if @options['where']
+      @options['where'] = Plucky::CriteriaHash.new(@options['where']).to_hash
+    end
+  end
+  
+  def validate(record, errors)
+    # noop
+  end
+  
+  def default
+    nil
+  end
+  
+  def strip_nil?
+    true
+  end
+  
+  def associate(associated_record, store, record)
+    associated_record.set_meta(foreign_key(record), record.id)
+    associated_record.save_without_validation
+  end
+  
+  def unassociate(associated_record, store, record)
+    return unless associated_record.get_meta(foreign_key) == record.id
+    associated_record.set_meta(foreign_key(record), nil)
+    associated_record.save_without_validation
+  end
+  
+  protected
+    def clear(store, record)
+      all(store, record).each {|associated_record| unassociate(associated_record, store, record)}
+    end
+    
+    def all(store, record)
+      scope(record).all
+    end
+    
+    def scope(record)
+      if @options['through']
+        through_query = record.field(@options['through'].to_s).scope(record).only('_id')
+        cursor = Record.collection.find(through_query.criteria.to_hash, through_query.options.to_hash)
+        ids = cursor.to_a.collect {|doc| doc['_id']}
+        scope = record.site.model(model_name).where(foreign_key(record) => ids)
+      elsif @options['extends']
+        scope = record.field(@options['extends'].to_s).scope(record)
+      else
+        scope = record.site.model(model_name).where(foreign_key(record) => record.id)
+      end
+      scope = scope.where(@options['where'].to_hash) if @options['where']
+      scope = scope.sort(@options['order'].to_s) if @options['order']
+      scope = scope.limit(@options['limit'].to_i) if @options['limit']
+      scope = scope.skip(@options['skip'].to_i) if @options['skip']
+      scope
+    end
+    
+    def associated(store, record)
+      record.site.model(model_name).first(foreign_key(record) => record.id)
+    end
+end

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

@@ -0,0 +1,38 @@
+module RecordAssociation
+  private
+    def process_json_item(raw_id, store, record)
+      return nil if raw_id.blank?
+      associated_record = model(record).find(BSON::ObjectId.from_string(raw_id))
+      if !associated_record.nil?
+        if model_name == 'Model'
+          return associated_record if associated_record.is_a?(Model)
+        elsif associated_record.model.ancestors.include?(model(record))
+          return associated_record
+        end
+      end
+      nil
+    end
+    
+    def foreign_key(record)
+      @foreign_key ||= (options['foreign_key'] || model_name.to_s.underscore) # FIXME: should be foreign_key || record.model.name.underscore
+    end
+    
+    def model_name
+      @model_name ||= (options['model'] || name).to_s.classify
+    end
+    
+    def model(record)
+      # caching was causing a bug where running migrations on a new site would fail because
+      # calls to NewModel.parent were generating the query:
+      # {id: parent_id, _site_id: yodel_dev_site_id NOT new_site.id}
+      #@model ||=
+      case model_name
+        when 'Site'
+          Site
+        when 'Remote'
+          Remote
+        else
+          record.site.model(model_name)
+        end
+    end
+end

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

@@ -0,0 +1,32 @@
+class ManyStoreAssociation < Association
+  include StoreAssociation
+  include ManyAssociation
+  
+  def default_input_type
+    :store_many
+  end
+  
+  def typecast(value, record)
+    return ChangeSensitiveArray.new(record, name, []) if value.blank?
+    raise "ManyStoreAssociation values must be enumerable (#{name})" unless value.respond_to?(:each)
+    ChangeSensitiveArray.new(record, name, all(value, record))
+  end
+  
+  def untypecast(value, record)
+    return nil if value.blank?
+    raise "ManyStoreAssociation values must be enumerable (#{name})" unless value.respond_to?(:each)
+    
+    store = record.get_raw(name) || []
+    store.clear
+    value.each do |associated_record|
+      store << associated_record.id
+    end
+    store
+  end
+  
+  def default
+    @options['default'] || []
+  end
+end
+
+Field::TYPES['many_store'] = ManyStoreAssociation

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

@@ -0,0 +1,14 @@
+class OneStoreAssociation < Association
+  include StoreAssociation
+  include OneAssociation
+  
+  def default_input_type
+    :store_one
+  end
+  
+  def untypecast(value, record)
+    value.respond_to?(:id) ? value.id : nil
+  end
+end
+
+Field::TYPES['one_store'] = OneStoreAssociation