elastic-rails 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a5c4d94d6d4b35572694f0968dfcb60251cd531a
-  data.tar.gz: 8fc9e4861325fb3e7ddf90d5751b7dd69892a0ac
+  metadata.gz: a85d4715234d67d4dac798756ad8c63b62b8aeb2
+  data.tar.gz: fa4bb1a83eae9d73ab8c1ce7717f4232922bd6f0
 SHA512:
-  metadata.gz: 7084256b0dca89eecfdb1a0b2b2c8784e52b155da96fc60b9419913314fe7fb06c01525669a10414cb807e0ec75d6538d8d0c7f344d14eb6fdde16abe3f8442c
-  data.tar.gz: 7f38c177624c2df6216e821701507a91000bd95980226bdad50bf1fab18d6146f1041bd4ffc1845c6824bfd819a8d6b31cba12b789abfd05d875ef13efe7418b
+  metadata.gz: c95fda8f2273c68285ee7bfc02c7f5b01bceccdfef74c3ad2dfa86d8d5cd27420a4c4598c608ba535900c2268030dea3ced38bbed62db35a6b0f037c3630866d
+  data.tar.gz: 1600194a988639918c4810d0bfebf9be14c24c9b9f78eb2ed64b9f64ed8e46ae82c03c2b38d8c563f229f42910c2823284ec8fafd34097ff8bd41f1b77484c10

data/lib/elastic/commands/build_agg_from_params.rb

@@ -2,7 +2,8 @@ module Elastic::Commands
   class BuildAggFromParams < Elastic::Support::Command.new(:index, :params)
     def perform
       parse_params
-      raise ArgumentError, "field not mapped: #{@field}" unless index.definition.has_field? @field
+      raise ArgumentError, "#{@field} not mapped" if field_definition.nil?
+      raise ArgumentError, "cant aggregate on #{@field}" if field_definition.nested?
 
       path = parse_nesting_path
       raise NotImplementedError, "nested paths not yet supported in aggregations" if path
@@ -12,10 +13,6 @@ module Elastic::Commands
 
     private
 
-    def agg_name
-      @options.fetch(:as, @field)
-    end
-
     def parse_params
       @field = params[0].to_s
       @options = params[1] || {}
@@ -28,36 +25,56 @@ module Elastic::Commands
     end
 
     def build_node
-      type = @options[:type]
-      type = infer_type_from_options_and_mapping if type.nil?
+      agg_type = infer_agg_type
+      raise "aggregation not supported by #{@field}" if agg_type.nil?
+
+      node_options = field_definition.public_send("#{agg_type}_aggregation_defaults")
+      node_options = node_options.merge(@options)
+      send("build_#{agg_type}", node_options)
+    end
 
-      send("build_#{type}")
+    def infer_agg_type
+      alternatives = infer_type_options
+      if alternatives.nil?
+        field_definition.supported_aggregations.first
+      else
+        field_definition.supported_aggregations.find { |q| alternatives.include? q }
+      end
     end
 
-    def infer_type_from_options_and_mapping
-      return :range if @options.key? :ranges
+    def infer_type_options
+      return [@options[:type].to_sym] if @options.key? :type
+      return [:range] if @options.key? :ranges
+      return [:histogram, :date_histogram] if @options.key? :interval
+      nil
+    end
 
-      properties = index.mapping.get_field_options @field
-      return :date_histogram if properties['type'] == 'date'
-      return :histogram if @options.key? :interval
+    def apply_query_defaults(_agg_type, _options)
+      _definition.default_options_for(query: _query_type).merge(_options)
+    end
 
-      :terms
+    def field_definition
+      @field_definition ||= index.definition.get_field @field
     end
 
-    def build_range
+    def build_range(_options)
       raise NotImplementedError, 'range aggregation not yet implemented'
     end
 
-    def build_histogram
+    def build_histogram(_options)
       raise NotImplementedError, 'histogram aggregation not yet implemented'
     end
 
-    def build_date_histogram
-      Elastic::Nodes::Agg::DateHistogram.build(agg_name, @field, interval: @options[:interval])
+    def build_date_histogram(_options)
+      Elastic::Nodes::Agg::DateHistogram.build(agg_name, @field, interval: _options[:interval])
+    end
+
+    def build_terms(_options)
+      Elastic::Nodes::Agg::Terms.build(agg_name, @field, size: _options[:size])
     end
 
-    def build_terms
-      Elastic::Nodes::Agg::Terms.build(agg_name, @field, size: @options[:size])
+    def agg_name
+      @options.fetch(:as, @field)
     end
   end
 end

data/lib/elastic/commands/build_query_from_params.rb

@@ -1,20 +1,10 @@
 module Elastic::Commands
-  class BuildQueryFromParams < Elastic::Support::Command.new(
-    :index, :params, block: nil, prefix: nil
-  )
-
+  class BuildQueryFromParams < Elastic::Support::Command.new(:index, :params, block: nil)
     def perform
       if block
         # TODO: builder mode, support nesting through first parameter
       else
-        node = Elastic::Nodes::Boolean.build_or(params.map do |part|
-          Elastic::Nodes::Boolean.build_and(part.map do |field, options|
-            field = field.to_s
-            path = get_nesting_path field
-            query_node = build_query_node(field, options)
-            path.nil? ? query_node : Elastic::Nodes::Nested.build(with_prefix(path), query_node)
-          end)
-        end)
+        node = build_or_node(params)
       end
 
       node.simplify
@@ -22,111 +12,151 @@ module Elastic::Commands
 
     private
 
-    def get_nesting_path(_field)
-      dot_index = _field.rindex('.')
-      return nil if dot_index.nil?
-      _field.slice 0, dot_index
+    def build_or_node(_array)
+      Elastic::Nodes::Boolean.build_or(_array.map do |part|
+        case part
+        when Elastic::Query
+          extract_query_node part
+        when Hash
+          build_and_node part
+        else
+          raise ArgumentError, "expected hash or query but got #{part.class}"
+        end
+      end)
     end
 
-    def build_query_node(_field, _options)
-      _field = with_prefix _field
-      _options = prepare_options _field, _options
+    def extract_query_node(_query)
+      raise ArgumentError, "query type mismatch, expected #{index.class}" if _query.index != index
+      _query.as_query_node
+    end
 
-      type = infer_type_from_params(_options)
-      send("build_#{type}", _field, _options)
+    def build_and_node(_hash)
+      Elastic::Nodes::Boolean.build_and(_hash.map do |field, options|
+        build_query_node field, options
+      end)
     end
 
-    def infer_type_from_params(_query)
-      return :term if _query.key? :term
-      return :term if _query.key? :terms
-      return :match if _query.key? :matches
-      return :range if _query.key? :gte
-      return :range if _query.key? :gt
-      return :range if _query.key? :lte
-      return :range if _query.key? :lt
-      return :nested if _query.key? :nested
-      nil
+    def build_query_node(_field, _options)
+      path, field = split_nesting_path(_field.to_s)
+      if path
+        definition = resolve_field_defintion! path
+        raise ArgumentError, "invalid nesting path #{path}" unless definition.nested?
+        build_nested_query(path, definition, field => _options)
+      else
+        build_regular_query(field, _options)
+      end
     end
 
-    def with_prefix(_path)
-      return _path if prefix.nil?
-      "#{prefix}.#{_path}"
+    def split_nesting_path(_field)
+      dot_index = _field.rindex('.')
+      return [nil, _field] if dot_index.nil?
+      [_field[0..dot_index - 1], _field[dot_index + 1..-1]]
     end
 
-    def prepare_options(_field, _options)
-      properties = index.mapping.get_field_options _field.to_s
-      raise ArgumentError, "field not mapped: #{_field}" if properties.nil?
+    def build_regular_query(_field, _options)
+      definition = resolve_field_defintion!(_field)
 
-      case properties['type']
-      when 'nested'
-        prepare_nested_options _options, properties
-      when 'string'
-        prepare_string_options _options, properties
+      if definition.nested?
+        build_nested_query(_field, definition, _options)
       else
-        prepare_default_options _options, properties
+        query_type = infer_query_type definition, _options
+        raise "query not supported by #{_field}" if query_type.nil?
+        _options = option_to_hash(query_type, _options) unless _options.is_a? Hash
+        _options = definition.public_send("#{query_type}_query_defaults").merge(_options)
+
+        send("build_#{query_type}", definition, _options)
       end
     end
 
-    def prepare_nested_options(_options, _properties)
-      return _options if _options.is_a?(Hash) && _options[:nested]
-      { nested: _options }
+    def resolve_field_defintion!(_path)
+      definition = index.definition.get_field _path
+      raise ArgumentError, "field not mapped: #{_path}" if definition.nil?
+      definition
     end
 
-    def prepare_string_options(_options, _properties)
-      return _options if _options.is_a? Hash
-      _properties['index'] == 'not_analyzed' ? { term: _options } : { matches: _options }
+    def infer_query_type(_definition, _options)
+      alternatives = infer_query_type_from_options(_options)
+      if alternatives.nil?
+        _definition.supported_queries.first
+      else
+        _definition.supported_queries.find { |q| alternatives.include? q }
+      end
     end
 
-    def prepare_default_options(_options, _properties)
-      return _options if _options.is_a? Hash
-      return range_to_options(_options) if _options.is_a? Range
-      { term: _options }
+    def build_nested_query(_path, _definition, _query)
+      case _query
+      when Elastic::NestedQuery
+        if _query.index != _definition.index
+          raise ArgumentError,
+            "query type mismatch for #{_path}, expected #{_definition.index.class}"
+        end
+
+        return _query.as_node.tap { |node| node.path = _path }
+      when Hash
+        _query = [_query]
+      end
+
+      nested_node = BuildQueryFromParams.for(index: _definition.index, params: _query)
+      Elastic::Nodes::Nested.build _path, nested_node
     end
 
-    def build_nested(_field, _options)
-      query = _options[:nested]
-      query = [query] unless query.is_a? Array
+    def infer_query_type_from_options(_options)
+      case _options
+      when Hash
+        return [_options[:type].to_sym] if _options.key?(:type)
+        return [:term] if _options.key?(:term) || _options.key?(:terms)
+        return [:match] if _options.key? :matches
+        return [:range] if _options.key?(:gte) || _options.key?(:gt)
+        return [:range] if _options.key?(:lte) || _options.key?(:lt)
+      when String, Symbol
+        return [:term, :match]
+      when Array
+        return [:term]
+      when Range
+        return [:range]
+      end
+
+      nil
+    end
 
-      nested_query = BuildQueryFromParams.for(index: index, params: query, prefix: _field)
-      Elastic::Nodes::Nested.build _field, nested_query
+    def option_to_hash(_query_type, _value)
+      case _query_type
+      when :term
+        { terms: _value }
+      when :match
+        { matches: _value.to_s }
+      when :range
+        { gte: _value.begin, (_value.exclude_end? ? :lt : :lte) => _value.end }
+      end
     end
 
+    # NOTE: the following methods could be placed in separate factories.
+
     def build_term(_field, _options)
-      terms = Array(_options[:term] || _options[:terms])
+      terms = Array(_options.fetch(:term, _options[:terms]))
 
       Elastic::Nodes::Term.new.tap do |node|
-        node.field = _field
+        node.field = _field.name
         node.mode = _options[:mode]
-        node.terms = terms.map { |t| prep(_field, t) }
+        node.terms = terms.map { |t| _field.prepare_value_for_query(t) }
       end
     end
 
     def build_range(_field, _options)
       Elastic::Nodes::Range.new.tap do |node|
-        node.field = _field
-        node.gte = prep(_field, _options[:gte]) if _options.key? :gte
-        node.gt = prep(_field, _options[:gt]) if _options.key? :gt
-        node.lte = prep(_field, _options[:lte]) if _options.key? :lte
-        node.lt = prep(_field, _options[:lt]) if _options.key? :lt
+        node.field = _field.name
+        node.gte = _field.prepare_value_for_query(_options[:gte]) if _options.key? :gte
+        node.gt = _field.prepare_value_for_query(_options[:gt]) if _options.key? :gt
+        node.lte = _field.prepare_value_for_query(_options[:lte]) if _options.key? :lte
+        node.lt = _field.prepare_value_for_query(_options[:lt]) if _options.key? :lt
       end
     end
 
     def build_match(_field, _options)
       Elastic::Nodes::Match.new.tap do |node|
-        node.field = _field
-        node.query = prep(_field, _options[:matches])
+        node.field = _field.name
+        node.query = _field.prepare_value_for_query(_options[:matches])
       end
     end
-
-    def range_to_options(_range)
-      {
-        gte: _range.begin,
-        (_range.exclude_end? ? :lt : :lte) => _range.end
-      }
-    end
-
-    def prep(_field, _value)
-      index.definition.get_field(_field).prepare_value_for_query(_value)
-    end
   end
 end

data/lib/elastic/commands/build_sort_from_params.rb

@@ -0,0 +1,41 @@
+module Elastic::Commands
+  class BuildSortFromParams < Elastic::Support::Command.new(:index, :params)
+    def perform
+      params.each do |param|
+        case param
+        when Hash
+          param.each { |field, options| add_sort field, options }
+        else
+          add_sort param
+        end
+      end
+
+      node.add_score_sort
+      node
+    end
+
+    private
+
+    def node
+      @node ||= Elastic::Nodes::Sort.new
+    end
+
+    def add_sort(_field, _options = {})
+      _field = _field.to_s
+      _options = { order: _options } unless _options.is_a? Hash
+
+      raise ArgumentError, "field not mapped: #{_field}" unless index.definition.has_field? _field
+
+      path = parse_nesting_path(_field)
+      raise NotImplementedError, "nested fields not yet supported in sorting" if path
+
+      node.add_sort(_field, _options)
+    end
+
+    def parse_nesting_path(_field)
+      dot_index = _field.rindex('.')
+      return nil if dot_index.nil?
+      _field.slice(0, dot_index)
+    end
+  end
+end

data/lib/elastic/commands/import_index_documents.rb

@@ -14,7 +14,7 @@ module Elastic::Commands
     private
 
     def import_collection
-      main_target.collect_for(collection, middleware_options) { |obj| queue obj }
+      main_target.collect_from(collection, middleware_options) { |obj| queue obj }
     end
 
     def import_target(_target)

data/lib/elastic/configuration.rb

@@ -1,13 +1,26 @@
 module Elastic
   module Configuration
+    DEFAULT = {
+      host: '127.0.0.1',
+      port: 9200,
+      page_size: 20,
+      coord_similarity: true
+    }
+
     extend self
 
+    def reset
+      @config = nil
+      self
+    end
+
     def configure(_options = nil, &_block)
       if _options.nil?
         _block.call self
       else
         @config = config.merge _options.symbolize_keys
       end
+      self
     end
 
     def api_client
@@ -30,10 +43,6 @@ module Elastic
       @config[:coord_similarity]
     end
 
-    def strict_mode
-      @config[:strict_types]
-    end
-
     def logger
       @config[:logger] || default_logger
     end
@@ -41,13 +50,7 @@ module Elastic
     private
 
     def config
-      @config ||= {
-        host: '127.0.0.1',
-        port: 9200,
-        page_size: 20,
-        coord_similarity: true,
-        strict_types: true
-      }
+      @config ||= DEFAULT
     end
 
     def default_logger

data/lib/elastic/core/adaptor.rb

@@ -48,7 +48,6 @@ module Elastic::Core
     def set_mapping(_type, _mapping)
       api_client.indices.put_mapping build_options(
         type: _type,
-        update_all_types: true,
         body: _mapping
       )
       self

data/lib/elastic/core/base_middleware.rb

@@ -22,8 +22,8 @@ module Elastic::Core
       not_supported :collect_all
     end
 
-    def collect_for(_collection, _options, &_block)
-      not_supported :collect_for
+    def collect_from(_collection, _options, &_block)
+      not_supported :collect_from
     end
 
     def find_by_ids(_ids, _options)

data/lib/elastic/core/default_middleware.rb

@@ -18,7 +18,7 @@ module Elastic::Core
       target.public_send(method, &_block) if method
     end
 
-    def collect_for(_collection, _options, &_block)
+    def collect_from(_collection, _options, &_block)
       method = collect_method_for(_collection)
       raise ArgumentError, "Could not find a method to iterate over collection" if method.nil?
       _collection.public_send(method, &_block)

data/lib/elastic/core/definition.rb

@@ -7,11 +7,11 @@ module Elastic::Core
     end
 
     def targets
-      @target_cache ||= load_targets.freeze
+      raise 'attempting to access targets before definition has been frozen' if @target_cache.nil?
+      @target_cache
     end
 
     def targets=(_values)
-      @target_cache = nil
       @targets = _values
     end
 
@@ -26,12 +26,11 @@ module Elastic::Core
     def initialize
       @targets = []
       @field_map = {}
-      @frozen = false
+      @field_cache = {}
       @middleware_options = HashWithIndifferentAccess.new
     end
 
     def register_field(_field)
-      raise 'definition has been frozen' if @frozen
       @field_map[_field.name] = _field
     end
 
@@ -40,59 +39,60 @@ module Elastic::Core
     end
 
     def expanded_field_names
-      @expanded_field_names ||= @field_map.map { |_, field| field.expanded_names }.flatten
+      @field_map.map { |_, field| field.expanded_names }.flatten
+    end
+
+    def freeze
+      return if frozen?
+      cache_targets
+      complete_and_validate_fields
+      freeze_fields
+      @middleware_options.freeze
+      super
     end
 
     def get_field(_name)
+      ensure_frozen!
+
       _name = _name.to_s
-      separator = _name.index '.'
-      if separator.nil?
-        @field_map[_name]
-      else
-        parent = @field_map[_name[0...separator]]
-        parent.try(:get_field, _name[separator + 1..-1])
-      end
+      @field_cache[_name] = resolve_field(_name) unless @field_cache.key? _name
+      @field_cache[_name]
     end
 
     def has_field?(_name)
+      ensure_frozen!
+
       !get_field(_name).nil?
     end
 
     def as_es_mapping
-      # TODO: Make this a command
+      ensure_frozen!
+
       properties = {}
       @field_map.each_value do |field|
-        field_def = field.mapping_options
-
-        if !field_def.key?(:type) && field.mapping_inference_enabled?
-          inferred = infer_mapping_options(field.name)
-          field_def.merge! inferred.symbolize_keys unless inferred.nil?
-        end
-
-        if Elastic::Configuration.strict_mode && !field_def.key?(:type)
-          raise "explicit field type for #{field.name} required"
-        end
-
-        properties[field.name] = field_def if field_def.key? :type
+        properties[field.name] = field.mapping_options
       end
 
       { 'properties' => properties.as_json }
     end
 
-    def freeze
-      unless @frozen
-        @field_map.each_value(&:freeze)
-        @frozen = true
-        @middleware_options.freeze
+    private
+
+    def resolve_field(_name)
+      separator = _name.index '.'
+      if separator.nil?
+        @field_map[_name]
+      else
+        parent = @field_map[_name[0...separator]]
+        return nil if parent.nil?
+        parent.get_field(_name[separator + 1..-1])
       end
     end
 
-    def frozen?
-      !!@frozen
+    def cache_targets
+      @target_cache = load_targets.freeze
     end
 
-    private
-
     def load_targets
       mode = nil
       @targets.map do |target|
@@ -107,6 +107,25 @@ module Elastic::Core
       end
     end
 
+    def complete_and_validate_fields
+      @field_map.each_value do |field|
+        field.merge! infer_mapping_options(field.name) if field.needs_inference?
+
+        error = field.validate
+        raise error unless error.nil?
+      end
+
+      @field_map.freeze
+    end
+
+    def ensure_frozen!
+      raise 'definition needs to be frozen' unless frozen?
+    end
+
+    def freeze_fields
+      @field_map.each_value(&:freeze)
+    end
+
     def load_target_middleware(_target)
       Middleware.wrap(_target)
     end