elasticband 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af49e433d1512419bc8c9b383a2b0cb61fe968f4
-  data.tar.gz: d6c0940f96228c7e203969232ed7ed4f3e236157
+  metadata.gz: ae34274114e94681aaa9b43e5640f314bf265193
+  data.tar.gz: 1406a12e82fada6ad971a853248906aad2166999
 SHA512:
-  metadata.gz: d545e4df0a47007b785292f55b29bc6e9a02e7fc3fdf2059c95c9fab1c5fb4b0081d0a241f2373a7f9304f408b7d3eee1b0fdff80bbf9869dddac0906443a43f
-  data.tar.gz: 0e7665259f56491b1c876934f7ac584b50a46022de13c2c02dca468fe3d0fe076bb919abf4da28f5bf8641dc5aab431cd9aba75993dda15e60111ca7b1e7ea97
+  metadata.gz: 61d9b27b7468403e5591395db6000f157881775d905465600e0ff04d5f2cdfa88a8f26a48da3a808d4565e0d56b356212dbb0462e24f88992c1bff213187d98a
+  data.tar.gz: b7064257bbc7bae491c156120da453715d29216ff75eadb451c2f7a55823f0c615ad41e90312d9be84940ea8db704fe8847c01b71f231ec73fe5deaed9e29e0c

data/lib/elasticband/query.rb

@@ -18,10 +18,12 @@ module Elasticband
       # * `on:` Defines which attributes will searched in documents
       # * `only:` Filter the search results where the condition is `true`
       # * `except`: Filter the search results where the condition is `false`.
+      # * `includes:` Filter the search results with a `Match` query.
       # * `boost_by:` Boosts the score of a query result based on a attribute of the document.
       #   This score will be multiplied for the `boost_by` attribute over function `ln2p`.
       # * `boost_where:` Boosts the score of a query result where some condition is `true`.
       #   This score will be multiplied by 1000 (arbitrary, based on gem `searchkick`)
+      # * `boost_function:` Boosts using the function passed.
       #
       # #### Examples
       # ```
@@ -40,9 +42,15 @@ module Elasticband
       # Query.parse('foo', except: { company: { id: 1 } })
       # => { filtered: { query: ..., filter: { not: { term: { status: :published } } } } }
       #
+      # Query.parse('foo', includes: ['company', on: :description])
+      # => { filtered: { query: ..., filter: { query: { match: { description: 'company' } } } } }
+      #
       # Query.parse('foo', boost_by: :contents_count)
       # => { function_score: { query: ..., field_value_factor: { field: :contents_count, modifier: :ln2p } } }
       #
+      # Query.parse('foo', boost_function: "_score * doc['users_count'].value")
+      # => { function_score: { query: ..., script_score: { script: '_score * doc['users_count'].value' } } }
+      #
       # Query.parse('foo', boost_where: { company: { id: 1 } })
       # => {
       #      function_score: {
@@ -55,8 +63,8 @@ module Elasticband
       # ```
       def parse(query_text, options = {})
         query = parse_on(query_text, options[:on])
-        query = parse_only_and_except(query, options[:only], options[:except])
-        query = parse_boost(query, options[:boost_by], options[:boost_where])
+        query = parse_query_filters(query, options.slice(:only, :except, :includes))
+        query = parse_boost(query, options.slice(:boost_by, :boost_where, :boost_function))
         query.to_h
       end
 
@@ -73,6 +81,8 @@ module Elasticband
       end
 
       def parse_on(query_text, on_options)
+        return Query.new if query_text.blank?
+
         if on_options.is_a?(Enumerable)
           Query::MultiMatch.new(query_text, on_options)
         else
@@ -80,10 +90,12 @@ module Elasticband
         end
       end
 
-      def parse_only_and_except(query, only_options, except_options)
-        return query if only_options.blank? && except_options.blank?
+      def parse_query_filters(query, filter_options)
+        return query if filter_options.blank?
 
-        filter = parse_filters(only_options) + parse_filters(except_options).map { |f| Filter::Not.new(f) }
+        filter = parse_filters(filter_options[:only])
+        filter += parse_filters(filter_options[:except]).map { |f| Filter::Not.new(f) }
+        filter += parse_includes_filter(filter_options[:includes])
         filter = join_filters(filter)
 
         Query::Filtered.new(filter, query)
@@ -93,6 +105,12 @@ module Elasticband
         filters.count > 1 ? Filter::And.new(filters) : filters.first
       end
 
+      def parse_includes_filter(includes_options)
+        return [] if includes_options.blank?
+
+        [Filter::Query.new(parse(*includes_options))]
+      end
+
       def parse_filters(options)
         return [] if options.blank?
 
@@ -107,19 +125,21 @@ module Elasticband
         end
       end
 
-      def parse_boost(query, boost_by_options, boost_where_options)
-        return query if boost_by_options.blank? && boost_where_options.blank?
+      def parse_boost(query, boost_options)
+        return query if boost_options.blank?
 
-        function = parse_boost_function(boost_by_options, boost_where_options)
+        function = parse_boost_function(boost_options)
         Query::FunctionScore.new(query, function)
       end
 
-      def parse_boost_function(boost_by_options, boost_where_options)
-        if boost_by_options.present?
-          ScoreFunction::FieldValueFactor.new(boost_by_options, modifier: :ln2p)
-        else
-          filter = join_filters(parse_filters(boost_where_options))
+      def parse_boost_function(boost_options)
+        if boost_options[:boost_by].present?
+          ScoreFunction::FieldValueFactor.new(boost_options[:boost_by], modifier: :ln2p)
+        elsif boost_options[:boost_where].present?
+          filter = join_filters(parse_filters(boost_options[:boost_where]))
           ScoreFunction::Filtered.new(filter, ScoreFunction::BoostFactor.new(1_000))
+        else
+          ScoreFunction::ScriptScore.new(boost_options[:boost_function])
         end
       end
     end

data/lib/elasticband/version.rb

@@ -1,3 +1,3 @@
 module Elasticband
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/spec/query_spec.rb

@@ -8,6 +8,12 @@ RSpec.describe Elasticband::Query do
   end
 
   describe '.parse' do
+    context 'with no query' do
+      subject { described_class.parse('') }
+
+      it { is_expected.to eq(match_all: {}) }
+    end
+
     context 'with only the query text' do
       subject { described_class.parse('foo') }
 
@@ -175,6 +181,27 @@ RSpec.describe Elasticband::Query do
         end
       end
 
+      context 'with `:includes` option' do
+        let(:options) { { includes: ['bar', on: :description] } }
+
+        it 'returns a filtered query with query filter' do
+          is_expected.to eq(
+            filtered: {
+              query: { match: { _all: 'foo' } },
+              filter: {
+                query: { match: { description: 'bar' } }
+              }
+            }
+          )
+        end
+
+        it 'calls `.parse` for the includes option' do
+          allow(described_class).to receive(:parse).with('foo', options).and_call_original
+          expect(described_class).to receive(:parse).with('bar', on: :description).and_call_original
+          subject
+        end
+      end
+
       context 'with `:boost_by` option' do
         let(:options) { { boost_by: :contents_count } }
 
@@ -191,6 +218,21 @@ RSpec.describe Elasticband::Query do
         end
       end
 
+      context 'with `:boost_function` option' do
+        let(:options) { { boost_function: "_score * doc['users_count'].value" } }
+
+        it 'returns a function score query with a `script_score` function' do
+          is_expected.to eq(
+            function_score: {
+              query: { match: { _all: 'foo' } },
+              script_score: {
+                script: "_score * doc['users_count'].value"
+              }
+            }
+          )
+        end
+      end
+
       context 'with `:boost_where` option' do
         context 'with a regular attribute' do
           let(:options) { { boost_where: { status: :published } } }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elasticband
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Glauber Campinho