elasticsearch-persistence 5.1.0 → 6.0.0.pre

data/lib/elasticsearch/persistence/model/errors.rb

@@ -1,8 +0,0 @@
-module Elasticsearch
-  module Persistence
-    module Model
-      class DocumentNotSaved     < StandardError; end
-      class DocumentNotPersisted < StandardError; end
-    end
-  end
-end

data/lib/elasticsearch/persistence/model/find.rb

@@ -1,180 +0,0 @@
-module Elasticsearch
-  module Persistence
-    module Model
-
-      module Find
-        class SearchRequest < Elasticsearch::Model::Searching::SearchRequest
-          def execute!
-            klass.gateway.search(definition[:body] || definition[:q], options)
-          end
-        end
-
-        module ClassMethods
-
-          def search(query_or_definition, options={})
-            SearchRequest.new(self, query_or_definition, options).execute!
-          end
-
-          # Returns all models (up to 10,000)
-          #
-          # @example Retrieve all people
-          #
-          #     Person.all
-          #     # => [#<Person:0x007ff1d8fb04b0 ... ]
-          #
-          # @example Retrieve all people matching a query
-          #
-          #     Person.all query: { match: { last_name: 'Smith'  } }
-          #     # => [#<Person:0x007ff1d8fb04b0 ... ]
-          #
-          def all(query={ query: { match_all: {} } }, options={})
-            query[:size] ||= 10_000
-            search(query, options)
-          end
-
-          # Returns the number of models
-          #
-          # @example Return the count of all models
-          #
-          #     Person.count
-          #     # => 2
-          #
-          # @example Return the count of models matching a simple query
-          #
-          #     Person.count('fox or dog')
-          #     # => 1
-          #
-          # @example Return the count of models matching a query in the Elasticsearch DSL
-          #
-          #    Person.search(query: { match: { title: 'fox dog' } })
-          #    # => 1
-          #
-          # @return [Integer]
-          #
-          def count(query_or_definition=nil, options={})
-            gateway.count( query_or_definition, options )
-          end
-
-          # Returns all models efficiently via the Elasticsearch's scroll API
-          #
-          # You can restrict the models being returned with a query.
-          #
-          # The {http://rubydoc.info/gems/elasticsearch-api/Elasticsearch/API/Actions#search-instance_method Search API}
-          # options are passed to the search method as parameters, all remaining options are passed
-          # as the `:body` parameter.
-          #
-          # The full {Persistence::Repository::Response::Results} instance is yielded to the passed
-          # block in each batch, so you can access any of its properties; calling `to_a` will
-          # convert the object to an Array of model instances.
-          #
-          # @example Return all models in batches of 20 x number of primary shards
-          #
-          #     Person.find_in_batches { |batch| puts batch.map(&:name) }
-          #
-          # @example Return all models in batches of 100 x number of primary shards
-          #
-          #     Person.find_in_batches(size: 100) { |batch| puts batch.map(&:name) }
-          #
-          # @example Return all models matching a specific query
-          #
-          #      Person.find_in_batches(query: { match: { name: 'test' } }) { |batch| puts batch.map(&:name) }
-          #
-          # @example Return all models, fetching only the `name` attribute from Elasticsearch
-          #
-          #      Person.find_in_batches( _source_include: 'name') { |_| puts _.response.hits.hits.map(&:to_hash) }
-          #
-          # @example Leave out the block to return an Enumerator instance
-          #
-          #      Person.find_in_batches(size: 100).map { |batch| batch.size }
-          #      # => [100, 100, 100, ... ]
-          #
-          # @return [String,Enumerator] The `scroll_id` for the request or Enumerator when the block is not passed
-          #
-          def find_in_batches(options={}, &block)
-            return to_enum(:find_in_batches, options) unless block_given?
-
-            search_params = options.extract!(
-              :index,
-              :type,
-              :scroll,
-              :size,
-              :explain,
-              :ignore_indices,
-              :ignore_unavailable,
-              :allow_no_indices,
-              :expand_wildcards,
-              :preference,
-              :q,
-              :routing,
-              :source,
-              :_source,
-              :_source_include,
-              :_source_exclude,
-              :stats,
-              :timeout)
-
-            scroll = search_params.delete(:scroll) || '5m'
-
-            body = options
-
-            # Get the initial batch of documents and the scroll_id
-            #
-            response = gateway.client.search( {
-                                         index: gateway.index_name,
-                                         type:  gateway.document_type,
-                                         scroll: scroll,
-                                         sort:   ['_doc'],
-                                         size:   20,
-                                         body:   body }.merge(search_params) )
-
-
-            # Scroll the search object and break when receiving an empty array of hits
-            #
-            while response['hits']['hits'].any? do
-              yield Repository::Response::Results.new(gateway, response)
-
-              response = gateway.client.scroll( { scroll_id: response['_scroll_id'], scroll: scroll } )
-            end
-
-            return response['_scroll_id']
-          end
-
-          # Iterate effectively over models using the `find_in_batches` method.
-          #
-          # All the options are passed to `find_in_batches` and each result is yielded to the passed block.
-          #
-          # @example Print out the people's names by scrolling through the index
-          #
-          #     Person.find_each { |person| puts person.name }
-          #
-          #     # # GET http://localhost:9200/people/person/_search?scroll=5m&size=20
-          #     # # GET http://localhost:9200/_search/scroll?scroll=5m&scroll_id=c2Nhbj...
-          #     # Test 0
-          #     # Test 1
-          #     # Test 2
-          #     # ...
-          #     # # GET http://localhost:9200/_search/scroll?scroll=5m&scroll_id=c2Nhbj...
-          #     # Test 20
-          #     # Test 21
-          #     # Test 22
-          #
-          # @example Leave out the block to return an Enumerator instance
-          #
-          #     Person.find_each.select { |person| person.name =~ /John/ }
-          #     # => => [#<Person {id: "NkltJP5vRxqk9_RMP7SU8Q", name: "John Smith",  ...}>]
-          #
-          # @return [String,Enumerator] The `scroll_id` for the request or Enumerator when the block is not passed
-          #
-          def find_each(options = {})
-            return to_enum(:find_each, options) unless block_given?
-
-            find_in_batches(options) do |batch|
-              batch.each { |result| yield result }
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/elasticsearch/persistence/model/rails.rb

@@ -1,47 +0,0 @@
-module Elasticsearch
-  module Persistence
-    module Model
-
-      # Make the `Persistence::Model` models compatible with Ruby On Rails applications
-      #
-      module Rails
-        def self.included(base)
-          base.class_eval do
-
-            def initialize(attributes={})
-              super(__convert_rails_dates(attributes))
-            end
-
-            def update(attributes={}, options={})
-              super(__convert_rails_dates(attributes), options)
-            end
-          end
-        end
-
-        # Decorates the passed in `attributes` so they extract the date & time values from Rails forms
-        #
-        # @example Correctly combine the date and time to a datetime string
-        #
-        #     params = { "published_on(1i)"=>"2014",
-        #                      "published_on(2i)"=>"1",
-        #                      "published_on(3i)"=>"1",
-        #                      "published_on(4i)"=>"12",
-        #                      "published_on(5i)"=>"00"
-        #                     }
-        #     MyRailsModel.new(params).published_on.iso8601
-        #     # => "2014-01-01T12:00:00+00:00"
-        #
-        def __convert_rails_dates(attributes={})
-          day = attributes.select { |p| p =~ /\([1-3]/ }.reduce({}) { |sum, item| (sum[item.first.gsub(/\(.+\)/, '')] ||= '' )<< item.last+'-'; sum  }
-          time = attributes.select { |p| p =~ /\([4-6]/ }.reduce({}) { |sum, item| (sum[item.first.gsub(/\(.+\)/, '')] ||= '' )<< item.last+':'; sum  }
-          unless day.empty?
-            attributes.update day.reduce({}) { |sum, item| sum[item.first] = item.last; sum[item.first] += ' ' + time[item.first] unless time.empty?; sum }
-          end
-
-          return attributes
-        end; module_function :__convert_rails_dates
-      end
-
-    end
-  end
-end

data/lib/elasticsearch/persistence/model/store.rb

@@ -1,254 +0,0 @@
-module Elasticsearch
-  module Persistence
-    module Model
-
-      # This module contains the storage related features of {Elasticsearch::Persistence::Model}
-      #
-      module Store
-        module ClassMethods #:nodoc:
-
-          # Creates a class instance, saves it, if validations pass, and returns it
-          #
-          # @example Create a new person
-          #
-          #     Person.create name: 'John Smith'
-          #     # => #<Person:0x007f889e302b30 ... @id="bG7yQDAXRhCi3ZfVcx6oAA", @name="John Smith" ...>
-          #
-          # @return [Object] The model instance
-          #
-          def create(attributes, options={})
-            object = self.new(attributes)
-            object.run_callbacks :create do
-              object.save(options)
-              object
-            end
-          end
-        end
-
-        module InstanceMethods
-
-          # Saves the model (if validations pass) and returns the response (or `false`)
-          #
-          # @example Save a valid model instance
-          #
-          #     p = Person.new(name: 'John')
-          #     p.save
-          #     => {"_index"=>"people", ... "_id"=>"RzFSXFR0R8u1CZIWNs2Gvg", "_version"=>1, "created"=>true}
-          #
-          # @example Save an invalid model instance
-          #
-          #     p = Person.new(name: nil)
-          #     p.save
-          #     # => false
-          #
-          # @return [Hash,FalseClass] The Elasticsearch response as a Hash or `false`
-          #
-          def save(options={})
-            unless options.delete(:validate) == false
-              return false unless valid?
-            end
-
-            run_callbacks :save do
-              options.update id: self.id
-              options.update index: self._index if self._index
-              options.update type:  self._type  if self._type
-
-              self[:updated_at] = Time.now.utc
-
-              response = self.class.gateway.save(self, options)
-
-              @_id       = response['_id']
-              @_index    = response['_index']
-              @_type     = response['_type']
-              @_version  = response['_version']
-              @persisted = true
-
-              response
-            end
-          end
-
-          # Deletes the model from Elasticsearch (if it's persisted), freezes it, and returns the response
-          #
-          # @example Delete a model instance
-          #
-          #     p.destroy
-          #     => {"_index"=>"people", ... "_id"=>"RzFSXFR0R8u1CZIWNs2Gvg", "_version"=>2 ...}
-          #
-          # @return [Hash] The Elasticsearch response as a Hash
-          #
-          def destroy(options={})
-            raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?
-
-            run_callbacks :destroy do
-              options.update index: self._index if self._index
-              options.update type:  self._type  if self._type
-
-              response = self.class.gateway.delete(self.id, options)
-
-              @destroyed = true
-              @persisted = false
-              self.freeze
-              response
-            end
-          end; alias :delete :destroy
-
-          # Updates the model (via Elasticsearch's "Update" API) and returns the response
-          #
-          # @example Update a model with partial attributes
-          #
-          #     p.update name: 'UPDATED'
-          #     => {"_index"=>"people", ... "_version"=>2}
-          #
-          # @example Pass a version for concurrency control
-          #
-          #     p.update( { name: 'UPDATED' }, { version: 2 } )
-          #     => {"_index"=>"people", ... "_version"=>3}
-          #
-          # @example An exception is raised when the version doesn't match
-          #
-          #     p.update( { name: 'UPDATED' }, { version: 2 } )
-          #     => Elasticsearch::Transport::Transport::Errors::Conflict: [409] {"error" ... }
-          #
-          # @return [Hash] The Elasticsearch response as a Hash
-          #
-          def update(attributes={}, options={})
-            unless options.delete(:validate) == false
-              return false unless valid?
-            end
-            raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?
-
-            run_callbacks :update do
-              options.update index: self._index if self._index
-              options.update type:  self._type  if self._type
-
-              attributes.update( { updated_at: Time.now.utc } )
-              response = self.class.gateway.update(self.id, { doc: attributes}.merge(options))
-
-              self.attributes = self.attributes.merge(attributes)
-              @_index    = response['_index']
-              @_type     = response['_type']
-              @_version  = response['_version']
-
-              response
-            end
-          end; alias :update_attributes :update
-
-          # Increments a numeric attribute (via Elasticsearch's "Update" API) and returns the response
-          #
-          # @example Increment the `salary` attribute by 1
-          #
-          #     p.increment :salary
-          #
-          # @example Increment the `salary` attribute by 100
-          #
-          #     p.increment :salary, 100
-          #
-          # @return [Hash] The Elasticsearch response as a Hash
-          #
-          def increment(attribute, value=1, options={})
-            raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?
-
-            options.update index: self._index if self._index
-            options.update type:  self._type  if self._type
-
-            response = self.class.gateway.update(self.id, { script: "ctx._source.#{attribute} += #{value}"}.merge(options))
-
-            self[attribute] += value
-
-            @_index    = response['_index']
-            @_type     = response['_type']
-            @_version  = response['_version']
-
-            response
-          end
-
-          # Decrements a numeric attribute (via Elasticsearch's "Update" API) and returns the response
-          #
-          # @example Decrement the `salary` attribute by 1
-          #
-          #     p.decrement :salary
-          #
-          # @example Decrement the `salary` attribute by 100
-          #
-          #     p.decrement :salary, 100
-          #
-          # @return [Hash] The Elasticsearch response as a Hash
-          #
-          def decrement(attribute, value=1, options={})
-            raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?
-
-            options.update index: self._index if self._index
-            options.update type:  self._type  if self._type
-
-            response = self.class.gateway.update(self.id, { script: "ctx._source.#{attribute} = ctx._source.#{attribute} - #{value}"}.merge(options))
-            self[attribute] -= value
-
-            @_index    = response['_index']
-            @_type     = response['_type']
-            @_version  = response['_version']
-
-            response
-          end
-
-          # Updates the `updated_at` attribute, saves the model and returns the response
-          #
-          # @example Update the `updated_at` attribute (default)
-          #
-          #     p.touch
-          #
-          # @example Update a custom attribute: `saved_on`
-          #
-          #     p.touch :saved_on
-          #
-          # @return [Hash] The Elasticsearch response as a Hash
-          #
-          def touch(attribute=:updated_at, options={})
-            raise DocumentNotPersisted, "Object not persisted: #{self.inspect}"  unless persisted?
-            raise ArgumentError, "Object does not have '#{attribute}' attribute" unless respond_to?(attribute)
-
-            run_callbacks :touch do
-              options.update index: self._index if self._index
-              options.update type:  self._type  if self._type
-
-              value = Time.now.utc
-              response = self.class.gateway.update(self.id, { doc: { attribute => value.iso8601 }}.merge(options))
-
-              self[attribute] = value
-
-              @_index    = response['_index']
-              @_type     = response['_type']
-              @_version  = response['_version']
-
-              response
-            end
-          end
-
-          # Returns true when the model has been destroyed, false otherwise
-          #
-          # @return [TrueClass,FalseClass]
-          #
-          def destroyed?
-            !!@destroyed
-          end
-
-          # Returns true when the model has been already saved to the database, false otherwise
-          #
-          # @return [TrueClass,FalseClass]
-          #
-          def persisted?
-            !!@persisted && !destroyed?
-          end
-
-          # Returns true when the model has not been saved yet, false otherwise
-          #
-          # @return [TrueClass,FalseClass]
-          #
-          def new_record?
-            !persisted? && !destroyed?
-          end
-        end
-      end
-
-    end
-  end
-end