trample_search 0.14.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c648e258dedbc817af3e8fd1dd0e2beb759dbbda
+  data.tar.gz: 92b492f65baf9d040f8b9a6616f109940441b53c
+SHA512:
+  metadata.gz: 6da88788dc47a9cf4749957aff836bfaadde11251b9a1b8d7d0bfac11129ac467f3252669a25f49e1c11a4ed5fe51a76004001869f9eb849a57e301ce05e1bb6
+  data.tar.gz: 087289caefa82470f2d59501e2d40b0574a37bd5a2fd377446e7009d7f3fd9fc483c809151f01e54d871b91696d7a82ccf681710df9f370aaf6904fbc9085a21

data/.gitignore

@@ -0,0 +1,12 @@
+*.swp
+*.swo
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+vendor

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://artifactory.dev.bloomberg.com:8080/artifactory/api/gems/rubygems/"
+
+# Specify your gem's dependencies in trample.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 richmolj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# Trample
+
+Additional querying sugar for [searchkick](https://github.com/ankane/searchkick).
+
+## Why Trample?
+
+Searchkick provides a nice query mechanism. But it doesn't provide a way to build up those queries, particularly syncing with UI input. Trample makes this simple:
+
+```ruby
+class PeopleSearchesController < ApplicationController
+
+  def update
+    search = PeopleSearch.new(params[:people_search)
+    search.query!
+    
+    render json: search
+  end
+
+end
+```
+
+Or, build up queries manually:
+
+```ruby
+search = PeopleSearch.new
+search.condition(:security_level).in(%w(low medium)) unless current_user.admin?
+search.paginate(size: 10, number: 2).sort("-age")
+search.query!
+search.results
+```
+
+## Usage
+
+Check out the complete [documentation](http://richmolj.github.io/trample), or see usage in the [specs](https://github.com/richmolj/trample/blob/master/spec/integration/search_spec.rb).
+
+## Specs
+
+Run elasticsearch on port 9250 and `bundle exec rspec`.
+
+## Contributing
+
+1. Fork it ( https://github.com/fotinakis/swagger-blocks/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

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 "trample"
+
+# 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

data/bin/rspec

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rspec-core', 'rspec')

data/bin/setup

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

data/lib/trample.rb

@@ -0,0 +1,22 @@
+require 'virtus'
+
+require "trample/version"
+require "trample/aggregation"
+require "trample/serializable"
+require "trample/condition"
+require "trample/condition_proxy"
+require "trample/metadata"
+require "trample/search"
+require "trample/backend/searchkick"
+require "trample/results"
+require "trample/errors"
+
+require "trample/swagger"
+
+require "trample/autocomplete/formatter"
+
+require "trample/railtie" if defined?(Rails)
+
+module Trample
+  # Your code goes here...
+end

data/lib/trample/aggregation.rb

@@ -0,0 +1,85 @@
+module Trample
+  class Aggregation
+    include Virtus.model
+
+    class Buckets < Array
+      def <<(entry)
+        if entry.is_a?(Hash)
+          super(Bucket.new(entry))
+        else
+          super
+        end
+      end
+    end
+
+    class Bucket
+      include Virtus.model
+      attribute :key, String
+      attribute :label, String, default: ->(bucket,attr) { bucket['key'] }
+      attribute :count, Integer, default: 0
+      attribute :selected, Boolean, default: false
+    end
+
+    attribute :name, Symbol
+    attribute :label, String
+    attribute :order, Integer
+    attribute :buckets, Buckets[Bucket]
+
+    attr_accessor :bucket_sort
+
+    def to_query
+      {name => selections}
+    end
+
+    def selections?
+      !selections.empty?
+    end
+
+    def selections
+      buckets.select(&:selected?).map(&:key)
+    end
+
+    # Usage:
+    # aggregation :foo do |agg|
+    #   agg.bucket_sort = :count
+    #   # OR agg.bucket_sort = :alpha
+    #   # OR add.bucket_sort = proc { |a, b| ... }
+    # end
+    def bucket_sort
+      @bucket_sort ||= :alpha
+
+      if @bucket_sort == :alpha
+        proc { |a, b| a.key.downcase <=> b.key.downcase }
+      elsif @bucket_sort == :count
+        proc { |a, b|
+          if a.count == b.count
+            a.key.downcase <=> b.key.downcase
+          else
+            b.count <=> a.count
+          end
+        }
+      else
+        @bucket_sort
+      end
+    end
+
+    def buckets
+      ordered = super
+      ordered.sort!(&bucket_sort)
+      ordered
+    end
+
+    def force(key, opts = {})
+      self.buckets << opts.merge(key: key)
+    end
+
+    def find_or_initialize_bucket(key)
+      bucket = buckets.find { |b| b['key'].downcase == key.downcase }
+      if bucket.nil?
+        bucket = Bucket.new(key: key)
+        self.buckets << bucket
+      end
+      bucket
+    end
+  end
+end

data/lib/trample/autocomplete/formatter.rb

@@ -0,0 +1,53 @@
+module Trample
+  module Autocomplete
+    class Formatter
+
+      def initialize(formatter = nil)
+        if formatter.respond_to?(:call)
+          @formatter = formatter
+        else
+          @formatter = hash_formatter_to_proc(formatter)
+        end
+      end
+
+      def format_all(results, options = {})
+        results = results.map do |r|
+          format_one(r)
+        end
+
+        if user_query = options[:user_query]
+          results.unshift(Hashie::Mash.new(id: user_query, key: user_query, text: "\"#{user_query}\"", user_query: true))
+        end
+
+        results
+      end
+
+      def format_one(result)
+        @formatter.call(result)
+      end
+
+      private
+
+      def default_hash
+        {
+          id: :id,
+          key: :id,
+          text: :name
+        }
+      end
+
+      def hash_formatter_to_proc(hash)
+        hash ||= default_hash
+
+        ->(result) {
+          {
+            id:   result.send(hash[:id]),
+            key:  result.send(hash[:key]),
+            text: result.send(hash[:text])
+          }
+        }
+      end
+
+    end
+  end
+end

data/lib/trample/backend/searchkick.rb

@@ -0,0 +1,94 @@
+require 'searchkick'
+
+module Trample
+  module Backend
+    class Searchkick
+
+      def initialize(metadata, models)
+        @metadata = metadata
+        @_models = models
+      end
+
+      def query!(conditions, aggregations)
+        query = build_query(conditions, aggregations, @metadata, @_models)
+        results = @_models.first.search(keywords(conditions), query)
+        parse_response_aggs!(results.aggs, aggregations) if results.response.has_key?('aggregations')
+
+        {
+          total:   results.total_count,
+          took:    results.response['took'],
+          results: results.results
+        }
+      end
+
+      private
+
+      def keywords(conditions)
+        if conditions[:keywords] and conditions[:keywords].values.first != ''
+          conditions[:keywords].values.first
+        else
+          '*'
+        end
+      end
+
+      def build_query(conditions, aggregations, metadata, models)
+        clauses = build_condition_clauses(conditions, aggregations)
+        query   = searchkick_payload(conditions[:keywords], clauses, metadata, aggregations)
+        query.merge!(index_name: models.map { |m| m.searchkick_index.name }) if models.length > 1
+        query
+      end
+
+      # N.B. aggs and conditions could hit same key
+      def build_condition_clauses(conditions, aggregations)
+        {}.tap do |clauses|
+          aggregations.each do |agg|
+            clauses.merge!(agg.to_query) if agg.selections?
+          end
+          conditions.each_pair do |name, condition|
+            next if condition.name == :keywords
+            merge_clause(clauses, condition.to_query) unless condition.blank?
+          end
+        end
+      end
+
+      def merge_clause(clauses, clause)
+        if clause[:or]
+          clauses[:or] ||= []
+          clauses[:or] << clause[:or]
+        else
+          clauses.merge!(clause)
+        end
+      end
+
+      def searchkick_payload(keywords, clauses, metadata, aggs)
+        payload = {
+          where:    clauses,
+          order:    _sorts(metadata),
+          page:     metadata.pagination.current_page,
+          per_page: metadata.pagination.per_page,
+          aggs:     aggs.map(&:name),
+          load:     false
+        }
+        payload[:fields] = keywords.fields if keywords and !keywords.fields.empty?
+        payload
+      end
+
+      def _sorts(metadata)
+        metadata.sort.map do |s|
+          {s.att => s.dir}
+        end
+      end
+
+      def parse_response_aggs!(response_aggs, search_aggs)
+        response_aggs.each_pair do |key, payload|
+          agg = search_aggs.find { |a| a.name.to_sym == key.to_sym }
+          payload['buckets'].each do |response_bucket|
+            bucket = agg.find_or_initialize_bucket(response_bucket['key'])
+            bucket.count = response_bucket['doc_count']
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/trample/condition.rb

@@ -0,0 +1,203 @@
+module Trample
+  class Condition
+    include Virtus.model
+
+    attribute :name, Symbol
+    attribute :query_name, Symbol, default: :name
+    attribute :values, Array
+    attribute :search_analyzed, Boolean, default: false
+    attribute :and, Boolean
+    attribute :not, Boolean
+    attribute :prefix, Boolean, default: false
+    attribute :any_text, Boolean, default: false
+    attribute :autocomplete, Boolean, default: false
+    attribute :from_eq
+    attribute :to_eq
+    attribute :from
+    attribute :to
+    attribute :single, Boolean, default: false
+    attribute :range, Boolean, default: false
+    attribute :fields, Array
+    attribute :user_query, Hash
+
+    def initialize(attrs)
+      attrs.merge!(single: true) if attrs[:name] == :keywords
+      super(attrs)
+    end
+
+    def blank?
+      values.reject { |v| v == "" || v.nil? }.empty? && !range?
+    end
+
+    def as_json(*opts)
+      if single?
+        values.first
+      elsif range?
+        {}.tap do |json|
+          json[:from_eq] = from_eq if from_eq?
+          json[:from]    = from if from?
+          json[:to_eq]   = to_eq if to_eq?
+          json[:to]      = to if to?
+        end
+      else
+        { values: values, and: and? }
+      end
+    end
+
+    def runtime_query_name
+      name = query_name
+      return "#{name}.text_start"   if prefix?
+      return "#{name}.text_middle"  if any_text?
+      return "#{name}.analyzed"     if search_analyzed?
+      return "#{name}.autocomplete" if autocomplete?
+      name
+    end
+
+    def to_query
+      if range?
+        to_range_query
+      else
+        _values      = values.dup.map { |v| v.is_a?(Hash) ? v.dup : v }
+        user_queries = _values.select(&is_user_query)
+        transformed  = transform_values(_values - user_queries)
+
+        user_query_clause = derive_user_query_clause(user_queries)
+        main_clause = derive_main_clause(transformed)
+
+        if user_query_clause.present?
+          { or: [ main_clause, user_query_clause ] }
+        else
+          main_clause
+        end
+      end
+    end
+
+    private
+
+    def transform_values(entries)
+      entries = pluck_autocomplete_keys(entries) if has_autocomplete_keys?(entries)
+      entries.map(&:downcase!) if search_analyzed?
+      entries = entries.first if entries.length == 1
+      entries
+    end
+
+    def derive_user_query_clause(user_queries)
+      if user_queries.length > 0
+        user_queries.each { |q| q.delete(:user_query) }
+        condition = Condition.new(user_query.merge(values: user_queries))
+        condition.to_query
+      else
+        {}
+      end
+    end
+
+    def derive_main_clause(transformed)
+      if prefix?
+        to_prefix_query(transformed)
+      elsif has_combinator?
+        to_combinator_query(transformed)
+      elsif exclusion?
+        to_exclusion_query(transformed)
+      else
+        {runtime_query_name => transformed}
+      end
+    end
+
+    def pluck_user_query_values!(values)
+      user_queries = values.select(&is_user_query)
+      values.reject!(&is_user_query)
+      [values, user_queries]
+    end
+
+    def has_user_queries?(entries)
+      entries.any?(&is_user_query)
+    end
+
+    def is_user_query
+      ->(entry) { entry.is_a?(Hash) and !!entry[:user_query] }
+    end
+
+    def pluck_autocomplete_keys(entries)
+      entries.map { |v| v[:key] }
+    end
+
+    def has_autocomplete_keys?(entries)
+      multiple? and entries.any? { |e| e.is_a?(Hash) }
+    end
+
+    def has_combinator?
+      not attributes[:and].nil?
+    end
+
+    def prefix?
+      !!prefix
+    end
+
+    def exclusion?
+      not attributes[:not].nil?
+    end
+
+    def anded?
+      has_combinator? and !!self.and
+    end
+
+    def multiple?
+      not single?
+    end
+
+    def not?
+      !!self.not
+    end
+
+    def from?
+      !!self.from
+    end
+
+    def to?
+      !!self.to
+    end
+
+    def from_eq?
+      !!self.from_eq
+    end
+
+    def to_eq?
+      !!self.to_eq
+    end
+
+    def to_prefix_query(vals)
+      if has_combinator?
+        to_combinator_query(vals)
+      else
+        {runtime_query_name => vals}
+      end
+    end
+
+    def to_exclusion_query(vals)
+      if not?
+        {runtime_query_name => {not: vals}}
+      else
+        {runtime_query_name => vals}
+      end
+    end
+
+    def to_combinator_query(vals, query_name_override = nil)
+      if anded?
+        {runtime_query_name => {all: vals}}
+      else
+        {runtime_query_name => vals}
+      end
+    end
+
+    def to_range_query
+      hash = {}
+      hash.merge!(gte: from_eq) if from_eq?
+      hash.merge!(gt: from) if from?
+      hash.merge!(lte: to_eq) if to_eq?
+      hash.merge!(lt: to) if to?
+
+      {runtime_query_name => hash}
+    end
+
+  end
+end