elastictastic 0.5.0 → 0.10.2

data/lib/elastictastic/middleware.rb

@@ -1,37 +1,70 @@
-require 'faraday'
+require 'elastictastic/transport_methods'
 
 module Elastictastic
+
   module Middleware
-    class JsonEncodeBody < Faraday::Middleware
-      def call(env)
-        case env[:body]
+
+    class Base
+
+      include TransportMethods
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def request(method, path, body = nil)
+        @connection.request(method, path, body)
+      end
+
+    end
+
+    class JsonEncodeBody < Base
+
+      def request(method, path, body = nil)
+        case body
         when String, nil
-          # nothing
-        else env[:body] = env[:body].to_json
+          super
+        else
+          @connection.request(
+            method, path,
+            Elastictastic.json_encode(body)
+          )
         end
-        @app.call(env)
       end
+
     end
 
-    class JsonDecodeResponse < Faraday::Middleware
-      def call(env)
-        @app.call(env).on_complete do
-          env[:body] &&= JSON.parse(env[:body])
+    class JsonDecodeResponse < Base
+
+      def request(method, path, body = nil)
+        response = super
+        if response.body.present?
+          Adapter::Response.new(
+            response.status,
+            response.headers,
+            Elastictastic.json_decode(response.body)
+          )
+        else
+          response
         end
       end
+
     end
 
-    class RaiseServerErrors < Faraday::Middleware
-      ERROR_PATTERN = /^([A-Z][A-Za-z]*)(?::\s*)?(.*)$/
-
-      def call(env)
-        @app.call(env).on_complete do
-          body = env[:body]
-          if body['error']
-            raise_error(body['error'], body['status'])
-          elsif body['_shards'] && body['_shards']['failures']
-            raise_error(
-              body['_shards']['failures'].first['reason'], body['status'])
+    class RaiseServerErrors < Base
+
+      def request(method, path, body = nil)
+        super.tap do |response|
+          if method != :head
+            if response.body.nil?
+              raise Elastictastic::ServerError::ServerError,
+                "No body in ElasticSearch response with status #{env[:status]}"
+            elsif response.body['error']
+              raise_error(response.body['error'], response.body['status'])
+            elsif response.body['_shards'] && response.body['_shards']['failures']
+              raise_error(
+                response.body['_shards']['failures'].first['reason'], response.body['status'])
+            end
           end
         end
       end
@@ -39,81 +72,30 @@ module Elastictastic
       private
 
       def raise_error(server_message, status)
-        match = ERROR_PATTERN.match(server_message)
-        if match
-          clazz = Elastictastic::ServerError.const_get(match[1])
-          error = clazz.new(match[2])
-          error.status = status
-          Kernel.raise error
-        else
-          Kernel.raise Elastictastic::ServerError::ServerError, server_message
-        end
+        ::Kernel.raise(Elastictastic::ServerError[server_message, status])
       end
+
     end
 
-    class LogRequests < Faraday::Middleware
-      def initialize(app, logger)
-        super(app)
+    class LogRequests < Base
+
+      def initialize(connection, logger)
+        super(connection)
         @logger = logger
       end
 
-      def call(env)
+      def request(method, path, body = nil)
         now = Time.now
-        body = env[:body]
-        @app.call(env).on_complete do
-          method = env[:method].to_s.upcase
+        super.tap do
           time = ((Time.now - now) * 1000).to_i
-          message = "ElasticSearch #{method} (#{time}ms) #{env[:url].path}"
+          message = "ElasticSearch #{method.to_s.upcase} (#{time}ms) #{path}"
           message << ' ' << body if body
           @logger.debug(message)
         end
       end
-    end
-
-    class Rotor < Faraday::Middleware
-      def initialize(app, *hosts)
-        first = nil
-        hosts.each do |host|
-          node = Node.new(app, host)
-          first ||= node
-          @head.next = node if @head
-          @head = node
-        end
-        @head.next = first
-      end
-
-      def call(env)
-        last = @head
-        begin
-          @head = @head.next
-          @head.call(env)
-        rescue Faraday::Error::ConnectionFailed => e
-          raise NoServerAvailable if @head == last
-          retry
-        end
-      end
-
-      class Node < Faraday::Middleware
-        attr_accessor :next
 
-        def initialize(app, url)
-          super(app)
-          # Create a connection instance so we can use its #build_url method.
-          # Kinda lame -- seems like it would make more sense for Faraday to
-          # just implement a middleware for injecting a host/path prefix.
-          @connection = Faraday::Connection.new(:url => url)
-        end
-
-        def call(env)
-          original_url = env[:url]
-          begin
-            env[:url] = @connection.build_url(original_url)
-            @app.call(env)
-          ensure
-            env[:url] = original_url
-          end
-        end
-      end
     end
+
   end
+
 end

data/lib/elastictastic/multi_get.rb

@@ -0,0 +1,30 @@
+module Elastictastic
+
+  class MultiGet
+
+    include Enumerable
+
+    def initialize
+      @docspecs = []
+      @scopes = []
+    end
+
+    def add(scope, *ids)
+      scope = scope.all
+      params = scope.multi_get_params
+      ids.flatten.each do |id|
+        @docspecs << params.merge('_id' => id.to_s)
+        @scopes << scope
+      end
+    end
+
+    def each
+      return if @docspecs.empty?
+      Elastictastic.client.mget(@docspecs)['docs'].zip(@scopes) do |hit, scope|
+        yield scope.materialize_hit(hit) if hit['exists']
+      end
+    end
+
+  end
+
+end

data/lib/elastictastic/multi_search.rb

@@ -0,0 +1,70 @@
+require 'stringio'
+
+module Elastictastic
+  class MultiSearch
+    Component = Struct.new(:scope, :search_type)
+
+    def self.query(*scopes)
+      new.query(*scopes).run
+    end
+
+    def self.count(*scopes)
+      new.count(*scopes).run
+    end
+
+    def initialize
+      @components = []
+    end
+
+    def query(*scopes)
+      components = validate_scopes_for_query(scopes.flatten).map do |scope|
+        Component.new(scope, 'query_then_fetch')
+      end
+      @components.concat(components)
+      self
+    end
+
+    def count(*scopes)
+      components = scopes.flatten.map { |scope| Component.new(scope, 'count') }
+      @components.concat(components)
+      self
+    end
+
+    def run
+      if @components.any?
+        responses = Elastictastic.client.msearch(search_bodies)['responses']
+        responses.zip(@components) do |response, component|
+          raise ServerError[response['error']] if response['error']
+          scope, search_type = component.scope, component.search_type
+          case search_type
+          when 'query_then_fetch' then scope.response = response
+          when 'count' then scope.counts = response
+          end
+        end
+      end
+      self
+    end
+
+    private
+
+    def search_bodies
+      StringIO.new.tap do |io|
+        @components.each do |component|
+          scope, search_type = component.scope, component.search_type
+          headers = scope.multi_search_headers.
+            merge('search_type' => search_type)
+          io.puts(Elastictastic.json_encode(headers))
+          io.puts(Elastictastic.json_encode(scope.params))
+        end
+      end.string
+    end
+
+    def validate_scopes_for_query(scopes)
+      scopes.each do |scope|
+        if scope.params['size'].blank?
+          raise ArgumentError, "Multi-search scopes must have an explicit size"
+        end
+      end
+    end
+  end
+end

data/lib/elastictastic/nested_document.rb

@@ -1,29 +1,5 @@
-module Elastictastic
-  module NestedDocument
-    extend ActiveSupport::Concern
-
-    included do
-      include Properties
-      include Dirty
-      include Dirty::NestedDocumentMethods
-      include MassAssignmentSecurity
-      include Validations
-    end
+warn 'Elastictastic::NestedDocument is deprecated. Use Elastictastic::EmbeddedDocument instead.'
 
-    module InstanceMethods
-      def initialize_copy(original)
-        self.write_attributes(original.read_attributes.dup)
-      end
-
-      def inspect
-        inspected = "#<#{self.class.name}"
-        if attributes.any?
-          inspected << ' ' << attributes.each_pair.map do |attr, value|
-            "#{attr}: #{value.inspect}"
-          end.join(', ')
-        end
-        inspected << '>'
-      end
-    end
-  end
+module Elastictastic
+  NestedDocument = EmbeddedDocument
 end

data/lib/elastictastic/new_relic_instrumentation.rb

@@ -11,14 +11,14 @@ module Elastictastic
     included do
       include NewRelic::Agent::MethodTracer
 
-      add_method_tracer :create, 'ElasticSearch/#{args[1].classify}#create'
-      add_method_tracer :delete, 'ElasticSearch/#{args[1].classify + "#" if args[1]}/delete'
-      add_method_tracer :get, 'ElasticSearch/#{args[1].classify}#get'
-      add_method_tracer :mget, 'ElasticSearch/mget'
-      add_method_tracer :put_mapping, 'ElasticSearch/#{args[1].classify}#put_mapping'
-      add_method_tracer :scroll, 'ElasticSearch/scroll'
-      add_method_tracer :search, 'ElasticSearch/#{args[1].classify}#search'
-      add_method_tracer :update, 'ElasticSearch/#{args[1].classify}#update'
+      add_method_tracer :create, 'Database/ElasticSearch/create'
+      add_method_tracer :delete, 'Database/ElasticSearch/delete'
+      add_method_tracer :get, 'Database/ElasticSearch/get'
+      add_method_tracer :mget, 'Database/ElasticSearch/mget'
+      add_method_tracer :put_mapping, 'Database/ElasticSearch/put_mapping'
+      add_method_tracer :scroll, 'Database/ElasticSearch/scroll'
+      add_method_tracer :search, 'Database/ElasticSearch/search'
+      add_method_tracer :update, 'Database/ElasticSearch/update'
     end
   end
 end

data/lib/elastictastic/observing.rb

@@ -7,15 +7,17 @@ module Elastictastic
       include ActiveModel::Observing
     end
 
-    module InstanceMethods
-      Callbacks::HOOKS.each do |method|
-        module_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{method}(*args)
+    Callbacks::HOOKS.each do |method|
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(options = {})
+          if options[:observers] == false
+            super
+          else
             notify_observers(:before_#{method})
             super.tap { notify_observers(:after_#{method}) }
           end
-        RUBY
-      end
+        end
+      RUBY
     end
   end
 end

data/lib/elastictastic/optimistic_locking.rb

@@ -0,0 +1,57 @@
+module Elastictastic
+
+  module OptimisticLocking
+
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def create_or_update(id, &block)
+        scope = current_scope
+        new.tap do |instance|
+          instance.id = id
+          yield instance
+        end.create do |e|
+          case e
+          when nil # chill
+          when Elastictastic::ServerError::DocumentAlreadyExistsEngineException,
+            Elastictastic::ServerError::DocumentAlreadyExistsException # 0.19+
+            scope.update(id, &block)
+          else
+            raise e
+          end
+        end
+      rescue Elastictastic::CancelSave
+        # Do Nothing
+      end
+
+      def update(id, &block)
+        instance = scoped({}).find_one(id, :preference => '_primary_first')
+        instance.try_update(current_scope, &block) if instance
+      end
+
+      def update_each(&block)
+        all.each { |instance| instance.try_update(current_scope, &block) }
+      end
+
+    end
+
+    def try_update(scope, &block) #:nodoc:
+      yield self
+      update do |e|
+        case e
+        when nil # chill
+        when Elastictastic::ServerError::VersionConflictEngineException,
+          Elastictastic::ServerError::VersionConflictException # 0.19
+          scope.update(id, &block)
+        else
+          raise e
+        end
+      end
+    rescue Elastictastic::CancelSave
+      # Do Nothing
+    end
+
+  end
+
+end

data/lib/elastictastic/parent_child.rb

@@ -31,7 +31,7 @@ module Elastictastic
       end
 
       def child_associations
-        @child_associations ||= {}
+        @_child_associations ||= {}
       end
 
       def mapping
@@ -41,75 +41,77 @@ module Elastictastic
       end
     end
 
-    module InstanceMethods
 
-      def initialize(attributes = {})
-        super
-        @children = Hash.new do |hash, child_association_name|
-          hash[child_association_name] = Elastictastic::ChildCollectionProxy.new(
-            self.class.child_association(child_association_name.to_s),
-            self
-          )
-        end
-      end
-
-      def elasticsearch_doc=(doc)
-        @parent_id = doc.delete('_parent')
-        super
+    def initialize(attributes = {})
+      super
+      @_children = Hash.new do |hash, child_association_name|
+        hash[child_association_name] = Elastictastic::ChildCollectionProxy.new(
+          self.class.child_association(child_association_name.to_s),
+          self
+        )
       end
+    end
 
-      def _parent #:nodoc:
-        return @parent if defined? @parent
-        @parent =
-          if @parent_id
-            self.class.parent_association.clazz.find(@parent_id)
-          end
-      end
+    def elasticsearch_doc=(doc)
+      @_parent_id = doc.delete('_parent')
+      super
+    end
 
-      def _parent_id #:nodoc:
-        if @parent
-          @parent_id = @parent.id
-        elsif @parent_id
-          @parent_id
+    def _parent #:nodoc:
+      return @_parent if defined? @_parent
+      @_parent =
+        if @_parent_id
+          self.class.parent_association.clazz.in_index(index).find(@_parent_id)
         end
+      #TODO - here's a piece of debugging to fix a problem where we get weird parents. remove after fixing
+      if @_parent && !@_parent.respond_to?(:id)
+        raise ArgumentError.new("Bad parent loaded from id #{@_parent_id} is a #{@_parent.class.name}.")
       end
+      @_parent
+    end
 
-      def parent_collection=(parent_collection)
-        if @parent_collection
-          raise Elastictastic::IllegalModificationError,
-            "Document is already a child of #{_parent}"
+    def _parent_id #:nodoc:
+      if @_parent_id
+        @_parent_id
+      elsif @_parent
+        unless @_parent.respond_to?(:id)
+          raise ArgumentError,
+            "@_parent is incorrectly set to #{Object.instance_method(:inspect).bind(@_parent).call}"
         end
-        if persisted?
-          raise Elastictastic::IllegalModificationError,
-            "Can't change parent of persisted object"
-        end
-        @parent_collection = parent_collection
-        @parent = parent_collection.parent
+        @_parent_id = @_parent.id
       end
+    end
 
-      def save
-        super
-        self.class.child_associations.each_pair do |name, association|
-          association.extract(self).transient_children.each do |child|
-            child.save unless child.pending_save?
-          end
-        end
+    def parent=(parent)
+      if @_parent
+        raise Elastictastic::IllegalModificationError,
+          "Document is already a child of #{_parent}"
+      end
+      if persisted?
+        raise Elastictastic::IllegalModificationError,
+          "Can't change parent of persisted object"
       end
+      #TODO - here's a piece of debugging to fix a problem where we get weird parents. remove after fixing
+      if parent && !parent.respond_to?(:id)
+        raise ArgumentError.new("Bad parent loaded from id #{parent_id} is a #{parent.class.name}.")
+      end
+      @_parent = parent
+    end
 
-      def persisted!
-        was_persisted = @persisted
-        super
-        if @parent_collection && !was_persisted
-          @parent_collection.persisted!(self)
+    def save(options = {})
+      super
+      self.class.child_associations.each_pair do |name, association|
+        association.extract(self).transient_children.each do |child|
+          child.save unless child.pending_save?
         end
       end
+    end
 
-      protected
-
-      def read_child(field_name)
-        @children[field_name.to_s]
-      end
+    protected
 
+    def read_child(field_name)
+      @_children[field_name.to_s]
     end
+
   end
 end

data/lib/elastictastic/persistence.rb

@@ -1,19 +1,19 @@
 module Elastictastic
   module Persistence
-    def save
-      persisted? ? update : create
+    def save(options = {}, &block)
+      persisted? ? update(options, &block) : create(options, &block)
     end
     
-    def destroy
+    def destroy(options = {}, &block)
       if persisted?
-        Elastictastic.persister.destroy(self)
+        Elastictastic.persister.destroy(self, &block)
       else
         raise OperationNotAllowed, "Cannot destroy transient document: #{inspect}"
       end
     end
 
     def persisted?
-      !!@persisted
+      !!@_persisted
     end
 
     def transient?
@@ -21,38 +21,38 @@ module Elastictastic
     end
 
     def pending_save?
-      !!@pending_save
+      !!@_pending_save
     end
 
     def pending_destroy?
-      !!@pending_destroy
+      !!@_pending_destroy
     end
 
     def persisted!
-      @persisted = true
-      @pending_save = false
+      @_persisted = true
+      @_pending_save = false
     end
 
     def transient!
-      @persisted = @pending_destroy = false
+      @_persisted = @_pending_destroy = false
     end
 
     def pending_save!
-      @pending_save = true
+      @_pending_save = true
     end
 
     def pending_destroy!
-      @pending_destroy = true
+      @_pending_destroy = true
     end
 
     protected
 
-    def create
-      Elastictastic.persister.create(self)
+    def create(options = {}, &block)
+      Elastictastic.persister.create(self, &block)
     end
 
-    def update
-      Elastictastic.persister.update(self)
+    def update(options = {}, &block)
+      Elastictastic.persister.update(self, &block)
     end
 
     private