elastic-rails 0.5.0 → 0.6.0

data/lib/elastic/railtie.rb

@@ -1,8 +1,10 @@
 require "elastic/railties/utils"
 require "elastic/railties/ar_helpers"
 require "elastic/railties/ar_middleware"
+require "elastic/railties/configuration_extensions"
 require "elastic/railties/type_extensions"
 require "elastic/railties/query_extensions"
+require "elastic/railties/indexing_job"
 require "elastic/railties/indexable_record"
 
 module Elastic
@@ -27,6 +29,11 @@ module Elastic
   extend Elastic::Railties::Utils
 end
 
+# Add activerecord related configuration parameters
+module Elastic::Configuration
+  include Elastic::Railties::ConfigurationExtensions
+end
+
 # Add activerecord related index helpers
 class Elastic::Type
   include Elastic::Railties::TypeExtensions

data/lib/elastic/railties/ar_helpers.rb

@@ -42,7 +42,8 @@ module Elastic::Railties
       when :string            then { type: :string, index: 'not_analyzed' }
       when :integer           then { type: :long } # not sure..
       when :float, :decimal   then { type: :double } # not sure..
-      when :datetime, :date   then { type: :date }
+      when :date              then { type: :date }
+      when :datetime          then { type: :time }
       when :boolean           then { type: :boolean }
       end
     end

data/lib/elastic/railties/configuration_extensions.rb

@@ -0,0 +1,13 @@
+module Elastic::Railties
+  module ConfigurationExtensions
+    def self.included(_klass)
+      _klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      def active_job_queue
+        config[:active_job_queue] || :default
+      end
+    end
+  end
+end

data/lib/elastic/railties/indexable_record.rb

@@ -41,8 +41,7 @@ module Elastic::Railties
     end
 
     def index_later
-      # TODO: ActiveJob support
-      index_now
+      IndexingJob.set(queue: Elastic::Configuration.active_job_queue).perform_later(self)
     end
   end
 end

data/lib/elastic/railties/indexing_job.rb

@@ -0,0 +1,8 @@
+module Elastic::Railties
+  class IndexingJob < ActiveJob::Base
+    def perform(*_indexables)
+      # TODO: use import for many indexables
+      _indexables.each &:index_now
+    end
+  end
+end

data/lib/elastic/railties/type_extensions.rb

@@ -7,7 +7,7 @@ module Elastic::Railties
     module ClassMethods
       def references(*_includes)
         # TODO: check target allows options
-        definition.middleware_options[:ar_collect_includes] = _includes
+        pre_definition.middleware_options[:ar_collect_includes] = _includes
       end
     end
   end

data/lib/elastic/results/aggregations.rb

@@ -9,7 +9,7 @@ module Elastic::Results
     end
 
     def [](_key)
-      @aggs[_key.to_s].try(:as_value)
+      @aggs[_key.to_sym].try(:as_value)
     end
 
     def each(&_block)

data/lib/elastic/results/bucket.rb

@@ -1,9 +1,10 @@
 module Elastic::Results
   class Bucket < Aggregations
-    attr_reader :key
+    attr_reader :key, :total
 
-    def initialize(_key, _aggs)
+    def initialize(_key, _total, _aggs)
       @key = _key
+      @total = _total
       super _aggs
     end
 

data/lib/elastic/results/grouped_result.rb

@@ -2,7 +2,10 @@ module Elastic::Results
   class GroupedResult < Base
     include Enumerable
 
-    def initialize(_groups)
+    attr_reader :key_names
+
+    def initialize(_key_names, _groups)
+      @key_names = _key_names.freeze
       @groups = _groups.to_a
     end
 
@@ -10,6 +13,19 @@ module Elastic::Results
       @groups.map { |g| group_as_pair g }.each(&_block)
     end
 
+    def [](_key)
+      if _key.is_a? Hash
+        mapped_results[_key]
+      else
+        raise ArgumentError, '' if @key_names.length > 1
+        mapped_results[@key_names.first => _key]
+      end
+    end
+
+    def each_group(&_block)
+      @groups.each(&_block)
+    end
+
     def last
       return nil if @groups.count == 0
       group_as_pair @groups.last
@@ -28,10 +44,24 @@ module Elastic::Results
       @groups.each { |h| h.traverse(&_block) }
     end
 
+    def map_to_group(&_block)
+      self.class.new(@key_names, @groups.map do |group|
+        Elastic::Results::ResultGroup.new group.keys, _block.call(group.as_value)
+      end)
+    end
+
     private
 
     def group_as_pair(_group)
       [_group.keys, _group.as_value]
     end
+
+    def mapped_results
+      @mapped_results ||= {}.tap do |map|
+        @groups.each do |g|
+          map[g.keys] = g.as_value
+        end
+      end
+    end
   end
 end

data/lib/elastic/results/hit.rb

@@ -1,25 +1,13 @@
 module Elastic::Results
   class Hit < Base
-    attr_accessor :raw, :ref
-
-    def initialize(_raw)
-      @raw = _raw
-    end
-
-    def id
-      @raw['_id']
-    end
-
-    def type
-      @raw['_type']
-    end
-
-    def score
-      @raw['_score']
-    end
-
-    def source
-      @raw['_source']
+    attr_reader :type, :id, :score, :source
+    attr_accessor :data
+
+    def initialize(_type, _id, _score, _source)
+      @type = _type
+      @id = _id
+      @score = _score
+      @source = _source
     end
   end
 end

data/lib/elastic/results/hit_collection.rb

@@ -1,38 +1,7 @@
 module Elastic::Results
-  class HitCollection < Base
-    include Enumerable
-
-    def initialize(_hits)
-      @hits = _hits
-    end
-
-    def count
-      @hits.count
-    end
-
-    def [](_idx)
-      @hits[_idx].try(:ref)
-    end
-
-    def last
-      @hits.last.try(:ref)
-    end
-
-    def each(&_block)
-      @hits.map(&:ref).each(&_block)
-    end
-
+  class HitCollection < ScoredCollection
     def each_hit(&_block)
-      @hits.each(&_block)
-    end
-
-    def each_with_score(&_block)
-      @hits.map { |h| [h.ref, h.score] }.each(&_block)
-    end
-
-    def traverse(&_block)
-      super
-      @hits.each { |h| h.traverse(&_block) }
+      collection.each(&_block)
     end
   end
 end

data/lib/elastic/results/root.rb

@@ -1,9 +1,10 @@
 module Elastic::Results
   class Root < HitCollection
-    attr_reader :aggregations
+    attr_reader :aggregations, :total
 
-    def initialize(_hits, _aggs)
+    def initialize(_hits, _total, _aggs)
       super _hits
+      @total = _total
       @aggregations = Aggregations.new _aggs
     end
 

data/lib/elastic/results/scored_collection.rb

@@ -0,0 +1,44 @@
+module Elastic::Results
+  class ScoredCollection < Base
+    include Enumerable
+
+    def initialize(_collection)
+      @collection = _collection
+    end
+
+    def count
+      @collection.count
+    end
+
+    def [](_idx)
+      @collection[_idx].try(:data)
+    end
+
+    def last
+      @collection.last.try(:data)
+    end
+
+    def each(&_block)
+      @collection.map(&:data).each(&_block)
+    end
+
+    def each_with_score(&_block)
+      @collection.map { |sd| [sd.data, sd.score] }.each(&_block)
+    end
+
+    def map_with_score(&_block)
+      ScoredCollection.new(
+        @collection.map { |sd| ScoredItem.new(_block.call(sd), sd.score) }.to_a
+      )
+    end
+
+    def traverse(&_block)
+      super
+      @collection.each { |sd| sd.traverse(&_block) }
+    end
+
+    private
+
+    attr_reader :collection
+  end
+end

data/lib/elastic/results/scored_item.rb

@@ -0,0 +1,10 @@
+module Elastic::Results
+  class ScoredItem < Base
+    attr_reader :data, :score
+
+    def initialize(_data, _score)
+      @data = _data
+      @score = _score
+    end
+  end
+end

data/lib/elastic/shims/base.rb

@@ -12,12 +12,14 @@ module Elastic::Shims
       @child.traverse(&_block)
     end
 
-    def render
-      @child.render
+    def render(_options = {})
+      @child.render(_options)
     end
 
-    def handle_result(_raw)
-      @child.handle_result(_raw)
+    def handle_result(_raw, _formatter)
+      @child.handle_result(_raw, _formatter)
     end
   end
 end
+
+require "elastic/shims/concerns/hit_picker"

data/lib/elastic/shims/concerns/hit_picker.rb

@@ -0,0 +1,41 @@
+module Elastic::Shims::Concerns
+  module HitPicker
+    def render(_options = {})
+      set_hits_source unless required_source_fields.nil?
+      super
+    end
+
+    def handle_result(_raw, _formatter)
+      result = super
+
+      case result
+      when Elastic::Results::Root
+        transform_collection(result)
+      when Elastic::Results::GroupedResult
+        result.map_to_group { |c| transform_collection(c) }
+      else
+        raise "unable to pick from result of type #{result.class}"
+      end
+    end
+
+    private
+
+    def set_hits_source
+      child.pick(Elastic::Nodes::Concerns::HitProvider) do |node|
+        node.source = required_source_fields
+      end
+    end
+
+    def transform_collection(_collection)
+      _collection.map_with_score { |h| pick_from_hit(h) }
+    end
+
+    def pick_from_hit(_hit)
+      raise NotImplementedError, 'pick_from_hit not implemented'
+    end
+
+    def required_source_fields
+      nil
+    end
+  end
+end

data/lib/elastic/shims/field_picking.rb

@@ -0,0 +1,20 @@
+module Elastic::Shims
+  class FieldPicking < Base
+    include Elastic::Shims::Concerns::HitPicker
+
+    def initialize(_child, _field)
+      super(_child)
+      @field = _field
+    end
+
+    private
+
+    def pick_from_hit(_hit)
+      _hit.source[@field]
+    end
+
+    def required_source_fields
+      [@field]
+    end
+  end
+end

data/lib/elastic/shims/grouping.rb

@@ -1,23 +1,32 @@
 module Elastic::Shims
   class Grouping < Base
-    def handle_result(_raw)
-      groups = []
-      group_recursive(super.aggregations, HashWithIndifferentAccess.new, groups)
-      Elastic::Results::GroupedResult.new groups
+    def handle_result(_raw, _formatter)
+      chain = extract_aggregation_chain
+      groups = group_recursive(super.aggregations, chain)
+      Elastic::Results::GroupedResult.new chain, groups
     end
 
     private
 
-    def group_recursive(_agg_context, _keys, _groups)
-      name, agg = _agg_context.first
+    def extract_aggregation_chain
+      child.pick(Elastic::Nodes::Concerns::Aggregable).map do |node|
+        bucketed = node.aggregations.find { |n| n.is_a? Elastic::Nodes::Concerns::Bucketed }
+        bucketed.try(:name)
+      end.reject(&:nil?)
+    end
 
-      if agg.is_a? Elastic::Results::BucketCollection
+    def group_recursive(_agg_context, _chain, _keys = {}, _groups = [], _idx = 0)
+      if _idx < _chain.length
+        name = _chain[_idx]
+        agg = _agg_context[name] || []
         agg.each do |bucket|
-          group_recursive(bucket, _keys.merge(name => bucket.key), _groups)
+          group_recursive(bucket, _chain, _keys.merge(name => bucket.key), _groups, _idx + 1)
         end
       else
         _groups << Elastic::Results::ResultGroup.new(_keys, _agg_context)
       end
+
+      _groups
     end
   end
 end

data/lib/elastic/shims/id_picking.rb

@@ -0,0 +1,15 @@
+module Elastic::Shims
+  class IdPicking < Base
+    include Elastic::Shims::Concerns::HitPicker
+
+    private
+
+    def pick_from_hit(_hit)
+      _hit.id
+    end
+
+    def required_source_fields
+      false
+    end
+  end
+end

data/lib/elastic/shims/populating.rb

@@ -6,12 +6,12 @@ module Elastic::Shims
       @config = _config
     end
 
-    def render
+    def render(_options = {})
       disable_hits_source if populate_by_id?
       super
     end
 
-    def handle_result(_raw)
+    def handle_result(_raw, _formatter)
       result = super
       populate result
       result
@@ -37,13 +37,10 @@ module Elastic::Shims
       if populate_by_id?
         ids = _hits.map(&:id)
         objects = target.find_by_ids(ids, middleware_options)
-        objects.each_with_index { |o, i| _hits[i].ref = o }
+        objects.each_with_index { |o, i| _hits[i].data = o }
       else
         _hits.each do |hit|
-          hit.ref = target.build_from_data(
-            formatter.format(hit.source),
-            middleware_options
-          )
+          hit.data = target.build_from_data(hit.source, middleware_options)
         end
       end
     end
@@ -61,9 +58,5 @@ module Elastic::Shims
         @index.definition.middleware_options.merge(@config.middleware_options).freeze
       end
     end
-
-    def formatter
-      @formatter ||= Elastic::Core::SourceFormatter.new(@index.mapping)
-    end
   end
 end

data/lib/elastic/shims/reducing.rb

@@ -1,19 +1,15 @@
 module Elastic::Shims
   class Reducing < Base
-    def handle_result(_raw)
+    def handle_result(_raw, _formatter)
       result = super
 
       case result
       when Elastic::Results::Root
         result.aggregations.first.last.as_value
       when Elastic::Results::GroupedResult
-        groups = result.map do |keys, bucket|
-          Elastic::Results::ResultGroup.new keys, bucket.first.last
-        end
-
-        Elastic::Results::GroupedResult.new groups
+        result.map_to_group { |b| b.first.last }
       else
-        result
+        raise "unable to reduce result of type #{result.class}"
       end
     end
   end

data/lib/elastic/shims/total_picking.rb

@@ -0,0 +1,16 @@
+module Elastic::Shims
+  class TotalPicking < Base
+    def handle_result(_raw, _formatter)
+      result = super
+
+      case result
+      when Elastic::Results::Root
+        result.total
+      when Elastic::Results::GroupedResult
+        result.map_to_group { |bucket| Elastic::Results::Metric.new(bucket.total) }
+      else
+        raise "unable to pick from result of type #{result.class}"
+      end
+    end
+  end
+end

data/lib/elastic/type.rb

@@ -81,13 +81,16 @@ module Elastic
       end
     end
 
-    private_class_method def self.load_mapping
-      freeze_index_definition
+    def self.load_mapping
       Elastic::Core::MappingManager.new(adaptor, definition).tap(&:fetch)
     end
 
-    private_class_method def self.default_suffix
+    private_class_method :load_mapping
+
+    def self.default_suffix
       to_s.underscore
     end
+
+    private_class_method :default_suffix
   end
 end

data/lib/elastic/types/base_type.rb

@@ -1,38 +1,45 @@
 module Elastic::Types
   class BaseType < Elastic::Core::Serializer
     def self.target=(_name_or_class)
-      definition.targets = [_name_or_class]
+      pre_definition.targets = [_name_or_class]
     end
 
     def self.targets=(_names_or_classes)
-      definition.targets = _names_or_classes
+      pre_definition.targets = _names_or_classes
     end
 
-    def self.definition
-      @definition ||= Elastic::Core::Definition.new.tap do |definition|
+    def self.pre_definition
+      @pre_definition ||= Elastic::Core::Definition.new.tap do |definition|
         definition.targets = [default_target] unless default_target.nil?
       end
     end
 
-    def self.freeze_index_definition
-      unless definition.frozen?
-        definition.fields.each do |field|
+    def self.definition
+      @definition ||= begin
+        pre_definition.fields.each do |field|
           field.disable_mapping_inference if original_value_occluded? field.name
         end
 
-        definition.freeze
+        pre_definition.freeze
+        pre_definition
       end
     end
 
+    def self.freeze_definition
+      definition # calling definition freezes it
+    end
+
     def initialize(_object)
       super(self.class.definition, _object)
     end
 
-    private_class_method def self.default_target
+    def self.default_target
       @default_target ||= begin
         target = to_s.match(/^(.*)Index$/)
         target ? target[1] : nil
       end
     end
+
+    private_class_method :default_target
   end
 end

data/lib/elastic/types/faceted_type.rb

@@ -10,7 +10,7 @@ module Elastic::Types
     end
 
     def field(_name, _options = {})
-      definition.register_field Elastic::Fields::Value.new(_name, _options)
+      pre_definition.register_field Elastic::Fields::Value.new(_name, _options)
     end
   end
 end

data/lib/elastic/types/nestable_type.rb

@@ -6,9 +6,9 @@ module Elastic::Types
         using.target = (target || _name.to_s.singularize.camelize.constantize) rescue nil
       end
 
-      using = (_name + '_index').camelize.constantize if using.nil?
+      using = (_name.to_s.singularize + '_index').camelize.constantize if using.nil?
 
-      definition.register_field Elastic::Fields::Nested.new(_name, using)
+      pre_definition.register_field Elastic::Fields::Nested.new(_name, using)
     end
   end
 end

data/lib/elastic/version.rb

@@ -1,3 +1,3 @@
 module Elastic
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end