elastics-client 1.0.4

data/lib/elastics/errors.rb

@@ -0,0 +1,43 @@
+module Elastics
+
+  class ArgumentError          < ArgumentError; end
+  class SourceError            < StandardError; end
+  class MissingPartialError    < StandardError; end
+  class DocumentMappingError   < StandardError; end
+  class MissingIndexEntryError < StandardError; end
+  class ExistingIndexError     < StandardError; end
+  class MissingHttpClientError < StandardError; end
+  class MissingParentError     < StandardError; end
+  class MissingVariableError   < StandardError; end
+
+  class HttpError < StandardError
+
+    attr_reader :response
+
+    def initialize(response, caller_line=nil)
+      @response    = response
+      @caller_line = caller_line
+    end
+
+    def status
+      response.status
+    end
+
+    def body
+      response.body
+    end
+
+    def to_s
+      log = "#@caller_line\n" if @caller_line
+      "#{log}#{status}: #{body}"
+    end
+
+    def to_hash
+      MultiJson.decode response.body
+    rescue MultiJson::DecodeError
+      {}
+    end
+
+  end
+
+end

data/lib/elastics/http_clients/base.rb

@@ -0,0 +1,15 @@
+module Elastics
+  module HttpClients
+    class Base
+
+      attr_accessor :options, :base_uri, :raise_proc
+
+      def initialize(base_uri='http://localhost:9200', options={})
+        @options    = options
+        @base_uri   = base_uri
+        @raise_proc = proc{|response| response.status >= 400}
+      end
+
+    end
+  end
+end

data/lib/elastics/http_clients/loader.rb

@@ -0,0 +1,51 @@
+module Elastics
+  module HttpClients
+
+    class Dummy
+      def request(*)
+        raise MissingHttpClientError,
+              'you should install the gem "patron" (recommended for performances) or "rest-client", ' +
+              'or provide your own http-client interface and set Elastics::Configuration.http_client'
+      end
+    end
+
+    module Loader
+
+      extend self
+
+      def new_http_client
+        if Gem::Specification.respond_to?(:find_all_by_name)
+          case
+            # terrible way to check whether a gem is available.
+            # Gem.available? was just perfect: that's probably the reason it has been deprecated!
+            # https://github.com/rubygems/rubygems/issues/176
+          when Gem::Specification::find_all_by_name('patron').any?      then require_patron
+          when Gem::Specification::find_all_by_name('rest-client').any? then require_rest_client
+          else Dummy.new
+          end
+        else
+          case
+          when Gem.available?('patron')      then require_patron
+          when Gem.available?('rest-client') then require_rest_client
+          else Dummy.new
+          end
+        end
+      end
+
+    private
+
+      def require_patron
+        require 'patron'
+        require 'elastics/http_clients/patron'
+        Patron.new
+      end
+
+      def require_rest_client
+        require 'rest-client'
+        require 'elastics/http_clients/rest_client'
+        RestClient.new
+      end
+
+    end
+  end
+end

data/lib/elastics/http_clients/patron.rb

@@ -0,0 +1,29 @@
+module Elastics
+  module HttpClients
+    class Patron < Base
+
+      def request(method, path, data=nil)
+        # patron would raise an error for :post and :put requests with no data
+        # and elasticsearch ignores the data when it expects no data,
+        # so we silence patron by adding some dummy data
+        data = {} if (method == 'POST' || method == 'PUT') && data.nil?
+        opts = options.merge(:data => data)
+        session.request method.to_s.downcase.to_sym, path, {}, opts
+      rescue ::Patron::TimeoutError
+        session.request method.to_s.downcase.to_sym, path, {}, opts
+      end
+
+    private
+
+      def session
+        Thread.current[:elastics_patron_session] ||= begin
+                                                      sess                       = ::Patron::Session.new
+                                                      sess.headers['User-Agent'] = "elastics-#{Elastics::VERSION}"
+                                                      sess.base_url              = base_uri
+                                                      sess
+                                                    end
+      end
+
+    end
+  end
+end

data/lib/elastics/http_clients/rest_client.rb

@@ -0,0 +1,36 @@
+module Elastics
+  module HttpClients
+    class RestClient < Base
+
+      def request(method, path, data=nil)
+        url  = "#{base_uri}#{path}"
+        opts = options.merge( :method  => method.to_s.downcase.to_sym,
+                              :url     => url,
+                              :payload => data )
+        response = ::RestClient::Request.new( opts ).execute
+        extend_response(response, url)
+
+      rescue ::RestClient::ExceptionWithResponse => e
+        extend_response(e.response, url)
+      end
+
+    private
+
+      def extend_response(response, url)
+        response.extend ResponseExtension
+        response.url = url
+        response
+      end
+
+      module ResponseExtension
+        attr_accessor :url
+
+        def status
+          code.to_i
+        end
+
+      end
+
+    end
+  end
+end

data/lib/elastics/logger.rb

@@ -0,0 +1,37 @@
+require 'logger'
+
+module Elastics
+  class Logger < ::Logger
+
+
+    attr_accessor :debug_variables, :debug_request, :debug_result, :curl_format
+
+    def initialize(*)
+      super
+      self.level     = ::Logger::WARN
+      self.progname  = 'ELASTICS'
+      self.formatter = proc do |severity, datetime, progname, msg|
+        elastics_format(severity, msg)
+      end
+      @debug_variables = true
+      @debug_request   = true
+      @debug_result    = true
+      @curl_format     = false
+    end
+
+    def elastics_format(severity, msg)
+      prefix = Dye.dye(" ELASTICS-#{severity} ", "ELASTICS-#{severity}:", :blue, :bold, :reversed) + ' '
+      msg.split("\n").map{|l| prefix + l}.join("\n") + "\n"
+    end
+
+    # force color in console (used with jruby)
+    def color=(bool)
+      Dye.color = bool
+    end
+
+    def color
+      Dye.color?
+    end
+
+  end
+end

data/lib/elastics/prog_bar.rb

@@ -0,0 +1,39 @@
+module Elastics
+  class ProgBar
+
+    attr_reader :pbar, :total_count
+
+    def initialize(total_count, batch_size=nil, prefix_message=nil)
+      @total_count      = total_count
+      @successful_count = 0
+      @failed_count     = 0
+      @pbar             = ::ProgressBar.new('processing...', total_count)
+      @pbar.clear
+      @pbar.bar_mark = '|'
+      puts '_' * @pbar.send(:get_term_width)
+      message = "#{prefix_message}Processing #{total_count} documents"
+      message << " in batches of #{batch_size}:" unless batch_size.nil?
+      puts message
+      @pbar.send(:show)
+    end
+
+    def process_result(result, inc)
+      unless result.nil? || result.empty?
+        unless result.failed.size == 0
+          Conf.logger.error "Failed load:\n#{result.failed.to_yaml}"
+          @pbar.bar_mark = 'F'
+        end
+        @failed_count     += result.failed.size
+        @successful_count += result.successful.size
+      end
+      @pbar.inc(inc)
+    end
+
+    def finish
+      @pbar.finish
+      puts "Processed #@total_count. Successful #@successful_count. Skipped #{@total_count - @successful_count - @failed_count}. Failed #@failed_count."
+      puts 'See the log for the details about the failures.' unless @failed_count == 0
+    end
+
+  end
+end

data/lib/elastics/rails.rb

@@ -0,0 +1 @@
+raise NotImplementedError, %(The "flex/rails" file has been replaced by the "elastics-rails" gem. Please, use "elastics-rails" in place of "flex" in Rails applications (change "gem 'flex', require => 'flex/rails'" to "gem 'elastics-rails'" in your Gemfile). Please, read the upgrade notes at http://elastics.github.io/elastics/doc/7-Tutorials/2-Migrate-from-0.x.html.)

data/lib/elastics/result.rb

@@ -0,0 +1,24 @@
+module Elastics
+  class Result < ::Hash
+
+    attr_reader :template, :response
+    attr_accessor :variables
+
+    def initialize(template, variables, response, result=nil)
+      @template  = template
+      @variables = variables
+      @response  = response
+      replace result || !response.body.empty? && MultiJson.decode(response.body) || return
+      Conf.result_extenders.each do |ext|
+        next if ext.respond_to?(:should_extend?) && !ext.should_extend?(self)
+        extend ext
+      end
+    end
+
+    def to_elastics_result(force=false)
+      return self if variables[:context].nil? || variables[:raw_result] &&! force
+      variables[:context].respond_to?(:elastics_result) ? variables[:context].elastics_result(self) : self
+    end
+
+  end
+end

data/lib/elastics/result/bulk.rb

@@ -0,0 +1,20 @@
+module Elastics
+  class Result
+    module Bulk
+
+      # extend if result comes from a bulk url
+      def self.should_extend?(result)
+        result.response.url =~ /\b_bulk\b/
+      end
+
+      def failed
+        self['items'].reject{|i| i['index']['ok']}
+      end
+
+      def successful
+        self['items'].select{|i| i['index']['ok']}
+      end
+
+    end
+  end
+end

data/lib/elastics/result/document.rb

@@ -0,0 +1,67 @@
+module Elastics
+  class Result
+
+    #  adds sugar to documents with the following structure (_source is optional):
+    #
+    #    {
+    #        "_index" : "twitter",
+    #        "_type" : "tweet",
+    #        "_id" : "1",
+    #        "_source" : {
+    #            "user" : "kimchy",
+    #            "postDate" : "2009-11-15T14:12:12",
+    #            "message" : "trying out Elastics Search"
+    #        }
+    #    }
+
+    module Document
+
+      # extend if result has a structure like a document
+      def self.should_extend?(obj)
+        %w[_index _type _id].all? {|k| obj.has_key?(k)}
+      end
+
+      def respond_to?(meth, private=false)
+        smeth = meth.to_s
+        readers.has_key?(smeth) || has_key?(smeth) || has_key?("_#{smeth}") || super
+      end
+
+      # exposes _source and readers: automatically supply object-like reader access
+      # also expose meta readers like _id, _source, etc, also callable without the leading '_'
+      def method_missing(meth, *args, &block)
+        smeth = meth.to_s
+        case
+        # field name
+        when readers.has_key?(smeth)
+          readers[smeth]
+        # result item
+        when has_key?(smeth)
+          self[smeth]
+        # result item called without the '_' prefix
+        when has_key?("_#{smeth}")
+          self["_#{smeth}"]
+        else
+          super
+        end
+      end
+
+      # used to get the unprefixed (by live-reindex) index name
+      def index_basename
+        @index_basename ||= self['_index'].sub(/^\d{14}_/, '')
+      end
+
+
+      private
+
+      def readers
+        @readers ||= begin
+                       readers = (self['_source']||{}).merge(self['fields']||{})
+                       # flattened reader for multi_readers or attachment readers
+                       readers.keys.each{|k| readers[k.gsub('.','_')] = readers.delete(k) if k.include?('.')}
+                       readers
+                     end
+      end
+
+    end
+  end
+end

data/lib/elastics/result/multi_get.rb

@@ -0,0 +1,24 @@
+module Elastics
+  class Result
+    module MultiGet
+
+      # extend if result comes from a search url
+      def self.should_extend?(result)
+        result.response.url =~ /\b_mget\b/ && result['docs']
+      end
+
+      # extend the hits results on extended
+      def self.extended(result)
+        result['docs'].each { |h| h.extend(Document) }
+        result['docs'].extend Struct::Paginable
+        result['docs'].setup(result['docs'].size, result.variables)
+      end
+
+      def docs
+        self['docs']
+      end
+      alias_method :collection, :docs
+
+    end
+  end
+end

data/lib/elastics/result/search.rb

@@ -0,0 +1,28 @@
+module Elastics
+  class Result
+    module Search
+
+      # extend if result comes from a search url
+      def self.should_extend?(result)
+        result.response.url =~ /\b_m?search\b/ && result['hits']
+      end
+
+      # extend the hits results on extended
+      def self.extended(result)
+        result['hits']['hits'].each { |h| h.extend(Document) }
+        result['hits']['hits'].extend Struct::Paginable
+        result['hits']['hits'].setup(result['hits']['total'], result.variables)
+      end
+
+      def collection
+        self['hits']['hits']
+      end
+      alias_method :documents, :collection
+
+      def facets
+        self['facets']
+      end
+
+    end
+  end
+end

data/lib/elastics/struct/array.rb

@@ -0,0 +1,25 @@
+module Elastics
+  module Struct
+    class Array < ::Array
+
+      include Symbolize
+
+      def push(*vals)
+        super *symbolize(vals)
+      end
+
+      def <<(val)
+        super symbolize(val)
+      end
+
+      def insert(*vals)
+        super *symbolize(vals)
+      end
+
+      def unshift(*vals)
+        super *symbolize(vals)
+      end
+
+    end
+  end
+end