elastic_record 2.0.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f659725ca3b959336aaf4a3b8e5964ad5bb9a645
-  data.tar.gz: ecd8c9c725a0e20d9d36f9273fb8cb211f173f1d
+  metadata.gz: fa1490c6f1419caa30179923ab783f171cb76a40
+  data.tar.gz: 998fa7673a9166e71699850e4ea3ac83655ca9b8
 SHA512:
-  metadata.gz: 6185d059786865130f6f51128dd99523d01762fd46752874c1b253d0c1794b90ecf77f06ac1a1394f29588b259db107e2b1da33cc1c67849c8d3edc391584986
-  data.tar.gz: b4ca5642f7db62e9a6cdf619c6808802f5adddbf079f1900f7387de0753a459b4737d7447080c1cffd4c6c4915460be74be690ec95afbe4d3d608c2d35db65ae
+  metadata.gz: 1bc5edfa1886f1ee4d942d590489c33223613145e8145706168c1a94843f3ec9d0faf165e1285adacfcc67820e3ed0d078e8a22d25fa94828b10491b7f97732f
+  data.tar.gz: cb659e49e466576f1ab4195d481561393083131ec031d3c2c10bb724d1cd0e2e8a1722c49b76d4009b6e85377762e823506b12ba45701d6f9e935666f2b08c9f

data/.gitignore

@@ -1,2 +1,3 @@
 Gemfile.lock
 test/dummy/log/*.log
+test/dummy/.env

data/.travis.yml

@@ -1,10 +1,16 @@
-services:
-  - elasticsearch
+rvm: 2.2.3
+cache: bundler
+sudo: required
+dist: trusty
+before_install:
+- wget https://download.elasticsearch.org/elasticsearch/release/org/elasticsearch/distribution/deb/elasticsearch/2.2.2/elasticsearch-2.2.2.deb
+- sudo dpkg -i elasticsearch-2.2.2.deb
+- sudo service elasticsearch start
+- sudo apt-get install --yes mysql-server
 before_script:
-  - bundle exec rake app:db:create
-  - bundle exec rake app:index:reset
-rvm:
-  - 2.1.2
-env:
-  - "GEM=ar:mysql2"
-  - "GEM=ar:postgresql"
+- cp test/dummy/.env.example test/dummy/.env
+- curl localhost:9200
+- bundle exec rake app:db:setup
+- bundle exec rake app:index:reset
+services:
+- postgresql

data/Gemfile

@@ -1,10 +1,11 @@
 source 'https://rubygems.org'
 
 gemspec
-gem 'rails', '~> 4.2.0'
-gem 'fakeweb'
-gem 'rake'
-gem 'arelastic', path: '~/code/arelastic'
 
+gem 'dotenv-rails'
+gem 'oj'
 gem 'mysql2'
 gem 'pg'
+gem 'rails', '~> 4.2.0'
+gem 'rake', '~> 10.5.0'
+gem 'webmock', require: false

data/README.md

@@ -0,0 +1,214 @@
+# ElasticRecord #
+[![Build Status](https://secure.travis-ci.org/data-axle/elastic_record.png?rvm=2.0.0)](http://travis-ci.org/data-axle/elastic_record)
+[![Code Climate](https://codeclimate.com/github/data-axle/elastic_record.png)](https://codeclimate.com/github/data-axle/elastic_record)
+
+ElasticRecord is an Elasticsearch 2.x ORM.
+
+## Setup ##
+
+Include ElasticRecord into your model:
+
+```ruby
+class Product < ActiveRecord::Base
+  include ElasticRecord::Model
+end
+```
+
+### Connection ###
+
+There are two ways to set up which server to connect to:
+
+```ruby
+# config/initializers/elastic_search.rb
+ElasticRecord.configure do |config|
+  config.servers = "es1.example.com:9200"
+end
+```
+
+```yaml
+# config/elasticsearch.yml:
+development:
+  servers: es1.example.com:9200
+  timeout: 10
+  retries: 2
+```
+
+## Search API ##
+
+ElasticRecord adds the method 'elastic_search' to your models. It works similar to active_record scoping:
+```ruby
+search = Product.elastic_search
+```
+
+### Filtering ###
+
+If a simple hash is passed into filter, a term or terms query is created:
+
+```ruby
+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:
+
+```ruby
+search.filter(prefix: { name: "Sca" }) # Creates a prefix filter
+```
+
+An Arelastic object can also be passed in, working similarily to Arel:
+
+```ruby
+# Name starts with 'Sca'
+search.filter(Product.arelastic[:name].prefix("Sca"))
+
+# Name does not start with 'Sca'
+search.filter(Product.arelastic[:name].prefix("Sca").negate)
+
+# Size is greater than 5
+search.filter(Product.arelastic[:size].gt(5))
+
+# Name is 'hola' or name is missing
+search.filter(Product.arelastic[:name].eq("hola").or(Product.arelastic[:name].missing))
+```
+
+Helpful Arel builders can be found at https://github.com/matthuhiggins/arelastic/blob/master/lib/arelastic/builders/filter.rb.
+
+### Querying ###
+
+To create a query string, pass a string to search.query:
+
+```ruby
+search.query("red AND fun*") # Creates {query_string: {"red AND fun*"}}
+```
+
+Complex queries are done using either a hash or an arelastic object:
+
+```ruby
+search.query(match: {description: "amazing"})
+```
+
+### Ordering ###
+
+```ruby
+search.order(:price)          # sort by price
+search.order(:color, :price)  # sort by color, then price
+search.order(price: :desc)    # sort by price in descending order
+```
+
+### Offsets and Limits ###
+
+To change the 'size' and 'from' values of a query, use offset and limit:
+
+```ruby
+search.limit(40).offset(80)   # Creates a query with {size: 40, from: 80}
+```
+
+### Aggregations ###
+
+Aggregations are added with the aggregate method:
+
+```ruby
+search.aggregate('popular_colors' => {'terms' => {'field' => 'color'}})
+```
+
+It is important to note that adding aggregations to a query is different than retrieving the results of the query:
+
+```ruby
+search = search.aggregate('popular_colors' => {'terms' => {'field' => 'color'}})
+search.aggregations
+#=> {"popular_colors" => {"buckets" => ...}}
+```
+
+### Getting Results ###
+
+A search object behaves similar to an active_record scope, implementing a few methods of its own and delegating the rest to Array, and your class.
+
+```ruby
+search.count        # Return the number of search results
+search.first        # Limit results to 1 and return the first result or nil
+search.find(id)     # Add an ids filter to the existing query
+search.as_elastic   # Return the json hash that will be sent to elastic search.
+```
+
+The search object behaves like an array when necessary:
+
+```ruby
+search.each do |product|
+  ...
+end
+```
+
+Class methods can be executed within scopes:
+
+```ruby
+class Product
+  def self.increase_prices
+    all.each do { |product| product.increment(:price, 10) }
+  end
+end
+
+# Increase the price of all red products by $10.
+Product.filter(color: 'red').increase_prices
+```
+
+## Index Configuration
+
+While elastic search automatically maps fields, you may wish to override the defaults:
+
+```ruby
+class Product < ActiveRecord::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:
+
+```ruby
+class Product
+  elastic_index.mapping = {
+    properties: {
+      name: {type: "string", index: "analyzed"}
+      status: {type: "string", index: "not_analyzed"}
+    }
+  }
+end
+```
+
+### Index Management ###
+
+If you need to manage multiple indexes via the rake tasks, you will need to declare them explicitly:
+
+```ruby
+ElasticRecord.configure do |config|
+  config.model_names = %w(Product Order Location)
+end
+```
+
+Create the index:
+
+```ruby
+rake index:create CLASS=Product
+```
+
+### Index Admin Functions ###
+
+Core and Index APIs can be accessed with Product.elastic_index. Some examples include:
+
+```ruby
+Product.elastic_index.create_and_deploy  # Create a new index
+Product.elastic_index.reset              # Delete related indexes and deploy a new one
+Product.elastic_index.refresh            # Call the refresh API
+Product.elastic_index.get_mapping        # Get the index mapping defined by elastic search
+```
+
+## JSON Adapter ##
+
+By default, ElasticRecord uses ActiveSupport::JSON to serialize Elasticsearch payloads. There
+is optional support for using the Oj gem. To use Oj, ensure that oj is required and set:
+```ruby
+  ElasticRecord::JSON.parser = :oj
+```
+To return to the default parser, set the variable to :active_support.

data/elastic_record.gemspec

@@ -2,22 +2,22 @@
 
 Gem::Specification.new do |s|
   s.name = 'elastic_record'
-  s.version = '2.0.2'
-  s.summary = 'Use Elastic Search with your objects'
-  s.description = 'Find your records with elastic search'
+  s.version = '3.0.0'
+  s.summary = 'An Elasticsearch querying ORM'
+  s.description = 'Find your records with Elasticsearch'
 
   s.required_ruby_version     = '>= 1.9.3'
   s.required_rubygems_version = ">= 1.8.11"
-  s.license     = 'MIT'
 
+  s.license           = 'MIT'
   s.authors           = ['Infogroup', 'Matthew Higgins']
   s.email             = 'developer@matthewhiggins.com'
   s.homepage          = 'http://github.com/data-axle/elastic_record'
 
-  s.extra_rdoc_files = ['README.rdoc']
+  s.extra_rdoc_files = ['README.md']
   s.files       = `git ls-files`.split("\n")
   s.test_files  = `git ls-files -- {test}/*`.split("\n")
 
-  s.add_dependency 'arelastic', '>= 0.7.0'
-  s.add_dependency 'activemodel'
+  s.add_dependency 'arelastic', '~> 1.1', '>= 1.1.2'
+  s.add_dependency 'activemodel', '~> 0'
 end

data/lib/elastic_record.rb

@@ -8,6 +8,7 @@ module ElasticRecord
   autoload :Config, 'elastic_record/config'
   autoload :Connection, 'elastic_record/connection'
   autoload :Index, 'elastic_record/index'
+  autoload :JSON, 'elastic_record/json'
   autoload :Lucene, 'elastic_record/lucene'
   autoload :Model, 'elastic_record/model'
   autoload :Relation, 'elastic_record/relation'

data/lib/elastic_record/callbacks.rb

@@ -4,33 +4,29 @@ module ElasticRecord
       return unless base.respond_to?(:after_save) &&  base.respond_to?(:after_destroy)
 
       base.class_eval do
-        after_save if: :changed? do
+        after_create do
           self.class.elastic_index.index_record self
         end
 
+        after_update if: :changed? do
+          method = self.class.elastic_index.partial_updates ? :update_record : :index_record
+          self.class.elastic_index.send(method, self)
+        end
+
         after_destroy do
           self.class.elastic_index.delete_document id
         end
       end
     end
 
-
     def as_search
       json = {}
 
       elastic_index.mapping[:properties].each do |field, mapping|
-        next if !respond_to?(field)
-        value = send(field)
-
-        if value.present? || value == false
-          json[field] = case mapping[:type]
-            when :object
-              value.as_search
-            when :nested
-              value.map(&:as_search)
-            else
-              value
-            end
+        value = elastic_search_value field, mapping
+
+        unless value.nil?
+          json[field] = value
         end
       end
 
@@ -38,5 +34,41 @@ module ElasticRecord
 
       json
     end
+
+    def as_partial_update_document
+      json = {}
+
+      mappings = elastic_index.mapping[:properties]
+      changed.each do |field|
+        if field_mapping = mappings[field]
+          json[field] = elastic_search_value field, field_mapping
+        end
+      end
+
+      amend_partial_update_document(json) if respond_to?(:partial_update_document)
+
+      json
+    end
+
+    def elastic_search_value(field, mapping)
+      value = try field
+      return if value.nil?
+
+      value = case mapping[:type]
+        when :object
+          value.as_search
+        when :nested
+          value.map(&:as_search)
+        else
+          value
+        end
+
+      if value.present? || value == false
+        value
+      end
+
+    rescue
+      raise "Field not found for #{field.inspect}"
+    end
   end
 end

data/lib/elastic_record/config.rb

@@ -29,27 +29,7 @@ module ElasticRecord
 
       def settings=(settings)
         self.servers = settings['servers']
-
-        if settings['options']
-          warn("**************************************",
-            "elasticsearch.yml/:options is deprecated. For example, the following:",
-            "development:",
-            "  servers: 127.0.0.1:9200",
-            "  options:",
-            "    timeout: 10",
-            "    retries: 2",
-            "",
-            "becomes:",
-            "",
-            "development:",
-            "  servers: 127.0.0.1:9200",
-            "  timeout: 10",
-            "  retries: 2",
-            "**************************************")
-          self.connection_options = settings['options']
-        else
-          self.connection_options = settings
-        end
+        self.connection_options = settings
 
         if scroll_keep_alive = settings['scroll_keep_alive'].presence
           self.scroll_keep_alive = scroll_keep_alive

data/lib/elastic_record/connection.rb

@@ -9,15 +9,16 @@ module ElasticRecord
     def initialize(servers, options = {})
       self.servers = Array(servers)
 
+      @shuffled_servers       = nil
       self.current_server     = next_server
       self.request_count      = 0
       self.max_request_count  = 100
       self.options            = options.symbolize_keys
-      self.bulk_stack        = []
+      self.bulk_stack         = []
     end
 
     def head(path)
-      http_request(:head, path).code
+      http_request_with_retry(:head, path).code
     end
 
     def json_get(path, json = nil)
@@ -37,25 +38,33 @@ module ElasticRecord
     end
 
     def json_request(method, path, json)
-      body = json.is_a?(Hash) ? ActiveSupport::JSON.encode(json) : json
-      response = http_request(method, path, body)
+      body = json.is_a?(Hash) ? ElasticRecord::JSON.encode(json) : json
+      response = http_request_with_retry(method, path, body)
 
-      json = ActiveSupport::JSON.decode response.body
-      raise ConnectionError.new(json['error']) if json['error']
+      json = ElasticRecord::JSON.decode(response.body)
+      raise ConnectionError.new(response.code, json['error']) if json['error']
 
       json
     end
 
-    def http_request(method, path, body = nil)
+    def http_request_with_retry(*args)
       with_retry do
-        request = new_request(method, path, body)
-        http = new_http
+        response = http_request(*args)
 
-        ActiveSupport::Notifications.instrument("request.elastic_record") do |payload|
-          payload[:http]      = http
-          payload[:request]   = request
-          payload[:response]  = http.request(request)
-        end
+        raise ConnectionError.new(response.code, response.body) if response.code.to_i >= 500
+
+        response
+      end
+    end
+
+    def http_request(method, path, body = nil)
+      request = new_request(method, path, 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
 
@@ -70,6 +79,7 @@ module ElasticRecord
       request = METHODS[method].new(path)
       request.basic_auth(options[:username], options[:password]) if options[:username].present?
       request.body = body
+      request.content_type = 'application/json'
       request
     end