elasticsearch-rails2 0.0.1

data/lib/elasticsearch/rails2/naming.rb

@@ -0,0 +1,125 @@
+module Elasticsearch
+
+  module Rails2
+    # Provides methods for getting and setting index name
+    #
+    module Naming
+
+      module ClassMethods
+
+        # Get or set the name of the index
+        #
+        # @example Set the index name for the `Building` model
+        #
+        #     class Building
+        #       index_name "buildings-#{Rails.env}"
+        #     end
+        #
+        # @example Set the index name for the `Building` model and re-evaluate it on each call
+        #
+        #     class Building
+        #       index_name { "buildings-#{Time.now.year}" }
+        #     end
+        #
+        # @example Directly set the index name for the `Building` model
+        #
+        #     Building.index_name "buildings-#{Rails.env}"
+        #
+        #
+        def index_name name=nil, &block
+          if name || block_given?
+            return (@index_name = name || block)
+          end
+
+          if @index_name.respond_to?(:call)
+            @index_name.call
+          else
+            @index_name || Elasticsearch::Rails2.index_name || "#{self.model_name.collection}_index"
+          end
+        end
+
+        # Set the index name
+        #
+        # @see index_name
+        def index_name=(name)
+          @index_name = name
+        end
+
+        # Get or set the document type
+        #
+        # @example Set the document type for the `Building` model
+        #
+        #     class Building
+        #       document_type "my-building"
+        #     end
+        #
+        # @example Directly set the document type for the `Building` model
+        #
+        #     Building.document_type "my-building"
+        #
+        def document_type name=nil
+          @document_type = name || @document_type || self.model_name.collection
+        end
+
+
+        # Set the document type
+        #
+        # @see document_type
+        #
+        def document_type=(name)
+          @document_type = name
+        end
+      end
+
+      module InstanceMethods
+
+        # Get or set the index name for the model instance
+        #
+        # @example Set the index name for an instance of the `Building` model
+        #
+        #     @building.index_name "buildings-#{@building.sourceid}"
+        #
+        #
+        def index_name name=nil, &block
+          if name || block_given?
+            return (@index_name = name || block)
+          end
+
+          if @index_name.respond_to?(:call)
+            @index_name.call
+          else
+            @index_name || self.class.index_name
+          end
+        end
+
+        # Set the index name
+        #
+        # @see index_name
+        def index_name=(name)
+          @index_name = name
+        end
+
+        # Get or set the document type
+        #
+        # @example Set the document type for an instance of the `Building` model
+        #
+        #     @bulding.document_type "my-building"
+        #
+        #
+        def document_type name=nil
+          @document_type = name || @document_type || self.class.document_type
+        end
+
+
+        # Set the document type
+        #
+        # @see document_type
+        #
+        def document_type=(name)
+          @document_type = name
+        end
+      end
+
+    end
+  end
+end

data/lib/elasticsearch/rails2/response.rb

@@ -0,0 +1,77 @@
+module Elasticsearch
+  module Rails2
+    # Contains modules and classes for wrapping the response from Elasticsearch
+    #
+    module Response
+
+      # Encapsulate the response returned from the Elasticsearch client
+      #
+      # Implements Enumerable and forwards its methods to the {#results} object.
+      #
+      class Response
+        attr_reader :klass, :search, :response,
+                    :took, :timed_out, :shards
+
+        include Enumerable
+
+        delegate :each, :empty?, :size, :slice, :[], :to_ary, to: :results
+
+        def initialize(klass, search, options={})
+          @klass     = klass
+          @search    = search
+        end
+
+        # Returns the Elasticsearch response
+        #
+        # @return [Hash]
+        #
+        def response
+          @response ||= begin
+            Hashie::Mash.new(search.execute!)
+          end
+        end
+
+        # Returns the collection of "hits" from Elasticsearch
+        #
+        # @return [Results]
+        #
+        def results
+          @results ||= Results.new(klass, self)
+        end
+
+        # Returns the collection of records from the database
+        #
+        # @return [Records]
+        #
+        def records
+          @records ||= Records.new(klass, self)
+        end
+
+        # Returns the "took" time
+        #
+        def took
+          response['took']
+        end
+
+        # Returns whether the response timed out
+        #
+        def timed_out
+          response['timed_out']
+        end
+
+        # Returns the statistics on shards
+        #
+        def shards
+          Hashie::Mash.new(response['_shards'])
+        end
+
+        # Returns whether the response scroll id
+        #
+        def scroll_id
+          response['_scroll_id']
+        end
+
+      end
+    end
+  end
+end

data/lib/elasticsearch/rails2/response/result.rb

@@ -0,0 +1,62 @@
+module Elasticsearch
+  module Rails2
+    module Response
+
+      # Encapsulates the "hit" returned from the Elasticsearch client
+      #
+      # Wraps the raw Hash with in a `Hashie::Mash` instance, providing
+      # access to the Hash properties by calling Ruby methods.
+      #
+      # @see https://github.com/intridea/hashie
+      #
+      class Result
+
+        # @param attributes [Hash] A Hash with document properties
+        #
+        def initialize(attributes={})
+          @result = Hashie::Mash.new(attributes)
+        end
+
+        # Return document `_id` as `id`
+        #
+        def id
+          @result['_id']
+        end
+
+        # Return document `_type` as `_type`
+        #
+        def type
+          @result['_type']
+        end
+
+        # Delegate methods to `@result` or `@result._source`
+        #
+        def method_missing(name, *arguments)
+          case
+          when name.to_s.end_with?('?')
+            @result.__send__(name, *arguments) || ( @result._source && @result._source.__send__(name, *arguments) )
+          when @result.respond_to?(name)
+            @result.__send__ name, *arguments
+          when @result._source && @result._source.respond_to?(name)
+            @result._source.__send__ name, *arguments
+          else
+            super
+          end
+        end
+
+        # Respond to methods from `@result` or `@result._source`
+        #
+        def respond_to?(method_name, include_private = false)
+          @result.respond_to?(method_name.to_sym) || \
+          @result._source && @result._source.respond_to?(method_name.to_sym) || \
+          super
+        end
+
+        def as_json(options={})
+          @result.as_json(options)
+        end
+
+      end
+    end
+  end
+end

data/lib/elasticsearch/rails2/response/results.rb

@@ -0,0 +1,52 @@
+module Elasticsearch
+  module Rails2
+    module Response
+
+      # Encapsulates the collection of documents returned from Elasticsearch
+      #
+      # Implements Enumerable and forwards its methods to the {#results} object.
+      #
+      class Results
+        attr_reader :klass, :response
+
+        include Enumerable
+
+        delegate :each, :empty?, :size, :slice, :[], :to_a, :to_ary, to: :results
+
+        # @param klass    [Class] The name of the model class
+        # @param response [Hash]  The full response returned from Elasticsearch client
+        # @param options  [Hash]  Optional parameters
+        #
+        def initialize(klass, response, options={})
+          @klass     = klass
+          @response  = response
+        end
+
+        # Returns the {Results} collection
+        #
+        def results
+          @results  = response.response['hits']['hits'].map { |hit| Result.new(hit) }
+        end
+
+        # Returns the total number of hits
+        #
+        def total
+          response.response['hits']['total']
+        end
+
+        # Returns the max_score
+        #
+        def max_score
+          response.response['hits']['max_score']
+        end
+
+        # Returns the hit IDs
+        #
+        def ids
+          response.response['hits']['hits'].map { |hit| hit['_id'] }
+        end
+
+      end
+    end
+  end
+end

data/lib/elasticsearch/rails2/searching.rb

@@ -0,0 +1,120 @@
+module Elasticsearch
+  module Rails2
+
+    # Contains functionality related to searching.
+    #
+    module Searching
+
+      # Wraps a search request definition
+      #
+      class SearchRequest
+        attr_reader :klass, :definition, :options
+
+        # @param klass [Class] The class of the model
+        # @param query_or_payload [String,Hash,Object] The search request definition
+        #                                              (string, JSON, Hash, or object responding to `to_hash`)
+        # @param options [Hash] Optional parameters to be passed to the Elasticsearch client
+        #
+        def initialize(klass, query_or_payload, options={})
+          @klass   = klass
+          @options = options
+
+          __index_name    = options[:index] || klass.index_name
+          __document_type = options[:type]  || klass.document_type
+
+          case
+            # search query: ...
+            when query_or_payload.respond_to?(:to_hash)
+              body = query_or_payload.to_hash
+
+            # search '{ "query" : ... }'
+            when query_or_payload.is_a?(String) && query_or_payload =~ /^\s*{/
+              body = query_or_payload
+
+            # search '...'
+            else
+              q = query_or_payload
+          end
+
+          if body
+            @definition = { index: __index_name, type: __document_type, body: body }.update options
+          else
+            @definition = { index: __index_name, type: __document_type, q: q }.update options
+          end
+        end
+
+        # Performs the request and returns the response from client
+        #
+        # @return [Hash] The response from Elasticsearch
+        #
+        def execute!
+          klass.client.search(@definition)
+        end
+      end
+
+      module ClassMethods
+
+        # Provides a `search` method for the model to easily search within an index/type
+        # corresponding to the model settings.
+        #
+        # @param query_or_payload [String,Hash,Object] The search request definition
+        #                                              (string, JSON, Hash, or object responding to `to_hash`)
+        # @param options [Hash] Optional parameters to be passed to the Elasticsearch client
+        #
+        # @return [Elasticsearch::Rails2::Response]
+        #
+        # @example Simple search in `Article`
+        #
+        #     Article.search 'foo'
+        #
+        # @example Search using a search definition as a Hash
+        #
+        #     response = Article.search \
+        #                  query: {
+        #                    match: {
+        #                      title: 'foo'
+        #                    }
+        #                  },
+        #                  highlight: {
+        #                    fields: {
+        #                      title: {}
+        #                    }
+        #                  }
+        #
+        #     response.results.first.title
+        #     # => "Foo"
+        #
+        #     response.results.first.highlight.title
+        #     # => ["<em>Foo</em>"]
+        #
+        #     response.records.first.title
+        #     #  Article Load (0.2ms)  SELECT "articles".* FROM "articles" WHERE "articles"."id" IN (1, 3)
+        #     # => "Foo"
+        #
+        # @example Search using a search definition as a JSON string
+        #
+        #     Article.search '{"query" : { "match_all" : {} }}'
+        #
+        def search(query_or_payload, options={})
+          search = SearchRequest.new(self, query_or_payload, options)
+          Response::Response.new(self, search)
+        end
+
+        # Scan and scroll all ids
+        # Useful to do a SQL query with IN(...) operator
+        #
+        def scan_all_ids(query_or_payload, options={})
+          ids = []
+          scroll = options[:scroll]
+          search_response = search(query_or_payload, options.update(search_type: 'scan'))
+          response = search_response.response
+          while response = client.scroll(scroll_id: response['_scroll_id'], scroll: scroll) and !response['hits']['hits'].empty? do
+            response['hits']['hits'].each { |r| ids << r['_id']}
+          end
+          ids
+        end
+      end
+
+    end
+  end
+end

data/lib/elasticsearch/rails2/version.rb

@@ -0,0 +1,5 @@
+module Elasticsearch
+  module Rails2
+    VERSION = "0.0.1"
+  end
+end