elastictastic 0.5.0

data/lib/elastictastic/dirty.rb

@@ -0,0 +1,130 @@
+module Elastictastic
+  module Dirty
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::Dirty
+    end
+
+    module ClassMethods
+      def define_field(field_name, options, &block)
+        super
+        define_dirty_accessors(field_name)
+      end
+
+      def define_embed(embed_name, options)
+        super
+        define_dirty_accessors(embed_name)
+      end
+
+      private
+
+      # 
+      # We have to rewrite ActiveModel functionality here because in Rails 3.0,
+      # #define_attribute_methods has to be called exactly one time, and there's
+      # no place for us to do that. This appears to be fixed in ActiveModel 3.1
+      #
+      def define_dirty_accessors(attribute)
+        attribute = attribute.to_s
+        module_eval <<-RUBY, __FILE__, __LINE__+1
+          def #{attribute}_changed?
+            attribute_changed?(#{attribute.inspect})
+          end
+
+          def #{attribute}_change
+            attribute_change(#{attribute.inspect})
+          end
+
+          def #{attribute}_will_change!
+            attribute_will_change!(#{attribute.inspect})
+          end
+
+          def #{attribute}_was
+            attribute_was(#{attribute.inspect})
+          end
+
+          def reset_#{attribute}!
+            reset_attribute!(#{attribute})
+          end
+        RUBY
+      end
+    end
+
+    module InstanceMethods
+      def write_attribute(field, value)
+        attribute_will_change!(field)
+        super
+      end
+
+      def write_embed(field, value)
+        attribute_will_change!(field)
+        if Array === value
+          value.each do |el|
+            el.nesting_document = self
+            el.nesting_association = field
+          end
+          super(field, NestedCollectionProxy.new(self, field, value))
+        else
+          value.nesting_document = self
+          value.nesting_association = field
+          super
+        end
+      end
+
+      def save
+        super
+        clean_attributes!
+      end
+
+      def elasticsearch_doc=(doc)
+        super
+        clean_attributes!
+      end
+
+      protected
+
+      def clean_attributes!
+        changed_attributes.clear
+        @embeds.each_pair do |name, embedded|
+          Util.call_or_map(embedded) { |doc| doc.clean_attributes! }
+        end
+      end
+    end
+
+    module NestedDocumentMethods
+      attr_writer :nesting_document, :nesting_association
+
+      def attribute_will_change!(field)
+        super
+        if @nesting_document
+          @nesting_document.__send__("attribute_will_change!", @nesting_association)
+        end
+      end
+    end
+
+    class NestedCollectionProxy < Array
+      def initialize(owner, embed_name, collection = [])
+        @owner, @embed_name = owner, embed_name
+        super(collection)
+      end
+
+      [
+        :<<, :[]=, :collect!, :compact!, :delete, :delete_at, :delete_if,
+        :flatten!, :insert, :keep_if, :map!, :push, :reject!, :replace,
+        :reverse!, :rotate!, :select!, :shuffle!, :slice!, :sort!, :sort_by!,
+        :uniq!
+      ].each do |destructive_method|
+        module_eval <<-RUBY, __FILE__, __LINE__+1
+          def #{destructive_method}(*args)
+            @owner.__send__("\#{@embed_name}_will_change!")
+            super
+          end
+        RUBY
+      end
+
+      def clone
+        NestedCollectionProxy.new(@owner, @embed_name, map { |el| el.clone })
+      end
+    end
+  end
+end

data/lib/elastictastic/discrete_persistence_strategy.rb

@@ -0,0 +1,52 @@
+require 'singleton'
+
+module Elastictastic
+  class DiscretePersistenceStrategy
+    include Singleton
+
+    attr_accessor :auto_refresh
+
+    def create(doc)
+      response = Elastictastic.client.create(
+        doc.index,
+        doc.class.type,
+        doc.id,
+        doc.elasticsearch_doc,
+        params_for(doc)
+      )
+      doc.id = response['_id']
+      doc.persisted!
+    end
+
+    def update(doc)
+      Elastictastic.client.update(
+        doc.index,
+        doc.class.type,
+        doc.id,
+        doc.elasticsearch_doc,
+        params_for(doc)
+      )
+      doc.persisted!
+    end
+
+    def destroy(doc)
+      response = Elastictastic.client.delete(
+        doc.index.name,
+        doc.class.type,
+        doc.id,
+        params_for(doc)
+      )
+      doc.transient!
+      response['found']
+    end
+
+    private
+
+    def params_for(doc)
+      {}.tap do |params|
+        params[:refresh] = true if Elastictastic.config.auto_refresh
+        params[:parent] = doc._parent_id if doc._parent_id
+      end
+    end
+  end
+end

data/lib/elastictastic/document.rb

@@ -0,0 +1,98 @@
+module Elastictastic
+  module Document
+    extend ActiveSupport::Concern
+
+    included do
+      extend Scoped
+      include Properties
+      include Persistence
+      include ParentChild
+      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/errors.rb

@@ -0,0 +1,7 @@
+module Elastictastic
+  CancelBulkOperation = Class.new(StandardError)
+  IllegalModificationError = Class.new(StandardError)
+  OperationNotAllowed = Class.new(StandardError)
+  NoServerAvailable = Class.new(StandardError)
+  RecordInvalid = Class.new(StandardError)
+end

data/lib/elastictastic/field.rb

@@ -0,0 +1,38 @@
+module Elastictastic
+  class Field < BasicObject
+    private_class_method :new
+
+    def self.process(field_name, default_options, &block)
+      {}.tap do |properties|
+        new(field_name, default_options, properties, &block)
+      end
+    end
+
+    def self.with_defaults(options)
+      options = Util.deep_stringify(options)
+      { 'type' => 'string' }.merge(options).tap do |field_properties|
+        if field_properties['type'].to_s == 'date'
+          field_properties['format'] = 'date_time_no_millis'
+        end
+      end
+    end
+
+    def initialize(field_name, default_options, properties, &block)
+      @field_name = field_name
+      @properties = properties
+      if block
+        @properties['type'] = 'multi_field'
+        @properties['fields'] =
+          { field_name.to_s => Field.with_defaults(default_options) }
+        instance_eval(&block)
+      else
+        @properties.merge!(Field.with_defaults(default_options))
+      end
+    end
+
+    def field(field_name, options = {})
+      @properties['fields'][field_name.to_s] =
+        Field.with_defaults(options)
+    end
+  end
+end

data/lib/elastictastic/index.rb

@@ -0,0 +1,19 @@
+module Elastictastic
+  class Index
+    class <<self
+      def default
+        new(Elastictastic.config.default_index)
+      end
+    end
+
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      @name
+    end
+  end
+end

data/lib/elastictastic/mass_assignment_security.rb

@@ -0,0 +1,15 @@
+module Elastictastic
+  module MassAssignmentSecurity
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::MassAssignmentSecurity
+    end
+
+    module InstanceMethods
+      def attributes=(attributes)
+        super(sanitize_for_mass_assignment(attributes))
+      end
+    end
+  end
+end

data/lib/elastictastic/middleware.rb

@@ -0,0 +1,119 @@
+require 'faraday'
+
+module Elastictastic
+  module Middleware
+    class JsonEncodeBody < Faraday::Middleware
+      def call(env)
+        case env[:body]
+        when String, nil
+          # nothing
+        else env[:body] = env[:body].to_json
+        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])
+        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'])
+          end
+        end
+      end
+
+      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
+      end
+    end
+
+    class LogRequests < Faraday::Middleware
+      def initialize(app, logger)
+        super(app)
+        @logger = logger
+      end
+
+      def call(env)
+        now = Time.now
+        body = env[:body]
+        @app.call(env).on_complete do
+          method = env[:method].to_s.upcase
+          time = ((Time.now - now) * 1000).to_i
+          message = "ElasticSearch #{method} (#{time}ms) #{env[:url].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/nested_document.rb

@@ -0,0 +1,29 @@
+module Elastictastic
+  module NestedDocument
+    extend ActiveSupport::Concern
+
+    included do
+      include Properties
+      include Dirty
+      include Dirty::NestedDocumentMethods
+      include MassAssignmentSecurity
+      include Validations
+    end
+
+    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
+end

data/lib/elastictastic/new_relic_instrumentation.rb

@@ -0,0 +1,26 @@
+begin
+  require 'new_relic/agent/method_tracer'
+rescue LoadError => e
+  raise LoadError, "Can't use NewRelic instrumentation without NewRelic gem"
+end
+
+module Elastictastic
+  module NewRelicInstrumentation
+    extend ActiveSupport::Concern
+
+    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'
+    end
+  end
+end
+
+Elastictastic::Client.module_eval { include Elastictastic::NewRelicInstrumentation }

data/lib/elastictastic/observer.rb

@@ -0,0 +1,3 @@
+module Elastictastic
+  Observer = Class.new(ActiveModel::Observer)
+end

data/lib/elastictastic/observing.rb

@@ -0,0 +1,21 @@
+module Elastictastic
+  module Observing
+    extend ActiveSupport::Concern
+    extend ActiveModel::Observing::ClassMethods
+
+    included do
+      include ActiveModel::Observing
+    end
+
+    module InstanceMethods
+      Callbacks::HOOKS.each do |method|
+        module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*args)
+            notify_observers(:before_#{method})
+            super.tap { notify_observers(:after_#{method}) }
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/elastictastic/parent_child.rb

@@ -0,0 +1,115 @@
+module Elastictastic
+  module ParentChild
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      attr_reader :parent_association
+
+      def belongs_to(parent_name, options = {})
+        @parent_association = Association.new(parent_name, options)
+
+        module_eval(<<-RUBY, __FILE__, __LINE__+1)
+          def #{parent_name}
+            _parent
+          end
+        RUBY
+      end
+
+      def has_many(children_name, options = {})
+        children_name = children_name.to_s
+        child_associations[children_name] = Association.new(children_name, options)
+
+        module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{children_name}
+            read_child(#{children_name.inspect})
+          end
+        RUBY
+      end
+
+      def child_association(name)
+        child_associations[name.to_s]
+      end
+
+      def child_associations
+        @child_associations ||= {}
+      end
+
+      def mapping
+        super.tap do |mapping|
+          mapping[type]['_parent'] = { 'type' => @parent_association.clazz.type } if @parent_association
+        end
+      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
+      end
+
+      def _parent #:nodoc:
+        return @parent if defined? @parent
+        @parent =
+          if @parent_id
+            self.class.parent_association.clazz.find(@parent_id)
+          end
+      end
+
+      def _parent_id #:nodoc:
+        if @parent
+          @parent_id = @parent.id
+        elsif @parent_id
+          @parent_id
+        end
+      end
+
+      def parent_collection=(parent_collection)
+        if @parent_collection
+          raise Elastictastic::IllegalModificationError,
+            "Document is already a child of #{_parent}"
+        end
+        if persisted?
+          raise Elastictastic::IllegalModificationError,
+            "Can't change parent of persisted object"
+        end
+        @parent_collection = parent_collection
+        @parent = parent_collection.parent
+      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
+      end
+
+      def persisted!
+        was_persisted = @persisted
+        super
+        if @parent_collection && !was_persisted
+          @parent_collection.persisted!(self)
+        end
+      end
+
+      protected
+
+      def read_child(field_name)
+        @children[field_name.to_s]
+      end
+
+    end
+  end
+end