elastic_record 0.11.1 → 0.12.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3a25b326c628b294aff17e44d2465d1b988ca2c3
+  data.tar.gz: f20002ac648ecf9f7df8f524bf639e6b1be55af2
+SHA512:
+  metadata.gz: c3baffc104e19d488ae910b3265cd8dcb239ac5a1c05492cdbb1a7747bb2156f3e4085bd6de0defed0eea9dbd2b6b3478a17f759eeaf3a751e12d417f7912eef
+  data.tar.gz: 1bdeaefcffd51c750ad47d36ff5d8018d9040557f2f9a63d994715bb9206346c1439b1c2e8abcf09c997f127bf06fa6ccacccceef33798993f50548c4c5069db

data/Gemfile

@@ -1,4 +1,5 @@
-source :rubygems
+source 'https://rubygems.org'
+
 gemspec
 
 gem 'rake'

data/README.rdoc

@@ -9,16 +9,38 @@ The usual Gemfile addition:
   
   gem 'elastic_record'
 
-Creating the index:
-
-  rake index:create
 
 Include ElasticRecord into your model:
 
-  ActiveSupport.on_load :active_record do
+  class Product < YourFavoriteOrm::Base
     include ElasticRecord::Model
   end
 
+== Configuration
+
+While elastic search automatically maps fields, you may wish to override the defaults:
+
+  class Product < YourFavoriteOrm::Base
+    elastic_index.configure do
+      property :status, type: "string", index: "not_analyzed"
+    end
+  end
+
+You can also directly access Product.elastic_index.mapping and Product.elastic_index.settings:
+
+  class Product
+    elastic_index.mapping = {
+      properties: {
+        name: {type: "string", index: "analyzed"}
+        status: {type: "string", index: "not_analyzed"}
+      }
+    }
+  end
+
+Create the index:
+
+  rake index:create
+
 == Searching
 
 ElasticRecord adds the method 'elastic_search' to your models. It works similar to active_record scoping:
@@ -29,8 +51,9 @@ ElasticRecord adds the method 'elastic_search' to your models. It works similar
 
 If a simple hash is passed into filter, a term or terms query is created:
 
-  search.filter(color: 'red')         # Creates a term filter
-  search.filter(color: %w(red blue))  # Creates a terms filter
+  search.filter(color: 'red')         # Creates a 'term' filter
+  search.filter(color: %w(red blue))  # Creates a 'terms' filter
+  search.filter(color: nil)           # Creates a 'missing' filter
 
 If a hash containing hashes is passed into filter, it is used directly as a filter DSL expression:
 
@@ -47,9 +70,6 @@ An Arelastic object can also be passed in, working similarily to Arel:
   # Size is greater than 5
   search.filter(Product.arelastic[:size].gt(5))
 
-  # Product has a nil name
-  search.filter(Product.arelastic[:name].missing)
-
   # Name is 'hola' or name is missing
   search.filter(Product.arelastic[:name].eq("hola").or(Product.arelastic[:name].missing))
 
@@ -115,3 +135,11 @@ Class methods can be executed within scopes:
 
   # Increase the price of all red products by $10.
   Product.filter(color: 'red').increase_prices
+
+== Index Information
+
+Core and Index APIs can be accessed with Product.elastic_index. Some examples include:
+
+  Production.elastic_index.refresh      # Call the refresh API
+  Production.elastic_index.get_mapping  # Get the index mapping defined by elastic search
+  Production.elastic_index.reset        # Delete related indexes and deploy a new one

data/elastic_record.gemspec

@@ -1,8 +1,8 @@
 # -*- encoding: utf-8 -*-
- 
+
 Gem::Specification.new do |s|
   s.name = 'elastic_record'
-  s.version = '0.11.1'
+  s.version = '0.12.0'
   s.summary = 'Use Elastic Search with your objects'
   s.description = 'Find your records with elastic search'
 

data/lib/elastic_record/callbacks.rb

@@ -2,7 +2,7 @@ module ElasticRecord
   module Callbacks
     def self.included(base)
       base.class_eval do
-        after_save do
+        after_save if: :changed? do
           self.class.elastic_index.index_document id, as_search
         end
 

data/lib/elastic_record/connection.rb

@@ -15,7 +15,7 @@ module ElasticRecord
         self.servers = servers.split(',')
       end
 
-      self.current_server = choose_server
+      self.current_server = next_server
       self.request_count = 0
       self.max_request_count = 100
       self.options = options
@@ -60,27 +60,35 @@ module ElasticRecord
     }
 
     def http_request(method, path, body = nil)
-      request = METHODS[method].new(path)
-      request.body = body
-      http = new_http
-
-      ActiveSupport::Notifications.instrument("request.elastic_record") do |payload|
-        payload[:http]      = http
-        payload[:request]   = request
-        payload[:response]  = http.request(request)
+      with_retry do
+        request = METHODS[method].new(path)
+        request.body = body
+        http = new_http
+
+        ActiveSupport::Notifications.instrument("request.elastic_record") do |payload|
+          payload[:http]      = http
+          payload[:request]   = request
+          payload[:response]  = http.request(request)
+        end
       end
     end
 
     private
-      def choose_server
-        servers.sample
+      def next_server
+        if @shuffled_servers.nil?
+          @shuffled_servers = servers.shuffle
+        else
+          @shuffled_servers.push(@shuffled_servers.shift)
+        end
+
+        @shuffled_servers.first
       end
 
       def new_http
         self.request_count += 1
 
-        if request_count > max_request_count{}
-          self.current_server = choose_server
+        if request_count > max_request_count
+          self.current_server = next_server
           self.request_count = 0
         end
 
@@ -92,5 +100,20 @@ module ElasticRecord
         end
         http
       end
+
+      def with_retry
+        retry_count = 0
+        begin
+          yield
+        rescue StandardError
+          if retry_count < options[:retries].to_i
+            self.current_server = next_server
+            retry_count += 1
+            retry
+          else
+            raise
+          end
+        end
+      end
   end
 end

data/lib/elastic_record/index.rb

@@ -1,12 +1,31 @@
+require 'elastic_record/index/configurator'
 require 'elastic_record/index/deferred'
 require 'elastic_record/index/documents'
 require 'elastic_record/index/manage'
 require 'elastic_record/index/mapping'
 require 'elastic_record/index/percolator'
 require 'elastic_record/index/settings'
-require 'net/http'
+
+require 'active_support/core_ext/hash/deep_dup'
 
 module ElasticRecord
+  # ElasticRecord::Index provides access to elastic search's API. It is accessed with
+  # <tt>Widget.elastic_index</tt>. The methods provided are:
+  # 
+  # [create]
+  #   Create a new index that is not aliased
+  # [create_and_deploy]
+  #   Create a new index and alias it
+  # [reset]
+  #   Delete all aliased indexes and deploy a new one
+  # [refresh]
+  #   Call the refresh API
+  # [exists?(index_name)]
+  #   Returns if the index exists
+  # [get_mapping]
+  #   Returns the mapping currently stored by elastic search.
+  # [put_mapping]
+  #   Update elastic search's mapping
   class Index
     include Documents
     include Manage
@@ -23,8 +42,10 @@ module ElasticRecord
       @disabled = false
     end
 
-    # def initialize_copy(other)
-    # end
+    def initialize_copy(other)
+      @settings = settings.deep_dup
+      @mapping = mapping.deep_dup
+    end
 
     def alias_name
       @alias_name ||= model.base_class.model_name.collection
@@ -46,9 +67,17 @@ module ElasticRecord
       model.elastic_connection
     end
 
+    def configure(&block)
+      Configurator.new(self).instance_eval(&block)
+    end
+
+    def get(end_path, json = nil)
+      connection.json_get "/#{alias_name}/#{type}/#{end_path}", json
+    end
+
     private
       def new_index_name
-        "#{alias_name}_#{Time.now.to_i}"
+        "#{alias_name}_#{(Time.now.to_f * 100).to_i}"
       end
   end
 end

data/lib/elastic_record/index/configurator.rb

@@ -0,0 +1,14 @@
+module ElasticRecord
+  class Index
+    class Configurator
+      attr_reader :index
+      def initialize(index)
+        @index = index
+      end
+
+      def property(name, options)
+        index.mapping[:properties][name.to_sym] = options
+      end
+    end
+  end
+end

data/lib/elastic_record/index/documents.rb

@@ -8,9 +8,9 @@ module ElasticRecord
 
         index_name ||= alias_name
 
-        if @batch
-          @batch << { index: { _index: index_name, _type: type, _id: id } }
-          @batch << document
+        if batch = current_batch
+          current_batch << { index: { _index: index_name, _type: type, _id: id } }
+          current_batch << document
         else
           connection.json_put "/#{index_name}/#{type}/#{id}", document
         end
@@ -19,28 +19,28 @@ module ElasticRecord
       def delete_document(id, index_name = nil)
         index_name ||= alias_name
 
-        if @batch
-          @batch << { delete: { _index: index_name, _type: type, _id: id } }
+        if batch = current_batch
+          batch << { delete: { _index: index_name, _type: type, _id: id } }
         else
           connection.json_delete "/#{index_name}/#{type}/#{id}"
         end
       end
 
       def record_exists?(id)
-        connection.json_get("/#{alias_name}/#{type}/#{id}")['exists']
+        get(id)['exists']
       end
 
       def search(elastic_query, options = {})
-        url = "/#{alias_name}/#{type}/_search"
+        url = "_search"
         if options.any?
           url += "?#{options.to_query}"
         end
 
-        connection.json_get url, elastic_query
+        get url, elastic_query
       end
 
       def explain(id, elastic_query)
-        connection.json_get "/#{alias_name}/#{type}/#{id}/_explain", elastic_query
+        get "_explain", elastic_query
       end
 
       def scroll(scroll_id, scroll_keep_alive)
@@ -49,14 +49,14 @@ module ElasticRecord
       end
 
       def bulk
-        @batch = []
+        @_batch = []
         yield
-        if @batch.any?
-          body = @batch.map { |action| "#{ActiveSupport::JSON.encode(action)}\n" }.join
+        if @_batch.any?
+          body = @_batch.map { |action| "#{ActiveSupport::JSON.encode(action)}\n" }.join
           connection.json_post "/_bulk", body
         end
       ensure
-        @batch = nil
+        @_batch = nil
       end
 
       def bulk_add(batch, index_name = nil)
@@ -68,6 +68,14 @@ module ElasticRecord
           end
         end
       end
+
+      def current_batch
+        if @_batch
+          @_batch
+        elsif model.superclass.respond_to?(:elastic_index)
+          model.superclass.elastic_index.current_batch
+        end
+      end
     end
   end
 end

data/lib/elastic_record/index/manage.rb

@@ -9,7 +9,6 @@ module ElasticRecord
 
       def create(index_name = new_index_name)
         connection.json_put "/#{index_name}", "settings" => settings
-        # update_settings(index_name)
         update_mapping(index_name)
         index_name
       end
@@ -28,6 +27,10 @@ module ElasticRecord
         connection.head("/#{index_name}") == '200'
       end
 
+      def type_exists?(index_name = alias_name)
+        connection.head("/#{index_name}/#{type}") == '200'
+      end
+
       def deploy(index_name)
         actions = [
           {
@@ -50,14 +53,6 @@ module ElasticRecord
         connection.json_post '/_aliases', actions: actions
       end
 
-      def update_mapping(index_name = alias_name)
-        connection.json_put "/#{index_name}/#{type}/_mapping", type => mapping
-      end
-
-      def update_settings(index_name = alias_name)
-        connection.json_put "/#{index_name}/_settings", settings
-      end
-
       def refresh(index_name = alias_name)
         connection.json_post "/#{index_name}/_refresh"
       end

data/lib/elastic_record/index/mapping.rb

@@ -5,6 +5,18 @@ module ElasticRecord
         mapping.deep_merge!(mapping)
       end
 
+      def update_mapping(index_name = alias_name)
+        connection.json_put "/#{index_name}/#{type}/_mapping", type => mapping
+      end
+      
+      def get_mapping(index_name = alias_name)
+        connection.json_get "/#{index_name}/#{type}/_mapping"
+      end
+
+      def delete_mapping(index_name = alias_name)
+        connection.json_delete "/#{index_name}/#{type}"
+      end
+
       def mapping
         @mapping ||= {
           _source: {

data/lib/elastic_record/index/percolator.rb

@@ -5,6 +5,7 @@ module ElasticRecord
         unless exists? percolator_index_name
           create percolator_index_name
         else
+          delete_mapping(percolator_index_name) if type_exists?(percolator_index_name)
           update_mapping percolator_index_name
         end
 

data/lib/elastic_record/index/settings.rb

@@ -8,6 +8,10 @@ module ElasticRecord
       def settings
         @settings ||= {}
       end
+
+      def update_settings(index_name = alias_name)
+        connection.json_put "/#{index_name}/_settings", settings
+      end
     end
   end
 end

data/lib/elastic_record/lucene.rb

@@ -4,47 +4,65 @@ module ElasticRecord
   class Lucene
     # Special characters:
     # + - && || ! ( ) { } [ ] ^ " ~ * ? : \
-    ESCAPE_REGEX = /(\+|-|&&|\|\||!|\(|\)|{|}|\[|\]|`|"|~|\?|:|\\)/
+    ESCAPE_REGEX = /(\+|-|&&|\|\||!|\(|\)|{|}|\[|\]|`|"|~\*|\?|:|\\)/
 
     class << self
       def escape(query)
         query.gsub(ESCAPE_REGEX, "\\\\\\1")
       end
 
-      def query_words(query)
-        Shellwords::shellwords query.gsub("'", "\"'\"")
-      end
-
-      # Returns a lucene query that works like G
-      def smart_query(query, fields, &block)
+      # Returns a lucene query that works like GMail
+      def match_phrase(query, fields, &block)
         return if query.blank?
 
-        words = query_words(query)
+        words = split_phrase_into_words(query)
 
         words.map do |word|
           if word =~ /^(\w+):(.+)$/ && fields.include?($1)
-            match_word $2, [$1], &block
+            match_word $2, [block_given? ? yield($1) : $1]
           else
-            match_word word, fields, &block
+            match_word word, (block_given? ? fields.map(&block) : fields)
           end
         end.join(' AND ')
       end
 
-      private
+      # Performs a prefix match on the word:
+      # 
+      # ElasticRecord::Lucene.match_word('blue', ['color', 'name'])
+      #   => (color:blue* OR name:blue*)
+      # 
+      # In the case that the word has special characters, it is wrapped in quotes:
+      # 
+      # ElasticRecord::Lucene.match_word('A&M', ['name'])
+      #   => (name:"A&M")
+      def match_word(word, fields)
+        if word =~ / / || word =~ ESCAPE_REGEX
+          word = "\"#{word.gsub('"', '')}\""
+        else
+          word = "#{word}*"
+        end
 
-        def match_word(word, fields, &block)
-          if word =~ / / || word =~ ESCAPE_REGEX
-            word = "\"#{word}\""
-          else
-            word = "#{word}*"
-          end
+        or_query = fields.map do |field|
+          "#{field}:#{word}"
+        end.join(' OR ')
+
+        "(#{or_query})"
+      end
 
-          or_query = fields.map do |field|
-            field = yield(field) if block_given?
-            "#{field}:#{word}"
-          end.join(' OR ')
+      private
+        # Converts a sentence into the words:
+        # 
+        # split_phrase_into_words('his "blue fox"')
+        # => ['his', 'blue fox']
+        def split_phrase_into_words(phrase)
+          # If we have an odd number of double quotes,
+          # add a double quote to the end so that shellwords
+          # does not crap out.
+          if phrase.count('"') % 2 == 1
+            phrase = "#{phrase}\""
+          end
 
-          "(#{or_query})"
+          Shellwords::shellwords phrase.gsub("'", "\"'\"")
         end
     end
   end