elastictastic 0.5.0

data/lib/elastictastic/search.rb

@@ -0,0 +1,180 @@
+module Elastictastic
+  class Search
+    KEYS = %w(query filter from size sort highlight fields script_fields
+              preference facets)
+
+    attr_reader :sort, :from, :size, :fields, :script_fields, :preference, :facets
+    delegate :[], :to => :params
+
+    def initialize(params = {})
+      params = Util.deep_stringify(params) # this creates a copy
+      @queries, @query_filters = extract_queries_and_query_filters(params['query'])
+      @filters = extract_filters(params['filter'])
+      @from = params.delete('from')
+      @size = params.delete('size')
+      @sort = Util.ensure_array(params.delete('sort'))
+      highlight = params.delete('highlight')
+      if highlight
+        @highlight_fields = highlight.delete('fields')
+        @highlight_settings = highlight
+      end
+      @fields = Util.ensure_array(params.delete('fields'))
+      @script_fields = params.delete('script_fields')
+      @preference = params.delete('preference')
+      @facets = params.delete('facets')
+    end
+
+    def initialize_copy(other)
+      @queries = deep_copy(other.queries)
+      @query_filters = deep_copy(other.query_filters)
+      @filters = deep_copy(other.filters)
+      @sort = deep_copy(other.sort)
+      @highlight = deep_copy(other.highlight)
+      @fields = other.fields.dup if other.fields
+      @script_fields = deep_copy(other.script_fields)
+      @facets = deep_copy(other.facets)
+    end
+
+    def params
+      {}.tap do |params|
+        params['query'] = query
+        params['filter'] = filter
+        params['from'] = from
+        params['size'] = size
+        params['sort'] = maybe_array(sort)
+        params['highlight'] = highlight
+        params['fields'] = maybe_array(fields)
+        params['script_fields'] = script_fields
+        params['preference'] = preference
+        params['facets'] = facets
+        params.reject! { |k, v| v.blank? }
+      end
+    end
+
+    def query
+      query_query = maybe_array(queries) do
+        { 'bool' => { 'must' => queries }}
+      end
+      query_filter = maybe_array(query_filters) do
+        { 'and' => query_filters }
+      end
+      if query_query
+        if query_filter
+          { 'filtered' => { 'query' => query_query, 'filter' => query_filter }}
+        else
+          query_query
+        end
+      elsif query_filter
+        { 'constant_score' => { 'filter' => query_filter }}
+      end
+    end
+
+    def filter
+      maybe_array(filters) do
+        { 'and' => filters }
+      end
+    end
+
+    def highlight
+      if @highlight_fields
+        @highlight_settings.merge('fields' => @highlight_fields)
+      end
+    end
+
+    def merge(other)
+      dup.merge!(other)
+    end
+
+    def merge!(other)
+      @queries = combine(@queries, other.queries)
+      @query_filters = combine(@query_filters, other.query_filters)
+      @filters = combine(@filters, other.filters)
+      @from = other.from  || @from
+      @size = other.size || @size
+      @sort = combine(@sort, other.sort)
+      if @highlight_fields && other.highlight_fields
+        @highlight_fields = combine(highlight_fields_with_settings, other.highlight_fields_with_settings)
+        @highlight_settings = {}
+      else
+        @highlight_settings = combine(@highlight_settings, other.highlight_settings)
+        @highlight_fields = combine(@highlight_fields, other.highlight_fields)
+      end
+      @fields = combine(@fields, other.fields)
+      @script_fields = combine(@script_fields, other.script_fields)
+      @preference = other.preference || @preference
+      @facets = combine(@facets, other.facets)
+      self
+    end
+
+    protected
+    attr_reader :queries, :query_filters, :filters, :highlight_fields,
+                :highlight_settings
+
+    def highlight_fields_with_settings
+      if @highlight_fields
+        {}.tap do |fields_with_settings|
+          @highlight_fields.each_pair do |field, settings|
+            fields_with_settings[field] = @highlight_settings.merge(settings)
+          end
+        end
+      end
+    end
+
+    private
+
+    def maybe_array(array)
+      case array.length
+      when 0 then nil
+      when 1 then array.first
+      else
+        if block_given? then yield
+        else array
+        end
+      end
+    end
+
+    def combine(object1, object2)
+      if object1.nil? then object2
+      elsif object2.nil? then object1
+      else 
+        case object1
+        when Array then object1 + object2
+        when Hash then object1.merge(object2)
+        else raise ArgumentError, "Don't know how to combine #{object1.inspect} with #{object2.inspect}"
+        end
+      end
+    end
+
+    def extract_queries_and_query_filters(params)
+      if params.nil? then [[], []]
+      elsif params.keys == %w(filtered)
+        [extract_queries(params['filtered']['query']), extract_filters(params['filtered']['filter'])]
+      elsif params.keys == %w(constant_score) && params['constant_score'].keys == %w(filter)
+        [[], extract_filters(params['constant_score']['filter'])]
+      else
+        [extract_queries(params), []]
+      end
+    end
+
+    def extract_queries(params)
+      if params.nil? then []
+      elsif params.keys == %w(bool) && params['bool'].keys == %w(must)
+        params['bool']['must']
+      else [params]
+      end
+    end
+
+    def extract_filters(params)
+      if params.nil? then []
+      elsif params.keys == %w(and)
+        params['and']
+      else
+        [params]
+      end
+    end
+
+    def deep_copy(object)
+      Marshal.load(Marshal.dump(object)) unless object.nil?
+    end
+  end
+end

data/lib/elastictastic/server_error.rb

@@ -0,0 +1,15 @@
+module Elastictastic
+  module ServerError
+    class ServerError < StandardError
+      attr_accessor :status
+    end
+
+    class <<self
+      def const_missing(name)
+        Class.new(::Elastictastic::ServerError::ServerError).tap do |error|
+          const_set(name, error)
+        end
+      end
+    end
+  end
+end

data/lib/elastictastic/test_helpers.rb

@@ -0,0 +1,172 @@
+require 'fakeweb'
+
+module Elastictastic
+  module TestHelpers
+    ALPHANUM = ('0'..'9').to_a + ('A'..'Z').to_a + ('a'..'z').to_a
+
+    def stub_elasticsearch_create(index, type, *args)
+      options = args.extract_options!
+      id = args.pop
+      if id.nil?
+        id = ''
+        22.times { id << ALPHANUM[rand(ALPHANUM.length)] }
+        path = "/#{index}/#{type}"
+        method = :post
+      else
+        path = "/#{index}/#{type}/#{id}/_create"
+        method = :put
+      end
+
+      FakeWeb.register_uri(
+        method,
+        /^#{Regexp.escape(TestHelpers.uri_for_path(path))}(\?.*)?$/,
+        options.reverse_merge(:body => {
+          'ok' => 'true',
+          '_index' => index,
+          '_type' => type,
+          '_id' => id
+        }.to_json)
+      )
+      id
+    end
+
+    def stub_elasticsearch_update(index, type, id)
+      FakeWeb.register_uri(
+        :put,
+        /^#{TestHelpers.uri_for_path("/#{index}/#{type}/#{id}")}(\?.*)?$/,
+        :body => {
+          'ok' => 'true',
+          '_index' => index,
+          '_type' => type,
+          '_id' => id
+        }.to_json
+      )
+    end
+
+    def stub_elasticsearch_get(index, type, id, doc = {})
+      FakeWeb.register_uri(
+        :get,
+        /^#{Regexp.escape(TestHelpers.uri_for_path("/#{index}/#{type}/#{id}").to_s)}(\?.*)?$/,
+        :body => {
+          'ok' => true,
+          '_index' => index,
+          '_type' => type,
+          '_id' => id,
+          '_source' => doc,
+          'exists' => !doc.nil?
+        }.to_json
+      )
+    end
+
+    def stub_elasticsearch_mget(index, type, *ids)
+      given_ids_with_docs = ids.extract_options!
+      ids_with_docs = {}
+      ids.each { |id| ids_with_docs[id] = {} }
+      ids_with_docs.merge!(given_ids_with_docs)
+      path = index ? "/#{index}/#{type}/_mget" : "/_mget"
+      docs = ids_with_docs.each_pair.map do |id, doc|
+        id, index = *id if Array === id
+        {
+          '_index' => index,
+          '_type' => type,
+          '_id' => id,
+          'exists' => !!doc,
+          '_source' => doc
+        }
+      end
+
+      FakeWeb.register_uri(
+        :post,
+        TestHelpers.uri_for_path(path).to_s,
+        :body => {
+          'docs' => docs
+        }.to_json
+      )
+    end
+
+    def stub_elasticsearch_destroy(index, type, id, options = {})
+      FakeWeb.register_uri(
+        :delete,
+        /^#{TestHelpers.uri_for_path("/#{index}/#{type}/#{id}")}(\?.*)?$/,
+        options.reverse_merge(:body => {
+          'ok' => true,
+          'found' => true,
+          '_index' => 'test',
+          '_type' => 'test',
+          '_id' => id,
+          '_version' => 1
+        }.to_json)
+      )
+    end
+
+    def stub_elasticsearch_destroy_all(index, type)
+      FakeWeb.register_uri(
+        :delete,
+        TestHelpers.uri_for_path("/#{index}/#{type}"),
+        :body => { 'ok' => true }.to_json
+      )
+    end
+
+    def stub_elasticsearch_bulk(*responses)
+      FakeWeb.register_uri(
+        :post,
+        TestHelpers.uri_for_path("/_bulk"),
+        :body => { 'took' => 1, 'items' => responses }.to_json
+      )
+    end
+
+    def stub_elasticsearch_put_mapping(index, type)
+      FakeWeb.register_uri(
+        :put,
+        TestHelpers.uri_for_path("/#{index}/#{type}/_mapping"),
+        :body => { 'ok' => true, 'acknowledged' =>  true }.to_json
+      )
+    end
+
+    def stub_elasticsearch_search(index, type, data)
+      if Array === data
+        response = data.map do |datum|
+          { :body => datum.to_json }
+        end
+      else
+        response = { :body =>  data.to_json }
+      end
+
+      uri = TestHelpers.uri_for_path("/#{index}/#{type}/_search").to_s
+      FakeWeb.register_uri(
+        :post,
+        /^#{Regexp.escape(uri)}/,
+        response
+      )
+    end
+
+    def stub_elasticsearch_scan(index, type, batch_size, *hits)
+      scan_uri = Regexp.escape(TestHelpers.uri_for_path("/#{index}/#{type}/_search").to_s)
+      scroll_ids = Array.new(batch_size + 1) { rand(10**100).to_s(36) }
+      FakeWeb.register_uri(
+        :post,
+        /^#{scan_uri}\?.*search_type=scan/,
+        :body => {
+          '_scroll_id' => scroll_ids.first,
+          'hits' => { 'total' => hits.length, 'hits' => [] }
+        }.to_json
+      )
+
+      batches = hits.each_slice(batch_size).each_with_index.map do |hit_batch, i|
+        { :body => { '_scroll_id' => scroll_ids[i+1], 'hits' => { 'hits' => hit_batch }}.to_json }
+      end
+      batches << { :body => { 'hits' => { 'hits' => [] }}.to_json }
+      scroll_uri = Regexp.escape(TestHelpers.uri_for_path("/_search/scroll").to_s)
+      FakeWeb.register_uri(
+        :post,
+        /^#{scroll_uri}/,
+        batches
+      )
+      scroll_ids
+    end
+
+    def self.uri_for_path(path)
+      "#{Elastictastic.config.hosts.first}#{path}"
+    end
+  end
+end

data/lib/elastictastic/util.rb

@@ -0,0 +1,63 @@
+module Elastictastic
+  module Util
+    extend self
+
+    def deep_stringify(hash)
+      {}.tap do |stringified|
+        hash.each_pair do |key, value|
+          stringified[key.to_s] = Hash === value ? deep_stringify(value) : value
+        end
+      end
+    end
+
+    def deep_merge(l, r)
+      if l.nil? then r
+      elsif r.nil? then l
+      elsif Hash === l && Hash === r
+        {}.tap do |merged|
+          (l.keys | r.keys).each do |key|
+            merged[key] = deep_merge(l[key], r[key])
+          end
+        end
+      elsif Array === l && Array === r then l + r
+      elsif Array === l then l + [r]
+      elsif Array === r then [l] + r
+      else [l, r]
+      end
+    end
+
+    def ensure_array(object)
+      case object
+      when nil then []
+      when Array then object
+      else [object]
+      end
+    end
+
+    def call_or_each(object, &block)
+      if Array === object then object.each(&block)
+      else
+        block.call(object)
+        object
+      end
+    end
+
+    def call_or_map(object, &block)
+      if Array === object then object.map(&block)
+      else block.call(object)
+      end
+    end
+
+    def unflatten_hash(hash)
+      {}.tap do |unflattened|
+        hash.each_pair do |key, value|
+          namespace = key.split('.')
+          field_name = namespace.pop
+          namespace.inject(unflattened) do |current, component|
+            current[component] ||= {}
+          end[field_name] = value
+        end
+      end
+    end
+  end
+end

data/lib/elastictastic/validations.rb

@@ -0,0 +1,45 @@
+module Elastictastic
+  module Validations
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModel::Validations
+    end
+
+    module ClassMethods
+      def embed(*embed_names)
+        super
+        embed_names.extract_options!
+        args = embed_names + [{ :nested => true }]
+        validates(*args)
+      end
+    end
+
+    module InstanceMethods
+      def save
+        if valid?
+          super
+          true
+        else
+          false
+        end
+      end
+
+      def save!
+        if !save
+          raise Elastictastic::RecordInvalid, errors.full_messages.to_sentence
+        end
+        self
+      end
+    end
+
+    class NestedValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        value = [value].compact unless Array === value
+        unless value.all? { |el| el.valid? }
+          record.errors[:attribute] = :invalid
+        end
+      end
+    end
+  end
+end

data/lib/elastictastic/version.rb

@@ -0,0 +1,3 @@
+module Elastictastic
+  VERSION = '0.5.0'
+end

data/lib/elastictastic.rb

@@ -0,0 +1,82 @@
+require 'active_support/core_ext'
+require 'active_model'
+require 'elastictastic/errors'
+
+module Elastictastic
+  autoload :Association, 'elastictastic/association'
+  autoload :BulkPersistenceStrategy, 'elastictastic/bulk_persistence_strategy'
+  autoload :Callbacks, 'elastictastic/callbacks'
+  autoload :ChildCollectionProxy, 'elastictastic/child_collection_proxy'
+  autoload :Client, 'elastictastic/client'
+  autoload :Configuration, 'elastictastic/configuration'
+  autoload :Dirty, 'elastictastic/dirty'
+  autoload :DiscretePersistenceStrategy, 'elastictastic/discrete_persistence_strategy'
+  autoload :Document, 'elastictastic/document'
+  autoload :Field, 'elastictastic/field'
+  autoload :Index, 'elastictastic/index'
+  autoload :MassAssignmentSecurity, 'elastictastic/mass_assignment_security'
+  autoload :Middleware, 'elastictastic/middleware'
+  autoload :NestedCollectionProxy, 'elastictastic/nested_collection_proxy'
+  autoload :NestedDocument, 'elastictastic/nested_document'
+  autoload :Observer, 'elastictastic/observer'
+  autoload :Observing, 'elastictastic/observing'
+  autoload :ParentChild, 'elastictastic/parent_child'
+  autoload :Persistence, 'elastictastic/persistence'
+  autoload :Properties, 'elastictastic/properties'
+  autoload :Resource, 'elastictastic/resource'
+  autoload :Scope, 'elastictastic/scope'
+  autoload :ScopeBuilder, 'elastictastic/scope_builder'
+  autoload :Scoped, 'elastictastic/scoped'
+  autoload :Search, 'elastictastic/search'
+  autoload :ServerError, 'elastictastic/server_error'
+  autoload :TestHelpers, 'elastictastic/test_helpers'
+  autoload :Util, 'elastictastic/util'
+  autoload :Validations, 'elastictastic/validations'
+
+  class <<self
+    attr_writer :config
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def client
+      Thread.current['Elastictastic::client'] ||= Client.new(config)
+    end
+
+    def persister=(persister)
+      Thread.current['Elastictastic::persister'] = persister
+    end
+
+    def persister
+      Thread.current['Elastictastic::persister'] ||=
+        Elastictastic::DiscretePersistenceStrategy.instance
+    end
+
+    def bulk
+      original_persister = self.persister
+      begin
+        self.persister = Elastictastic::BulkPersistenceStrategy.new
+        yield
+        self.persister.flush
+      rescue Elastictastic::CancelBulkOperation
+        # Nothing to see here...
+      ensure
+        self.persister = original_persister
+      end
+    end
+
+    def Index(name_or_index)
+      Index === name_or_index ?  name_or_index : Index.new(name_or_index)
+    end
+
+    private
+
+    def new_transport
+      transport_class = const_get("#{config.transport.camelize}Transport")
+      transport_class.new(config)
+    end
+  end
+end
+
+require 'elastictastic/railtie' if defined? Rails

data/spec/environment.rb

@@ -0,0 +1,6 @@
+require 'bundler'
+Bundler.require(:default, :test, :development)
+
+%w(author blog comment post post_observer).each do |model|
+  require File.expand_path("../models/#{model}", __FILE__)
+end

data/spec/examples/active_model_lint_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe 'ActiveModel compliance' do
+  include ActiveModel::Lint::Tests
+
+  ActiveModel::Lint::Tests.public_instance_methods.each do |method|
+    method = method.to_s
+    if method =~ /^test_/
+      example method.gsub('_', ' ') do
+        __send__(method)
+      end
+    end
+  end
+
+  private
+
+  def model
+    Post.new
+  end
+end