elastic_record 0.8.2 → 0.9.0

data/elastic_record.gemspec

@@ -2,7 +2,7 @@
  
 Gem::Specification.new do |s|
   s.name = 'elastic_record'
-  s.version = '0.8.2'
+  s.version = '0.9.0'
   s.summary = 'Use Elastic Search with your objects'
   s.description = 'Find your records with elastic search'
 

data/lib/elastic_record/index/deferred.rb

@@ -0,0 +1,81 @@
+module ElasticRecord
+  class Index
+    module Deferred
+      class DeferredConnection
+        class DeferredAction < Struct.new(:method, :args, :block)
+          def run(index)
+            index.send(method, *args, &block)
+          end
+        end
+
+        attr_accessor :index
+        attr_accessor :deferred_actions
+        attr_accessor :writes_made
+
+        def initialize(index)
+          self.index = index
+          reset!
+        end
+
+        def reset!
+          if writes_made
+            begin
+              index.disable_deferring!
+              index.reset
+            ensure
+              index.enable_deferring!
+            end
+          end
+          self.deferred_actions = []
+          self.writes_made = false
+        end
+
+        def flush!
+          deferred_actions.each do |queued_action|
+            self.writes_made = true
+            queued_action.run(index.real_connection)
+          end
+          deferred_actions.clear
+        end
+
+        private
+          READ_METHODS = [:json_get, :head]
+          def method_missing(method, *args, &block)
+            super unless index.real_connection.respond_to?(method)
+
+            if READ_METHODS.include?(method)
+              flush!
+              index.real_connection.json_post "/#{index.alias_name}/_refresh"
+              index.real_connection.send(method, *args, &block)
+            else
+              deferred_actions << DeferredAction.new(method, args, block)
+            end
+          end
+      end
+
+      def enable_deferring!
+        @deferring_enabled = true
+      end
+
+      def disable_deferring!
+        @deferring_enabled = false
+      end
+
+      def connection
+        if @deferring_enabled
+          deferred_connection
+        else
+          real_connection
+        end
+      end
+
+      def reset_deferring!
+        deferred_connection.reset!
+      end
+
+      def deferred_connection
+        @deferred_connection ||= DeferredConnection.new(self)
+      end
+    end
+  end
+end

data/lib/elastic_record/index.rb

@@ -1,3 +1,4 @@
+require 'elastic_record/index/deferred'
 require 'elastic_record/index/documents'
 require 'elastic_record/index/manage'
 require 'elastic_record/index/mapping'
@@ -10,6 +11,7 @@ module ElasticRecord
     include Manage
     include Mapping
     include Percolator
+    include Deferred
 
     attr_accessor :model
     attr_accessor :disabled
@@ -35,13 +37,13 @@ module ElasticRecord
       @disabled = false
     end
 
+    def real_connection
+      model.elastic_connection
+    end
+
     private
       def new_index_name
         "#{alias_name}_#{Time.now.to_i}"
       end
-
-      def connection
-        model.elastic_connection
-      end
   end
 end

data/lib/elastic_record/model.rb

@@ -2,7 +2,9 @@ module ElasticRecord
   module Model
     def self.included(base)
       base.class_eval do
-        extend Searching, ClassMethods
+        extend Searching
+        extend ClassMethods
+        include SearchesMany
       end
     end
 

data/lib/elastic_record/relation/merging.rb

@@ -18,16 +18,17 @@ module ElasticRecord
             @values = other.values
           end
 
-          def normal_values
-            Relation::MULTI_VALUE_METHODS + Relation::SINGLE_VALUE_METHODS
-          end
-
           def merge
-            normal_values.each do |name|
+            Relation::SINGLE_VALUE_METHODS.each do |name|
               value = values[name]
               relation.send("#{name}!", value) unless value.blank?
             end
 
+            Relation::MULTI_VALUE_METHODS.each do |name|
+              value = values[name]
+              relation.send("#{name}!", *value) unless value.blank?
+            end
+
             relation
           end
         end

data/lib/elastic_record/relation/search_methods.rb

@@ -35,7 +35,7 @@ module ElasticRecord
       end
 
       def filter!(*args)
-        self.filter_values += args.flatten
+        self.filter_values += args
         self
       end
 
@@ -137,9 +137,9 @@ module ElasticRecord
           if query && filter
             arelastic.query.filtered(query, filter)
           elsif query
-            query
+            Arelastic::Searches::Query.new(query)
           elsif filter
-            arelastic.query.constant_score(filter)
+            arelastic.query.constant_score(Arelastic::Searches::Filter.new(filter))
           else
             arelastic.query.match_all
           end
@@ -150,9 +150,7 @@ module ElasticRecord
             query = Arelastic::Queries::QueryString.new query
           end
 
-          if query
-            Arelastic::Searches::Query.new query
-          end
+          query
         end
 
         def build_filter(filters)
@@ -161,6 +159,8 @@ module ElasticRecord
           filters.map do |filter|
             if filter.is_a?(Arelastic::Filters::Filter)
               nodes << filter
+            elsif filter.is_a?(ElasticRecord::Relation)
+              nodes << Arelastic::Filters::HasChild.new(filter.elastic_index.type, filter.as_elastic['query'])
             else
               filter.each do |field, terms|
                 case terms
@@ -176,9 +176,9 @@ module ElasticRecord
           end
 
           if nodes.size == 1
-            Arelastic::Searches::Filter.new nodes.first
+            nodes.first
           elsif nodes.size > 1
-            Arelastic::Searches::Filter.new Arelastic::Filters::And.new(nodes)
+            Arelastic::Filters::And.new(nodes)
           end
         end
 

data/lib/elastic_record/searches_many/association.rb

@@ -0,0 +1,134 @@
+require 'active_support/core_ext/module/delegation'
+
+module ElasticRecord
+  module SearchesMany
+    class Association
+      attr_reader :owner, :reflection, :collection
+
+      delegate :klass, :options, to: :reflection
+
+      def initialize(owner, reflection)
+        @owner      = owner
+        @reflection = reflection
+        @collection = []
+        @loaded     = false
+      end
+
+      def writer(other_records)
+        other_records = other_records.map do |other_record|
+          other_record.is_a?(Hash) ? klass.new(other_record) : other_record
+        end
+
+        if reflection.counter_cache_column
+          owner.send("#{reflection.counter_cache_column}=", other_records.size)
+        end
+
+        if reflection.touch_column
+          owner.send("#{reflection.touch_column}=", Time.current)
+        end
+
+        delete(load_collection - other_records)
+        merge_collections(load_collection, other_records)
+        concat(other_records - load_collection)
+      end
+  
+      def reader
+        CollectionProxy.new(self)
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def concat(*records)
+        load_collection if owner.new_record?
+
+        result = true
+
+        records.flatten.each do |record|
+          add_to_collection(record) do |r|
+            result &&= record.save unless owner.new_record?
+          end
+        end
+
+        result && records
+      end
+
+      def delete(records)
+        if options[:autosave] || owner.new_record?
+          records.each(&:mark_for_destruction)
+        else
+          record.destroy
+        end
+      end
+
+      def scope
+        search = klass.elastic_search.filter "#{reflection.belongs_to}_id" => owner.id
+        if options[:as]
+          search.filter! "#{reflection.belongs_to}_type" => owner.class.name
+        end
+        search
+      end
+
+      def load_collection
+        unless @loaded
+          @collection = merge_collections(persisted_collection, collection)
+          @loaded = true
+        end
+
+        loaded = true
+        collection
+      end
+
+      private
+        def load_persisted_collection?
+          !loaded? || owner.new_record?
+        end
+
+        def persisted_collection
+          scope.to_a
+        end
+
+        def merge_collections(existing_records, new_records)
+          return existing_records   if new_records.empty?
+          return new_records  if existing_records.empty?
+
+          existing_records.map! do |existing_record|
+            if new_record = new_records.delete(existing_record)
+              (existing_record.attributes.keys - new_record.changes.keys).each do |name|
+                new_record.send("#{name}=", existing_record.send(name))
+              end
+
+              new_record
+            else
+              existing_record
+            end
+          end
+
+          existing_records + new_records
+        end
+
+        def add_to_collection(record)
+          callback(:before_add, record)
+
+          record.send("#{reflection.belongs_to}=", owner)
+          yield(record) if block_given?
+          @collection << record
+
+          callback(:after_add, record)
+
+          record
+        end
+
+        def callback(method, record)
+          reflection.callbacks[method].each do |callback|
+            if callback.is_a?(Symbol)
+              owner.send(callback, record)
+            else
+              callback.call(owner, record)
+            end
+          end
+        end
+    end
+  end
+end

data/lib/elastic_record/searches_many/autosave.rb

@@ -0,0 +1,72 @@
+module ElasticRecord
+  module SearchesMany
+    module Autosave
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def add_autosave_callbacks(reflection)
+          add_autosave_after_save_callbacks(reflection)
+          add_autosave_validation_callbacks(reflection)
+        end
+
+        def add_autosave_after_save_callbacks(reflection)
+          before_save { save_autosave_records(reflection) }
+        end
+
+        def add_autosave_validation_callbacks(reflection)
+          validate { validate_autosave_records(reflection) }
+        end
+      end
+    end
+
+    def save_autosave_records(reflection)
+      if association = searches_many_instance_get(reflection.name)
+        associated_records_to_autosave(association).each do |record|
+          if record.marked_for_destruction?
+            record.destroy
+          elsif record.changed?
+            record.save
+          end
+        end
+      end      
+    end
+
+    def validate_autosave_records(reflection)
+      if association = searches_many_instance_get(reflection.name)
+        associated_records_to_autosave(association).each do |record|
+          unless record.valid?
+            record.errors.each do |attribute, message|
+              attribute = "#{reflection.name}.#{attribute}"
+              errors[attribute] << message
+              errors[attribute].uniq!
+            end
+          end
+        end
+      end
+    end
+
+    def associated_records_to_autosave(association)
+      if association.loaded?
+        association.load_collection
+      else
+        []
+      end
+    end
+
+    # Marks this record to be destroyed as part of the parents save transaction.
+    # This does _not_ actually destroy the record instantly, rather child record will be destroyed
+    # when <tt>parent.save</tt> is called.
+    #
+    # Only useful if the <tt>:autosave</tt> option on the parent is enabled for this associated model.
+    def mark_for_destruction
+      @marked_for_destruction = true
+    end
+
+    # Returns whether or not this record will be destroyed as part of the parents save transaction.
+    #
+    # Only useful if the <tt>:autosave</tt> option on the parent is enabled for this associated model.
+    def marked_for_destruction?
+      @marked_for_destruction
+    end
+  end
+end

data/lib/elastic_record/searches_many/builder.rb

@@ -0,0 +1,42 @@
+module ElasticRecord
+  module SearchesMany
+    class Builder
+      def self.build(model, name, options)
+        new(model, name, options).build
+      end
+
+      attr_reader :model, :name, :options
+      def initialize(model, name, options)
+        @model, @name, @options = model, name, options
+      end
+
+      def build        
+        define_writer
+        define_reader
+
+        reflection = ElasticRecord::SearchesMany::Reflection.new(model, name, options)
+        model.searches_many_reflections = model.searches_many_reflections.merge(name => reflection)
+
+        model.add_autosave_callbacks(reflection) # if options[:autosave]
+      end
+
+      def mixin
+        model.generated_searches_many_methods
+      end
+
+      def define_writer
+        name = self.name
+        mixin.redefine_method("#{name}=") do |records|
+          searches_many_association(name).writer(records)
+        end
+      end
+
+      def define_reader
+        name = self.name
+        mixin.redefine_method(name) do
+          searches_many_association(name).reader
+        end
+      end
+    end
+  end
+end

data/lib/elastic_record/searches_many/collection_proxy.rb

@@ -0,0 +1,20 @@
+module ElasticRecord
+  module SearchesMany
+    class CollectionProxy < ElasticRecord::Relation
+      def initialize(association)
+        @association = association
+        super association.klass, association.klass.arelastic
+        merge! association.scope
+      end
+
+      def to_a
+        @association.load_collection.reject(&:destroyed?)
+      end
+
+      def <<(*records)
+        @association.concat(records) && self
+      end
+      alias_method :push, :<<
+    end
+  end
+end

data/lib/elastic_record/searches_many/reflection.rb

@@ -0,0 +1,41 @@
+module ElasticRecord
+  module SearchesMany
+    class Reflection
+      attr_reader :model, :name, :options
+      attr_reader :callbacks
+      def initialize(model, name, options)
+        @model, @name, @options = model, name, options
+        @callbacks = define_callbacks(options)
+      end
+
+      def klass
+        klass_name.constantize
+      end
+
+      def klass_name
+        name.to_s.classify
+      end
+
+      def belongs_to
+        options[:as] ? options[:as].to_s : model.name.to_s.demodulize.underscore
+      end
+
+      CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
+      def define_callbacks(options)
+        Hash[CALLBACKS.map { |callback_name| [callback_name, Array(options[callback_name.to_sym])] }]
+      end
+
+      def touch_column
+        if options[:touch]
+          options[:touch] == true ? :updated_at : options[:touch].to_sym
+        end
+      end
+
+      def counter_cache_column
+        if options[:counter_cache]
+          (options[:counter_cache] == true ? "#{name}_count" : options[:counter_cache]).to_sym
+        end
+      end
+    end
+  end
+end

data/lib/elastic_record/searches_many.rb

@@ -0,0 +1,91 @@
+require 'elastic_record/searches_many/association'
+require 'elastic_record/searches_many/autosave'
+require 'elastic_record/searches_many/builder'
+require 'elastic_record/searches_many/collection_proxy'
+require 'elastic_record/searches_many/reflection'
+
+module ElasticRecord
+  module SearchesMany
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+
+        class_attribute :searches_many_reflections
+        self.searches_many_reflections = {}
+
+        include ElasticRecord::SearchesMany::Autosave
+      end
+    end
+
+    module ClassMethods
+      # Specifies a one-to-many association. The following methods for retrieval and query of
+      # collections of associated objects will be added:
+      # 
+      # [collection]
+      #   Returns an array of all the associated objects.
+      # [collection=objects]
+      #   Replaces the collections content by deleting and adding objects as appropriate.
+      # [collection_params=objects]
+      #   Support for nested assignment from a form
+      # === Options
+      # [:as]
+      #   Specifies a polymorphic interface (See <tt>belongs_to</tt>).
+      # [:touch]
+      #   Specify to update the owner when changed. Specify <tt>true</tt>
+      #   to update the updated_at field. If you specify a symbol, that attribute
+      #   will be updated with the current time in addition to the updated_at/on attribute.
+      # [:autosave]
+      #   If true, always save the associated objects or destroy them if marked for destruction, when
+      #   saving the parent object.
+      # [:counter_cache]
+      #   Caches the number of belonging objects on the associate class. This requires that a column
+      #   named <tt>#{table_name}_count</tt> (such as +comments_count+ for a belonging Comment class)
+      #   is used on the associate class (such as a Post class). You can also specify a custom counter
+      #   cache column by providing a column name instead of a +true+/+false+ value to this
+      #   option (e.g., <tt>:counter_cache => :my_custom_counter</tt>.)
+      # 
+      # === Example
+      # 
+      # Example: A Firm class declares <tt>has_many :clients</tt>, which will add:
+      # * <tt>Firm#clients</tt>
+      # * <tt>Firm#clients=(objects)</tt>
+      # * <tt>Firm#client_params=(params)</tt>
+      def searches_many(name, options = {})
+        ElasticRecord::SearchesMany::Builder.build(self, name, options)
+      end
+
+      def generated_searches_many_methods
+        @generated_searches_many_methods ||= begin
+          mod = const_set(:GeneratedSearchesManyMethods, Module.new)
+          include mod
+          mod
+        end
+      end
+    end
+
+    # Returns the searches_many instance for the given name, instantiating it if it doesn't already exist
+    def searches_many_association(name)
+      association = searches_many_instance_get(name)
+
+      if association.nil?
+        association = ElasticRecord::SearchesMany::Association.new(self, searches_many_reflections[name])
+        searches_many_instance_set(name, association)
+      end
+
+      association
+    end
+
+    private
+      def searches_many_cache
+        @searches_many_cache ||= {}
+      end
+
+      def searches_many_instance_get(name)
+        searches_many_cache[name.to_sym]
+      end
+    
+      def searches_many_instance_set(name, association)
+        searches_many_cache[name.to_sym] = association
+      end
+  end
+end

data/lib/elastic_record.rb

@@ -1,5 +1,6 @@
 require 'arelastic'
 require 'active_support/core_ext/object/blank' # required because ActiveModel depends on this but does not require it
+require 'active_support/concern'
 require 'active_model'
 
 module ElasticRecord
@@ -10,6 +11,7 @@ module ElasticRecord
   autoload :Lucene, 'elastic_record/lucene'
   autoload :Model, 'elastic_record/model'
   autoload :Relation, 'elastic_record/relation'
+  autoload :SearchesMany, 'elastic_record/searches_many'
   autoload :Searching, 'elastic_record/searching'
 
   class << self
@@ -19,4 +21,4 @@ module ElasticRecord
   end
 end
 
-require 'elastic_record/railtie' if defined?(Rails)
+require 'elastic_record/railtie' if defined?(Rails)

data/test/elastic_record/callbacks_test.rb

@@ -1,16 +1,11 @@
 require 'helper'
 
 class ElasticRecord::CallbacksTest < MiniTest::Spec
-  def setup
-    super
-    Widget.elastic_index.reset
-  end
-
   def test_added_to_index
     widget = Widget.new id: '10', color: 'green'
     refute Widget.elastic_index.record_exists?(widget.id)
 
-    widget.run_callbacks :save
+    widget.save
 
     assert Widget.elastic_index.record_exists?(widget.id)
   end
@@ -21,7 +16,7 @@ class ElasticRecord::CallbacksTest < MiniTest::Spec
 
     assert Widget.elastic_index.record_exists?(widget.id)
 
-    widget.run_callbacks :destroy
+    widget.destroy
 
     refute Widget.elastic_index.record_exists?(widget.id)
   end

data/test/elastic_record/config_test.rb

@@ -4,6 +4,6 @@ class ElasticRecord::ConfigTest < MiniTest::Spec
   def test_models
     ElasticRecord::Config.model_names = %w(Widget)
 
-    assert_equal [Widget], ElasticRecord::Config.models
+    assert_equal [Warehouse, Widget], ElasticRecord::Config.models
   end
 end

data/test/elastic_record/index/documents_test.rb

@@ -3,7 +3,7 @@ require 'helper'
 class ElasticRecord::Index::DocumentsTest < MiniTest::Spec
   def setup
     super
-    
+    index.disable_deferring!
     index.reset
   end
 

data/test/elastic_record/index/manage_test.rb

@@ -1,9 +1,13 @@
 require 'helper'
 
+# class Cat
+#   include TestModel
+# end
+
 class ElasticRecord::Index::ManageTest < MiniTest::Spec
   def setup
     super
-
+    index.disable_deferring!
     index.delete_all
   end
   

data/test/elastic_record/index/percolator_test.rb

@@ -1,6 +1,11 @@
 require 'helper'
 
 class ElasticRecord::Index::PercolatorTest < MiniTest::Spec
+  def setup
+    super
+    index.disable_deferring!
+  end
+
   def test_create_percolator
     index.delete(index.percolator_index_name) if index.exists?(index.percolator_index_name)
 

data/test/elastic_record/relation/batches_test.rb

@@ -2,7 +2,7 @@ require 'helper'
 
 class ElasticRecord::Relation::BatchesTest < MiniTest::Spec
   def setup
-    Widget.elastic_index.reset
+    super
     create_widgets
   end
 
@@ -37,7 +37,5 @@ class ElasticRecord::Relation::BatchesTest < MiniTest::Spec
         Widget.new(id: 10, color: 'blue'),
         Widget.new(id: 15, color: 'green'),
       ]
-      
-      Widget.elastic_index.refresh
     end
 end

data/test/elastic_record/relation/delegation_test.rb

@@ -1,13 +1,8 @@
 require 'helper'
 
 class ElasticRecord::Relation::DelegationTest < MiniTest::Spec
-  def setup
-    Widget.elastic_index.reset
-  end
-
   def test_delegate_to_array
     Widget.elastic_index.index_document('5', color: 'red')
-    Widget.elastic_index.refresh
     
     records = []
     Widget.elastic_relation.each do |record|

data/test/elastic_record/relation/finder_methods_test.rb

@@ -2,7 +2,7 @@ require 'helper'
 
 class ElasticRecord::Relation::FinderMethodsTest < MiniTest::Spec
   def setup
-    Widget.elastic_index.reset
+    super
     create_widgets
   end
 
@@ -37,8 +37,6 @@ class ElasticRecord::Relation::FinderMethodsTest < MiniTest::Spec
       Widget.elastic_index.bulk_add [
         Widget.new(color: 'red', id: '05'),
         Widget.new(color: 'blue', id: '10'),
-      ]
-      
-      Widget.elastic_index.refresh
+      ]      
     end
 end

data/test/elastic_record/relation/none_test.rb

@@ -1,11 +1,6 @@
 require 'helper'
 
 class ElasticRecord::Relation::NoneTest < MiniTest::Spec
-  def setup
-    super
-    Widget.elastic_index.reset
-  end
-
   def test_none
     none = Widget.elastic_relation.none
 

data/test/elastic_record/relation/search_methods_test.rb

@@ -57,6 +57,25 @@ class ElasticRecord::Relation::SearchMethodsTest < MiniTest::Spec
     assert_equal expected, relation.as_elastic['query']
   end
 
+  def test_filter_with_another_relation
+    relation.filter! Widget.elastic_search.query('red')
+
+    expected = {
+      "constant_score" => {
+        "filter" => {
+          "has_child" => {
+            "type" => "widget",
+            "query" => {
+              "query_string" => {"query"=>"red"}
+            }
+          }
+        }
+      }
+    }
+
+    assert_equal expected, relation.as_elastic['query']
+  end
+
   def test_query_with_only_query
     relation.query!('foo')
 

data/test/elastic_record/relation_test.rb

@@ -1,11 +1,6 @@
 require 'helper'
 
 class ElasticRecord::RelationTest < MiniTest::Spec
-  def setup
-    super
-    Widget.elastic_index.reset
-  end
-
   def test_count
     create_widgets [Widget.new(id: 5, color: 'red'), Widget.new(id: 10, color: 'blue')]
 
@@ -32,7 +27,6 @@ class ElasticRecord::RelationTest < MiniTest::Spec
     create_widgets [Widget.new(id: 10, color: 'blue')]
 
     # explain = Widget.elastic_relation.filter(color: 'blue').explain('10')
-    # p "explain = #{explain}"
   end
 
   def test_to_hits
@@ -70,6 +64,5 @@ class ElasticRecord::RelationTest < MiniTest::Spec
   private
     def create_widgets(widgets)
       Widget.elastic_index.bulk_add(widgets)
-      Widget.elastic_index.refresh
     end
 end

data/test/elastic_record/searches_many/autosave_test.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+class ElasticRecord::SearchesMany::AutosaveTest < MiniTest::Spec
+  def test_save_associations_callback
+    warehouse = Warehouse.new
+    widget = Widget.new
+    warehouse.widgets = [widget]
+    assert widget.new_record?
+  
+    warehouse.save
+  
+    assert widget.persisted?
+  end
+
+  def test_validate_associations_callback
+    warehouse = Warehouse.new
+    widget = Widget.new color: 123
+    warehouse.widgets = [widget]
+  
+    assert warehouse.invalid?
+    assert_equal ["is invalid"], warehouse.errors['widgets.color']
+  end
+  
+  def test_mark_for_destruction
+    widget = Widget.new
+  
+    widget.mark_for_destruction
+  
+    assert widget.marked_for_destruction?
+  end
+end

data/test/elastic_record/searches_many/collection_proxy_test.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+class ElasticRecord::SearchesMany::CollectionProxyTest < MiniTest::Spec
+  def test_add_to_new_record
+    warehouse = Warehouse.new
+    widget = Widget.new
+  
+    warehouse.widgets << widget
+  
+    assert widget.new_record?
+    assert_equal [widget], warehouse.widgets
+  end
+  
+  def test_add_to_persisted_record
+    warehouse = Warehouse.create
+    widget = Widget.new
+  
+    warehouse.widgets << widget
+  
+    assert !widget.new_record?
+    assert_equal [widget], warehouse.widgets
+  end
+end

data/test/elastic_record/searches_many/reflection_test.rb

@@ -0,0 +1,20 @@
+require 'helper'
+
+class ElasticRecord::SearchesMany::ReflectionTest < MiniTest::Spec
+  def test_touch_column
+    assert_nil reflection_class.new(Warehouse, :widgets, {}).touch_column
+    assert_equal :updated_at, reflection_class.new(Warehouse, :widgets, touch: true).touch_column
+    assert_equal :my_column, reflection_class.new(Warehouse, :widgets, touch: :my_column).touch_column
+  end
+  
+  def test_counter_cache_column
+    assert_nil reflection_class.new(Warehouse, :widgets, {}).counter_cache_column
+    assert_equal :widgets_count, reflection_class.new(Warehouse, :widgets, counter_cache: true).counter_cache_column
+    assert_equal :my_column, reflection_class.new(Warehouse, :widgets, counter_cache: :my_column).counter_cache_column
+  end
+
+  private
+    def reflection_class
+      ElasticRecord::SearchesMany::Reflection
+    end
+end

data/test/elastic_record/searches_many_test.rb

@@ -0,0 +1,65 @@
+require 'helper'
+
+class ElasticRecord::SearchesManyTest < MiniTest::Spec
+  def test_reader
+    warehouse = Warehouse.create
+    related_widget = Widget.create warehouse: warehouse
+    unrelated_widget = Widget.create
+  
+    assert_equal [related_widget], warehouse.widgets
+  end
+
+  def test_write_with_objects
+    warehouse = Warehouse.new
+    widget = Widget.new
+  
+    warehouse.widgets = [widget]
+  
+    assert widget.new_record?
+    assert_equal warehouse.id, widget.warehouse_id
+    # assert_equal 1, warehouse.widgets_count
+    # assert_in_delta Time.current, warehouse.widgets_updated_at, 5
+  end
+
+  def test_write_with_attributes
+    warehouse = Warehouse.new
+  
+    warehouse.widgets = [
+      {
+        color:  'blue',
+        name:   'Toy'
+      }
+    ]
+  
+    widgets = warehouse.widgets
+    assert_equal 1, widgets.size
+  end
+
+  def test_write_marks_destroyed
+    warehouse = Warehouse.new
+    widget = Widget.create warehouse: warehouse
+  
+    warehouse.widgets = []
+  
+    association = warehouse.searches_many_association(:widgets)
+    assert_equal 1, association.reader.size
+    assert association.reader.first.marked_for_destruction?
+  end
+
+  def test_write_existing_record
+    widget = Widget.create name: 'Toy', color: 'green'
+    warehouse = Warehouse.new widgets: [widget]
+  
+    warehouse.widgets = [
+      {
+        id: widget.id,
+        color:   "blue"
+      }
+    ]
+  
+    widgets = warehouse.widgets
+    assert_equal 1, widgets.size
+    assert_equal "blue", widgets.first.color
+    assert_equal "Toy", widgets.first.name
+  end
+end

data/test/helper.rb

@@ -3,8 +3,13 @@ Bundler.require
 
 require 'minitest/autorun'
 
-require 'support/widget'
 require 'support/connect'
+require 'support/models/test_model'
+require 'support/models/warehouse'
+require 'support/models/widget'
+Widget.elastic_index.reset
+
+ElasticRecord::Config.model_names = %w(Warehouse Widget)
 
 FakeWeb.allow_net_connect = %r[^https?://127.0.0.1]
 
@@ -13,6 +18,16 @@ module MiniTest
     def setup
       super
       FakeWeb.clean_registry
+
+      ElasticRecord::Config.models.each do |model|
+        model.elastic_index.enable_deferring!
+      end
+    end
+
+    def teardown
+      ElasticRecord::Config.models.each do |model|
+        model.elastic_index.reset_deferring!
+      end
     end
   end
 end

data/test/support/connect.rb

@@ -1 +1 @@
-ElasticRecord::Config.servers = '127.0.0.1:9200'
+ElasticRecord::Config.servers = '127.0.0.1:9200'

data/test/support/models/test_model.rb

@@ -0,0 +1,98 @@
+module TestModel
+  extend ActiveSupport::Concern
+
+  included do
+    extend ActiveModel::Naming
+    extend ActiveModel::Callbacks
+    define_model_callbacks :save, :destroy
+
+    include ActiveModel::Dirty
+    include ActiveModel::Validations
+
+    include ElasticRecord::Model
+    include ElasticRecord::Callbacks
+  end
+
+  module ClassMethods
+    def find(ids)
+      ids.map { |id| new(id: id, color: 'red') }
+    end
+
+    def base_class
+      self
+    end
+
+    def create(attributes = {})
+      record = new(attributes)
+      record.save
+      record
+    end
+
+    def define_attributes(attributes)
+      define_attribute_methods attributes
+
+      attributes.each do |attribute|
+        define_method attribute do
+          instance_variable_get("@#{attribute}")
+        end
+
+        define_method "#{attribute}=" do |value|
+          send("#{attribute}_will_change!")
+          instance_variable_set("@#{attribute}", value)
+        end
+      end
+
+      define_method 'attributes' do
+        Hash[attributes.map { |attr| [attr.to_s, send(attr)] }]
+      end
+    end
+  end
+
+  def initialize(attrs = {})
+    self.attributes = attrs
+  end
+
+  def attributes=(attrs)
+    attrs.each do |key, val|
+      send("#{key}=", val)
+    end
+  end
+
+  def id=(value)
+    @id = value
+  end
+
+  def id
+    @id ||= rand(10000).to_s
+  end
+
+  def save
+    @persisted = true
+    run_callbacks :save
+  end
+
+  def destroy
+    @destroyed = true
+    run_callbacks :destroy
+  end
+
+  def ==(other)
+    id == other.id
+  end
+
+  def changed?
+    true
+  end
+
+  def new_record?
+    !@persisted
+  end
+
+  def persisted?
+    @persisted
+  end
+
+  def destroyed?
+    @destroyed
+  end
+end

data/test/support/models/warehouse.rb

@@ -0,0 +1,6 @@
+class Warehouse
+  include TestModel
+
+  define_attributes [:name]
+  searches_many :widgets
+end

data/test/support/{widget.rb → models/widget.rb}

@@ -1,10 +1,9 @@
 class Widget
-  extend ActiveModel::Naming
-  extend ActiveModel::Callbacks
-  define_model_callbacks :save, :destroy
+  include TestModel
 
-  include ElasticRecord::Model
-  include ElasticRecord::Callbacks
+  validates :color, format: {with: /[a-z]/}
+
+  define_attributes [:name, :color, :warehouse_id]
 
   self.elastic_index.mapping[:properties].update(
     name: {
@@ -16,14 +15,13 @@ class Widget
     },
     color: {
       type: 'string', index: 'not_analyzed'
+    },
+    warehouse_id: {
+      type: 'string', index: 'not_analyzed'
     }
   )
-  
-  class << self
-    def find(ids)
-      ids.map { |id| new(id: id, color: 'red') }
-    end
 
+  class << self
     def anon(&block)
       Class.new(self) do
         def self.name
@@ -33,16 +31,9 @@ class Widget
         instance_eval(&block)
       end
     end
-
-    def base_class
-      self
-    end
   end
 
-  attr_accessor :id, :name, :color
-  def initialize(attributes = {})
-    attributes.each do |key, val|
-      send("#{key}=", val)
-    end
+  def warehouse=(other)
+    self.warehouse_id = other.id
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elastic_record
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-12 00:00:00.000000000 Z
+date: 2012-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: arelastic
@@ -62,6 +62,7 @@ files:
 - lib/elastic_record/config.rb
 - lib/elastic_record/connection.rb
 - lib/elastic_record/index.rb
+- lib/elastic_record/index/deferred.rb
 - lib/elastic_record/index/documents.rb
 - lib/elastic_record/index/manage.rb
 - lib/elastic_record/index/mapping.rb
@@ -79,6 +80,12 @@ files:
 - lib/elastic_record/relation/none.rb
 - lib/elastic_record/relation/search_methods.rb
 - lib/elastic_record/relation/value_methods.rb
+- lib/elastic_record/searches_many.rb
+- lib/elastic_record/searches_many/association.rb
+- lib/elastic_record/searches_many/autosave.rb
+- lib/elastic_record/searches_many/builder.rb
+- lib/elastic_record/searches_many/collection_proxy.rb
+- lib/elastic_record/searches_many/reflection.rb
 - lib/elastic_record/searching.rb
 - lib/elastic_record/tasks/index.rake
 - test/elastic_record/callbacks_test.rb
@@ -99,10 +106,16 @@ files:
 - test/elastic_record/relation/none_test.rb
 - test/elastic_record/relation/search_methods_test.rb
 - test/elastic_record/relation_test.rb
+- test/elastic_record/searches_many/autosave_test.rb
+- test/elastic_record/searches_many/collection_proxy_test.rb
+- test/elastic_record/searches_many/reflection_test.rb
+- test/elastic_record/searches_many_test.rb
 - test/elastic_record/searching_test.rb
 - test/helper.rb
 - test/support/connect.rb
-- test/support/widget.rb
+- test/support/models/test_model.rb
+- test/support/models/warehouse.rb
+- test/support/models/widget.rb
 homepage: http://github.com/matthuhiggins/elastic_record
 licenses:
 - MIT