elasticsearch-persistence 0.1.3 → 0.1.4

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

@@ -0,0 +1,239 @@
+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={})
+            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
+
+              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
+
+          # 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
+        end
+      end
+
+    end
+  end
+end

data/lib/elasticsearch/persistence/repository.rb

@@ -17,10 +17,12 @@ module Elasticsearch
       end
     end
 
-    # When included, creates an instance of the {Repository::Class} class as a "gateway"
+    # When included, creates an instance of the {Repository::Class Repository} class as a "gateway"
     #
     # @example Include the repository in a custom class
     #
+    #     require 'elasticsearch/persistence'
+    #
     #     class MyRepository
     #       include Elasticsearch::Persistence::Repository
     #     end

data/lib/elasticsearch/persistence/repository/search.rb

@@ -53,6 +53,31 @@ module Elasticsearch
           end
           Response::Results.new(self, response)
         end
+
+        # Return the number of domain object in the index
+        #
+        # @example Return the number of all domain objects
+        #
+        #     repository.count
+        #     # => 2
+        #
+        # @example Return the count of domain object matching a simple query
+        #
+        #     repository.count('fox or dog')
+        #     # => 1
+        #
+        # @example Return the count of domain object matching a query in the Elasticsearch DSL
+        #
+        #    repository.search(query: { match: { title: 'fox dog' } })
+        #    # => 1
+        #
+        # @return [Integer]
+        #
+        def count(query_or_definition=nil, options={})
+          query_or_definition ||= { query: { match_all: {} } }
+          response = search query_or_definition, options.update(search_type: 'count')
+          response.response.hits.total
+        end
       end
 
     end

data/lib/elasticsearch/persistence/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Persistence
-    VERSION = "0.1.3"
+    VERSION = "0.1.4"
   end
 end

data/lib/rails/generators/elasticsearch/model/model_generator.rb

@@ -0,0 +1,21 @@
+require "rails/generators/elasticsearch_generator"
+
+module Elasticsearch
+  module Generators
+    class ModelGenerator < ::Rails::Generators::NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+
+      desc "Creates an Elasticsearch::Persistence model"
+      argument :attributes, type: :array, default: [], banner: "attribute:type attribute:type"
+
+      check_class_collision
+
+      def create_model_file
+        @padding = attributes.map { |a| a.name.size }.max
+        template "model.rb.tt", File.join("app/models", class_path, "#{file_name}.rb")
+      end
+
+      hook_for :test_framework
+    end
+  end
+end

data/lib/rails/generators/elasticsearch/model/templates/model.rb.tt

@@ -0,0 +1,9 @@
+<% module_namespacing do -%>
+class <%= class_name %>
+  include Elasticsearch::Persistence::Model
+
+<% attributes.each do |attribute| -%>
+  <%= "attribute :#{attribute.name},".ljust(@padding+12) %> <%= attribute.type %>
+<% end -%>
+end
+<% end -%>

data/lib/rails/generators/elasticsearch_generator.rb

@@ -0,0 +1,2 @@
+require "rails/generators/named_base"
+require "rails/generators/active_model"

data/test/integration/model/model_basic_test.rb

@@ -0,0 +1,157 @@
+require 'test_helper'
+
+require 'elasticsearch/persistence/model'
+
+module Elasticsearch
+  module Persistence
+    class PersistenceModelBasicIntegrationTest < Elasticsearch::Test::IntegrationTestCase
+
+      class ::Person
+        include Elasticsearch::Persistence::Model
+
+        settings index: { number_of_shards: 1 }
+
+        attribute :name, String,
+                  mapping: { fields: {
+                    name: { type: 'string', analyzer: 'snowball' },
+                    raw:  { type: 'string', analyzer: 'keyword' }
+                  } }
+
+        attribute :birthday,   Date
+        attribute :department, String
+        attribute :salary,     Integer
+        attribute :admin,      Boolean, default: false
+
+        validates :name, presence: true
+      end
+
+      context "A basic persistence model" do
+        setup do
+          Person.create_index! force: true
+        end
+
+        should "save the object with custom ID" do
+          person = Person.new id: 1, name: 'Number One'
+          person.save
+
+          document = Person.find(1)
+          assert_not_nil document
+          assert_equal 'Number One', document.name
+        end
+
+        should "create the object with custom ID" do
+          person = Person.create id: 1, name: 'Number One'
+
+          document = Person.find(1)
+          assert_not_nil document
+          assert_equal 'Number One', document.name
+        end
+
+        should "save and find the object" do
+          person = Person.new name: 'John Smith', birthday: Date.parse('1970-01-01')
+          person.save
+
+          assert_not_nil person.id
+          document = Person.find(person.id)
+
+          assert_instance_of Person, document
+          assert_equal 'John Smith', document.name
+          assert_equal 'John Smith', Person.find(person.id).name
+
+          assert_not_nil Elasticsearch::Persistence.client.get index: 'people', type: 'person', id: person.id
+        end
+
+        should "delete the object" do
+          person = Person.create name: 'John Smith', birthday: Date.parse('1970-01-01')
+
+          person.destroy
+          assert person.frozen?
+
+          assert_raise Elasticsearch::Transport::Transport::Errors::NotFound do
+            Elasticsearch::Persistence.client.get index: 'people', type: 'person', id: person.id
+          end
+        end
+
+        should "update an object attribute" do
+          person = Person.create name: 'John Smith'
+
+          person.update name: 'UPDATED'
+
+          assert_equal 'UPDATED', person.name
+          assert_equal 'UPDATED', Person.find(person.id).name
+        end
+
+        should "increment an object attribute" do
+          person = Person.create name: 'John Smith', salary: 1_000
+
+          person.increment :salary
+
+          assert_equal 1_001, person.salary
+          assert_equal 1_001, Person.find(person.id).salary
+        end
+
+        should "update the object timestamp" do
+          person = Person.create name: 'John Smith'
+          updated_at = person.updated_at
+
+          sleep 1
+          person.touch
+
+          assert person.updated_at > updated_at, [person.updated_at, updated_at].inspect
+
+          found = Person.find(person.id)
+          assert found.updated_at > updated_at, [found.updated_at, updated_at].inspect
+        end
+
+        should "find instances by search" do
+          Person.create name: 'John Smith'
+          Person.create name: 'Mary Smith'
+          Person.gateway.refresh_index!
+
+          people = Person.search query: { match: { name: 'smith' } },
+                                 highlight: { fields: { name: {} } }
+
+          assert_equal 2, people.total
+          assert_equal 2, people.size
+
+          assert people.map_with_hit { |o,h| h._score }.all? { |s| s > 0 }
+
+          assert_not_nil people.first.hit
+          assert_match /smith/i, people.first.hit.highlight['name'].first
+        end
+
+        should "find instances in batches" do
+          50.times { |i| Person.create name: "John #{i+1}" }
+          Person.gateway.refresh_index!
+
+          @batches = 0
+          @results = []
+
+          Person.find_in_batches(_source_include: 'name') do |batch|
+            @batches += 1
+            @results += batch.map(&:name)
+          end
+
+          assert_equal  3, @batches
+          assert_equal 50, @results.size
+          assert_contains @results, 'John 1'
+        end
+
+        should "find each instance" do
+          50.times { |i| Person.create name: "John #{i+1}" }
+          Person.gateway.refresh_index!
+
+          @results = []
+
+          Person.find_each(_source_include: 'name') do |person|
+            @results << person.name
+          end
+
+          assert_equal 50, @results.size
+          assert_contains @results, 'John 1'
+        end
+      end
+
+    end
+  end
+end