elastic_record 0.4.1 → 0.5.0

data/elastic_record.gemspec

@@ -2,7 +2,7 @@
  
 Gem::Specification.new do |s|
   s.name = 'elastic_record'
-  s.version = '0.4.1'
+  s.version = '0.5.0'
   s.summary = 'Use Elastic Search with your objects'
   s.description = 'Find your records with elastic search'
 

data/lib/elastic_record.rb

@@ -1,5 +1,7 @@
 require 'arelastic'
 require 'rubberband'
+require 'active_support/core_ext/object/blank' # required because ActiveModel depends on this but does not require it
+require 'active_model'
 
 module ElasticRecord
   autoload :Callbacks, 'elastic_record/callbacks'

data/lib/elastic_record/index.rb

@@ -1,12 +1,15 @@
 require 'elastic_record/index/documents'
 require 'elastic_record/index/manage'
 require 'elastic_record/index/mapping'
+require 'elastic_record/index/percolator'
+require 'net/http'
 
 module ElasticRecord
   class Index
     include Documents
     include Manage
     include Mapping
+    include Percolator
 
     attr_accessor :model
     attr_accessor :disabled
@@ -32,25 +35,46 @@ module ElasticRecord
       @disabled = false
     end
 
-    private
+    # private
       def new_index_name
         "#{alias_name}_#{Time.now.to_i}"
       end
 
-      def json_get(path)
-        ActiveSupport::JSON.decode http.get(path).body
+      def head(path)
+        http_request(Net::HTTP::Head, path).code
       end
 
-      def json_post(path, json)
-        http.post(path, ActiveSupport::JSON.encode(json))
+      def json_get(path, json = nil)
+        json_request Net::HTTP::Get, path, json
       end
 
-      def json_put(path, json)
-        http.put(path, ActiveSupport::JSON.encode(json))
+      def json_post(path, json = nil)
+        json_request Net::HTTP::Post, path, json
       end
 
-      def json_delete(path)
-        ActiveSupport::JSON.decode http.delete(path).body
+      def json_put(path, json = nil)
+        json_request Net::HTTP::Put, path, json
+      end
+
+      def json_delete(path, json = nil)
+        json_request Net::HTTP::Delete, path, json
+      end
+
+      def json_request(request_klass, path, json)
+        body = json ? ActiveSupport::JSON.encode(json) : nil
+        response = http_request(request_klass, path, body)
+        json = ActiveSupport::JSON.decode response.body
+
+        raise json['error'] if json['error']
+
+        json
+      end
+
+      def http_request(request_klass, path, body = nil)
+        request = request_klass.new(path)
+        request.body = body
+
+        http.request(request)
       end
 
       def connection

data/lib/elastic_record/index/manage.rb

@@ -8,13 +8,13 @@ module ElasticRecord
       end
 
       def create(index_name = new_index_name)
-        http.put("/#{index_name}", '')
+        json_put "/#{index_name}"
         update_mapping(index_name)
         index_name
       end
 
       def delete(index_name)
-        http.delete("/#{index_name}")
+        json_delete "/#{index_name}"
       end
 
       def delete_all
@@ -24,7 +24,7 @@ module ElasticRecord
       end
 
       def exists?(index_name)
-        http.head("/#{index_name}").code == '200'
+        head("/#{index_name}") == '200'
       end
 
       def deploy(index_name)
@@ -50,7 +50,6 @@ module ElasticRecord
       end
 
       def update_mapping(index_name)
-        # connection.update_mapping(mapping, index: index_name)
         json_put "/#{index_name}/#{type}/_mapping", type => mapping
       end
 

data/lib/elastic_record/index/percolator.rb

@@ -0,0 +1,31 @@
+module ElasticRecord
+  class Index
+    module Percolator
+      def create_percolator(name, elastic_query)
+        unless exists? percolator_index_name
+          create percolator_index_name
+        else
+          update_mapping percolator_index_name
+        end
+
+        json_put "/_percolator/#{percolator_index_name}/#{name}", elastic_query
+      end
+
+      def delete_percolator(name)
+        json_delete "/_percolator/#{percolator_index_name}/#{name}"
+      end
+
+      def percolator_exists?(name)
+        json_get("/_percolator/#{percolator_index_name}/#{name}")['exists']
+      end
+
+      def percolate(document)
+        json_get("/#{percolator_index_name}/#{type}/_percolate", 'doc' => document)['matches']
+      end
+
+      def percolator_index_name
+        @percolator_index_name ||= "percolate_#{alias_name}"
+      end
+    end
+  end
+end

data/lib/elastic_record/relation.rb

@@ -25,6 +25,10 @@ module ElasticRecord
       to_hits.facets
     end
 
+    def create_percolator(name)
+      klass.elastic_index.create_percolator(name, as_elastic)
+    end
+
     def reset
       @hits = @records = nil
     end

data/lib/elastic_record/relation/batches.rb

@@ -1,26 +1,28 @@
 module ElasticRecord
-  module Batches
-    def find_each
-      find_in_batches do |records|
-        records.each { |record| yield record }
+  class Relation
+    module Batches
+      def find_each
+        find_in_batches do |records|
+          records.each { |record| yield record }
+        end
       end
-    end
 
-    def find_in_batches(options = {})
-      options[:size] ||= 100
-      options[:scroll]  ||= '20m'
-      options[:search_type] = 'scan'
+      def find_in_batches(options = {})
+        options[:size] ||= 100
+        options[:scroll]  ||= '20m'
+        options[:search_type] = 'scan'
 
-      hits = klass.elastic_connection.search(as_elastic, options)
+        hits = klass.elastic_connection.search(as_elastic, options)
 
-      klass.elastic_connection.scroll(hits.scroll_id, scroll: options[:scroll], ids_only: true) do |hits|
-        yield klass.find(hits.to_a)
+        klass.elastic_connection.scroll(hits.scroll_id, scroll: options[:scroll], ids_only: true) do |hits|
+          yield klass.find(hits.to_a)
+        end
       end
-    end
 
-    def reindex
-      relation.find_in_batches do |batch|
-        elastic_index.bulk_add(batch)
+      def reindex
+        relation.find_in_batches do |batch|
+          elastic_index.bulk_add(batch)
+        end
       end
     end
   end

data/lib/elastic_record/relation/delegation.rb

@@ -1,22 +1,24 @@
 module ElasticRecord
-  module Delegation
-    def to_ary
-      to_a.to_ary
-    end
+  class Relation
+    module Delegation
+      def to_ary
+        to_a.to_ary
+      end
 
-    def include?(obj)
-      to_a.include?(obj)
-    end
+      def include?(obj)
+        to_a.include?(obj)
+      end
 
-    private
-      def method_missing(method, *args, &block)
-        if klass.respond_to?(method)
-          scoping { klass.send(method, *args, &block) }
-        elsif Array.method_defined?(method)
-          to_a.send(method, *args, &block)
-        else
-          super
+      private
+        def method_missing(method, *args, &block)
+          if klass.respond_to?(method)
+            scoping { klass.send(method, *args, &block) }
+          elsif Array.method_defined?(method)
+            to_a.send(method, *args, &block)
+          else
+            super
+          end
         end
-      end
+    end
   end
 end

data/lib/elastic_record/relation/finder_methods.rb

@@ -1,25 +1,27 @@
 module ElasticRecord
-  module FinderMethods
-    def find(id)
-      filter(arelastic.filter.ids(id)).to_a.first
-    end
+  class Relation
+    module FinderMethods
+      def find(id)
+        filter(arelastic.filter.ids(id)).to_a.first
+      end
 
-    def first
-      find_one order('_uid')
-    end
+      def first
+        find_one order('_uid')
+      end
 
-    def last
-      find_one order('color' => 'reverse')
-    end
+      def last
+        find_one order('color' => 'reverse')
+      end
 
-    def all
-      to_a
-    end
+      def all
+        to_a
+      end
 
-    private
+      private
 
-    def find_one(relation)
-      relation.limit(1).to_a.first
+      def find_one(relation)
+        relation.limit(1).to_a.first
+      end
     end
   end
 end

data/lib/elastic_record/relation/merging.rb

@@ -1,34 +1,36 @@
 module ElasticRecord
-  module Merging
-    def merge!(other)
-      Merger.new(self, other).merge
-    end
-
-    def merge(other)
-      clone.merge!(other)
-    end
+  class Relation
+    module Merging
+      def merge!(other)
+        Merger.new(self, other).merge
+      end
 
-    private
-      class Merger
-        attr_accessor :relation, :values
+      def merge(other)
+        clone.merge!(other)
+      end
 
-        def initialize(relation, other)
-          @relation = relation
-          @values = other.values
-        end
+      private
+        class Merger
+          attr_accessor :relation, :values
 
-        def normal_values
-          Relation::MULTI_VALUE_METHODS + Relation::SINGLE_VALUE_METHODS
-        end
+          def initialize(relation, other)
+            @relation = relation
+            @values = other.values
+          end
 
-        def merge
-          normal_values.each do |name|
-            value = values[name]
-            relation.send("#{name}!", value) unless value.blank?
+          def normal_values
+            Relation::MULTI_VALUE_METHODS + Relation::SINGLE_VALUE_METHODS
           end
 
-          relation
+          def merge
+            normal_values.each do |name|
+              value = values[name]
+              relation.send("#{name}!", value) unless value.blank?
+            end
+
+            relation
+          end
         end
-      end
+    end
   end
 end

data/lib/elastic_record/relation/search_methods.rb

@@ -1,213 +1,215 @@
 module ElasticRecord
-  module SearchMethods
-    Relation::MULTI_VALUE_METHODS.each do |name|
-      class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{name}_values                   # def filter_values
-          @values[:#{name}] || []            #   @values[:filter] || []
-        end                                  # end
-                                             #
-        def #{name}_values=(values)          # def filter_values=(values)
-          @values[:#{name}] = values         #   @values[:filter] = values
-        end                                  # end
-      CODE
-    end
+  class Relation
+    module SearchMethods
+      Relation::MULTI_VALUE_METHODS.each do |name|
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}_values                   # def filter_values
+            @values[:#{name}] || []            #   @values[:filter] || []
+          end                                  # end
+                                               #
+          def #{name}_values=(values)          # def filter_values=(values)
+            @values[:#{name}] = values         #   @values[:filter] = values
+          end                                  # end
+        CODE
+      end
 
-    Relation::SINGLE_VALUE_METHODS.each do |name|
-      class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{name}_value                    # def offset_value
-          @values[:#{name}]                  #   @values[:offset]
-        end                                  # end
+      Relation::SINGLE_VALUE_METHODS.each do |name|
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}_value                    # def offset_value
+            @values[:#{name}]                  #   @values[:offset]
+          end                                  # end
 
-        def #{name}_value=(value)            # def offset_value=(value)
-          @values[:#{name}] = value          #   @values[:offset] = value
-        end                                  # end
-      CODE
-    end
+          def #{name}_value=(value)            # def offset_value=(value)
+            @values[:#{name}] = value          #   @values[:offset] = value
+          end                                  # end
+        CODE
+      end
     
-    def query!(value)
-      self.query_value = value
-      self
-    end
-
-    def query(value)
-      clone.query! value
-    end
+      def query!(value)
+        self.query_value = value
+        self
+      end
 
-    def filter!(*args)
-      self.filter_values += args.flatten
-      self
-    end
+      def query(value)
+        clone.query! value
+      end
 
-    def filter(*args)
-      clone.filter!(*args)
-    end
+      def filter!(*args)
+        self.filter_values += args.flatten
+        self
+      end
 
-    def limit!(value)
-      self.limit_value = value
-      self
-    end
+      def filter(*args)
+        clone.filter!(*args)
+      end
 
-    def limit(value)
-      clone.limit!(value)
-    end
+      def limit!(value)
+        self.limit_value = value
+        self
+      end
 
-    def offset!(value)
-      self.offset_value = value
-      self
-    end
+      def limit(value)
+        clone.limit!(value)
+      end
 
-    def offset(value)
-      clone.offset! value
-    end
+      def offset!(value)
+        self.offset_value = value
+        self
+      end
 
-    def select!(*args)
-      self.select_values += args.flatten
-      self
-    end
+      def offset(value)
+        clone.offset! value
+      end
 
-    def select(*args, &block)
-      if block_given?
-        to_a.select(&block)
-      else
-        clone.select! *args
+      def select!(*args)
+        self.select_values += args.flatten
+        self
       end
-    end
 
-    def facet!(name_or_facet, options = {})
-      if name_or_facet.is_a?(String)
-        self.facet_values += [arelastic.facet[name_or_facet].terms(name_or_facet, options)]
-      else
-        self.facet_values += [name_or_facet]
+      def select(*args, &block)
+        if block_given?
+          to_a.select(&block)
+        else
+          clone.select! *args
+        end
       end
 
-      self
-    end
+      def facet!(name_or_facet, options = {})
+        if name_or_facet.is_a?(String)
+          self.facet_values += [arelastic.facet[name_or_facet].terms(name_or_facet, options)]
+        else
+          self.facet_values += [name_or_facet]
+        end
 
-    def facet(facet_or_name, options = {})
-      clone.facet! facet_or_name, options = {}
-    end
+        self
+      end
 
-    def order!(*args)
-      self.order_values += args.flatten
-      self
-    end
+      def facet(facet_or_name, options = {})
+        clone.facet! facet_or_name, options = {}
+      end
 
-    def order(*args)
-      clone.order! *args
-    end
+      def order!(*args)
+        self.order_values += args.flatten
+        self
+      end
 
-    def extending!(*modules, &block)
-      modules << Module.new(&block) if block_given?
+      def order(*args)
+        clone.order! *args
+      end
 
-      self.extending_values += modules.flatten
-      extend(*extending_values)
+      def extending!(*modules, &block)
+        modules << Module.new(&block) if block_given?
 
-      self
-    end
+        self.extending_values += modules.flatten
+        extend(*extending_values)
 
-    def extending(*modules, &block)
-      clone.extending!(*modules, &block)
-    end
+        self
+      end
 
-    def as_elastic
-      build_search.as_elastic
-    end
+      def extending(*modules, &block)
+        clone.extending!(*modules, &block)
+      end
 
-    private
-      def build_search
-        searches = [
-          build_query_and_filter(query_value, filter_values),
-          build_limit(limit_value),
-          build_offset(offset_value),
-          build_facets(facet_values),
-          build_orders(order_values)
-        ].compact
-
-        Arelastic::Nodes::HashGroup.new searches
-      end
-
-      def build_query_and_filter(query, filters)
-        query = build_query(query)
-        filter = build_filter(filters)
-        if query && filter
-          arelastic.query.filtered(query, filter)
-        elsif query
-          query
-        elsif filter
-          arelastic.query.constant_score(filter)
-        else
-          arelastic.query.match_all
-        end
+      def as_elastic
+        build_search.as_elastic
       end
 
-      def build_query(query)
-        if query.is_a?(String)
-          query = Arelastic::Queries::QueryString.new query
+      private
+        def build_search
+          searches = [
+            build_query_and_filter(query_value, filter_values),
+            build_limit(limit_value),
+            build_offset(offset_value),
+            build_facets(facet_values),
+            build_orders(order_values)
+          ].compact
+
+          Arelastic::Nodes::HashGroup.new searches
         end
 
-        if query
-          Arelastic::Searches::Query.new query
+        def build_query_and_filter(query, filters)
+          query = build_query(query)
+          filter = build_filter(filters)
+          if query && filter
+            arelastic.query.filtered(query, filter)
+          elsif query
+            query
+          elsif filter
+            arelastic.query.constant_score(filter)
+          else
+            arelastic.query.match_all
+          end
         end
-      end
 
-      def build_filter(filters)
-        nodes = []
+        def build_query(query)
+          if query.is_a?(String)
+            query = Arelastic::Queries::QueryString.new query
+          end
 
-        filters.map do |filter|
-          if filter.is_a?(Arelastic::Filters::Filter)
-            nodes << filter
-          else
-            filter.each do |field, terms|
-              case terms
-              when Array, Range
-                nodes << arelastic[field].in(terms)
-              when Hash
-                nodes << {field => terms}
-              else
-                nodes << arelastic[field].eq(terms)
+          if query
+            Arelastic::Searches::Query.new query
+          end
+        end
+
+        def build_filter(filters)
+          nodes = []
+
+          filters.map do |filter|
+            if filter.is_a?(Arelastic::Filters::Filter)
+              nodes << filter
+            else
+              filter.each do |field, terms|
+                case terms
+                when Array, Range
+                  nodes << arelastic[field].in(terms)
+                when Hash
+                  nodes << {field => terms}
+                else
+                  nodes << arelastic[field].eq(terms)
+                end
               end
             end
           end
-        end
 
-        if nodes.size == 1
-          Arelastic::Searches::Filter.new nodes.first
-        elsif nodes.size > 1
-          Arelastic::Searches::Filter.new Arelastic::Filters::And.new(nodes)
+          if nodes.size == 1
+            Arelastic::Searches::Filter.new nodes.first
+          elsif nodes.size > 1
+            Arelastic::Searches::Filter.new Arelastic::Filters::And.new(nodes)
+          end
         end
-      end
 
-      # def normalize_value(value)
-      #   case value
-      #   when true
-      #     "T"
-      #   when false
-      #     "F"
-      #   when Time
-      #     value.iso8601
-      #   else
-      #     value
-      #   end
-      # end
-
-      def build_limit(limit)
-        if limit
-          Arelastic::Searches::Size.new(limit)
+        # def normalize_value(value)
+        #   case value
+        #   when true
+        #     "T"
+        #   when false
+        #     "F"
+        #   when Time
+        #     value.iso8601
+        #   else
+        #     value
+        #   end
+        # end
+
+        def build_limit(limit)
+          if limit
+            Arelastic::Searches::Size.new(limit)
+          end
         end
-      end
 
-      def build_offset(offset)
-        if offset
-          Arelastic::Searches::From.new(offset)
+        def build_offset(offset)
+          if offset
+            Arelastic::Searches::From.new(offset)
+          end
         end
-      end
 
-      def build_facets(facets)
-        Arelastic::Searches::Facets.new(facets) unless facets.empty?
-      end
+        def build_facets(facets)
+          Arelastic::Searches::Facets.new(facets) unless facets.empty?
+        end
 
-      def build_orders(orders)
-        Arelastic::Searches::Sort.new(orders) unless orders.empty?
-      end
+        def build_orders(orders)
+          Arelastic::Searches::Sort.new(orders) unless orders.empty?
+        end
+    end
   end
 end

data/test/elastic_record/index/percolator_test.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+class ElasticRecord::Index::PercolatorTest < MiniTest::Spec
+  def test_create_percolator
+    index.delete(index.percolator_index_name) if index.exists?(index.percolator_index_name)
+
+    index.create_percolator('green', 'color' => 'green')
+
+    assert index.exists?(index.percolator_index_name)
+    assert index.percolator_exists?('green')
+    refute index.percolator_exists?('blue')
+  end
+
+  def test_percolator_index_name
+    assert_equal 'percolate_widgets', index.percolator_index_name
+  end
+
+  private
+    def index
+      Widget.elastic_index
+    end
+end

data/test/elastic_record/relation_test.rb

@@ -3,7 +3,28 @@ require 'helper'
 class ElasticRecord::RelationTest < MiniTest::Spec
   def setup
     Widget.elastic_index.reset
+  end
+
+  def test_count
     create_widgets
+
+    assert_equal 2, Widget.elastic_relation.count
+  end
+
+  def test_facets
+    create_widgets
+
+    facets = Widget.elastic_relation.facet(Widget.arelastic.facet['popular_colors'].terms('color')).facets
+
+    assert_equal 2, facets['popular_colors']['total']
+  end
+
+  def test_percolate
+    Widget.elastic_relation.filter(color: 'green').create_percolator('green')
+    Widget.elastic_relation.filter(color: 'blue').create_percolator('blue')
+    widget = Widget.new(color: 'green')
+
+    assert_equal ['green'], Widget.elastic_index.percolate(widget.as_search)
   end
 
   def test_to_hits
@@ -11,27 +32,21 @@ class ElasticRecord::RelationTest < MiniTest::Spec
   end
 
   def test_to_ids
+    create_widgets
     assert_equal ['5', '10'], Widget.elastic_relation.to_ids
   end
 
   def test_to_a
+    create_widgets
     array = Widget.elastic_relation.to_a
 
     assert_equal 2, array.size
     assert array.first.is_a?(Widget)
   end
 
-  def test_count
-    assert_equal 2, Widget.elastic_relation.count
-  end
-
-  def test_facets
-    facets = Widget.elastic_relation.facet(Widget.arelastic.facet['popular_colors'].terms('color')).facets
-
-    assert_equal 2, facets['popular_colors']['total']
-  end
-
   def test_equal
+    create_widgets
+
     assert(Widget.elastic_relation.filter(color: 'green') == Widget.elastic_relation.filter(color: 'green'))
     assert(Widget.elastic_relation.filter(color: 'green') != Widget.elastic_relation.filter(color: 'blue'))
 

data/test/helper.rb

@@ -3,9 +3,6 @@ Bundler.require
 
 require 'minitest/autorun'
 
-require 'active_support/core_ext/object/blank'
-require 'active_model'
-
 require 'support/widget'
 require 'support/connect'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elastic_record
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-05 00:00:00.000000000 Z
+date: 2012-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: arelastic
@@ -80,6 +80,7 @@ files:
 - lib/elastic_record/index/documents.rb
 - lib/elastic_record/index/manage.rb
 - lib/elastic_record/index/mapping.rb
+- lib/elastic_record/index/percolator.rb
 - lib/elastic_record/model.rb
 - lib/elastic_record/orm/active_record.rb
 - lib/elastic_record/railtie.rb
@@ -98,6 +99,7 @@ files:
 - test/elastic_record/index/documents_test.rb
 - test/elastic_record/index/manage_test.rb
 - test/elastic_record/index/mapping_test.rb
+- test/elastic_record/index/percolator_test.rb
 - test/elastic_record/index_test.rb
 - test/elastic_record/model_test.rb
 - test/elastic_record/relation/batches_test.rb