elastictastic 0.5.0 → 0.10.2

data/lib/elastictastic/callbacks.rb

@@ -9,21 +9,27 @@ module Elastictastic
       define_model_callbacks(*HOOKS)
     end
 
-    module InstanceMethods
-      def save
-        run_callbacks(:save) { super }
-      end
+    def save(options = {})
+      with_callbacks(:save, options) { super }
+    end
 
-      def create
-        run_callbacks(:create) { super }
-      end
+    def create(options = {})
+      with_callbacks(:create, options) { super }
+    end
 
-      def update
-        run_callbacks(:update) { super }
-      end
+    def update(options = {})
+      with_callbacks(:update, options) { super }
+    end
+
+    def destroy(options = {})
+      with_callbacks(:destroy, options) { super }
+    end
+
+    private
 
-      def destroy
-        run_callbacks(:destroy) { super }
+    def with_callbacks(name, options)
+      if options[:callbacks] == false then yield
+      else run_callbacks(name) { yield }
       end
     end
   end

data/lib/elastictastic/child_collection_proxy.rb

@@ -1,6 +1,6 @@
 module Elastictastic
   class ChildCollectionProxy < Scope
-    attr_reader :parent, :transient_children
+    attr_reader :parent
 
     def initialize(association, parent)
       super(
@@ -12,10 +12,10 @@ module Elastictastic
               'filter' => { 'term' => { '_parent' => parent.id }}
             }
           }
-        )
+        ),
+        self
       )
       @parent = parent
-      @parent_collection = self
       @transient_children = []
     end
 
@@ -25,28 +25,32 @@ module Elastictastic
     end
 
     def first
-      super || @transient_children.first
+      super || transient_children.first
     end
 
     def each(&block)
       if block
-        super
-        @transient_children.each(&block)
+        super if @parent.persisted?
+        transient_children.each(&block)
       else
         ::Enumerator.new(self, :each)
       end
     end
 
-    def persisted!(child)
-      @transient_children.delete(child)
-    end
-
     def <<(child)
-      child.parent_collection = self
+      child.parent = @parent
       @transient_children << child
       self
     end
 
+    def transient_children
+      @transient_children.tap do |children|
+        children.reject! do |child|
+          !child.transient?
+        end
+      end
+    end
+
     private
 
     def params_for_find

data/lib/elastictastic/client.rb

@@ -1,48 +1,70 @@
-require 'faraday'
-
 module Elastictastic
   class Client
     attr_reader :connection
 
     def initialize(config)
-      builder = Faraday::Builder.new do |builder|
-        builder.use Middleware::RaiseServerErrors
-        builder.use Middleware::JsonEncodeBody
-        builder.use Middleware::JsonDecodeResponse
-        if config.logger
-          builder.use Middleware::LogRequests, config.logger
-        end
-      end
+      adapter_options = {
+        :request_timeout => config.request_timeout,
+        :connect_timeout => config.connect_timeout
+      }
       if config.hosts.length == 1
-        builder.adapter config.adapter
-        @connection =
-          Faraday.new(:url => config.hosts.first, :builder => builder)
+        connection = Adapter[config.adapter].
+          new(config.hosts.first, adapter_options)
       else
-        builder.use Middleware::Rotor, *config.hosts
-        builder.adapter config.adapter
-        @connection = Faraday.new(:builder => builder)
+        connection = Rotor.new(
+          config.hosts,
+          adapter_options.merge(
+            :adapter => config.adapter,
+            :backoff_threshold => config.backoff_threshold,
+            :backoff_start => config.backoff_start,
+            :backoff_max => config.backoff_max
+          )
+        )
       end
+      if config.logger
+        connection = Middleware::LogRequests.new(connection, config.logger)
+      end
+      connection = Middleware::JsonDecodeResponse.new(connection)
+      connection = Middleware::JsonEncodeBody.new(connection)
+      connection = Middleware::RaiseServerErrors.new(connection)
+      @connection = connection
     end
 
     def create(index, type, id, doc, params = {})
       if id
         @connection.put(
-          path_with_query("/#{index}/#{type}/#{id}/_create", params), doc)
+          path_with_query("/#{index}/#{type}/#{id}/_create", params),
+          doc
+        )
       else
-        @connection.post(path_with_query("/#{index}/#{type}", params), doc)
+        @connection.post(
+          path_with_query("/#{index}/#{type}", params),
+          doc
+        )
       end.body
     end
 
     def update(index, type, id, doc, params = {})
-      @connection.put(path_with_query("/#{index}/#{type}/#{id}", params), doc)
+      @connection.put(
+        path_with_query("/#{index}/#{type}/#{id}", params),
+        doc
+      ).body
     end
 
     def bulk(commands, params = {})
       @connection.post(path_with_query('/_bulk', params), commands).body
     end
 
+    def exists?(index, type, id, params = {})
+      @connection.head(
+        path_with_query("/#{index}/#{type}/#{id}", params)
+      ).status == 200
+    end
+
     def get(index, type, id, params = {})
-      @connection.get(path_with_query("/#{index}/#{type}/#{id}", params)).body
+      @connection.get(
+        path_with_query("/#{index}/#{type}/#{id}", params)
+      ).body
     end
 
     def mget(docspec, index = nil, type = nil)
@@ -67,11 +89,12 @@ module Elastictastic
       ).body
     end
 
+    def msearch(search_bodies)
+      @connection.post('/_msearch', search_bodies).body
+    end
+
     def scroll(id, options = {})
-      @connection.post(
-        "/_search/scroll?#{options.to_query}",
-        id
-      ).body
+      @connection.post("/_search/scroll?#{options.to_query}", id).body
     end
 
     def put_mapping(index, type, mapping)

data/lib/elastictastic/configuration.rb

@@ -1,15 +1,20 @@
 module Elastictastic
   class Configuration
 
-    attr_writer :hosts, :adapter, :default_index, :auto_refresh, :default_batch_size
-    attr_accessor :logger
+    attr_writer :hosts, :default_index, :auto_refresh, :default_batch_size, :adapter
+    attr_accessor :logger, :connect_timeout, :request_timeout, :backoff_threshold, :backoff_start, :backoff_max
+    attr_reader :extra_middlewares
+
+    def initialize
+      @extra_middlewares = []
+    end
 
     def host=(host)
       @hosts = [host]
     end
 
     def hosts
-      @hosts ||= ['http://localhost:9200']
+      @hosts ||= [default_host]
     end
 
     def adapter
@@ -17,7 +22,12 @@ module Elastictastic
     end
 
     def default_index
-      @default_index ||= 'default'
+      return @default_index if defined? @default_index
+      if url_from_env && url_from_env.path =~ /^\/([^\/]+)/
+        @default_index = $1
+      else
+        @default_index = 'default'
+      end
     end
 
     def auto_refresh
@@ -28,6 +38,51 @@ module Elastictastic
       @default_batch_size ||= 100
     end
 
+    def json_engine=(json_engine)
+      original_engine = MultiJson.engine
+      MultiJson.engine = json_engine
+      @json_engine = MultiJson.engine
+    ensure
+      MultiJson.engine = original_engine
+    end
+
+    def json_engine
+      @json_engine || MultiJson.engine
+    end
+
+    def use_middleware(*args)
+      @extra_middlewares << args
+    end
+
+    def presets
+      @presets ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def presets=(new_presets)
+      presets.merge!(new_presets)
+    end
+
+    private
+
+    def default_host
+      if url_from_env
+        url_from_env.class.build(
+          :host => url_from_env.host,
+          :port => url_from_env.port
+        )
+      else
+        'http://localhost:9200'
+      end
+    end
+
+    def url_from_env
+      return @url_from_env if defined? @url_from_env
+      @url_from_env = 
+        if ENV['ELASTICSEARCH_URL']
+          URI.parse(ENV['ELASTICSEARCH_URL'])
+        end
+    end
+
     ActiveModel::Observing::ClassMethods.public_instance_methods(false).each do |method|
       delegate method, :to => :"::Elastictastic::Observing"
     end

data/lib/elastictastic/dirty.rb

@@ -50,54 +50,68 @@ module Elastictastic
       end
     end
 
-    module InstanceMethods
-      def write_attribute(field, value)
-        attribute_will_change!(field)
-        super
-      end
+    def write_attribute(field, value)
+      attribute_may_change!(field) { super }
+    end
 
-      def write_embed(field, value)
-        attribute_will_change!(field)
+    def write_embed(field, value)
+      attribute_may_change!(field) do
         if Array === value
           value.each do |el|
             el.nesting_document = self
             el.nesting_association = field
           end
           super(field, NestedCollectionProxy.new(self, field, value))
-        else
+        elsif value
           value.nesting_document = self
           value.nesting_association = field
           super
+        else
+          super
         end
       end
+    end
 
-      def save
-        super
-        clean_attributes!
-      end
+    def save(options = {})
+      super
+      clean_attributes!
+    end
 
-      def elasticsearch_doc=(doc)
-        super
-        clean_attributes!
-      end
+    def elasticsearch_doc=(doc)
+      super
+      clean_attributes!
+    end
 
-      protected
+    protected
 
-      def clean_attributes!
-        changed_attributes.clear
-        @embeds.each_pair do |name, embedded|
-          Util.call_or_map(embedded) { |doc| doc.clean_attributes! }
-        end
+    def clean_attributes!
+      changed_attributes.clear
+      @_embeds.each_pair do |name, embedded|
+        Util.call_or_map(embedded) { |doc| doc && doc.clean_attributes! }
       end
     end
 
-    module NestedDocumentMethods
+    def attribute_may_change!(field)
+      attribute_will_change!(field) unless changed_attributes.key?(field)
+      old_value = changed_attributes[field]
+      yield
+      attribute_not_changed!(field) if old_value == __send__(field)
+    end
+
+    def attribute_not_changed!(field)
+      changed_attributes.delete(field)
+    end
+
+    module EmbeddedDocumentMethods
       attr_writer :nesting_document, :nesting_association
 
-      def attribute_will_change!(field)
-        super
+      def attribute_may_change!(field)
         if @nesting_document
-          @nesting_document.__send__("attribute_will_change!", @nesting_association)
+          @nesting_document.attribute_may_change!(@nesting_association) do
+            super
+          end
+        else
+          super
         end
       end
     end
@@ -116,8 +130,9 @@ module Elastictastic
       ].each do |destructive_method|
         module_eval <<-RUBY, __FILE__, __LINE__+1
           def #{destructive_method}(*args)
-            @owner.__send__("\#{@embed_name}_will_change!")
-            super
+            @owner.__send__(:attribute_may_change!, @embed_name) do
+              super
+            end
           end
         RUBY
       end

data/lib/elastictastic/discrete_persistence_strategy.rb

@@ -4,39 +4,61 @@ module Elastictastic
   class DiscretePersistenceStrategy
     include Singleton
 
+    DEFAULT_HANDLER = proc { |e| raise(e) if e }
+
     attr_accessor :auto_refresh
 
-    def create(doc)
-      response = Elastictastic.client.create(
-        doc.index,
-        doc.class.type,
-        doc.id,
-        doc.elasticsearch_doc,
-        params_for(doc)
-      )
+    def create(doc, &block)
+      block ||= DEFAULT_HANDLER
+      begin
+        response = Elastictastic.client.create(
+          doc.index,
+          doc.class.type,
+          doc.id,
+          doc.elasticsearch_doc,
+          params_for(doc)
+        )
+      rescue => e
+        return block.call(e)
+      end
       doc.id = response['_id']
+      doc.version = response['_version']
       doc.persisted!
+      block.call
     end
 
-    def update(doc)
-      Elastictastic.client.update(
-        doc.index,
-        doc.class.type,
-        doc.id,
-        doc.elasticsearch_doc,
-        params_for(doc)
-      )
+    def update(doc, &block)
+      block ||= DEFAULT_HANDLER
+      begin
+        response = Elastictastic.client.update(
+          doc.index,
+          doc.class.type,
+          doc.id,
+          doc.elasticsearch_doc,
+          params_for(doc)
+        )
+      rescue => e
+        return block.call(e)
+      end
+      doc.version = response['_version']
       doc.persisted!
+      block.call
     end
 
-    def destroy(doc)
-      response = Elastictastic.client.delete(
-        doc.index.name,
-        doc.class.type,
-        doc.id,
-        params_for(doc)
-      )
+    def destroy(doc, &block)
+      block ||= DEFAULT_HANDLER
+      begin
+        response = Elastictastic.client.delete(
+          doc.index.name,
+          doc.class.type,
+          doc.id,
+          params_for(doc)
+        )
+      rescue => e
+        return block.call(e)
+      end
       doc.transient!
+      block.call
       response['found']
     end
 
@@ -46,6 +68,9 @@ module Elastictastic
       {}.tap do |params|
         params[:refresh] = true if Elastictastic.config.auto_refresh
         params[:parent] = doc._parent_id if doc._parent_id
+        params[:version] = doc.version if doc.version
+        routing = doc.class.route(doc)
+        params[:routing] = routing if routing
       end
     end
   end

data/lib/elastictastic/document.rb

@@ -3,96 +3,12 @@ module Elastictastic
     extend ActiveSupport::Concern
 
     included do
-      extend Scoped
-      include Properties
-      include Persistence
-      include ParentChild
+      include BasicDocument
       include Callbacks
       include Observing
       include Dirty
       include MassAssignmentSecurity
       include Validations
-
-      extend ActiveModel::Naming
-      include ActiveModel::Conversion
-    end
-
-    module ClassMethods
-      delegate :find, :destroy_all, :sync_mapping, :inspect, :find_each,
-               :find_in_batches, :first, :count, :empty?, :any?, :all,
-               :query, :filter, :from, :size, :sort, :highlight, :fields,
-               :script_fields, :preference, :facets, :to => :current_scope
-
-      def mapping
-        { type => { 'properties' => properties }}
-      end
-
-      def type
-        name.underscore
-      end
-
-      def in_index(name_or_index)
-        Scope.new(Elastictastic::Index(name_or_index), self)
-      end
-
-      def scoped(params)
-        current_scope.scoped(params)
-      end
-
-      private
-
-      def default_scope
-        in_index(Index.default)
-      end
-    end
-
-    module InstanceMethods
-      attr_reader :id
-
-      def initialize(attributes = {})
-        self.class.current_scope.initialize_instance(self)
-      end
-
-      def elasticsearch_hit=(hit) #:nodoc:
-        @id = hit['_id']
-        @index = Index.new(hit['_index'])
-        persisted!
-
-        doc = {}
-        doc.merge!(hit['_source']) if hit['_source']
-        fields = hit['fields']
-        if fields
-          unflattened_fields =
-            Util.unflatten_hash(fields.reject { |k, v| v.nil? })
-          if unflattened_fields.has_key?('_source')
-            doc.merge!(unflattened_fields.delete('_source'))
-          end
-          doc.merge!(unflattened_fields)
-        end
-        self.elasticsearch_doc=(doc)
-      end
-
-      def id=(id)
-        assert_transient!
-        @id = id
-      end
-
-      def index
-        return @index if defined? @index
-        @index = Index.default
-      end
-
-      def ==(other)
-        index == other.index && id == other.id
-      end
-
-      def inspect
-        inspected = "#<#{self.class.name} id: #{id}, index: #{index.name}"
-        attributes.each_pair do |attr, value|
-          inspected << ", #{attr}: #{value.inspect}"
-        end
-        inspected << ">"
-      end
     end
   end
 end

data/lib/elastictastic/embedded_document.rb

@@ -0,0 +1,34 @@
+module Elastictastic
+  module EmbeddedDocument
+    extend ActiveSupport::Concern
+
+    included do
+      include Properties
+      include Dirty
+      include Dirty::EmbeddedDocumentMethods
+      include MassAssignmentSecurity
+      include Validations
+
+      include ActiveModel::Serializers::JSON
+      include ActiveModel::Serializers::Xml
+
+      self.include_root_in_json = false
+    end
+
+    def initialize_copy(original)
+      self.write_attributes(original.read_attributes.dup)
+    end
+
+    def attributes
+      {}
+    end
+
+    def ==(other)
+      other.nil? ? false : @_attributes == other.read_attributes && @_embeds == other.read_embeds
+    end
+
+    def eql?(other)
+      self.class == other.class && self == other
+    end
+  end
+end

data/lib/elastictastic/errors.rb

@@ -1,7 +1,19 @@
 module Elastictastic
-  CancelBulkOperation = Class.new(StandardError)
-  IllegalModificationError = Class.new(StandardError)
-  OperationNotAllowed = Class.new(StandardError)
-  NoServerAvailable = Class.new(StandardError)
-  RecordInvalid = Class.new(StandardError)
+  Error = Class.new(StandardError)
+  CancelSave = Class.new(Error)
+  IllegalModificationError = Class.new(Error)
+  OperationNotAllowed = Class.new(Error)
+  MissingParameter = Class.new(Error)
+
+  class ConnectionFailed < Error
+    attr_reader :source
+
+    def initialize(source)
+      super(source.message)
+      @source = source
+    end
+  end
+
+  NoServerAvailable = Class.new(ConnectionFailed)
+  RecordInvalid = Class.new(Error)
 end

data/lib/elastictastic/field.rb

@@ -10,6 +10,9 @@ module Elastictastic
 
     def self.with_defaults(options)
       options = Util.deep_stringify(options)
+      if preset = options.delete('preset')
+        options = ::Elastictastic.config.presets[preset].merge(options)
+      end
       { 'type' => 'string' }.merge(options).tap do |field_properties|
         if field_properties['type'].to_s == 'date'
           field_properties['format'] = 'date_time_no_millis'

data/lib/elastictastic/mass_assignment_security.rb

@@ -6,10 +6,8 @@ module Elastictastic
       include ActiveModel::MassAssignmentSecurity
     end
 
-    module InstanceMethods
-      def attributes=(attributes)
-        super(sanitize_for_mass_assignment(attributes))
-      end
+    def attributes=(attributes)
+      super(sanitize_for_mass_assignment(attributes))
     end
   end
 end