Merge pull request #104 from theablefew/refactor/query_method_specs

Add better specs for query methods and query builder

lib/stretchy/attributes/transformers/keyword_transformer.rb

@@ -59,7 +59,10 @@ def protected?(arg)
           # this is for text fields that have a keyword subfield
           # `:text` and `:string` fields add a `:keyword` subfield to the attribute mapping automatically
           def transform(item, *ignore) 
-            return unless Stretchy.configuration.auto_target_keywords
+            return item unless Stretchy.configuration.auto_target_keywords
+            if item.is_a?(String)
+              return (!protected?(item) && keyword_available?(item)) ? "#{item}.#{keyword_field_for(item)}" : item 
+            end
             item.each_with_object({}) do |(key, value), new_item|
               if ignore && ignore.include?(key)
                 new_item[key] = value

lib/stretchy/relations/query_builder.rb

@@ -64,7 +64,7 @@ def regexes
       end
 
       def fields
-        values[:field]
+        values[:fields]
       end
 
       def source
@@ -150,24 +150,21 @@ def build_query
 
           structure.hybrid do
             structure.queries do
-                hybrid[:neural].each do |n|
-                  structure.child! do
-                    params = n.dup
-                    field_name, query_text = params.shift
-                    structure.neural do
-                      structure.set! field_name do
-                        structure.query_text query_text
-                        structure.extract! params, *params.keys
-                      end
-                    end
+              structure.child! do
+                params = hybrid[:neural].dup
+                field_name, query_text = params.shift 
+                structure.neural do
+                  structure.set! field_name do
+                    structure.query_text query_text
+                    structure.extract! params, *params.keys
                   end
                 end
+              end
 
-                hybrid[:query].each do |query|
-                  structure.child! do
-                    structure.extract! query, *query.keys
-                  end
-                end
+              structure.child! do
+                hybrid_query = hybrid[:query].dup
+                structure.extract! hybrid_query, *hybrid_query.keys
+              end
 
             end
           end unless hybrid.nil?
@@ -222,7 +219,7 @@ def build_query
 
       def build_regexp
         regexes.each do |args|
-            target_field = args.first.keys.first
+            target_field = keyword_transformer.transform(args.first.keys.first.to_s)
             value_field = args.first.values.first
             structure.set! target_field, args.last.merge(value: value_field)
         end
@@ -300,7 +297,7 @@ def build_search_options
 
       def extra_search_options
         unless self.count?
-          values[:size] = size.present? ? size : values[:default_size]
+          values[:size] = size.present? ? size : default_size
         else 
           values[:size] = nil
         end
@@ -310,7 +307,7 @@ def extra_search_options
       def compact_where(q, opts = {bool:true})
         return if q.nil?
         if opts.delete(:bool)
-          as_must(q)
+          as_must([merge_and_append(q)])
         else
           as_query_string(q.flatten)
         end
@@ -343,26 +340,29 @@ def as_query_string(q)
 
         q.each do |arg|
           arg.each_pair { |k,v|  _and << "(#{k}:#{v})" } if arg.class == Hash
-          _and << "(#{arg})" if arg.class == String
+          if q.length == 1
+            _and << "#{arg}" if arg.class == String
+          else
+            _and << "(#{arg})" if arg.class == String
+          end
         end
         _and.join(" AND ")
       end
 
       def merge_and_append(queries)
-        builder = {}
-
-        queries.each do |q|
-          q.each do |k, v|
-            if builder.key?(k)
-              builder[k] = builder[k].class == Array ? builder[k] : [builder[k]]
-              builder[k] << v
+        result = {}
+        queries.each do |hash|
+          hash.each do |key, value|
+            if result[key].is_a?(Array)
+              result[key] << value
+            elsif result.key?(key)
+              result[key] = [result[key], value]
             else
-              builder[k] = v  
+              result[key] = value
             end
           end
         end
-
-        builder
+        result
       end
 
       def extract_highlighter(highlighter)

lib/stretchy/relations/query_methods.rb

@@ -27,7 +27,7 @@ def registry
       MULTI_VALUE_METHODS = [
         :where,
         :order, 
-        :field,
+        :fields,
         :highlight,
         :source,
         :must_not,

lib/stretchy/relations/query_methods/field.rb → lib/stretchy/relations/query_methods/fields.rb

@@ -1,7 +1,7 @@
 module Stretchy
   module Relations
     module QueryMethods
-      module Field
+      module Fields
         extend ActiveSupport::Concern
 
         # Specify the fields to be returned by the Elasticsearch query.
@@ -49,16 +49,16 @@ module Field
         #   Model.fields('books.*')
         # ```
         #
-        def field(*args)
+        def fields(*args)
           spawn.field!(*args)
         end
 
         # Alias for {#field}
         # @see #field
-        alias :fields :field
+        alias :field :fields
 
         def field!(*args) # :nodoc:
-          self.field_values += args
+          self.fields_values += args
           self
         end
 

lib/stretchy/relations/query_methods/hybrid.rb

@@ -49,7 +49,7 @@ def hybrid(opts)
         end
 
         def hybrid!(opts) # :nodoc:
-          self.hybrid_values += [opts]
+          self.hybrid_values = opts
           self
         end
 

lib/stretchy/relations/query_methods/query_string.rb

@@ -28,22 +28,12 @@ module QueryString
         # ```
         #
         def query_string(opts = :chain, *rest)
-          if opts == :chain
-            WhereChain.new(spawn)
-          elsif opts.blank?
-            self
-          else
-            spawn.query_string!(opts, *rest)
-          end
+          spawn.query_string!(opts, *rest)
         end
 
         def query_string!(opts, *rest) # :nodoc:
-          if opts == :chain
-            WhereChain.new(self)
-          else
-            self.query_string_values += build_where(opts, rest)
-            self
-          end
+          self.query_string_values += build_where(opts, rest)
+          self
         end
 
         QueryMethods.register!(:query_string)

lib/stretchy/relations/query_methods/regexp.rb

@@ -48,8 +48,6 @@ def regexp!(args) # :nodoc:
           args = args.to_a
           target_field, regex = args.shift
           opts = args.to_h
-          opts.reverse_merge!(use_keyword: true)
-          target_field = "#{target_field}.keyword" if opts.delete(:use_keyword)
           opts.merge!(case_insensitive: true) if regex.casefold?
           self.regexp_values += [[Hash[target_field, regex.source], opts]]
           self

lib/stretchy/relations/query_methods/where.rb

@@ -63,8 +63,11 @@ def where(opts = :chain, *rest)
             opts.each do |key, value|
               case value
               when Range
-                opts.delete(key)
-                between(value, key)
+                range = opts.delete(key)
+                range_options = {gte: range.begin}
+                upper_bound = range.exclude_end? ? :lt : :lte
+                range_options[upper_bound] = range.end
+                filter_query(:range, key => range_options)
               when Hash
                 opts.delete(key)
                 filter_query(:range, key => value) if value.keys.any? { |k| [:gte, :lte, :gt, :lt].include?(k) }

spec/models/test_model.rb

@@ -1,5 +1,6 @@
 class TestModel < StretchyModel
   attribute :name, :text
+  attribute :title, :keyword
   attribute :age, :integer
   attribute :tags, :array
   attribute :data, :hash

spec/stretchy/attributes/transformers/keyword_transformer_spec.rb

@@ -74,7 +74,7 @@ class MyModel < Stretchy::Record
 
     it 'does not transform' do
       transformed_keywords = values[:where].map do |arg|
-        described_class.new(model.attribute_types).transform(arg)
+        expect(described_class.new(model.attribute_types).transform(arg)).to eq(arg)
       end 
     end
   end

spec/stretchy/neural_spec.rb

@@ -123,11 +123,6 @@
             expect(described_class).to respond_to(:neural)
         end
 
-        it 'adds values' do
-            values = described_class.neural(passage_embedding: { query_text: 'hello world', model_id: '1234'}).values[:neural]
-            expect(values.first).to eq({passage_embedding: { query_text: 'hello world', model_id: '1234'}})
-        end
-
         it 'returns results' do
             allow_any_instance_of(Elasticsearch::Persistence::Repository).to receive(:search).and_return(results)
             expect(described_class.neural(passage_embedding: 'hello world', model_id: '1234', k:2).total).to eq(2)
@@ -152,10 +147,6 @@
               expect(described_class).to respond_to(:hybrid)
           end
 
-          it 'adds values' do
-              values = described_class.hybrid(neural: [{passage_embedding: 'hello world', model_id: '1234', k: 2}], query: [{term: {status: :active}}]).values[:hybrid]
-              expect(values).to eq([{neural: [{passage_embedding: 'hello world', model_id: '1234', k: 2}], query: [{term: {status: :active}}]}])
-          end
       end