elasticsearch-persistence-queryable 0.1.8

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

@@ -0,0 +1,31 @@
+module Elasticsearch
+  module Persistence
+    module Repository
+
+      # Provide serialization and deserialization between Ruby objects and Elasticsearch documents
+      #
+      # Override these methods in your repository class to customize the logic.
+      #
+      module Serialize
+
+        # Serialize the object for storing it in Elasticsearch
+        #
+        # In the default implementation, call the `to_hash` method on the passed object.
+        #
+        def serialize(document)
+          document.to_hash
+        end
+
+        # Deserialize the document retrieved from Elasticsearch into a Ruby object
+        #
+        # Use the `klass` property, if defined, otherwise try to get the class from the document's `_type`.
+        #
+        def deserialize(document)
+          _klass = klass || __get_klass_from_type(document['_type'])
+          _klass.new document['_source'] || document['fields']
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Elasticsearch
+  module Persistence
+    module Repository
+
+      # Save and delete documents in Elasticsearch
+      #
+      module Store
+
+        # Store the serialized object in Elasticsearch
+        #
+        # @example
+        #     repository.save(myobject)
+        #     => {"_index"=>"...", "_type"=>"...", "_id"=>"...", "_version"=>1, "created"=>true}
+        #
+        # @return {Hash} The response from Elasticsearch
+        #
+        def save(document, options={})
+          serialized = serialize(document)
+          id   = __get_id_from_document(serialized)
+          client.index( { index: index_name, id: id, body: serialized }.merge(options) )
+        end
+
+        # Update the serialized object in Elasticsearch with partial data or script
+        #
+        # @example Update the document with partial data
+        #
+        #     repository.update id: 1, title: 'UPDATED',  tags: []
+        #     # => {"_index"=>"...", "_type"=>"...", "_id"=>"1", "_version"=>2}
+        #
+        # @example Update the document with a script
+        #
+        #     repository.update 1, script: 'ctx._source.views += 1'
+        #     # => {"_index"=>"...", "_type"=>"...", "_id"=>"1", "_version"=>3}
+        #
+        # @return {Hash} The response from Elasticsearch
+        #
+        def update(document, options={})
+          case
+            when document.is_a?(String) || document.is_a?(Integer)
+              id = document
+            when document.respond_to?(:to_hash)
+              serialized = document.to_hash
+              id = __extract_id_from_document(serialized)
+            else
+              raise ArgumentError, "Expected a document ID or a Hash-like object, #{document.class} given"
+          end
+
+          type = options.delete(:type) || \
+                 (defined?(serialized) && serialized && serialized.delete(:type)) || \
+                 document_type || \
+                 __get_type_from_class(klass)
+
+          if defined?(serialized) && serialized
+            body = if serialized[:script]
+                       serialized.select { |k, v| [:script, :params, :upsert].include? k }
+                     else
+                       { doc: serialized }
+                   end
+          else
+            body = {}
+            body.update( doc: options.delete(:doc)) if options[:doc]
+            body.update( script: options.delete(:script)) if options[:script]
+            body.update( params: options.delete(:params)) if options[:params]
+            body.update( upsert: options.delete(:upsert)) if options[:upsert]
+          end
+
+          client.update( { index: index_name, id: id, body: body }.merge(options) )
+        end
+
+        # Remove the serialized object or document with specified ID from Elasticsearch
+        #
+        # @example Remove the document with ID 1
+        #
+        #     repository.delete(1)
+        #     # => {"_index"=>"...", "_type"=>"...", "_id"=>"1", "_version"=>4}
+        #
+        # @return {Hash} The response from Elasticsearch
+        #
+        def delete(document, options={})
+          if document.is_a?(String) || document.is_a?(Integer)
+            id   = document
+            type = document_type || __get_type_from_class(klass)
+          else
+            serialized = serialize(document)
+            id   = __get_id_from_document(serialized)
+            type = document_type || __get_type_from_class(klass || document.class)
+          end
+          client.delete( { index: index_name, id: id }.merge(options) )
+        end
+      end
+
+    end
+  end
+end

data/lib/elasticsearch/persistence/repository.rb

@@ -0,0 +1,77 @@
+module Elasticsearch
+  module Persistence
+
+    # Delegate methods to the repository (acting as a gateway)
+    #
+    module GatewayDelegation
+      def method_missing(method_name, *arguments, &block)
+        gateway.respond_to?(method_name) ? gateway.__send__(method_name, *arguments, &block) : super
+      end
+
+      def respond_to?(method_name, include_private=false)
+        gateway.respond_to?(method_name) || super
+      end
+
+      def respond_to_missing?(method_name, *)
+        gateway.respond_to?(method_name) || super
+      end
+    end
+
+    # 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
+    #
+    module Repository
+      def self.included(base)
+        gateway = Elasticsearch::Persistence::Repository::Class.new host: base
+
+        # Define the instance level gateway
+        #
+        base.class_eval do
+          define_method :gateway do
+            @gateway ||= gateway
+          end
+
+          include GatewayDelegation
+        end
+
+        # Define the class level gateway
+        #
+        (class << base; self; end).class_eval do
+          define_method :gateway do |&block|
+            @gateway ||= gateway
+            @gateway.instance_eval(&block) if block
+            @gateway
+          end
+
+          include GatewayDelegation
+        end
+
+        # Catch repository methods (such as `serialize` and others) defined in the receiving class,
+        # and overload the default definition in the gateway
+        #
+        def base.method_added(name)
+          if :gateway != name && respond_to?(:gateway) && (gateway.public_methods - Object.public_methods).include?(name)
+            gateway.define_singleton_method(name, self.new.method(name).to_proc)
+          end
+        end
+      end
+
+      # Shortcut method to allow concise repository initialization
+      #
+      # @example Create a new default repository
+      #
+      #     repository = Elasticsearch::Persistence::Repository.new
+      #
+      def new(options={}, &block)
+        Elasticsearch::Persistence::Repository::Class.new( {index: 'repository'}.merge(options), &block )
+      end; module_function :new
+    end
+  end
+end

data/lib/elasticsearch/persistence/scoping/default.rb

@@ -0,0 +1,137 @@
+module Elasticsearch
+  module Persistence
+    module Scoping
+      module Default
+        extend ActiveSupport::Concern
+
+        included do
+          # Stores the default scope for the class.
+          class_attribute :default_scopes, instance_writer: false, instance_predicate: false
+
+          self.default_scopes = []
+        end
+
+        module ClassMethods
+          # Returns a scope for the model without the previously set scopes.
+          #
+          #   class Post < ActiveRecord::Base
+          #     def self.default_scope
+          #       where published: true
+          #     end
+          #   end
+          #
+          #   Post.all                                  # Fires "SELECT * FROM posts WHERE published = true"
+          #   Post.unscoped.all                         # Fires "SELECT * FROM posts"
+          #   Post.where(published: false).unscoped.all # Fires "SELECT * FROM posts"
+          #
+          # This method also accepts a block. All queries inside the block will
+          # not use the previously set scopes.
+          #
+          #   Post.unscoped {
+          #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
+          #   }
+          def unscoped
+            block_given? ? relation.scoping { yield } : relation
+          end
+
+          def before_remove_const #:nodoc:
+            self.current_scope = nil
+          end
+
+          protected
+
+          # Use this macro in your model to set a default scope for all operations on
+          # the model.
+          #
+          #   class Article < ActiveRecord::Base
+          #     default_scope { where(published: true) }
+          #   end
+          #
+          #   Article.all # => SELECT * FROM articles WHERE published = true
+          #
+          # The +default_scope+ is also applied while creating/building a record.
+          # It is not applied while updating a record.
+          #
+          #   Article.new.published    # => true
+          #   Article.create.published # => true
+          #
+          # (You can also pass any object which responds to +call+ to the
+          # +default_scope+ macro, and it will be called when building the
+          # default scope.)
+          #
+          # If you use multiple +default_scope+ declarations in your model then
+          # they will be merged together:
+          #
+          #   class Article < ActiveRecord::Base
+          #     default_scope { where(published: true) }
+          #     default_scope { where(rating: 'G') }
+          #   end
+          #
+          #   Article.all # => SELECT * FROM articles WHERE published = true AND rating = 'G'
+          #
+          # This is also the case with inheritance and module includes where the
+          # parent or module defines a +default_scope+ and the child or including
+          # class defines a second one.
+          #
+          # If you need to do more complex things with a default scope, you can
+          # alternatively define it as a class method:
+          #
+          #   class Article < ActiveRecord::Base
+          #     def self.default_scope
+          #       # Should return a scope, you can call 'super' here etc.
+          #     end
+          #   end
+          def default_scope(scope = nil)
+            scope = Proc.new if block_given?
+
+            if scope.is_a?(Relation) || !scope.respond_to?(:call)
+              raise ArgumentError,
+                "Support for calling #default_scope without a block is removed. For example instead " \
+                "of `default_scope where(color: 'red')`, please use " \
+                "`default_scope { where(color: 'red') }`. (Alternatively you can just redefine " \
+                "self.default_scope.)"
+            end
+
+            self.default_scopes += [scope]
+          end
+
+          def build_default_scope(base_rel = relation) # :nodoc:
+            if !self.is_a?(method(:default_scope).owner)
+              # The user has defined their own default scope method, so call that
+              evaluate_default_scope { default_scope }
+            elsif default_scopes.any?
+              evaluate_default_scope do
+                default_scopes.inject(base_rel) do |default_scope, scope|
+                  default_scope.merge(base_rel.scoping { scope.call })
+                end
+              end
+            end
+          end
+
+          def ignore_default_scope? # :nodoc:
+            ScopeRegistry.value_for(:ignore_default_scope, self)
+          end
+
+          def ignore_default_scope=(ignore) # :nodoc:
+            ScopeRegistry.set_value_for(:ignore_default_scope, self, ignore)
+          end
+
+          # The ignore_default_scope flag is used to prevent an infinite recursion
+          # situation where a default scope references a scope which has a default
+          # scope which references a scope...
+          def evaluate_default_scope # :nodoc:
+            return if ignore_default_scope?
+
+            begin
+              self.ignore_default_scope = true
+              yield
+            ensure
+              self.ignore_default_scope = false
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/elasticsearch/persistence/scoping/named.rb

@@ -0,0 +1,70 @@
+module Elasticsearch
+  module Persistence
+    module Scoping
+      module Named
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def all(options={})
+            if current_scope
+              current_scope.clone
+            else
+              default_scoped.size(10000)
+            end
+          end
+
+          def default_scoped # :nodoc:
+            relation.merge(build_default_scope)
+          end
+
+          # Collects attributes from scopes that should be applied when creating
+          # an AR instance for the particular class this is called on.
+          def scope_attributes # :nodoc:
+            all.scope_for_create
+          end
+
+          # Are there default attributes associated with this scope?
+          def scope_attributes? # :nodoc:
+            current_scope || default_scopes.any?
+          end
+
+          def scope(name, body, &block)
+            if dangerous_class_method?(name)
+              raise ArgumentError, "You tried to define a scope named \"#{name}\" " \
+                "on the model \"#{self.name}\", but Active Record already defined " \
+                "a class method with the same name."
+            end
+
+            extension = Module.new(&block) if block
+
+            singleton_class.send(:define_method, name) do |*args|
+              scope = all.scoping { body.call(*args) }
+              scope = scope.extending(extension) if extension
+
+              scope || all
+            end
+          end
+
+          BLACKLISTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
+
+          private
+          def dangerous_class_method?(method_name)
+            BLACKLISTED_CLASS_METHODS.include?(method_name.to_s) || class_method_defined_within?(method_name, Model, self.superclass)
+          end
+
+          def class_method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc
+            if klass.respond_to?(name, true)
+              if superklass.respond_to?(name, true)
+                klass.method(name).owner != superklass.method(name).owner
+              else
+                true
+              end
+            else
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/persistence/scoping.rb

@@ -0,0 +1,52 @@
+module Elasticsearch
+  module Persistence
+    module Scoping
+      extend ActiveSupport::Concern
+
+      included do
+        include Default
+        include Named
+      end
+
+      module ClassMethods
+        def current_scope
+           ScopeRegistry.value_for(:current_scope, base_class.to_s)
+        end
+
+        def current_scope=(scope) #:nodoc:
+          ScopeRegistry.set_value_for(:current_scope, base_class.to_s, scope)
+        end
+      end
+
+      class ScopeRegistry # :nodoc:
+        extend ActiveSupport::PerThreadRegistry
+
+        VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope]
+
+        def initialize
+          @registry = Hash.new { |hash, key| hash[key] = {} }
+        end
+
+        # Obtains the value for a given +scope_name+ and +variable_name+.
+        def value_for(scope_type, variable_name)
+          raise_invalid_scope_type!(scope_type)
+          @registry[scope_type][variable_name]
+        end
+
+        # Sets the +value+ for a given +scope_type+ and +variable_name+.
+        def set_value_for(scope_type, variable_name, value)
+          raise_invalid_scope_type!(scope_type)
+          @registry[scope_type][variable_name] = value
+        end
+
+        private
+
+        def raise_invalid_scope_type!(scope_type)
+          if !VALID_SCOPE_TYPES.include?(scope_type)
+            raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/persistence/version.rb

@@ -0,0 +1,5 @@
+module Elasticsearch
+  module Persistence
+    VERSION = "0.1.8"
+  end
+end

data/lib/elasticsearch/persistence.rb

@@ -0,0 +1,157 @@
+require 'elasticsearch'
+require 'elasticsearch/model/indexing'
+require 'hashie'
+require 'jbuilder'
+
+require 'rails/instrumentation/railtie' if defined?(Rails)
+
+require 'elasticsearch/rails_compatibility'
+
+require 'elasticsearch/persistence/version'
+
+require 'elasticsearch/persistence/client'
+require 'elasticsearch/persistence/scoping'
+require 'elasticsearch/persistence/scoping/default'
+require 'elasticsearch/persistence/scoping/named'
+require 'elasticsearch/persistence/inheritence'
+require 'elasticsearch/persistence/querying'
+require 'elasticsearch/persistence/query_cache'
+
+require 'elasticsearch/persistence/repository/response/results'
+require 'elasticsearch/persistence/repository/naming'
+require 'elasticsearch/persistence/repository/serialize'
+require 'elasticsearch/persistence/repository/store'
+require 'elasticsearch/persistence/repository/find'
+require 'elasticsearch/persistence/repository/search'
+require 'elasticsearch/persistence/repository/class'
+require 'elasticsearch/persistence/repository'
+
+require 'elasticsearch/persistence/relation/finder_methods'
+require 'elasticsearch/persistence/relation/query_methods'
+require 'elasticsearch/persistence/relation/search_option_methods'
+require 'elasticsearch/persistence/relation/spawn_methods'
+require 'elasticsearch/persistence/relation/delegation'
+require 'elasticsearch/persistence/relation/merger'
+
+require 'elasticsearch/persistence/relation'
+require 'elasticsearch/persistence/null_relation'
+
+
+module Elasticsearch
+  # Persistence for Ruby domain objects and models in Elasticsearch
+  # ===============================================================
+  #
+  # `Elasticsearch::Persistence` contains modules for storing and retrieving Ruby domain objects and models
+  # in Elasticsearch.
+  #
+  # == Repository
+  #
+  # The repository patterns allows to store and retrieve Ruby objects in Elasticsearch.
+  #
+  #     require 'elasticsearch/persistence'
+  #
+  #     class Note
+  #       def to_hash; {foo: 'bar'}; end
+  #     end
+  #
+  #     repository = Elasticsearch::Persistence::Repository.new
+  #
+  #     repository.save Note.new
+  #     # => {"_index"=>"repository", "_type"=>"note", "_id"=>"mY108X9mSHajxIy2rzH2CA", ...}
+  #
+  # Customize your repository by including the main module in a Ruby class
+  #     class MyRepository
+  #       include Elasticsearch::Persistence::Repository
+  #
+  #       index 'my_notes'
+  #       klass Note
+  #
+  #       client Elasticsearch::Client.new log: true
+  #     end
+  #
+  #     repository = MyRepository.new
+  #
+  #     repository.save Note.new
+  #     # 2014-04-04 22:15:25 +0200: POST http://localhost:9200/my_notes/note [status:201, request:0.009s, query:n/a]
+  #     # 2014-04-04 22:15:25 +0200: > {"foo":"bar"}
+  #     # 2014-04-04 22:15:25 +0200: < {"_index":"my_notes","_type":"note","_id":"-d28yXLFSlusnTxb13WIZQ", ...}
+  #
+  # == Model
+  #
+  # The active record pattern allows to use the interface familiar from ActiveRecord models:
+  #
+  #     require 'elasticsearch/persistence'
+  #
+  #     class Article
+  #       attribute :title, String, mapping: { analyzer: 'snowball' }
+  #     end
+  #
+  #     article = Article.new id: 1, title: 'Test'
+  #     article.save
+  #
+  #     Article.find(1)
+  #
+  #     article.update_attributes title: 'Update'
+  #
+  #     article.destroy
+  #
+  module Persistence
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Client
+      autoload :Model
+      autoload :Repository
+      autoload :Scoping
+      autoload :Relation
+      autoload :NullRelation
+      autoload :Querying
+      autoload :Inheritence
+      autoload :QueryCache
+
+      autoload_under 'relation' do
+        autoload :QueryMethods
+        autoload :QueryBuilder
+        autoload :SearchOptionMethods
+        autoload :FinderMethods
+        autoload :SpawnMethods
+        autoload :Delegation
+      end
+    end
+
+    module Model
+      extend ActiveSupport::Autoload
+
+      autoload :GatewayDelegation
+      #autoload :Callbacks
+    end
+
+    module Repository
+      extend ActiveSupport::Autoload
+      autoload :Class
+      autoload :Find
+      autoload :Search
+      autoload :Serialize
+      autoload :Store
+      autoload :Naming
+    end
+
+    module Scoping
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :Named
+        autoload :Default
+      end
+    end
+
+    def self.eager_load!
+      super
+      Elasticsearch::Persistence::Scoping.eager_load!
+    end
+
+    extend Client::ClassMethods
+    extend QueryCache::CacheMethods
+
+  end
+end

data/lib/elasticsearch/rails_compatibility.rb

@@ -0,0 +1,17 @@
+require 'active_support'
+
+if defined?(Rails)
+  if Rails::VERSION::MAJOR >= 4
+    require 'active_support'
+    require 'active_support/rails'
+    require 'active_support/per_thread_registry'
+  elsif Rails::VERSION::MAJOR == 3
+    require 'active_support/dependencies/autoload'
+    require 'active_support/concern'
+    require 'active_support/core_ext/class/attribute'
+    require 'active_support/core_ext/module/delegation'
+    require 'active_support/deprecation'
+    require 'active_support/inflector'
+    require 'elasticsearch/per_thread_registry'
+  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"