elastic_record 1.1.8 → 1.2.1

data/lib/elastic_record/searches_many/association.rb

@@ -1,149 +0,0 @@
-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
-
-        delete(load_collection - other_records)
-        merge_collections(load_collection, other_records)
-        concat(other_records - load_collection)
-
-        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
-      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)
-        records.each do |record|
-          callback(:before_remove, record)
-
-          if options[:autosave] || owner.new_record?
-            record.mark_for_destruction
-          else
-            record.destroy
-          end
-
-          callback(:after_remove, record)
-        end
-      end
-
-      def scope
-        search = klass.elastic_search.filter("#{reflection.belongs_to}_id" => owner.id).limit(1000000)
-        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
-
-        collection
-      end
-
-      def eager_loaded_collection(records)
-        unless @loaded
-          @collection = records
-          @loaded = true
-        end
-
-        collection
-      end
-
-      private
-
-        def load_persisted_collection?
-          !loaded? || owner.new_record?
-        end
-
-        def persisted_collection
-          @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.respond_to?(:call)
-              callback.call(owner, record)
-            else
-              owner.send(callback, record)
-            end
-          end
-        end
-    end
-  end
-end

data/lib/elastic_record/searches_many/autosave.rb

@@ -1,72 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

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

data/lib/elastic_record/searches_many/reflection.rb

@@ -1,45 +0,0 @@
-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
-        options[:class_name] || name.to_s.classify
-      end
-
-      def belongs_to
-        options[:as] ? options[:as].to_s : model.name.to_s.demodulize.underscore
-      end
-
-      def foreign_key
-        options[:foreign_key] ? options[:foreign_key].to_s : "#{model.name.to_s.demodulize.underscore}_id"
-      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

@@ -1,100 +0,0 @@
-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>.)
-      # [:class_name]
-      #   Specify the class name of the association. Use it only if that name can't be inferred
-      #   from the association name. So <tt>has_one :manager</tt> will by default be linked to the Manager class, but
-      #   if the real class name is Person, you'll have to specify it with this option.
-      # 
-      # === 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
-
-    def reload
-      super
-      searches_many_cache.clear
-    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/test/elastic_record/searches_many/association_test.rb

@@ -1,47 +0,0 @@
-require 'helper'
-
-class ElasticRecord::SearchesMany::AssociationTest < MiniTest::Spec
-
-  def test_writer_assignment_from_hash
-    warehouse = Warehouse.new
-    warehouse.widgets = [{color: 'blue', name: 'thing'}]
-
-    assert_equal 1, warehouse.widgets.all.count
-    expected = {
-      'color' => 'blue',
-      'name' => 'thing',
-      'warehouse_id' => warehouse.id,
-    }
-    assert_equal expected, warehouse.widgets[0].attributes
-  end
-
-  def test_writer
-    warehouse = Warehouse.new
-
-    warehouse.widgets = [{color: 'blue', name: 'thing'}]
-
-    assert_equal 1, warehouse.widgets.all.count
-
-    warehouse.widgets = [ {color: 'red', name: 'device'}, {color: 'blue', name: 'thing'} ]
-
-    assert_equal 3, warehouse.widgets.all.count
-    assert warehouse.widgets[0].marked_for_destruction?
-    refute warehouse.widgets[1].marked_for_destruction?
-    refute warehouse.widgets[2].marked_for_destruction?
-
-    expected = {
-      'color' => 'red',
-      'name' => 'device',
-      'warehouse_id' => warehouse.id,
-    }
-    assert_equal expected, warehouse.widgets[1].attributes
-
-    expected = {
-      'color' => 'blue',
-      'name' => 'thing',
-      'warehouse_id' => warehouse.id,
-    }
-    assert_equal expected, warehouse.widgets[2].attributes
-  end
-
-end

data/test/elastic_record/searches_many/autosave_test.rb

@@ -1,32 +0,0 @@
-require 'helper'
-
-class ElasticRecord::SearchesMany::AutosaveTest < MiniTest::Unit::TestCase
-  def test_save_associations_autosave_callback
-    warehouse = Warehouse.new
-    widget = Widget.new
-    warehouse.widgets = [widget]
-    assert warehouse.new_record?
-    assert widget.new_record?
-
-    warehouse.save
-
-    assert widget.persisted?
-  end
-
-  def test_validate_associations_autosave_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

@@ -1,23 +0,0 @@
-require 'helper'
-
-class ElasticRecord::SearchesMany::CollectionProxyTest < MiniTest::Unit::TestCase
-  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

@@ -1,33 +0,0 @@
-require 'helper'
-
-class ElasticRecord::SearchesMany::ReflectionTest < MiniTest::Unit::TestCase
-
-  def test_foreiegn_key
-    assert_equal 'warehouse_id', reflection_class.new(Warehouse, :widgets, {}).foreign_key
-    assert_equal 'foo_id', reflection_class.new(Warehouse, :widgets, {:foreign_key => 'foo_id' }).foreign_key
-  end
-
-  def test_klass_name
-    assert_equal 'Product', reflection_class.new(Warehouse, :widgets, {class_name: 'Product'}).klass_name
-    assert_equal 'Widget', reflection_class.new(Warehouse, :widgets, {}).klass_name
-  end
-
-  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

@@ -1,76 +0,0 @@
-require 'helper'
-
-class ElasticRecord::SearchesManyTest < MiniTest::Unit::TestCase
-  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
-
-  def test_reload
-    warehouse = Warehouse.create
-    widget = Widget.create name: 'Toy', color: 'green', warehouse: warehouse
-    assert_equal [widget], warehouse.widgets
-    widget.destroy
-
-    warehouse.reload
-
-    assert_equal [], warehouse.widgets
-  end
-end

data/test/support/models/option.rb

@@ -1,24 +0,0 @@
-class Option
-  include TestModel
-
-  define_attributes [:name, :widget_id]
-
-  searches_many :options
-
-  self.elastic_index.mapping[:properties].update(
-    name: {
-      type: 'multi_field',
-      fields: {
-        name: {type: 'string', index: 'not_analyzed'},
-        analyzed: {type: 'string', index: 'analyzed'}
-      }
-    },
-    widget_id: {
-      type: 'string', index: 'not_analyzed'
-    }
-  )
-
-  def widget=(other)
-    self.widget_id = other.id
-  end
-end