elasticsearch-persistence-queryable 0.1.8

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

@@ -0,0 +1,155 @@
+module Elasticsearch
+  module Persistence
+    module Model
+      module Find
+        module ClassMethods
+
+          # 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 scan/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.slice(
+              :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
+
+            puts "BODY: #{body}".color :red
+            # Get the initial scroll_id
+            #
+            response = gateway.client.search({ index: gateway.index_name,
+                                               type: gateway.document_type,
+                                               search_type: "scan",
+                                               scroll: scroll,
+                                               size: 20,
+                                               body: body }.merge(search_params))
+
+            # Get the initial batch of documents
+            #
+            response = gateway.client.scroll({ scroll_id: response["_scroll_id"], scroll: scroll })
+
+            # Break when receiving an empty array of hits
+            #
+            while response["hits"]["hits"].any?
+              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&search_type=scan&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/gateway_delegation.rb

@@ -0,0 +1,23 @@
+module Elasticsearch
+  module Persistence
+    module Model
+      module GatewayDelegation
+        delegate :settings,
+          :mappings,
+          :mapping,
+          :document_type,
+          :document_type=,
+          :index_name,
+          :index_name=,
+          :search,
+          :find,
+          :exists?,
+          :create_index!,
+          :delete_index!,
+          :index_exists?,
+          :refresh_index!,
+          to: :gateway
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Elasticsearch
+  module Persistence
+    module Model
+
+      # Subclass of `Hashie::Mash` to wrap Hash-like structures
+      # (responses from Elasticsearch, search definitions, etc)
+      #
+      # The primary goal of the subclass is to disable the
+      # warning being printed by Hashie for re-defined
+      # methods, such as `sort`.
+      #
+      class HashWrapper < ::Hashie::Mash
+        disable_warnings if respond_to?(:disable_warnings)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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
+
+            # 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 initialize(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
+
+              super(attributes)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,271 @@
+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.save(options)
+            object
+          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 = {})
+            return false unless valid?
+
+            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
+
+              if new_record?
+                response = run_callbacks :create do
+                  response = self.class.gateway.save(self, options)
+                  self[:updated_at] = Time.now.utc
+
+                  @_id = response["_id"]
+                  @_index = response["_index"]
+                  @_type = response["_type"]
+                  @_version = response["_version"]
+                  @persisted = true
+
+                  response
+                end
+              else
+                response = self.class.gateway.save(self, options)
+
+                self[:updated_at] = Time.now.utc
+
+                @_id = response["_id"]
+                @_index = response["_index"]
+                @_type = response["_type"]
+                @_version = response["_version"]
+                @persisted = true
+
+                response
+              end
+            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}
+          #
+          # @return [Hash] The Elasticsearch response as a Hash
+          #
+          def update(attributes = {}, options = {})
+            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
+
+          def becomes(klass)
+            became = klass.new(attributes)
+            changed_attributes = @changed_attributes if defined?(@changed_attributes)
+            became.instance_variable_set("@changed_attributes", changed_attributes || {})
+            became.instance_variable_set("@new_record", new_record?)
+            became.instance_variable_set("@destroyed", destroyed?)
+            became.instance_variable_set("@errors", errors)
+            became.instance_variable_set("@persisted", persisted?)
+            became.instance_variable_set("@_id", _id)
+            became.instance_variable_set("@_version", _version)
+            became.instance_variable_set("@_index", _index)
+            became.instance_variable_set("@_type", _type)
+            became
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/persistence/model.rb

@@ -0,0 +1,148 @@
+require "active_support/core_ext/module/delegation"
+
+require "active_model"
+require "virtus"
+
+#require 'elasticsearch/persistence'
+
+require "elasticsearch/persistence/model/base"
+require "elasticsearch/persistence/model/callbacks"
+require "elasticsearch/persistence/model/errors"
+require "elasticsearch/persistence/model/store"
+require "elasticsearch/persistence/model/find"
+require "elasticsearch/persistence/model/hash_wrapper"
+
+module Elasticsearch
+  module Persistence
+
+    # When included, extends a plain Ruby class with persistence-related features via the ActiveRecord pattern
+    #
+    # @example Include the repository in a custom class
+    #
+    #     require 'elasticsearch/persistence/model'
+    #
+    #     class MyObject
+    #       include Elasticsearch::Persistence::Repository
+    #     end
+    #
+    module Model
+      def self.included(base)
+        base.class_eval do
+          include ActiveModel::Naming
+          include ActiveModel::Conversion
+          include ActiveModel::Serialization
+          include ActiveModel::Serializers::JSON
+          include ActiveModel::Validations
+          include ActiveModel::Validations::Callbacks
+
+          include Virtus.model
+          extend ActiveModel::Callbacks
+
+          define_model_callbacks :create, :save, :update, :destroy
+          define_model_callbacks :find, :touch, only: :after
+
+          include Elasticsearch::Persistence::Model::Callbacks
+
+          include Elasticsearch::Persistence::Model::Base::InstanceMethods
+
+          extend Elasticsearch::Persistence::Model::Store::ClassMethods
+          include Elasticsearch::Persistence::Model::Store::InstanceMethods
+
+          extend Elasticsearch::Persistence::Model::GatewayDelegation
+
+          extend Elasticsearch::Persistence::Model::Find::ClassMethods
+          extend Elasticsearch::Persistence::Querying
+          extend Elasticsearch::Persistence::Inheritence
+          extend Elasticsearch::Persistence::Delegation::DelegateCache
+
+          include Elasticsearch::Persistence::Scoping
+
+          class << self
+
+            # Re-define the Virtus' `attribute` method, to configure Elasticsearch mapping as well
+            #
+            def attribute(name, type = nil, options = {}, &block)
+              mapping = options.delete(:mapping) || {}
+
+              if type == :keyword || type.nil?
+                type = String
+                mapping = { type: "keyword" }.merge(mapping)
+              end
+
+              super
+
+              gateway.mapping do
+                indexes name, { type: Utils::lookup_type(type) }.merge(mapping)
+              end
+
+              gateway.mapping(&block) if block_given?
+            end
+
+            # Return the {Repository::Class} instance
+            #
+            def gateway(&block)
+              @gateway ||= Elasticsearch::Persistence::Repository::Class.new host: self
+              block.arity < 1 ? @gateway.instance_eval(&block) : block.call(@gateway) if block_given?
+              @gateway
+            end
+
+            # Set the default sort key to be used in sort operations
+            #
+            def default_sort_key(field = nil)
+              @default_sort_key = field unless field.nil?
+              @default_sort_key
+            end
+
+            private
+
+            # Return a Relation instance to chain queries
+            #
+            def relation
+              Relation.create(self, {})
+            end
+          end
+
+          # Configure the repository based on the model (set up index_name, etc)
+          #
+          gateway do
+            klass base
+            index_name base.model_name.collection.gsub(/\//, "-")
+            document_type base.model_name.element
+
+            def serialize(document)
+              document.to_hash.except(:id, "id")
+            end
+
+            def deserialize(document)
+              object = klass.new document["_source"] || document["fields"]
+
+              # Set the meta attributes when fetching the document from Elasticsearch
+              #
+              object.instance_variable_set :@_id, document["_id"]
+              object.instance_variable_set :@_index, document["_index"]
+              object.instance_variable_set :@_type, document["_type"]
+              object.instance_variable_set :@_version, document["_version"]
+
+              # Store the "hit" information (highlighting, score, ...)
+              #
+              object.instance_variable_set :@hit,
+                                           HashWrapper.new(document.except("_index", "_type", "_id", "_version", "_source"))
+
+              object.instance_variable_set(:@persisted, true)
+              object
+            end
+          end
+
+          # Set up common attributes
+          #
+          attribute :created_at, DateTime, default: lambda { |o, a| Time.now.utc }
+          attribute :updated_at, DateTime, default: lambda { |o, a| Time.now.utc }
+
+          default_sort_key :created_at
+
+          attr_reader :hit
+        end
+      end
+    end
+  end
+end