elasticsearch-persistence-queryable 0.1.8

data/lib/elasticsearch/persistence/relation/spawn_methods.rb

@@ -0,0 +1,61 @@
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+require 'elasticsearch/persistence/relation/merger'
+
+module Elasticsearch
+  module Persistence
+
+      module SpawnMethods
+        def spawn
+          clone
+        end
+
+        def merge(other)
+          if other.is_a?(Array)
+            to_a & other
+          elsif other
+            spawn.merge!(other)
+          else
+            self
+          end
+        end
+
+        def merge!(other) # :nodoc:
+          if !other.is_a?(Relation) && other.respond_to?(:to_proc)
+            instance_exec(&other)
+          else
+            klass = other.is_a?(Hash) ? Relation::HashMerger : Relation::Merger
+            klass.new(self, other).merge
+          end
+        end
+
+        # Removes from the query the condition(s) specified in +skips+.
+        #
+        #   Post.order('id asc').except(:order)                  # discards the order condition
+        #   Post.where('id > 10').order('id asc').except(:where) # discards the where condition but keeps the order
+        def except(*skips)
+          relation_with values.except(*skips)
+        end
+
+        # Removes any condition from the query other than the one(s) specified in +onlies+.
+        #
+        #   Post.order('id asc').only(:where)         # discards the order condition
+        #   Post.order('id asc').only(:where, :order) # uses the specified order
+        def only(*onlies)
+          if onlies.any? { |o| o == :where }
+            onlies << :bind
+          end
+          relation_with values.slice(*onlies)
+        end
+
+        private
+
+        def relation_with(values) # :nodoc:
+          result = Relation.create(klass, values)
+          result.extend(*extending_values) if extending_values.any?
+          result
+        end
+      end
+
+    end
+end

data/lib/elasticsearch/persistence/relation.rb

@@ -0,0 +1,110 @@
+module Elasticsearch
+  module Persistence
+    class Relation
+
+        MULTI_VALUE_METHODS  = [:order, :where, :or_filter, :filter, :bind, :extending, :unscope, :skip_callbacks]
+        SINGLE_VALUE_METHODS = [:limit, :offset, :routing, :size]
+
+        INVALID_METHODS_FOR_DELETE_ALL = [:limit, :offset]
+
+        VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
+
+        include FinderMethods, SpawnMethods, QueryMethods, SearchOptionMethods, Delegation
+
+        attr_reader :klass, :loaded
+        alias :model :klass
+        alias :loaded? :loaded
+
+        delegate :blank?, :empty?, :any?, :many?, to: :results
+
+        def initialize(klass, values={})
+            @klass  = klass
+            @values = values
+            @offsets = {}
+            @loaded = false
+        end
+
+        def build(*args)
+         @klass.new *args
+        end
+
+        def to_a
+          load
+          @records
+        end
+        alias :results :to_a
+
+        def as_json(options = nil)
+          to_a.as_json(options)
+        end
+
+        def to_elastic
+          query_builder.to_elastic
+        end
+
+        def create(*args, &block)
+           scoping { @klass.create!(*args, &block) }
+        end
+
+        def scoping
+          previous, klass.current_scope = klass.current_scope, self
+          yield
+        ensure
+          klass.current_scope = previous
+        end
+
+        def load
+          exec_queries unless loaded?
+
+          self
+        end
+        alias :fetch :load
+
+        def delete(opts=nil)
+        end
+
+        def exec_queries
+          # Run safety callback
+          klass.circuit_breaker_callbacks.each do |cb|
+            current_scope_values = self.send("#{cb[:options][:in]}_values")
+            next if skip_callbacks_values.include? cb[:name]
+            valid = if cb[:callback].nil?
+              current_scope_values.collect(&:keys).flatten.include? cb[:name]
+            else
+              cb[:callback].call(current_scope_values.collect(&:keys).flatten, current_scope_values)
+            end
+
+            raise Elasticsearch::Persistence::Model::QueryOptionMissing, "#{cb[:name]} #{cb[:options][:message]}" unless valid
+          end
+
+          @records = @klass.fetch_results(query_builder)
+
+          @loaded = true
+          @records
+        end
+
+        def values
+          Hash[@values]
+        end
+
+        def inspect
+          entries = to_a.results.take([size_value.to_i + 1, 11].compact.min).map!(&:inspect)
+          message = {}
+          message = {total: to_a.total, max: to_a.total}
+          message.merge!(aggregations: results.aggregations.keys) unless results.aggregations.nil?
+          message = message.each_pair.collect { |k,v|  "#{k}: #{v}" }
+          message.unshift entries.join(', ') unless entries.size.zero?
+          "#<#{self.class.name} #{message.join(', ')}>"
+        end
+
+
+
+        private
+
+        def query_builder
+          QueryBuilder.new(values)
+        end
+
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Elasticsearch
+  module Persistence
+    module Repository
+
+      # The default repository class, to be used either directly, or as a gateway in a custom repository class
+      #
+      # @example Standalone use
+      #
+      #     repository = Elasticsearch::Persistence::Repository::Class.new
+      #     # => #<Elasticsearch::Persistence::Repository::Class ...>
+      #     repository.save(my_object)
+      #     # => {"_index"=> ... }
+      #
+      # @example Shortcut use
+      #
+      #     repository = Elasticsearch::Persistence::Repository.new
+      #     # => #<Elasticsearch::Persistence::Repository::Class ...>
+      #
+      # @example Configuration via a block
+      #
+      #     repository = Elasticsearch::Persistence::Repository.new do
+      #       index 'my_notes'
+      #     end
+      #
+      #     # => #<Elasticsearch::Persistence::Repository::Class ...>
+      #     # > repository.save(my_object)
+      #     # => {"_index"=> ... }
+      #
+      # @example Accessing the gateway in a custom class
+      #
+      #     class MyRepository
+      #       include Elasticsearch::Persistence::Repository
+      #     end
+      #
+      #     repository = MyRepository.new
+      #
+      #     repository.gateway.client.info
+      #     # => {"status"=>200, "name"=>"Venom", ... }
+      #
+      class Class
+        include Elasticsearch::Persistence::Client::ClassMethods
+        include Elasticsearch::Persistence::Repository::Naming
+        include Elasticsearch::Persistence::Repository::Serialize
+        include Elasticsearch::Persistence::Repository::Store
+        include Elasticsearch::Persistence::Repository::Find
+        include Elasticsearch::Persistence::Repository::Search
+
+        include Elasticsearch::Model::Indexing::ClassMethods
+
+        attr_reader :options
+
+        def initialize(options={}, &block)
+          @options = options
+          index_name options.delete(:index)
+          block.arity < 1 ? instance_eval(&block) : block.call(self) if block_given?
+        end
+
+        # Return the "host" class, if this repository is a gateway hosted in another class
+        #
+        # @return [nil, Class]
+        #
+        # @api private
+        #
+        def host
+          options[:host]
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Elasticsearch
+  module Persistence
+    module Repository
+      class DocumentNotFound < StandardError; end
+
+      # Retrieves one or more domain objects from the repository
+      #
+      module Find
+
+        # Retrieve a single object or multiple objects from Elasticsearch by ID or IDs
+        #
+        # @example Retrieve a single object by ID
+        #
+        #     repository.find(1)
+        #     # => <Note ...>
+        #
+        # @example Retrieve multiple objects by IDs
+        #
+        #     repository.find(1, 2)
+        #     # => [<Note ...>, <Note ...>
+        #
+        # @return [Object,Array]
+        #
+        def find(*args)
+          options  = args.last.is_a?(Hash) ? args.pop : {}
+          ids      = args
+
+          if args.size == 1
+            id = args.pop
+            id.is_a?(Array) ? __find_many(id, options) : __find_one(id, options)
+          else
+            __find_many args, options
+          end
+        end
+
+        # Return if object exists in the repository
+        #
+        # @example
+        #
+        #     repository.exists?(1)
+        #     => true
+        #
+        # @return [true, false]
+        #
+        def exists?(id, options={})
+          type     = document_type || (klass ? __get_type_from_class(klass) : '_all')
+          client.exists( { index: index_name,  id: id }.merge(options) )
+        end
+
+        # @api private
+        #
+        def __find_one(id, options={})
+          type     = document_type || (klass ? __get_type_from_class(klass) : '_all')
+          document = client.get( { index: index_name, id: id }.merge(options) )
+
+          deserialize(document)
+        rescue Elasticsearch::Transport::Transport::Errors::NotFound => e
+          raise DocumentNotFound, e.message, caller
+        end
+
+        # @api private
+        #
+        def __find_many(ids, options={})
+          type     = document_type || (klass ? __get_type_from_class(klass) : '_all')
+          documents = client.mget( { index: index_name,  body: { ids: ids } }.merge(options) )
+
+          documents['docs'].map { |document| document['found'] ? deserialize(document) : nil }
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+module Elasticsearch
+  module Persistence
+    module Repository
+
+      # Wraps all naming-related features of the repository (index name, the domain object class, etc)
+      #
+      module Naming
+
+        # Get or set the class used to initialize domain objects when deserializing them
+        #
+        def klass name=nil
+          @klass = name || @klass
+        end
+
+        # Set the class used to initialize domain objects when deserializing them
+        #
+        def klass=klass
+          @klass = klass
+        end
+
+        # Get or set the index name used when storing and retrieving documents
+        #
+        def index_name name=nil
+          @index_name = name || @index_name || begin
+            if respond_to?(:host) && host && host.is_a?(Module)
+              self.host.to_s.underscore.gsub(/\//, '-')
+            else
+              self.class.to_s.underscore.gsub(/\//, '-')
+            end
+          end
+        end; alias :index :index_name
+
+        # Set the index name used when storing and retrieving documents
+        #
+        def index_name=(name)
+          @index_name = name
+        end; alias :index= :index_name=
+
+        # Get or set the document type used when storing and retrieving documents
+        #
+        def document_type name=nil
+          @document_type = name || @document_type || (klass ? klass.to_s.underscore : nil)
+        end; alias :type :document_type
+
+        # Set the document type used when storing and retrieving documents
+        #
+        def document_type=(name)
+          @document_type = name
+        end; alias :type= :document_type=
+
+        # Get the Ruby class from the Elasticsearch `_type`
+        #
+        # @example
+        #     repository.__get_klass_from_type 'note'
+        #     => Note
+        #
+        # @return [Class] The class corresponding to the passed type
+        # @raise [NameError] if the class cannot be found
+        #
+        # @api private
+        #
+        def __get_klass_from_type(type)
+          klass = type.classify
+          klass.constantize
+        rescue NameError => e
+          raise NameError, "Attempted to get class '#{klass}' from the '#{type}' type, but no such class can be found."
+        end
+
+        # Get the Elasticsearch `_type` from the Ruby class
+        #
+        # @example
+        #     repository.__get_type_from_class Note
+        #     => "note"
+        #
+        # @return [String] The type corresponding to the passed class
+        #
+        # @api private
+        #
+        def __get_type_from_class(klass)
+          klass.to_s.underscore
+        end
+
+        # Get a document ID from the document (assuming Hash or Hash-like object)
+        #
+        # @example
+        #     repository.__get_id_from_document title: 'Test', id: 'abc123'
+        #     => "abc123"
+        #
+        # @api private
+        #
+        def __get_id_from_document(document)
+          document[:id] || document['id'] || document[:_id] || document['_id']
+        end
+
+        # Extract a document ID from the document (assuming Hash or Hash-like object)
+        #
+        # @note Calling this method will *remove* the `id` or `_id` key from the passed object.
+        #
+        # @example
+        #     options = { title: 'Test', id: 'abc123' }
+        #     repository.__extract_id_from_document options
+        #     # => "abc123"
+        #     options
+        #     # => { title: 'Test' }
+        #
+        # @api private
+        #
+        def __extract_id_from_document(document)
+          document.delete(:id) || document.delete('id') || document.delete(:_id) || document.delete('_id')
+        end
+      end
+
+    end
+  end
+end

data/lib/elasticsearch/persistence/repository/response/results.rb

@@ -0,0 +1,105 @@
+module Elasticsearch
+  module Persistence
+    module Repository
+      module Response # :nodoc:
+
+        # Encapsulates the domain objects and documents returned from Elasticsearch when searching
+        #
+        # Implements `Enumerable` and forwards its methods to the {#results} object.
+        #
+        class Results
+          include Enumerable
+
+          delegate :aggregations, to: :response
+
+          attr_reader :repository, :loaded
+          alias :loaded? :loaded
+
+          # @param repository [Elasticsearch::Persistence::Repository::Class] The repository instance
+          # @param response   [Hash]  The full response returned from the Elasticsearch client
+          # @param options    [Hash]  Optional parameters
+          #
+          def initialize(repository, response, options={})
+            @repository = repository
+            @response   = Elasticsearch::Persistence::Model::HashWrapper.new(response)
+            @options    = options
+            @loaded     = false
+          end
+
+          def method_missing(method_name, *arguments, &block)
+            results.respond_to?(method_name) ? results.__send__(method_name, *arguments, &block) : super
+          end
+
+          def respond_to?(method_name, include_private = false)
+            results.respond_to?(method_name) || super
+          end
+
+          def inner_hits
+            response['hits']['hits'].collect { |d| d['inner_hits'] }
+          end
+
+
+          # The number of total hits for a query
+          #
+          def total
+            response['hits']['total']
+          end
+
+          # The maximum score for a query
+          #
+          def max_score
+            response['hits']['max_score']
+          end
+
+          # Yields [object, hit] pairs to the block
+          #
+          def each_with_hit(&block)
+            results.zip(response['hits']['hits']).each(&block)
+          end
+
+          # Yields [object, hit] pairs and returns the result
+          #
+          def map_with_hit(&block)
+            results.zip(response['hits']['hits']).map(&block)
+          end
+
+          # Return the collection of domain objects
+          #
+          # @example Iterate over the results
+          #
+          #     results.map { |r| r.attributes[:title] }
+          #     => ["Fox", "Dog"]
+          #
+          # @return [Array]
+          #
+          def results
+            @results ||= response['hits']['hits'].map do |document|
+              repository.deserialize(document.to_hash)
+            end
+            @loaded = true
+            @results
+          end
+
+          def delete(opts=nil)
+          end
+
+          # Access the response returned from Elasticsearch by the client
+          #
+          # @example Access the aggregations in the response
+          #
+          #     results = repository.search query: { match: { title: 'fox dog' } },
+          #                                 aggregations: { titles: { terms: { field: 'title' } } }
+          #     results.response.aggregations.titles.buckets.map { |term| "#{term['key']}: #{term['doc_count']}" }
+          #     # => ["brown: 1", "dog: 1", ...]
+          #
+          # @return [Hashie::Mash]
+          #
+          def response
+            @response
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+module Elasticsearch
+  module Persistence
+    module Repository
+
+      # Returns a collection of domain objects by an Elasticsearch query
+      #
+      module Search
+        include Elasticsearch::Persistence::QueryCache
+        # Returns a collection of domain objects by an Elasticsearch query
+        #
+        # Pass the query either as a string or a Hash-like object
+        #
+        # @example Return objects matching a simple query
+        #
+        #     repository.search('fox or dog')
+        #
+        # @example Return objects matching a query in the Elasticsearch DSL
+        #
+        #    repository.search(query: { match: { title: 'fox dog' } })
+        #
+        # @example Define additional search parameters, such as highlighted excerpts
+        #
+        #    results = repository.search(query: { match: { title: 'fox dog' } }, highlight: { fields: { title: {} } })
+        #     results.map_with_hit { |d,h| h.highlight.title.join }
+        #     # => ["quick brown <em>fox</em>", "fast white <em>dog</em>"]
+        #
+        # @example Perform aggregations as part of the request
+        #
+        #     results = repository.search query: { match: { title: 'fox dog' } },
+        #                                 aggregations: { titles: { terms: { field: 'title' } } }
+        #     results.response.aggregations.titles.buckets.map { |term| "#{term['key']}: #{term['doc_count']}" }
+        #     # => ["brown: 1", "dog: 1", ... ]
+        #
+        # @example Pass additional options to the search request, such as `size`
+        #
+        #     repository.search query: { match: { title: 'fox dog' } }, size: 25
+        #     # GET http://localhost:9200/notes/note/_search
+        #     # > {"query":{"match":{"title":"fox dog"}},"size":25}
+        #
+        # @return [Elasticsearch::Persistence::Repository::Response::Results]
+        #
+        def search(query_or_definition, options = {})
+          request = { index: index_name, body: query_or_definition.to_hash }
+
+          case
+          when query_or_definition.respond_to?(:to_hash)
+            request.merge!(body: query_or_definition.to_hash)
+          when query_or_definition.is_a?(String)
+            request.merge!(q: query_or_definition)
+          else
+            raise ArgumentError, "[!] Pass the search definition as a Hash-like object or pass the query as a String" +
+                                 " -- #{query_or_definition.class} given."
+          end
+
+          response = cache_query(to_curl(request.merge(options)), klass) { client.search(request.merge(options)) }
+
+          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: {} } }
+
+          request = { index: index_name, body: query_or_definition.to_hash }
+          response = cache_query(to_curl(request.merge(options), "_count"), klass) { client.count(request.merge(options)) }
+
+          response
+        end
+
+        private
+
+        ## TODO: Not happy with where this is living right now.
+        #
+        def to_curl(arguments = {}, end_point = "_search")
+          host = client.transport.options[:hosts]&.first || client.transport.options[:url]
+          arguments[:index] = "_all" if !arguments[:index] && arguments[:type]
+
+          valid_params = [
+            :analyzer,
+            :analyze_wildcard,
+            :default_operator,
+            :df,
+            :explain,
+            :fields,
+            :from,
+            :ignore_indices,
+            :ignore_unavailable,
+            :allow_no_indices,
+            :expand_wildcards,
+            :lenient,
+            :lowercase_expanded_terms,
+            :preference,
+            :q,
+            :routing,
+            :scroll,
+            :search_type,
+            :size,
+            :sort,
+            :source,
+            :_source,
+            :_source_include,
+            :_source_exclude,
+            :stats,
+            :suggest_field,
+            :suggest_mode,
+            :suggest_size,
+            :suggest_text,
+            :timeout,
+            :version,
+          ]
+
+          method = "GET"
+          path = Elasticsearch::API::Utils.__pathify(Elasticsearch::API::Utils.__listify(arguments[:index]), end_point)
+
+          params = Elasticsearch::API::Utils.__validate_and_extract_params arguments, valid_params
+          body = arguments[:body]
+
+          params[:fields] = Elasticsearch::API::Utils.__listify(params[:fields]) if params[:fields]
+
+          url = path
+
+          unless host.is_a? String
+            host_parts = "#{host[:protocol].to_s}://#{host[:host]}"
+            host_parts = "#{host_parts}:#{host[:port]}" if host[:port]
+          else
+            host_parts = host
+          end
+
+          trace_url = "#{host_parts}/#{url}"
+          trace_url += "?#{::Faraday::Utils::ParamsHash[params].to_query}" unless params.blank?
+          trace_body = body ? " -d '#{body.to_json}'" : ""
+
+          Rainbow("curl -X #{method.to_s.upcase} '#{CGI.unescape(trace_url)}'#{trace_body}\n").color :white
+        end
+      end
+    end
+  end
+end