chewie 0.2.4

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "chewie"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/chewie.gemspec

@@ -0,0 +1,38 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "chewie/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "chewie"
+  spec.version       = Chewie::VERSION
+  spec.authors       = ["mrjonesbot"]
+  spec.email         = ["nate@mrjones.io"]
+
+  spec.summary       = "A declarative interface for building Elasticsearch queries"
+  spec.homepage      = "https://github.com/mrjonesbot/chewie"
+  spec.license       = "MIT"
+
+  spec.metadata["yard.run"] = "yri"
+
+  # spec.metadata["homepage_uri"] = spec.homepage
+  # spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "yard"
+
+  spec.add_runtime_dependency(%q<activesupport>, [">= 5.1.6"])
+  spec.add_runtime_dependency(%q<pry>)
+end

data/lib/chewie.rb

@@ -0,0 +1,47 @@
+require './lib/chewie/version'
+require 'chewie/utils'
+require 'chewie/interface/bool'
+require 'chewie/interface/term_level'
+require 'chewie/interface/full_text'
+require 'chewie/handler/reduced'
+require 'active_support/all'
+require 'pry'
+
+module Chewie
+  include Chewie::Interface::Bool
+  include Chewie::Interface::TermLevel
+  include Chewie::Interface::FullText
+
+  def handlers
+    @handlers ||= {
+      query: [],
+      bool: []
+    }
+  end
+
+  def build(query: '', filters: {}, options: {})
+    query_data = set_query_data(query, filters)
+    bool_options = options[:bool] || {}
+
+    match_all_query(options) if query_data[:filters].empty?
+
+    context(:query, options) do
+      query_context = reduce_handlers(data: query_data)
+      bool_context = context(:bool, bool_options) do
+        reduce_handlers(data: query_data, context: :bool)
+      end
+
+      query_context.merge(bool_context)
+    end
+  end
+
+  private
+
+  include Utils
+
+  def match_all_query(options)
+    context(:query, options) do
+      { match_all: {} }
+    end
+  end
+end

data/lib/chewie/handler/reduced.rb

@@ -0,0 +1,60 @@
+require 'chewie/query/term_level'
+require 'chewie/query/bool'
+require 'chewie/query/full_text'
+
+module Chewie
+  module Handler
+    class Reduced
+      attr_reader :context, :query, :clause, :built_query, :clause_or_query
+
+      def initialize(context:, handler: {}, filters: {})
+        @context = context
+        @query = handler[:query]
+        @clause = handler[:clause]
+        @built_query = build_query(handler, filters)
+        @clause_or_query = (@clause || @query)
+      end
+
+      def reduce_with(handlers, hash)
+        has_one = handlers[query].one?
+
+        if has_one && is_top_level_query
+          set_in_hash(hash)
+        else
+          push_to_array(hash)
+        end
+      end
+
+      private
+
+      def set_in_hash(hash)
+        hash[clause_or_query] =
+          (hash[clause_or_query] || {}).merge(built_query)
+      end
+
+      def push_to_array(hash)
+        hash[clause_or_query] =
+          (hash[clause_or_query] || []).push(built_query)
+      end
+
+      def is_top_level_query
+        !(context == :bool && clause.present?)
+      end
+
+      def build_query(handler, filters)
+        query_type = handler[:query_type]
+
+        case query_type
+        when :term_level
+          ::Chewie::Query::TermLevel.new(handler, filters).build
+        when :bool
+          ::Chewie::Query::Bool.new(handler, filters).build
+        when :full_text
+          ::Chewie::Query::FullText.new(handler, filters).build
+        else
+          raise "Could not build a query for type: #{query_type}"
+        end
+      end
+    end
+  end
+end

data/lib/chewie/interface/bool.rb

@@ -0,0 +1,64 @@
+module Chewie
+  module Interface
+    module Bool
+
+      # @param attribute [Symbol] Field you wish to search
+      # @param with [Symbol] Specify the term-level query [term, terms, range]
+      # @param combine [Array] Target additional filter values to be combined in the formatted output (optional)
+      # @param format [Lambda] Define custom output with :combine values at runtime (optional)
+      # @return [Hash] A valid bool query
+      # @note See README#filtering-by-associations use case for :combine and :filter options
+      def filter_by(attribute, with:, combine: [], format: nil)
+        handler = {
+          query: :filter,
+          attribute: attribute, 
+          with: with,
+          combine: combine, 
+          format: format,
+          query_type: :bool,
+        }
+        set_handler(context: :bool, handler: handler)
+      end
+
+      # (see #filter_by)
+      def should_include(attribute, with:, combine: [], format: nil)
+        handler = {
+          query: :should,
+          attribute: attribute, 
+          with: with,
+          combine: combine, 
+          format: format,
+          query_type: :bool,
+        }
+        set_handler(context: :bool, handler: handler)
+      end
+
+      # (see #filter_by)
+      def must_not_include(attribute, with:, combine: [], format: nil)
+        handler = {
+          query: :must_not,
+          attribute: attribute, 
+          with: with,
+          combine: combine, 
+          format: format,
+          query_type: :bool,
+        }
+        set_handler(context: :bool, handler: handler)
+      end
+
+      # (see #filter_by)
+      def must_include(attribute, with:, combine: [], format: nil)
+        handler = {
+          query: :must,
+          attribute: attribute, 
+          with: with,
+          combine: combine, 
+          format: format,
+          query_type: :bool,
+        }
+
+        set_handler(context: :bool, handler: handler)
+      end
+    end
+  end
+end

data/lib/chewie/interface/full_text.rb

@@ -0,0 +1,44 @@
+module Chewie
+  module Interface
+    module FullText
+
+      # @param attribute [Symbol] Field you wish to search
+      # @param context [Symbol] Desired context the query should appear (see https://www.elastic.co/guide/en/elasticsearch/reference/current/compound-queries.html)
+      # @param clause [Symbol] Specify a nested clause, usually context dependent (optional)
+      # @param options [Hash] Options to augment search behavior: https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-query.html#match-field-params
+      # @return [Hash] A valid "must" query
+      def match(attribute, context: :query, clause: nil, options: {})
+        handler = {
+          query: :match,
+          clause: clause,
+          attribute: attribute,
+          query_type: :full_text,
+          options: options,
+        }
+
+        set_handler(context: context, handler: handler)
+      end
+
+      # @param with [Array] A collection of field symbols to match against
+      # @param context [Symbol] Desired context the query should appear (see https://www.elastic.co/guide/en/elasticsearch/reference/current/compound-queries.html)
+      # @param clause [Symbol] Specify a nested clause, usually context dependent (optional)
+      # @param options [Hash] Options to augment search behavior
+      # @return [Hash] A valid "multi-match" query
+      def multimatch(with: [], context: :query, clause: nil, options: {})
+        if context == :compound
+          raise 'Please include a :clause value for compound queries.'
+        end
+
+        handler = {
+          query: :multimatch,
+          clause: clause,
+          with: with,
+          query_type: :full_text,
+          options: options,
+        }
+
+        set_handler(context: context, handler: handler)
+      end
+    end
+  end
+end

data/lib/chewie/interface/term_level.rb

@@ -0,0 +1,73 @@
+module Chewie
+  module Interface
+    module TermLevel
+
+      # @param attribute [Symbol] Field you wish to search
+      # @param context [Symbol] Desired context the query should appear (see https://www.elastic.co/guide/en/elasticsearch/reference/current/compound-queries.html)
+      # @param clause [Symbol] Specify a nested clause, usually context dependent (optional)
+      # @param options [Lambda] Options to augment search behavior: https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-fuzzy-query.html#fuzzy-query-field-params
+      # @return [Hash] A valid "fuzzy" query
+      def fuzzy(attribute, context: :query, clause: nil, options: {})
+        handler = {
+          query: :fuzzy,
+          clause: clause,
+          attribute: attribute,
+          query_type: :term_level,
+          options: options,
+        }
+        set_handler(context: context, handler: handler)
+      end
+
+      # @param attribute [Symbol] Field you wish to search
+      # @param context [Symbol] Desired context the query should appear (see https://www.elastic.co/guide/en/elasticsearch/reference/current/compound-queries.html)
+      # @param clause [Symbol] Specify a nested clause, usually context dependent (optional)
+      # @param options [Lambda] Options to augment search behavior: https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-range-query.html#range-query-field-params
+      # @return [Hash] A valid "range" query
+      def range(attribute, context: :query, clause: nil, options: {})
+        handler = {
+          query: :range,
+          clause: clause,
+          attribute: attribute,
+          query_type: :term_level,
+          options: options
+        }
+
+        set_handler(context: context, handler: handler)
+      end
+
+      # @param attribute [Symbol] Field you wish to search
+      # @param context [Symbol] Desired context the query should appear (see https://www.elastic.co/guide/en/elasticsearch/reference/current/compound-queries.html)
+      # @param clause [Symbol] Specify a nested clause, usually context dependent (optional)
+      # @param options [Lambda] Options to augment search behavior: https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-term-query.html#term-field-params
+      # @return [Hash] A valid "term" query
+      def term(attribute, context: :query, clause: nil, options: {})
+        handler = {
+          query: :term,
+          clause: clause,
+          attribute: attribute,
+          query_type: :term_level,
+          options: options
+        }
+
+        set_handler(context: context, handler: handler)
+      end
+
+      # @param attribute [Symbol] Field you wish to search
+      # @param context [Symbol] Desired context the query should appear (see https://www.elastic.co/guide/en/elasticsearch/reference/current/compound-queries.html)
+      # @param clause [Symbol] Specify a nested clause, usually context dependent (optional)
+      # @param options [Lambda] Options to augment search behavior: https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-terms-query.html#terms-top-level-params
+      # @return [Hash] A valid "terms" query
+      def terms(attribute, context: :query, clause: nil, options: {})
+        handler = {
+          query: :terms,
+          clause: clause,
+          attribute: attribute,
+          query_type: :term_level,
+          options: options
+        }
+
+        set_handler(context: context, handler: handler)
+      end
+    end
+  end
+end

data/lib/chewie/query/bool.rb

@@ -0,0 +1,51 @@
+require 'chewie/utils'
+
+module Chewie
+  module Query
+    class Bool
+      attr_reader :attribute, :query_format, :with, :value, :combine, :filters
+
+      def initialize(handler, filters)
+        @attribute = handler[:attribute]
+        @query_format = handler[:format]
+        @with = handler[:with]
+        @value = filters[attribute]
+        @combine = handler[:combine]
+        @filters = filters
+      end
+
+      def build
+        return {} if value.nil?
+        return [] if [value].flatten.empty?
+
+        context(with) do
+          { attribute => exposed_value }
+        end
+      end
+
+      private
+
+      include Utils
+
+      def should_format
+        query_format.present?
+      end
+
+      def exposed_value
+        expose_or_return_value(formatted_value, with, should_format)
+      end
+
+      def formatted_value
+        if should_format
+          format_values(value, combined, query_format)
+        else
+          value
+        end
+      end
+
+      def combined
+        combine_values(combine, filters)
+      end
+    end
+  end
+end

data/lib/chewie/query/full_text.rb

@@ -0,0 +1,60 @@
+require 'chewie/utils'
+
+module Chewie
+  module Query
+    class FullText
+      attr_reader :attribute, :with, :query, :clause, :value, :options, :strategy
+
+      def initialize(handler, filters)
+        @attribute = handler[:attribute]
+        @with = handler[:with]
+        @query = handler[:query]
+        @clause = handler[:clause]
+        @value = filters[attribute] || filters[:query]
+        @options = handler.fetch(:options, {})
+        @strategy = clause.present? ? 'clause' : 'attribute'
+      end
+
+      def build
+        return {} if value.nil?
+        return [] if [value].flatten.empty?
+
+        send("create_with_#{strategy}")
+      end
+
+      private
+
+      include Utils
+
+      def create_with_clause
+        context(query) do
+          multimatch_query? ? multimatch_query : attribute_query
+        end
+      end
+
+      def create_with_attribute
+        return multimatch_query if multimatch_query?
+
+        context(attribute) do
+          if !value.is_a? Hash
+            { query: value }.merge(options)
+          else
+            value.merge(options)
+          end
+        end
+      end
+
+      def multimatch_query?
+        with.present?
+      end
+
+      def attribute_query
+        { attribute => { query: value }.merge(options) }
+      end
+      
+      def multimatch_query
+        { fields: with, query: value }.merge(options)
+      end
+    end
+  end
+end