tire 0.5.8 → 0.6.0

data/README.markdown

@@ -471,6 +471,10 @@ In this case, just wrap the `mapping` method in a `settings` one, passing it the
     end
 ```
 
+Note, that the index will be created with settings and mappings only when it doesn't exist yet.
+To re-create the index with correct configuration, delete it first: `URL.index.delete` and
+create it afterwards: `URL.create_elasticsearch_index`.
+
 It may well be reasonable to wrap the index creation logic declared with `Tire.index('urls').create`
 in a class method of your model, in a module method, etc, to have better control on index creation when
 bootstrapping the application with Rake tasks or when setting up the test suite.
@@ -573,6 +577,24 @@ control on how the documents are added to or removed from the index:
     end
 ```
 
+Sometimes, you might want to have complete control about the indexing process. In such situations,
+just drop down one layer and use the `Tire::Index#store` and `Tire::Index#remove` methods directly:
+
+```ruby
+    class Article < ActiveRecord::Base
+      acts_as_paranoid
+      include Tire::Model::Search
+
+      after_save do
+        if deleted_at.nil?
+          self.index.store self
+        else
+          self.index.remove self
+        end
+      end
+    end
+```
+
 When you're integrating _Tire_ with ActiveRecord models, you should use the `after_commit`
 and `after_rollback` hooks to keep the index in sync with your database.
 
@@ -662,11 +684,11 @@ Are we saying you have to fiddle with this thing in a `rails console` or silly R
 Just call the included _Rake_ task on the command line:
 
 ```bash
-    $ rake environment tire:import CLASS='Article'
+    $ rake environment tire:import:all
 ```
 
-You can also force-import the data by deleting the index first (and creating it with mapping
-provided by the `mapping` block in your model):
+You can also force-import the data by deleting the index first (and creating it with
+correct settings and/or mappings provided by the `mapping` block in your model):
 
 ```bash
     $ rake environment tire:import CLASS='Article' FORCE=true

data/lib/tire.rb

@@ -23,6 +23,7 @@ require 'tire/http/client'
 require 'tire/search'
 require 'tire/search/query'
 require 'tire/search/queries/match'
+require 'tire/search/queries/custom_filters_score'
 require 'tire/search/sort'
 require 'tire/search/facet'
 require 'tire/search/filter'

data/lib/tire/dsl.rb

@@ -5,26 +5,35 @@ module Tire
       Configuration.class_eval(&block)
     end
 
-    def search(indices=nil, payload={}, &block)
+    def search(indices=nil, params={}, &block)
       if block_given?
-        Search::Search.new(indices, payload, &block)
+        Search::Search.new(indices, params, &block)
       else
-        raise ArgumentError, "Please pass a Ruby Hash or an object with `to_hash` method, not #{payload.class}" \
-              unless payload.respond_to?(:to_hash)
+        raise ArgumentError, "Please pass a Ruby Hash or an object with `to_hash` method, not #{params.class}" \
+              unless params.respond_to?(:to_hash)
+
+       params = params.to_hash
+
+       if payload = params.delete(:payload)
+          options = params
+        else
+          payload = params
+        end
 
         # Extract URL parameters from payload
         #
         search_params = %w| search_type routing scroll from size timeout |
 
-        options = search_params.inject({}) do |sum,item|
+        search_options = search_params.inject({}) do |sum,item|
           if param = (payload.delete(item) || payload.delete(item.to_sym))
             sum[item.to_sym] = param
           end
           sum
         end
 
-        options.update(:payload => payload) unless payload.empty?
-        Search::Search.new(indices, options)
+        search_options.update(options) if options && !options.empty?
+        search_options.update(:payload => payload) unless payload.empty?
+        Search::Search.new(indices, search_options)
       end
     end
 

data/lib/tire/http/client.rb

@@ -47,6 +47,10 @@ module Tire
           Response.new e.http_body, e.http_code
         end
 
+        def self.__host_unreachable_exceptions
+          [Errno::ECONNREFUSED, ::RestClient::ServerBrokeConnection, ::RestClient::RequestTimeout]
+        end
+
         private
 
         def self.perform(response)

data/lib/tire/http/clients/curb.rb

@@ -56,6 +56,10 @@ module Tire
           Response.new client.body_str, client.response_code
         end
 
+        def self.__host_unreachable_exceptions
+          [::Curl::Err::HostResolutionError, ::Curl::Err::ConnectionFailedError]
+        end
+
       end
 
     end

data/lib/tire/http/clients/faraday.rb

@@ -13,14 +13,14 @@ require 'faraday'
 #     require 'tire/http/clients/faraday'
 #
 #     Tire.configure do |config|
-#     
+#
 #       # Unless specified, tire will use Faraday.default_adapter and no middleware
 #       Tire::HTTP::Client::Faraday.faraday_middleware = Proc.new do |builder|
 #         builder.adapter :typhoeus
 #       end
-#     
+#
 #       config.client(Tire::HTTP::Client::Faraday)
-#     
+#
 #     end
 #
 #
@@ -58,6 +58,10 @@ module Tire
             request(:head, url)
           end
 
+          def __host_unreachable_exceptions
+            [::Faraday::Error::ConnectionFailed, ::Faraday::Error::TimeoutError]
+          end
+
           private
           def request(method, url, data = nil)
             conn = ::Faraday.new( &(faraday_middleware || DEFAULT_MIDDLEWARE) )

data/lib/tire/index.rb

@@ -1,6 +1,8 @@
 module Tire
   class Index
 
+    SUPPORTED_META_PARAMS_FOR_BULK = [:_routing, :_ttl, :_version, :_version_type, :_percolate, :_parent, :_timestamp]
+
     attr_reader :name, :response
 
     def initialize(name, &block)
@@ -135,6 +137,7 @@ module Tire
       params[:parent]  = options[:parent]  if options[:parent]
       params[:routing] = options[:routing] if options[:routing]
       params[:replication] = options[:replication] if options[:replication]
+      params[:version] = options[:version] if options[:version]
 
       params_encoded = params.empty? ? '' : "?#{params.to_param}"
 
@@ -180,15 +183,24 @@ module Tire
 
         header = { action.to_sym => { :_index => name, :_type => type, :_id => id } }
 
-        if document.respond_to?(:to_hash) && hash = document.to_hash
-          meta = {}
-          meta[:_version]   = hash.delete(:_version)
-          meta[:_routing]   = hash.delete(:_routing)
-          meta[:_percolate] = hash.delete(:_percolate)
-          meta[:_parent]    = hash.delete(:_parent)
-          meta[:_timestamp] = hash.delete(:_timestamp)
-          meta[:_ttl]       = hash.delete(:_ttl)
-          meta              = meta.reject { |name,value| !value || value.empty? }
+        if document.respond_to?(:to_hash) && doc_hash = document.to_hash
+          meta = doc_hash.select do |k,v|
+            [ :_parent,
+              :_percolate,
+              :_routing,
+              :_timestamp,
+              :_ttl,
+              :_version,
+              :_version_type].include?(k)
+          end
+          # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
+          meta = Hash[meta] unless meta.is_a?(Hash)
+
+          # meta = SUPPORTED_META_PARAMS_FOR_BULK.inject({}) { |hash, param|
+          #   value = doc_hash.delete(param)
+          #   hash[param] = value unless !value || value.empty?
+          #   hash
+          # }
           header[action.to_sym].update(meta)
         end
 
@@ -223,7 +235,8 @@ module Tire
         end
 
       ensure
-        curl = %Q|curl -X POST "#{url}/_bulk" --data-binary '{... data omitted ...}'|
+        data = Configuration.logger && Configuration.logger.level.to_s == 'verbose' ? payload.join("\n") : '... data omitted ...'
+        curl = %Q|curl -X POST "#{url}/_bulk" --data-binary '#{data}'|
         logged('_bulk', curl)
       end
 

data/lib/tire/model/import.rb

@@ -8,6 +8,8 @@ module Tire
     # Two dedicated strategies for popular pagination libraries are also provided: WillPaginate and Kaminari.
     # These could be used in situations where your model is neither ActiveRecord nor Mongoid based.
     #
+    # You can implement your own custom strategy and pass it via the `:strategy` option.
+    #
     # Note, that it's always possible to use the `Tire::Index#import` method directly.
     #
     # @note See `Tire::Import::Strategy`.
@@ -22,10 +24,12 @@ module Tire
       end
 
       # Importing strategies for common persistence frameworks (ActiveModel, Mongoid), as well as
-      # pagination libraries (WillPaginate, Kaminari).
+      # pagination libraries (WillPaginate, Kaminari), or a custom strategy.
       #
       module Strategy
         def self.from_class(klass, options={})
+          return const_get(options[:strategy]).new(klass, options) if options[:strategy]
+
           case
           when defined?(::ActiveRecord) && klass.ancestors.include?(::ActiveRecord::Base)
             ActiveRecord.new klass, options
@@ -62,10 +66,15 @@ module Tire
         class Mongoid
           include Base
           def import &block
-            0.step(klass.count, options[:per_page]) do |offset|
-              items = klass.limit(options[:per_page]).skip(offset)
-              index.import items.to_a, options, &block
+            items = []
+            klass.all.each do |item|
+              items << item
+              if items.length % options[:per_page] == 0
+                index.import items, options, &block
+                items = []
+              end
             end
+            index.import items, options, &block unless items.empty?
             self
           end
         end

data/lib/tire/model/indexing.rb

@@ -112,7 +112,8 @@ module Tire
               result
             end
           end
-        rescue Errno::ECONNREFUSED => e
+
+        rescue *Tire::Configuration.client.__host_unreachable_exceptions => e
           STDERR.puts "Skipping index creation, cannot connect to Elasticsearch",
                       "(The original exception was: #{e.inspect})"
           false

data/lib/tire/results/collection.rb

@@ -58,7 +58,7 @@ module Tire
       alias :[] :slice
 
       def to_ary
-        self
+        results
       end
 
       def as_json(options=nil)
@@ -106,12 +106,17 @@ module Tire
           hits.map do |h|
             document = {}
 
-            # Update the document with content and ID
-            document = h['_source'] ? document.update( h['_source'] || {} ) : document.update( __parse_fields__(h['fields']) )
-            document.update( {'id' => h['_id']} )
+            # Update the document with fields and/or source
+            document.update h['_source'] if h['_source']
+            document.update __parse_fields__(h['fields']) if h['fields']
+
+            # Set document ID
+            document['id'] = h['_id']
 
             # Update the document with meta information
-            ['_score', '_type', '_index', '_version', 'sort', 'highlight', '_explanation'].each { |key| document.update( {key => h[key]} || {} ) }
+            ['_score', '_type', '_index', '_version', 'sort', 'highlight', '_explanation'].each do |key|
+              document.update key => h[key]
+            end
 
             # Return an instance of the "wrapper" class
             @wrapper.new(document)

data/lib/tire/results/item.rb

@@ -34,6 +34,9 @@ module Tire
         @attributes[key.to_sym]
       end
 
+      alias :read_attribute_for_serialization :[]
+
+
       def id
         @attributes[:_id]   || @attributes[:id]
       end

data/lib/tire/search/facet.rb

@@ -1,11 +1,6 @@
 module Tire
   module Search
 
-    #--
-    # TODO: Implement all elastic search facets (geo, histogram, range, etc)
-    # http://elasticsearch.org/guide/reference/api/search/facets/
-    #++
-
     class Facet
 
       def initialize(name, options={}, &block)
@@ -48,6 +43,11 @@ module Tire
         self
       end
 
+      def geo_distance(field, point, ranges=[], options={})
+        @value[:geo_distance] = { field => point, :ranges => ranges }.update(options)
+        self
+      end
+
       def terms_stats(key_field, value_field, options={})
         @value[:terms_stats] = {:key_field => key_field, :value_field => value_field}.update(options)
         self

data/lib/tire/search/queries/custom_filters_score.rb

@@ -0,0 +1,128 @@
+module Tire
+  module Search
+
+    # Custom Filters Score
+    # ==============
+    #
+    # Author: Jerry Luk <jerryluk@gmail.com>
+    #
+    #
+    # Adds support for "custom_filters_score" queries in Tire DSL.
+    #
+    # It hooks into the Query class and inserts the custom_filters_score query types.
+    #
+    #
+    # Usage:
+    # ------
+    #
+    # Require the component:
+    #
+    #     require 'tire/queries/custom_filters_score'
+    #
+    # Example:
+    # -------
+    #
+    #     Tire.search 'articles' do
+    #       query do
+    #         custom_filters_score do
+    #           query { term :title, 'Harry Potter' }
+    #           filter do
+    #             filter :match_all
+    #             boost 1.1
+    #           end
+    #           filter do
+    #             filter :term, :author => 'Rowling',
+    #             script '2.0'
+    #           end
+    #           score_mode 'total'
+    #         end
+    #       end
+    #     end
+    #
+    # For available options for these queries see:
+    #
+    # * <http://www.elasticsearch.org/guide/reference/query-dsl/custom-filters-score-query.html>
+    #
+    #
+    class Query
+
+      def custom_filters_score(&block)
+        @custom_filters_score = CustomFiltersScoreQuery.new
+        block.arity < 1 ? @custom_filters_score.instance_eval(&block) : block.call(@custom_filters_score) if
+          block_given?
+        @value[:custom_filters_score] = @custom_filters_score.to_hash
+        @value
+      end
+
+      class CustomFiltersScoreQuery
+        class CustomFilter
+          def initialize(&block)
+            @value = {}
+            block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+          end
+
+          def filter(type, *options)
+            @value[:filter] = Filter.new(type, *options).to_hash
+            @value
+          end
+
+          def boost(value)
+            @value[:boost] = value
+            @value
+          end
+
+          def script(value)
+            @value[:script] = value
+            @value
+          end
+
+          def to_hash
+            @value
+          end
+
+          def to_json
+            to_hash.to_json
+          end
+        end
+
+        def initialize(&block)
+          @value = {}
+          block.arity < 1 ? self.instance_eval(&block) : block.call(self) if block_given?
+        end
+
+        def query(options={}, &block)
+          @value[:query] = Query.new(&block).to_hash
+          @value
+        end
+
+        def filter(&block)
+          custom_filter = CustomFilter.new
+          block.arity < 1 ? custom_filter.instance_eval(&block) : block.call(custom_filter) if block_given?
+          @value[:filters] ||= []
+          @value[:filters] << custom_filter.to_hash
+          @value
+        end
+
+        def score_mode(value)
+          @value[:score_mode] = value
+          @value
+        end
+
+        def params(value)
+          @value[:params] = value
+          @value
+        end
+
+        def to_hash
+          @value[:filters] ?
+          @value :
+          @value.merge(:filters => [CustomFilter.new{ filter(:match_all); boost(1) }.to_hash]) # Needs at least one filter
+        end
+
+        def to_json
+          to_hash.to_json
+        end
+      end
+    end
+  end
+end