elasticband 0.1.3 → 0.1.4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MWNjYjdlNWNlYzIwZWRhMzg5M2YwOGNkNGI3MzE5ZjAwZjkxYjM1NA==
+    ZDIyZmVkODQxNTU1MzJkODExOTU3YjQ1MGNhNGVhNDc2YmU4MWZmNw==
   data.tar.gz: !binary |-
-    M2ViMmE2ZDNiY2VkOTg4ZGE2ODgyNTA0MjY1OGNkOGRjMDI3ZDUwMA==
+    NmRkZWU0ZWQwOGQxYWZlNzEwZmZlZjU1YjRhZWZiYTVlNWJjYTllNA==
 SHA512:
   metadata.gz: !binary |-
-    YzI3NDFiOGQ3ZTUxNDI1ZTY4ZjdmZDNkOTJiOGI1NmM0NTlmODFjYTk2NGM2
-    NTRkNTA3N2VjYTNlNTE1NjIzYTNiM2Q4ZDhhMGMyMWIwMGI0ODUwM2NiMzY5
-    MWI3NDBmY2YwMWNkZWE5NmExNzFhOTBlNjlkOTdiM2I4OTQ3MDA=
+    ZDE5ZjIzNTFkMTM0MWNiOTE3NzJjYmVmYzJiNTQ5OWU4YWEwZjI2YTZjMzM3
+    ODVmNzdmODU2YmVhYzk3N2ZjMzNhNTY5MTAxNTg4ODg4Mjg0NDNmYmI3NzJl
+    MDc3ZGMwMGMxMDZmYWQ4NzIzMjYwMTk3Y2JmZjg4MWFhY2E0Zjg=
   data.tar.gz: !binary |-
-    NDkyYjZkNzVlMTEwOTcwNzgxZTAxYTM1MDQzMzY2ZjZjYTcxMTI4YzgxZTJi
-    ODM2NzhiMjg3OTZhN2RhNjE0OGU0MGRmN2VlYzM5YTcwNGU1ZTA3OTBkYTVk
-    ZmI2ZWY1MTVlN2IyZWRiNzk3ZjY4ZTRjN2FiZmMwNzQzZmRiN2E=
+    N2Q4NjNmOTJhODc4MTZiYTc2ZTMzZWJhYjBiODllNjg1OGQ4MmVlMDVjZTky
+    NmNmMzMyM2JhOWUxMWFjNWFiMGQ3YjI4ZWU1N2IxMzY5NWUxODA1ZmM3MDg4
+    ZWQzNTBiNDZiMjRiOWZhMTAzOThjNDIzMTU4NDAxMWI0NTkxYzE=

data/lib/elasticband/aggregation/filter.rb

@@ -0,0 +1,23 @@
+module Elasticband
+  class Aggregation
+    class Filter < Aggregation
+      attr_accessor :filter, :options
+
+      def initialize(name, filter, options = {})
+        super(name)
+        self.filter = filter
+        self.options = options
+      end
+
+      def to_h
+        super(aggregation_hash)
+      end
+
+      private
+
+      def aggregation_hash
+        { filter: filter.to_h }.merge!(options)
+      end
+    end
+  end
+end

data/lib/elasticband/aggregation.rb

@@ -1,4 +1,5 @@
 require 'elasticband/aggregation/field_based'
+require 'elasticband/aggregation/filter'
 require 'elasticband/aggregation/max'
 require 'elasticband/aggregation/nested'
 require 'elasticband/aggregation/terms'
@@ -6,6 +7,8 @@ require 'elasticband/aggregation/top_hits'
 
 module Elasticband
   class Aggregation
+    PARSE_AGGREGATIONS = %i(group_by group_max top_hits group_by_filter)
+
     attr_accessor :name
 
     def initialize(name)
@@ -17,8 +20,6 @@ module Elasticband
     end
 
     class << self
-      PARSE_AGGREGATIONS = %i(group_by group_max top_hits)
-
       # Parses some options to a Elasticsearch syntax, aggregations can be nested in another.
       #
       # #### Options
@@ -31,6 +32,7 @@ module Elasticband
       #   It can receive an array with some attributes:
       #   * `script:` Generates max defined by the script
       # * `top_hits:` A number of results that should be return inside the group ranked by score.
+      # * `group_by_filter:` Filter and group results with a name using Elasticband::Filter.parse options
       #
       # #### Examples
       # ```
@@ -42,6 +44,10 @@ module Elasticband
       #
       # Aggregation.parse(group_by: [:status, size: 5, top_hits: 3])
       # => { status: { terms: { field: :status, size: 5 }, aggs: { top_status: { top_hits: 3 } } } }
+      #
+      # Aggregation.parse(group_by_filter: [:published_results, only: { status: :published }])
+      # => { published_results: { filter: { term: { status: :published } } } }
+      # ```
       def parse(options)
         merge(*parse_aggregations(options))
       end
@@ -69,6 +75,7 @@ module Elasticband
         when :group_by then parse_field_aggregation(Aggregation::Terms, :by, aggregation_options)
         when :group_max then parse_field_aggregation(Aggregation::Max, :max, aggregation_options)
         when :top_hits then parse_top_hits(root_aggregation, aggregation_options)
+        when :group_by_filter then parse_filter(*aggregation_options)
         end
       end
 
@@ -93,6 +100,15 @@ module Elasticband
         aggregation = Aggregation::TopHits.new(name, size, options.except(*PARSE_AGGREGATIONS))
         parse_aggregations(options, aggregation)
       end
+
+      def parse_filter(aggregation_name, options)
+        return {} if options.blank?
+
+        filter = Elasticband::Filter.parse(options)
+        filter_options = options.except(*(PARSE_AGGREGATIONS + Elasticband::Filter::PARSE_FILTERS))
+        aggregation = Aggregation::Filter.new(aggregation_name, filter, filter_options)
+        parse_aggregations(options, aggregation)
+      end
     end
   end
 end

data/lib/elasticband/filter.rb

@@ -6,8 +6,76 @@ require 'elasticband/filter/terms'
 
 module Elasticband
   class Filter
+    PARSE_FILTERS = %i(only except includes)
+
     def to_h
       { match_all: {} }
     end
+
+    class << self
+      # Parses filter options to a Elasticsearch syntax
+      #
+      # #### Options
+      #
+      # * `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.
+      #
+      # #### Examples
+      # ```
+      # Filter.parse(only: { status: :published })
+      # => { term: { status: :published } }
+      #
+      # Filter.parse(except: { company: { id: 1 } })
+      # => { not: { term: { status: :published } } }
+      #
+      # Filter.parse(includes: ['company', on: :description])
+      # => { query: { match: { description: 'company' } } }
+      # ```
+      def parse(options = {})
+        return {} if options.blank?
+
+        filter = parse_filters(options[:only])
+        filter += parse_filters(options[:except]).map { |f| Filter::Not.new(f) }
+        filter += parse_includes_filter(options[:includes])
+        join_filters(filter).to_h
+      end
+
+      private
+
+      def join_filters(filters)
+        filters.count > 1 ? Filter::And.new(filters) : filters.first
+      end
+
+      def parse_includes_filter(includes_options)
+        return [] if includes_options.blank?
+
+        [Filter::Query.new(Elasticband::Query.parse(*includes_options))]
+      end
+
+      def parse_filters(options)
+        return [] if options.blank?
+
+        to_dotted_notation(options).map { |attribute, value| parse_filter(attribute, value) }
+      end
+
+      def parse_filter(attribute, value)
+        if value.is_a?(Enumerable)
+          Filter::Terms.new(value, attribute)
+        else
+          Filter::Term.new(value, attribute)
+        end
+      end
+
+      def to_dotted_notation(hash_params, prefix = nil, dotted_hash = {})
+        hash_params.each_with_object(dotted_hash) do |(key, val), hash|
+          if val.is_a?(Hash)
+            to_dotted_notation(val, "#{prefix}#{key}.", hash)
+          else
+            hash["#{prefix}#{key}"] = val
+          end
+        end
+      end
+    end
   end
 end

data/lib/elasticband/query.rb

@@ -11,14 +11,12 @@ module Elasticband
     end
 
     class << self
-      # Parses a query text with options to a Elasticsearch syntax
+      # Parses a query text with options to a Elasticsearch syntax.
+      # Check Elasticband::Filter.parse for filter options.
       #
       # #### Options
       #
-      # * `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.
+      # * `on:` Defines which attributes will searched in documents.
       # * `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`.
@@ -63,23 +61,13 @@ module Elasticband
       # ```
       def parse(query_text, options = {})
         query = parse_on(query_text, options[:on])
-        query = parse_query_filters(query, options.slice(:only, :except, :includes))
+        query = parse_query_filters(query, options)
         query = parse_boost(query, options.slice(:boost_by, :boost_where, :boost_function))
         query.to_h
       end
 
       private
 
-      def to_dotted_notation(hash_params, prefix = nil, dotted_hash = {})
-        hash_params.each_with_object(dotted_hash) do |(key, val), hash|
-          if val.is_a?(Hash)
-            to_dotted_notation(val, "#{prefix}#{key}.", hash)
-          else
-            hash["#{prefix}#{key}"] = val
-          end
-        end
-      end
-
       def parse_on(query_text, on_options)
         return Query.new if query_text.blank?
 
@@ -91,38 +79,9 @@ module Elasticband
       end
 
       def parse_query_filters(query, filter_options)
-        return query if filter_options.blank?
-
-        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)
-      end
-
-      def join_filters(filters)
-        filters.count > 1 ? Filter::And.new(filters) : filters.first
-      end
+        filter = Filter.parse(filter_options)
 
-      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?
-
-        to_dotted_notation(options).map { |attribute, value| parse_filter(attribute, value) }
-      end
-
-      def parse_filter(attribute, value)
-        if value.is_a?(Enumerable)
-          Filter::Terms.new(value, attribute)
-        else
-          Filter::Term.new(value, attribute)
-        end
+        filter.blank? ? query : Query::Filtered.new(filter, query)
       end
 
       def parse_boost(query, boost_options)
@@ -136,7 +95,7 @@ module Elasticband
         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]))
+          filter = Filter.parse(only: boost_options[:boost_where])
           ScoreFunction::Filtered.new(filter, ScoreFunction::BoostFactor.new(1_000))
         else
           boost_function, boost_function_params = boost_options[:boost_function]

data/lib/elasticband/version.rb

@@ -1,3 +1,3 @@
 module Elasticband
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/spec/aggregation/filter_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Aggregation::Filter do
+  describe '#to_h' do
+    let(:filter) { Elasticband::Filter.new }
+
+    before { allow(filter).to receive(:to_h) { 'filter' } }
+
+    context 'without options' do
+      subject { described_class.new(:aggregation_name, filter).to_h }
+
+      it { is_expected.to eq(aggregation_name: { filter: 'filter' }) }
+    end
+
+    context 'with options' do
+      subject { described_class.new(:aggregation_name, filter, _cache: true).to_h }
+
+      it { is_expected.to eq(aggregation_name: { filter: 'filter', _cache: true }) }
+    end
+  end
+end

data/spec/aggregation_spec.rb

@@ -65,6 +65,15 @@ RSpec.describe Elasticband::Aggregation do
       end
     end
 
+    context 'with `:group_by_filter` option' do
+      let(:options) { { group_by_filter: [:published_results, filter_options] } }
+      let(:filter_options) { { only: { status: :published } } }
+
+      before { expect(Elasticband::Filter).to receive(:parse).with(filter_options) { { name: 'filter' } } }
+
+      it { is_expected.to eq(published_results: { filter: { name: 'filter' } }) }
+    end
+
     context 'with more than one aggregation' do
       let(:options) { { group_by: :status, group_max: :price } }
 

data/spec/filter_spec.rb

@@ -6,4 +6,82 @@ RSpec.describe Elasticband::Filter do
 
     it { is_expected.to eq(match_all: {}) }
   end
+
+  describe '.parse' do
+    subject { described_class.parse(options) }
+
+    context 'with `:only/:except` option' do
+      context 'with only `:only` option' do
+        context 'with a single clause' do
+          let(:options) { { only: { status: :published } } }
+
+          it { is_expected.to eq(term: { status: :published }) }
+        end
+
+        context 'with multiple clauses' do
+          let(:options) { { only: { status: :published, company_id: 1 } } }
+
+          it { is_expected.to eq(and: [{ term: { status: :published } }, term: { company_id: 1 }]) }
+        end
+
+        context 'with a nested attribute' do
+          let(:options) { { only: { company: { id: 1 } } } }
+
+          it { is_expected.to eq(term: { 'company.id': 1 }) }
+        end
+
+        context 'with multiple values' do
+          let(:options) { { only: { status: %i(published rejected) } } }
+
+          it { is_expected.to eq(terms: { status: %i(published rejected) }) }
+        end
+      end
+
+      context 'with only `:except` option' do
+        context 'with a single clause' do
+          let(:options) { { except: { status: :published } } }
+
+          it { is_expected.to eq(not: { term: { status: :published } }) }
+        end
+
+        context 'with multiple clauses' do
+          let(:options) { { except: { status: :published, company_id: 1 } } }
+
+          it 'returns a filtered query with a `not` filter wrapping an `and` filter' do
+            is_expected.to eq(
+              and: [{ not: { term: { status: :published } } }, not: { term: { company_id: 1 } }]
+            )
+          end
+        end
+
+        context 'with a nested attribute' do
+          let(:options) { { except: { company: { id: 1 } } } }
+
+          it { is_expected.to eq(not: { term: { 'company.id': 1 } }) }
+        end
+
+        context 'with multiple values' do
+          let(:options) { { except: { status: %i(published rejected) } } }
+
+          it { is_expected.to eq(not: { terms: { status: %i(published rejected) } }) }
+        end
+      end
+
+      context 'with both options' do
+        let(:options) { { only: { status: :published }, except: { company_id: 1 } } }
+
+        it { is_expected.to eq(and: [{ term: { status: :published } }, not: { term: { company_id: 1 } }]) }
+      end
+    end
+
+    context 'with `:includes` option' do
+      let(:options) { { includes: ['bar', on: :description] } }
+
+      before do
+        expect(Elasticband::Query).to receive(:parse).with('bar', on: :description) { { name: 'query' } }
+      end
+
+      it { is_expected.to eq(query: { name: 'query' }) }
+    end
+  end
 end

data/spec/query_spec.rb

@@ -43,162 +43,13 @@ RSpec.describe Elasticband::Query do
         end
       end
 
-      context 'with `:only/:except` option' do
-        context 'with only `:only` option' do
-          context 'with a single clause' do
-            let(:options) { { only: { status: :published } } }
+      context 'with filters options' do
+        let(:options) { { only: { status: :published } } }
 
-            it 'returns a filtered query with a `term` filter' do
-              is_expected.to eq(
-                filtered: {
-                  query: { match: { _all: 'foo' } },
-                  filter: { term: { status: :published } }
-                }
-              )
-            end
-          end
-
-          context 'with multiple clauses' do
-            let(:options) { { only: { status: :published, company_id: 1 } } }
-
-            it 'returns a filtered query with an `and` filter' do
-              is_expected.to eq(
-                filtered: {
-                  query: { match: { _all: 'foo' } },
-                  filter: {
-                    and: [
-                      { term: { status: :published } },
-                      term: { company_id: 1 }
-                    ]
-                  }
-                }
-              )
-            end
-          end
-
-          context 'with a nested attribute' do
-            let(:options) { { only: { company: { id: 1 } } } }
-
-            it 'returns a filtered query with a `term` filter on dotted notation' do
-              is_expected.to eq(
-                filtered: {
-                  query: { match: { _all: 'foo' } },
-                  filter: { term: { 'company.id': 1 } }
-                }
-              )
-            end
-          end
-
-          context 'with multiple values' do
-            let(:options) { { only: { status: %i(published rejected) } } }
-
-            it 'returns a filtered query with a `terms` filter' do
-              is_expected.to eq(
-                filtered: {
-                  query: { match: { _all: 'foo' } },
-                  filter: { terms: { status: %i(published rejected) } }
-                }
-              )
-            end
-          end
-        end
-
-        context 'with only `:except` option' do
-          context 'with a single clause' do
-            let(:options) { { except: { status: :published } } }
-
-            it 'returns a filtered query with a `not` filter wrapping a `term` filter' do
-              is_expected.to eq(
-                filtered: {
-                  query: { match: { _all: 'foo' } },
-                  filter: { not: { term: { status: :published } } }
-                }
-              )
-            end
-          end
-
-          context 'with multiple clauses' do
-            let(:options) { { except: { status: :published, company_id: 1 } } }
-
-            it 'returns a filtered query with a `not` filter wrapping an `and` filter' do
-              is_expected.to eq(
-                filtered: {
-                  query: { match: { _all: 'foo' } },
-                  filter: {
-                    and: [
-                      { not: { term: { status: :published } } },
-                      not: { term: { company_id: 1 } }
-                    ]
-                  }
-                }
-              )
-            end
-          end
-
-          context 'with a nested attribute' do
-            let(:options) { { except: { company: { id: 1 } } } }
-
-            it 'returns a filtered query with a `not` filter wrapping a `term` filter on dotted notation' do
-              is_expected.to eq(
-                filtered: {
-                  query: { match: { _all: 'foo' } },
-                  filter: { not: { term: { 'company.id': 1 } } }
-                }
-              )
-            end
-          end
-
-          context 'with multiple values' do
-            let(:options) { { except: { status: %i(published rejected) } } }
+        before { expect(Elasticband::Filter).to receive(:parse).with(options) { { name: 'filter' } } }
 
-            it 'returns a filtered query with `not` filter wrapping a `terms` filter' do
-              is_expected.to eq(
-                filtered: {
-                  query: { match: { _all: 'foo' } },
-                  filter: { not: { terms: { status: %i(published rejected) } } }
-                }
-              )
-            end
-          end
-        end
-
-        context 'with both options' do
-          let(:options) { { only: { status: :published }, except: { company_id: 1 } } }
-
-          it 'returns a filtered query combining the filters' do
-            is_expected.to eq(
-              filtered: {
-                query: { match: { _all: 'foo' } },
-                filter: {
-                  and: [
-                    { term: { status: :published } },
-                    not: { term: { company_id: 1 } }
-                  ]
-                }
-              }
-            )
-          end
-        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
+        it 'return a filtered query' do
+          is_expected.to eq(filtered: { query: { match: { _all: 'foo' } }, filter: { name: 'filter' } })
         end
       end
 
@@ -256,65 +107,12 @@ RSpec.describe Elasticband::Query do
       context 'with `:boost_where` option' do
         context 'with a regular attribute' do
           let(:options) { { boost_where: { status: :published } } }
+          let(:filter_options) { { only: { status: :published } } }
 
-          it 'returns a function score query with a `boost_factor` filtered function' do
-            is_expected.to eq(
-              function_score: {
-                query: { match: { _all: 'foo' } },
-                functions: [
-                  {
-                    filter: { term: { status: :published } },
-                    boost_factor: 1000
-                  }
-                ]
-              }
-            )
+          before do
+            allow(Elasticband::Filter).to receive(:parse)
+            expect(Elasticband::Filter).to receive(:parse).with(filter_options) { { name: 'filter' } }
           end
-        end
-
-        context 'with a multiple attributes' do
-          let(:options) { { boost_where: { status: :published, company_id: 1 } } }
-
-          it 'returns a function score query with a `boost_factor` filtered function' do
-            is_expected.to eq(
-              function_score: {
-                query: { match: { _all: 'foo' } },
-                functions: [
-                  {
-                    filter: {
-                      and: [
-                        { term: { status: :published } },
-                        term: { company_id: 1 }
-                      ]
-                    },
-                    boost_factor: 1000
-                  }
-                ]
-              }
-            )
-          end
-        end
-
-        context 'with a nested attribute' do
-          let(:options) { { boost_where: { company: { id: 1 } } } }
-
-          it 'returns a function score query with a `boost_factor` filtered function' do
-            is_expected.to eq(
-              function_score: {
-                query: { match: { _all: 'foo' } },
-                functions: [
-                  {
-                    filter: { term: { 'company.id': 1 } },
-                    boost_factor: 1000
-                  }
-                ]
-              }
-            )
-          end
-        end
-
-        context 'with multiple values' do
-          let(:options) { { boost_where: { status: %i(published rejected) } } }
 
           it 'returns a function score query with a `boost_factor` filtered function' do
             is_expected.to eq(
@@ -322,7 +120,7 @@ RSpec.describe Elasticband::Query do
                 query: { match: { _all: 'foo' } },
                 functions: [
                   {
-                    filter: { terms: { status: %i(published rejected) } },
+                    filter: { name: 'filter' },
                     boost_factor: 1000
                   }
                 ]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elasticband
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Glauber Campinho
@@ -116,6 +116,7 @@ files:
 - lib/elasticband.rb
 - lib/elasticband/aggregation.rb
 - lib/elasticband/aggregation/field_based.rb
+- lib/elasticband/aggregation/filter.rb
 - lib/elasticband/aggregation/max.rb
 - lib/elasticband/aggregation/nested.rb
 - lib/elasticband/aggregation/terms.rb
@@ -139,6 +140,7 @@ files:
 - lib/elasticband/search.rb
 - lib/elasticband/version.rb
 - spec/aggregation/field_based_spec.rb
+- spec/aggregation/filter_spec.rb
 - spec/aggregation/max_spec.rb
 - spec/aggregation/nested_spec.rb
 - spec/aggregation/terms_spec.rb