[STORE] Added the first version of the ActiveRecord-based model persistence

Using the `Elasticsearch::Persistence::Repository` from previous commits,
this patch adds support for the ActiveRecord pattern of persistance
for Ruby objects in Elasticsearch.

The goal is to have a 1:1 implementation to the ActiveRecord::Base implementation,
allowing to use it as a drop-in replacement for similar OxMs in Rails applications,
with minimal changes to the model definition and application code.

The model implementation uses [Virtus](https://github.com/solnic/virtus)
for handling the model attributes, and [ActiveModel](https://github.com/rails/rails/tree/master/activemodel)
for validations, callbacks, and similar model-related features.

Example:
--------

require 'elasticsearch/persistence/model'

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

  before_save do
    puts "About to save: #{self}"
  end
end

Person.gateway.create_index! force: true

person = Person.create name: 'John Smith', salary: 10_000
About to save: #<Person:0x007f961e89f010>
=> #<Person:0x007f961e89f010 ...>

person.id
=> "zNf3yxZDQsOTZfNfTX4E5A"

person = Person.find(person.id)
=> #<Person:0x007f961cf1f478 ... >

person.salary
=> 10000

person.increment :salary
=> { ... "_version"=>2}
person.salary
=> 10001

person.update admin: true
=> { ... "_version"=>3}

Person.search('smith').to_a
=> [#<Person:0x007f961ebc5b90 ...>]

Author: karmi

elasticsearch-persistence/elasticsearch-persistence.gemspec

@@ -26,13 +26,16 @@ Gem::Specification.new do |s|
   s.add_dependency "elasticsearch",       '> 0.4'
   s.add_dependency "elasticsearch-model", '>= 0.1'
   s.add_dependency "activesupport",       '> 3'
+  s.add_dependency "activemodel",         '> 3'
   s.add_dependency "hashie"
+  s.add_dependency "virtus"
 
   s.add_development_dependency "bundler", "~> 1.5"
   s.add_development_dependency "rake"
 
   s.add_development_dependency "oj"
-  s.add_development_dependency "virtus"
+
+  s.add_development_dependency "rails"
 
   s.add_development_dependency "elasticsearch-extensions"
 

elasticsearch-persistence/lib/elasticsearch/persistence/model.rb

@@ -0,0 +1,109 @@
+require 'active_support/core_ext/module/delegation'
+
+require 'active_model'
+require 'virtus'
+
+require 'elasticsearch/persistence'
+require 'elasticsearch/persistence/model/errors'
+require 'elasticsearch/persistence/model/store'
+
+module Elasticsearch
+  module Persistence
+
+    module Model
+      module Utils
+        def lookup_type(type)
+          case
+            when type == String
+              'string'
+            when type == Integer
+              'integer'
+            when type == Float
+              'float'
+            when type == Date || type == Time || type == DateTime
+              'date'
+            when type == Virtus::Attribute::Boolean
+              'boolean'
+          end
+        end; module_function :lookup_type
+      end
+
+      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 Virtus.model
+
+          extend  ActiveModel::Callbacks
+          define_model_callbacks :create, :save, :update, :destroy
+          define_model_callbacks :find, :touch, only: :after
+
+          extend  Elasticsearch::Persistence::Model::Store::ClassMethods
+          include Elasticsearch::Persistence::Model::Store::InstanceMethods
+
+          class << self
+            def attribute(name, type=nil, options={}, &block)
+              mapping = options.delete(:mapping) || {}
+              super
+
+              gateway.mapping do
+                indexes name, {type: Utils::lookup_type(type)}.merge(mapping)
+              end
+
+              gateway.mapping(&block) if block_given?
+            end
+
+            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
+
+            delegate :settings,
+                     :mappings,
+                     :mapping,
+                     :document_type,
+                     :document_type=,
+                     :index_name,
+                     :index_name=,
+                     :search,
+                     :find,
+                     :exists?,
+              to: :gateway
+          end
+
+          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']
+              object.set_id document['_id']
+              object.instance_variable_set(:@persisted, true)
+              object
+            end
+          end
+
+          attribute :id,         String, writer: :private
+          attribute :created_at, DateTime, default: lambda { |o,a| Time.now.utc }
+          attribute :updated_at, DateTime, default: lambda { |o,a| Time.now.utc }
+
+          def set_id(id)
+            self.id = id
+          end
+        end
+
+      end
+    end
+
+  end
+end

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

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

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

@@ -0,0 +1,95 @@
+module Elasticsearch
+  module Persistence
+    module Model
+
+      module Store
+        module ClassMethods
+          def create(attributes, options={})
+            object = self.new(attributes)
+            object.run_callbacks :create do
+              object.save(options)
+              object
+            end
+          end
+        end
+
+        module InstanceMethods
+          def save(options={})
+            return false unless valid?
+            run_callbacks :save do
+              response = self.class.gateway.save(self, options.merge(id: self.id))
+              self[:updated_at] = Time.now.utc
+              @persisted = true
+              set_id(response['_id']) if respond_to?(:set_id)
+              response
+            end
+          end
+
+          def destroy(options={})
+            raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?
+
+            run_callbacks :destroy do
+              response = self.class.gateway.delete(self.id, options)
+              @destroyed = true
+              @persisted = false
+              self.freeze
+              response
+            end
+          end; alias :delete :destroy
+
+          def update(attributes={}, options={})
+            raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?
+
+            run_callbacks :update do
+              attributes.update( { updated_at: Time.now.utc } )
+              response = self.class.gateway.update(self.id, { doc: attributes}.merge(options))
+              self.attributes = self.attributes.merge(attributes)
+              response
+            end
+          end; alias :update_attributes :update
+
+          def increment(attribute, value=1, options={})
+            raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?
+
+            response = self.class.gateway.update(self.id, { script: "ctx._source.#{attribute} += #{value}"}.merge(options))
+            self[attribute] += value
+            response
+          end
+
+          def decrement(attribute, value=1, options={})
+            raise DocumentNotPersisted, "Object not persisted: #{self.inspect}" unless persisted?
+
+            response = self.class.gateway.update(self.id, { script: "ctx._source.#{attribute} = ctx._source.#{attribute} - #{value}"}.merge(options))
+            self[attribute] -= value
+            response
+          end
+
+          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
+              value = Time.now.utc
+              response = self.class.gateway.update(self.id, { doc: { attribute => value.iso8601 }}.merge(options))
+              self[attribute] = value
+              response
+            end
+          end
+
+          def destroyed?
+            !!@destroyed
+          end
+
+          def persisted?
+            !!@persisted && !destroyed?
+          end
+
+          def new_record?
+            !persisted? && !destroyed?
+          end
+        end
+      end
+
+    end
+  end
+end

elasticsearch-persistence/test/integration/model/model_basic_test.rb

@@ -0,0 +1,101 @@
+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
+        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' } }
+
+          assert_equal 2, people.total
+          assert_equal 2, people.size
+
+          assert people.map_with_hit { |o,h| h._score }.all? { |s| s > 0 }
+        end
+      end
+
+    end
+  end
+end