elastic-rails 0.1.0 → 0.5.0

data/lib/elastic/results/bucket_collection.rb

@@ -0,0 +1,17 @@
+module Elastic::Results
+  class BucketCollection < Base
+    extend Forwardable
+    include Enumerable
+
+    def_delegators :@buckets, :last, :first, :count, :[], :each
+
+    def initialize(_buckets)
+      @buckets = _buckets
+    end
+
+    def traverse(&_block)
+      super
+      @buckets.each { |b| b.traverse(&_block) }
+    end
+  end
+end

data/lib/elastic/results/grouped_result.rb

@@ -0,0 +1,37 @@
+module Elastic::Results
+  class GroupedResult < Base
+    include Enumerable
+
+    def initialize(_groups)
+      @groups = _groups.to_a
+    end
+
+    def each(&_block)
+      @groups.map { |g| group_as_pair g }.each(&_block)
+    end
+
+    def last
+      return nil if @groups.count == 0
+      group_as_pair @groups.last
+    end
+
+    def count
+      @groups.count
+    end
+
+    def group_at(_idx)
+      @groups[_idx]
+    end
+
+    def traverse(&_block)
+      super
+      @groups.each { |h| h.traverse(&_block) }
+    end
+
+    private
+
+    def group_as_pair(_group)
+      [_group.keys, _group.as_value]
+    end
+  end
+end

data/lib/elastic/results/hit.rb

@@ -0,0 +1,25 @@
+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']
+    end
+  end
+end

data/lib/elastic/results/hit_collection.rb

@@ -0,0 +1,38 @@
+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
+
+    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) }
+    end
+  end
+end

data/lib/elastic/results/metric.rb

@@ -0,0 +1,13 @@
+module Elastic::Results
+  class Metric < Base
+    attr_reader :value
+
+    def initialize(_value)
+      @value = _value
+    end
+
+    def as_value
+      @value
+    end
+  end
+end

data/lib/elastic/results/result_group.rb

@@ -0,0 +1,19 @@
+module Elastic::Results
+  class ResultGroup < Base
+    attr_reader :keys, :data
+
+    def initialize(_keys, _data)
+      @keys = _keys.freeze
+      @data = _data
+    end
+
+    def as_value
+      @data.as_value
+    end
+
+    def traverse(&_block)
+      super
+      @data.traverse(&_block)
+    end
+  end
+end

data/lib/elastic/results/root.rb

@@ -0,0 +1,15 @@
+module Elastic::Results
+  class Root < HitCollection
+    attr_reader :aggregations
+
+    def initialize(_hits, _aggs)
+      super _hits
+      @aggregations = Aggregations.new _aggs
+    end
+
+    def traverse(&_block)
+      super
+      aggregations.traverse(&_block)
+    end
+  end
+end

data/lib/elastic/shims/base.rb

@@ -0,0 +1,23 @@
+module Elastic::Shims
+  class Base
+    include Elastic::Support::Traversable
+
+    attr_reader :child
+
+    def initialize(_child)
+      @child = _child
+    end
+
+    def traverse(&_block)
+      @child.traverse(&_block)
+    end
+
+    def render
+      @child.render
+    end
+
+    def handle_result(_raw)
+      @child.handle_result(_raw)
+    end
+  end
+end

data/lib/elastic/shims/grouping.rb

@@ -0,0 +1,23 @@
+module Elastic::Shims
+  class Grouping < Base
+    def handle_result(_raw)
+      groups = []
+      group_recursive(super.aggregations, HashWithIndifferentAccess.new, groups)
+      Elastic::Results::GroupedResult.new groups
+    end
+
+    private
+
+    def group_recursive(_agg_context, _keys, _groups)
+      name, agg = _agg_context.first
+
+      if agg.is_a? Elastic::Results::BucketCollection
+        agg.each do |bucket|
+          group_recursive(bucket, _keys.merge(name => bucket.key), _groups)
+        end
+      else
+        _groups << Elastic::Results::ResultGroup.new(_keys, _agg_context)
+      end
+    end
+  end
+end

data/lib/elastic/shims/populating.rb

@@ -0,0 +1,69 @@
+module Elastic::Shims
+  class Populating < Base
+    def initialize(_index, _config, _child)
+      super _child
+      @index = _index
+      @config = _config
+    end
+
+    def render
+      disable_hits_source if populate_by_id?
+      super
+    end
+
+    def handle_result(_raw)
+      result = super
+      populate result
+      result
+    end
+
+    private
+
+    def disable_hits_source
+      child.pick(Elastic::Nodes::Concerns::HitProvider) do |node|
+        node.source = false
+      end
+    end
+
+    def populate(_result)
+      groups = _result.pick(Elastic::Results::Hit).group_by(&:type)
+      groups.each { |t, h| populate_group(t, h) }
+    end
+
+    def populate_group(_type_name, _hits)
+      target = resolve_target(_type_name)
+      raise "Unexpected type name #{_type_name}" if target.nil?
+
+      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 }
+      else
+        _hits.each do |hit|
+          hit.ref = target.build_from_data(
+            formatter.format(hit.source),
+            middleware_options
+          )
+        end
+      end
+    end
+
+    def populate_by_id?
+      @index.definition.mode == :index
+    end
+
+    def resolve_target(_type_name)
+      @index.definition.targets.find { |t| t.type_name == _type_name }
+    end
+
+    def middleware_options
+      @middleware_options ||= begin
+        @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

@@ -0,0 +1,20 @@
+module Elastic::Shims
+  class Reducing < Base
+    def handle_result(_raw)
+      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
+      else
+        result
+      end
+    end
+  end
+end

data/lib/elastic/support/command.rb

@@ -0,0 +1,34 @@
+module Elastic::Support
+  module Command
+    def self.new(*_attributes)
+      attr_names = []
+      attr_defaults = {}
+
+      _attributes.each do |att|
+        if att.is_a? Hash
+          attr_defaults.merge! att
+          attr_names += att.keys
+        else
+          attr_names << att
+        end
+      end
+
+      Struct.new(*attr_names) do
+        def self.for(kwargs = {})
+          new(kwargs).perform
+        end
+
+        def perform
+        end
+
+        define_method(:initialize) do |kwargs = {}|
+          kwargs = attr_defaults.merge kwargs
+          attr_values = attr_names.map { |a| kwargs[a] }
+          super(*attr_values)
+        end
+
+        define_method(:perform) {}
+      end
+    end
+  end
+end

data/lib/elastic/support/transform.rb

@@ -0,0 +1,37 @@
+module Elastic::Support
+  class Transform
+    def initialize(_transform)
+      @transform = _transform
+    end
+
+    def apply(_value)
+      case @transform
+      when Symbol
+        _value.public_send @transform
+      when String
+        _value.instance_eval(@transform)
+      when Proc
+        _value.instance_exec(&@transform)
+      when nil
+        _value
+      else
+        raise ArgumentError, "invalid transformation type #{@transform.class}"
+      end
+    end
+
+    def apply_to_many(_values)
+      case @transform
+      when Symbol
+        _values.map(&@transform)
+      when String
+        _values.map { |v| v.instance_eval(@transform) }
+      when Proc
+        _values.map { |v| v.instance_exec(&@transform) }
+      when nil
+        _values
+      else
+        raise ArgumentError, "invalid transformation type #{@transform.class}"
+      end
+    end
+  end
+end

data/lib/elastic/support/traversable.rb

@@ -0,0 +1,22 @@
+module Elastic::Support
+  module Traversable
+    def traverse(&_block)
+      raise NotImplementedError, "every traversable tree must implement 'traverse'"
+    end
+
+    def pick(*_types, &_block)
+      if _types.empty?
+        enum = Enumerator.new do |y|
+          traverse { |h| y << h }
+        end
+      else
+        enum = Enumerator.new do |y|
+          traverse { |h| y << h if _types.any? { |t| h.is_a? t } }
+        end
+      end
+
+      return enum if _block.nil?
+      enum.each(&_block)
+    end
+  end
+end

data/lib/elastic/type.rb

@@ -1,121 +1,93 @@
 module Elastic
-  class Type
-    MAPPING_OPTIONS = [ :type, :analyzer, :boost, :coerce, :copy_to, :doc_values, :dynamic,
-      :enabled, :fielddata, :geohash, :geohash_precision, :geohash_prefix, :format, :ignore_above,
-      :ignore_malformed, :include_in_all, :index_options, :lat_lon, :index, :fields, :norms,
-      :null_value, :position_increment_gap, :properties, :search_analyzer, :similarity, :store,
-      :term_vector ]
+  class Type < Types::BaseType
+    extend Types::FacetedType
+    extend Types::NestableType
 
-    def self.connection
-      @connection ||= Elastic.connect index
-    end
-
-    def self.index=(_value)
-      @index = _value
-    end
+    class << self
+      extend Forwardable
 
-    def self.index
-      @index
+      def_delegators :query, :must, :should, :segment, :stats, :maximum, :minimum, :sum, :average,
+        :coord_similarity, :limit, :offset, :pluck, :ids, :total
     end
 
-    def self.type_name=(_value)
-      @type_name = _value
+    def self.suffix
+      @suffix || default_suffix
     end
 
-    def self.type_name
-      @type_name ||= to_s.underscore
+    def self.suffix=(_value)
+      @suffix = _value
     end
 
-    def self.fields(*_fields)
-      raise ArgumentError, 'must provide at least a field name' if _fields.length == 0
-
-      options = {}
-      options = _fields.pop if _fields.last.is_a? Hash
-
-      _fields.each do |name|
-        register_field(name, options)
-        register_mapping(name, options)
-        register_transform(name, options[:transform]) if options.key? :transform
-      end
+    def self.adaptor
+      @adaptor ||= Elastic::Core::Adaptor.new(suffix)
     end
 
-    def self.field(_field, _options)
-      fields(_field, _options)
+    def self.mapping
+      @mapping ||= load_mapping
     end
 
-    def self.store(_data, _options = {})
-      connection.index(type_name, new(_data).render, mapping: { type_name => type_mapping })
+    def self.reindex(verbose: true)
+      drop
+      mapping.migrate
+      Commands::ImportIndexDocuments.for index: self, verbose: verbose
+      ensure_full_mapping
+      self
     end
 
-    def self.store_bulk(_collection, _options = {})
-      # TODO
+    def self.import(_collection)
+      enforce_mapping!
+      Commands::ImportIndexDocuments.for index: self, collection: _collection
+      ensure_full_mapping
+      self
     end
 
-    def self.query(_query)
-      connection.query type_name, _query
+    def self.index(_object)
+      new(_object).save
     end
 
-    def self.clear(_options = {})
-      connection.clear type_name
+    def self.query
+      enforce_mapping!
+      ensure_full_mapping
+      Query.new self
     end
 
-    def self.prepare_field_for_query(_field, _value)
-      transform = transforms[_field.to_sym]
-      transform.nil? ? _value : transform.apply(_value)
+    def self.drop
+      adaptor.drop if adaptor.exists?
+      self
     end
 
-    attr_reader :object
-
-    def initialize(_object)
-      @object = _object
+    def self.refresh
+      adaptor.refresh
+      self
     end
 
-    def render
-      document = {}
-      document[:id] = fetch_object_property(:id) if object_has_property?(:id)
-
-      self.class.type_fields.each do |name, options|
-        document[name] = fetch_object_property(name)
+    def self.enforce_mapping!
+      if mapping.out_of_sync?
+        raise 'elastic mapping out of sync, run `rake es:migrate`'
       end
-
-      document
-    end
-
-    private
-
-    def self.type_fields
-      @type_fields ||= []
-    end
-
-    def self.type_mapping
-      @type_mapping ||= { "properties" => { } }
-    end
-
-    def self.transforms
-      @transforms ||= { }
-    end
-
-    def self.register_field(_name, _options)
-      type_fields << [_name.to_sym, _options]
     end
 
-    def self.register_mapping(_name, _options)
-      field = _options.slice(*MAPPING_OPTIONS)
-      field.merge! type: 'string', index: 'not_analyzed' if _options[:type].try(:to_sym) == :term
-      type_mapping["properties"][_name.to_s] = field if field.length > 0
+    def self.ensure_full_mapping
+      if mapping.incomplete?
+        mapping.fetch
+      end
     end
 
-    def self.register_transform(_name, _transform)
-      transforms[_name.to_sym] = ValueTransform.new self, _transform
+    def save
+      self.class.tap do |klass|
+        klass.enforce_mapping!
+        klass.adaptor.index as_es_document
+        klass.ensure_full_mapping
+      end
     end
 
-    def object_has_property?(_name)
-      self.respond_to?(_name) || object.respond_to?(_name)
+    private_class_method def self.load_mapping
+      freeze_index_definition
+      Elastic::Core::MappingManager.new(adaptor, definition).tap(&:fetch)
     end
 
-    def fetch_object_property(_name)
-      value = self.respond_to?(_name) ? public_send(_name) : object.public_send(_name)
-      self.class.prepare_field_for_query _name, value
+    private_class_method def self.default_suffix
+      to_s.underscore
     end
   end
 end

data/lib/elastic/types/base_type.rb

@@ -0,0 +1,38 @@
+module Elastic::Types
+  class BaseType < Elastic::Core::Serializer
+    def self.target=(_name_or_class)
+      definition.targets = [_name_or_class]
+    end
+
+    def self.targets=(_names_or_classes)
+      definition.targets = _names_or_classes
+    end
+
+    def self.definition
+      @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|
+          field.disable_mapping_inference if original_value_occluded? field.name
+        end
+
+        definition.freeze
+      end
+    end
+
+    def initialize(_object)
+      super(self.class.definition, _object)
+    end
+
+    private_class_method def self.default_target
+      @default_target ||= begin
+        target = to_s.match(/^(.*)Index$/)
+        target ? target[1] : nil
+      end
+    end
+  end
+end

data/lib/elastic/types/faceted_type.rb

@@ -0,0 +1,16 @@
+module Elastic::Types
+  module FacetedType
+    def fields(*_fields)
+      raise ArgumentError, 'must provide at least a field name' if _fields.empty?
+
+      options = {}
+      options = _fields.pop if _fields.last.is_a? Hash
+
+      _fields.each { |name| field(name, options) }
+    end
+
+    def field(_name, _options = {})
+      definition.register_field Elastic::Fields::Value.new(_name, _options)
+    end
+  end
+end

data/lib/elastic/types/nestable_type.rb

@@ -0,0 +1,14 @@
+module Elastic::Types
+  module NestableType
+    def nested(_name, using: nil, target: nil, &_block)
+      unless _block.nil?
+        using = Class.new(Elastic::NestedType, &_block)
+        using.target = (target || _name.to_s.singularize.camelize.constantize) rescue nil
+      end
+
+      using = (_name + '_index').camelize.constantize if using.nil?
+
+      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.1.0"
+  VERSION = "0.5.0"
 end