elasticband 0.1.0

data/lib/elasticband/query.rb

@@ -0,0 +1,127 @@
+require 'elasticband/query/filtered'
+require 'elasticband/query/function_score'
+require 'elasticband/query/match'
+require 'elasticband/query/multi_match'
+require 'elasticband/query/score_function'
+
+module Elasticband
+  class Query
+    def to_h
+      { match_all: {} }
+    end
+
+    class << self
+      # Parses a query text with options to a Elasticsearch syntax
+      #
+      # #### 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`.
+      # * `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`)
+      #
+      # #### Examples
+      # ```
+      # Query.parse('foo')
+      # => { match: { _all: 'foo' } }
+      #
+      # Query.parse('foo', on: :name)
+      # => { match: { name: 'foo' } }
+      #
+      # Query.parse('foo', on: %i(name description))
+      # => { multi_match: { query: 'foo', fields: [:name, :description] } }
+      #
+      # Query.parse('foo', only: { status: :published })
+      # => { filtered: { query: ..., filter: { term: { status: :published } } } }
+      #
+      # Query.parse('foo', except: { company: { id: 1 } })
+      # => { filtered: { query: ..., filter: { not: { term: { status: :published } } } } }
+      #
+      # Query.parse('foo', boost_by: :contents_count)
+      # => { function_score: { query: ..., field_value_factor: { field: :contents_count, modifier: :ln2p } } }
+      #
+      # Query.parse('foo', boost_where: { company: { id: 1 } })
+      # => {
+      #      function_score: {
+      #        query: ...,
+      #        functions: [
+      #          { filter: { term: { 'company.id': 1 } }, boost_factor: 1000 }
+      #        ]
+      #      }
+      #    }
+      # ```
+      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.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)
+        if on_options.is_a?(Enumerable)
+          Query::MultiMatch.new(query_text, on_options)
+        else
+          Query::Match.new(query_text, on_options)
+        end
+      end
+
+      def parse_only_and_except(query, only_options, except_options)
+        return query if only_options.blank? && except_options.blank?
+
+        filter = parse_filters(only_options) + parse_filters(except_options).map { |f| Filter::Not.new(f) }
+        filter = join_filters(filter)
+
+        Query::Filtered.new(filter, query)
+      end
+
+      def join_filters(filters)
+        filters.count > 1 ? Filter::And.new(filters) : filters.first
+      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 parse_boost(query, boost_by_options, boost_where_options)
+        return query if boost_by_options.blank? && boost_where_options.blank?
+
+        function = parse_boost_function(boost_by_options, boost_where_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))
+          ScoreFunction::Filtered.new(filter, ScoreFunction::BoostFactor.new(1_000))
+        end
+      end
+    end
+  end
+end

data/lib/elasticband/search.rb

@@ -0,0 +1,18 @@
+module Elasticband
+  class Search
+    class << self
+      # Parses a query text with options to a Elasticsearch search syntax.
+      # See Elasticband::Query.parse and Elasticband::Aggregation.parse options for details.
+      #
+      # #### Examples
+      # ```
+      # Search.parse('foo', on: :name, group_by: :status)
+      # => { query: { match: { name: 'foo' } }, aggs: { status: { terms: { field: :status } } } }
+      # ```
+      def parse(query_text, options)
+        hash = { query: Query.parse(query_text, options), aggs: Aggregation.parse(options) }
+        hash.reject { |_, value| value.blank? }
+      end
+    end
+  end
+end

data/lib/elasticband/version.rb

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

data/lib/elasticband.rb

@@ -0,0 +1,12 @@
+require 'active_support'
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/array'
+
+require 'elasticband/aggregation'
+require 'elasticband/filter'
+require 'elasticband/query'
+require 'elasticband/search'
+require 'elasticband/version'
+
+module Elasticband
+end

data/spec/aggregation/nested_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Aggregation::Nested do
+  describe '#to_h' do
+    subject { described_class.new(root_aggregation, nested_aggregation).to_h }
+
+    let(:root_aggregation) { Elasticband::Aggregation.new(:root_aggregation) }
+    let(:nested_aggregation) { Elasticband::Aggregation.new(:nested_aggregation) }
+
+    before do
+      allow(root_aggregation).to receive(:to_h) { { root_aggregation: { key_1: :value_1 } } }
+      allow(nested_aggregation).to receive(:to_h) { { nested_aggregation: { key_2: :value_2 } } }
+    end
+
+    it 'returns a nested aggreagation hash' do
+      is_expected.to eq(
+        root_aggregation: {
+          key_1: :value_1,
+          aggs: {
+            nested_aggregation: {
+              key_2: :value_2
+            }
+          }
+        }
+      )
+    end
+  end
+end

data/spec/aggregation/terms_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Aggregation::Terms do
+  describe '#to_h' do
+    context 'without options' do
+      subject { described_class.new(:aggregation_name, :field_name).to_h }
+
+      it { is_expected.to eq(aggregation_name: { terms: { field: :field_name } }) }
+    end
+
+    context 'with options' do
+      subject { described_class.new(:aggregation_name, :field_name, size: 1).to_h }
+
+      it { is_expected.to eq(aggregation_name: { terms: { field: :field_name, size: 1 } }) }
+    end
+  end
+end

data/spec/aggregation/top_hits_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Aggregation::TopHits do
+  describe '#to_h' do
+    subject { described_class.new(:top_hits_aggregation, root_aggregation, 3).to_h }
+
+    let(:root_aggregation) { Elasticband::Aggregation.new(:root_aggregation) }
+
+    before do
+      allow(root_aggregation).to receive(:to_h) { { root_aggregation: { terms: { field: :field_name } } } }
+    end
+
+    it 'returns a nested aggreagation hash' do
+      is_expected.to eq(
+        root_aggregation: {
+          terms: { field: :field_name },
+          aggs: {
+            top_hits_aggregation: {
+              top_hits: { size: 3 }
+            }
+          }
+        }
+      )
+    end
+  end
+end

data/spec/aggregation_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Aggregation do
+  describe '#to_h' do
+    context 'without a aggregation_hash' do
+      subject { described_class.new(:aggregation_name).to_h }
+
+      it { is_expected.to eq(aggregation_name: {}) }
+    end
+
+    context 'with a aggregation_hash' do
+      subject { described_class.new(:aggregation_name).to_h(key: :value) }
+
+      it { is_expected.to eq(aggregation_name: { key: :value }) }
+    end
+  end
+
+  describe '.parse' do
+    subject { described_class.parse(options) }
+
+    context 'with `:group_by` option' do
+      context 'with the field_name' do
+        let(:options) { { group_by: :status } }
+
+        it { is_expected.to eq(status: { terms: { field: :status } }) }
+      end
+
+      context 'with an array with field_name and :top_hits option' do
+        let(:options) { { group_by: [:status, top_hits: 3] } }
+
+        it 'returns the `terms` aggregation with a `top_hits` nested' do
+          is_expected.to eq(
+            status: {
+              terms: { field: :status },
+              aggs: { top_status: { top_hits: { size: 3 } } }
+            }
+          )
+        end
+      end
+
+      context 'with an array with field_name and other options' do
+        let(:options) { { group_by: [:status, size: 3] } }
+
+        it { is_expected.to eq(status: { terms: { field: :status, size: 3 } }) }
+      end
+    end
+  end
+end

data/spec/filter/and_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Filter::And do
+  describe '#to_h' do
+    let(:filter_1) { Elasticband::Filter.new }
+    let(:filter_2) { Elasticband::Filter.new }
+
+    before do
+      allow(filter_1).to receive(:to_h) { 'filter_1' }
+      allow(filter_2).to receive(:to_h) { 'filter_2' }
+    end
+
+    context 'with only one filter' do
+      subject { described_class.new(filter_1).to_h }
+
+      it { is_expected.to eq(and: ['filter_1']) }
+    end
+
+    context 'with multiple filters' do
+      subject { described_class.new([filter_1, filter_2]).to_h }
+
+      it { is_expected.to eq(and: %w(filter_1 filter_2)) }
+    end
+
+    context 'with options' do
+      subject { described_class.new(filter_1, _cache: true).to_h }
+
+      it { is_expected.to eq(and: { filter: ['filter_1'], _cache: true }) }
+    end
+  end
+end

data/spec/filter/not_spec.rb

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

data/spec/filter/query_spec.rb

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

data/spec/filter/term_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Filter::Term do
+  describe '#to_h' do
+    context 'without options' do
+      subject { described_class.new('filter', :field_name).to_h }
+
+      it { is_expected.to eq(term: { field_name: 'filter' }) }
+    end
+
+    context 'with options' do
+      subject { described_class.new('filter', :field_name, _cache: true).to_h }
+
+      it { is_expected.to eq(term: { field_name: 'filter', _cache: true }) }
+    end
+  end
+end

data/spec/filter/terms_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Filter::Terms do
+  describe '#to_h' do
+    context 'with only one value' do
+      subject { described_class.new('filter', :field_name).to_h }
+
+      it { is_expected.to eq(terms: { field_name: ['filter'] }) }
+    end
+
+    context 'with multiple values' do
+      subject { described_class.new(%w(filter_1 filter_2), :field_name).to_h }
+
+      it { is_expected.to eq(terms: { field_name: %w(filter_1 filter_2) }) }
+    end
+
+    context 'with options' do
+      subject { described_class.new('filter', :field_name, _cache: true).to_h }
+
+      it { is_expected.to eq(terms: { field_name: ['filter'], _cache: true }) }
+    end
+  end
+end

data/spec/filter_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Filter do
+  describe '#to_h' do
+    subject { described_class.new.to_h }
+
+    it { is_expected.to eq(match_all: {}) }
+  end
+end

data/spec/query/filtered_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Query::Filtered do
+  describe '#to_h' do
+    let(:other_query) { Elasticband::Query.new }
+    let(:filter) { Elasticband::Filter.new }
+
+    before do
+      allow(other_query).to receive(:to_h) { 'query' }
+      allow(filter).to receive(:to_h) { 'filter' }
+    end
+
+    context 'with only filter' do
+      subject { described_class.new(filter).to_h }
+
+      it { is_expected.to eq(filtered: { filter: 'filter' }) }
+    end
+
+    context 'with filter and query' do
+      subject { described_class.new(filter, other_query).to_h }
+
+      it { is_expected.to eq(filtered: { query: 'query', filter: 'filter' }) }
+    end
+
+    context 'with filter and options' do
+      subject { described_class.new(filter, nil, strategy: :leap_frog).to_h }
+
+      it { is_expected.to eq(filtered: { filter: 'filter', strategy: :leap_frog }) }
+    end
+
+    context 'with filter, query and options' do
+      subject { described_class.new(filter, other_query, strategy: :leap_frog).to_h }
+
+      it { is_expected.to eq(filtered: { query: 'query', filter: 'filter', strategy: :leap_frog }) }
+    end
+  end
+end

data/spec/query/function_score_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Query::FunctionScore do
+  describe '#to_h' do
+    let(:other_query) { Elasticband::Query.new }
+    let(:filter) { Elasticband::Filter.new }
+    let(:score_function_1) { Elasticband::Query::ScoreFunction.new }
+    let(:score_function_2) { Elasticband::Query::ScoreFunction.new }
+
+    before do
+      allow(other_query).to receive(:to_h) { 'query' }
+      allow(filter).to receive(:to_h) { 'filter' }
+      allow(score_function_1).to receive(:to_h) { { score_function_1: 'score_function_1' } }
+      allow(score_function_2).to receive(:to_h) { { score_function_2: 'score_function_2' } }
+    end
+
+    context 'with a single function' do
+      context 'with a query' do
+        subject { described_class.new(other_query, score_function_1).to_h }
+
+        it { is_expected.to eq(function_score: { query: 'query', score_function_1: 'score_function_1' }) }
+      end
+
+      context 'with filter' do
+        subject { described_class.new(filter, score_function_1).to_h }
+
+        it { is_expected.to eq(function_score: { filter: 'filter', score_function_1: 'score_function_1' }) }
+      end
+    end
+
+    context 'with multiple functions' do
+      subject { described_class.new(other_query, [score_function_1, score_function_2]).to_h }
+
+      it 'returns a hash with the query/filter and an array with the functions' do
+        is_expected.to eq(
+          function_score: {
+            query: 'query',
+            functions: [
+              { score_function_1: 'score_function_1' },
+              { score_function_2: 'score_function_2' }
+            ]
+          }
+        )
+      end
+    end
+
+    context 'with options' do
+      subject { described_class.new(other_query, score_function_1, boost: 1.2).to_h }
+
+      it 'returns a hash with the query, function and options' do
+        is_expected.to eq(
+          function_score: {
+            query: 'query',
+            score_function_1: 'score_function_1',
+            boost: 1.2
+          }
+        )
+      end
+    end
+
+    context 'with a filtered function' do
+      let(:filtered_function) { Elasticband::Query::ScoreFunction::Filtered.new(filter, score_function_1) }
+
+      subject { described_class.new(other_query, filtered_function).to_h }
+
+      it 'returns a hash with the query/filter and an array with the function' do
+        is_expected.to eq(
+          function_score: {
+            query: 'query',
+            functions: [{ filter: 'filter', score_function_1: 'score_function_1' }]
+          }
+        )
+      end
+    end
+  end
+end

data/spec/query/match_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Query::Match do
+  describe '#to_h' do
+    context 'without field' do
+      subject { described_class.new('q').to_h }
+
+      it { is_expected.to eq(match: { _all: 'q' }) }
+    end
+
+    context 'with a field and no options' do
+      subject { described_class.new('q', :field_name).to_h }
+
+      it { is_expected.to eq(match: { field_name: 'q' }) }
+    end
+
+    context 'with options' do
+      subject { described_class.new('q', :field_name, operator: :and).to_h }
+
+      it { is_expected.to eq(match: { field_name: { query: 'q', operator: :and } }) }
+    end
+  end
+end

data/spec/query/multi_match_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Query::MultiMatch do
+  describe '#to_h' do
+    context 'without field' do
+      subject { described_class.new('q').to_h }
+
+      it { is_expected.to eq(multi_match: { query: 'q', fields: [:_all] }) }
+    end
+
+    context 'with a single field' do
+      subject { described_class.new('q', :field_name).to_h }
+
+      it { is_expected.to eq(multi_match: { query: 'q', fields: [:field_name] }) }
+    end
+
+    context 'with multiple fields' do
+      subject { described_class.new('q', [:field_name_1, :field_name_2]).to_h }
+
+      it { is_expected.to eq(multi_match: { query: 'q', fields: [:field_name_1, :field_name_2] }) }
+    end
+
+    context 'with options' do
+      subject { described_class.new('q', :field_name, operator: :and).to_h }
+
+      it { is_expected.to eq(multi_match: { query: 'q', operator: :and, fields: [:field_name] }) }
+    end
+  end
+end

data/spec/query/score_function/boost_factor_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Query::ScoreFunction::BoostFactor do
+  describe '#to_h' do
+    subject { described_class.new(1.2).to_h }
+
+    it { is_expected.to eq(boost_factor: 1.2) }
+  end
+end

data/spec/query/score_function/field_value_factor_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Query::ScoreFunction::FieldValueFactor do
+  describe '#to_h' do
+    context 'without options' do
+      subject { described_class.new(:field_name).to_h }
+
+      it { is_expected.to eq(field_value_factor: { field: :field_name }) }
+    end
+
+    context 'with options' do
+      subject { described_class.new(:field_name, factor: 1.2).to_h }
+
+      it { is_expected.to eq(field_value_factor: { field: :field_name, factor: 1.2 }) }
+    end
+  end
+end

data/spec/query/score_function/filtered_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Query::ScoreFunction::Filtered do
+  describe '#to_h' do
+    let(:other_score_function) { Elasticband::Query::ScoreFunction.new }
+    let(:filter) { Elasticband::Filter.new }
+
+    before do
+      allow(other_score_function).to receive(:to_h) { { function_name: 'score_function' } }
+      allow(filter).to receive(:to_h) { 'filter' }
+    end
+
+    context 'without options' do
+      subject { described_class.new(filter, other_score_function).to_h }
+
+      it { is_expected.to eq(filter: 'filter', function_name: 'score_function') }
+    end
+
+    context 'with options' do
+      subject { described_class.new(filter, other_score_function, weight: 2).to_h }
+
+      it { is_expected.to eq(filter: 'filter', function_name: 'score_function', weight: 2) }
+    end
+  end
+end

data/spec/query/score_function/script_score_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Query::ScoreFunction::ScriptScore do
+  describe '#to_h' do
+    context 'without options' do
+      subject { described_class.new('script').to_h }
+
+      it { is_expected.to eq(script_score: { script: 'script' }) }
+    end
+
+    context 'with options' do
+      subject { described_class.new('script', params: { param_1: :value_1 }).to_h }
+
+      it { is_expected.to eq(script_score: { script: 'script', params: { param_1: :value_1 } }) }
+    end
+  end
+end

data/spec/query/score_function_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+RSpec.describe Elasticband::Query::ScoreFunction do
+  describe '#to_h' do
+    subject { described_class.new.to_h }
+
+    it { is_expected.to be_a(Hash) }
+    it { is_expected.to be_empty }
+  end
+end