trample_search 0.14.0

data/lib/trample/condition_proxy.rb

@@ -0,0 +1,91 @@
+module Trample
+  class ConditionProxy
+
+    def initialize(name, search)
+      condition = search.class._conditions[name.to_sym]
+      raise ConditionNotFoundError.new(search, name) unless condition
+
+      @condition_class = condition.class
+      @condition_config = condition.attributes.dup
+      @search = search
+      @name = name
+    end
+
+    def or(values)
+      set(values: values, and: false)
+    end
+    alias :in :or
+
+    def and(values)
+      set(values: values, and: true)
+    end
+    alias :all :and
+
+    def analyzed(value)
+      set(values: value, search_analyzed: true)
+    end
+
+    def not(values)
+      set(values: values, not: true)
+    end
+    alias :not_in :not
+
+    def gte(value)
+      merge(from_eq: value)
+    end
+
+    def gt(value)
+      merge(from: value)
+    end
+
+    def lte(value)
+      merge(to_eq: value)
+    end
+
+    def lt(value)
+      merge(to: value)
+    end
+
+    def within(range)
+      set(from: range.first, to: range.last)
+    end
+
+    def within_eq(range)
+      set(from_eq: range.first, to_eq: range.last)
+    end
+
+    def eq(value)
+      set(values: value)
+    end
+
+    def autocomplete(value)
+      set(values: value, autocomplete: true)
+    end
+
+    def starts_with(value)
+      set(values: value, prefix: true)
+    end
+
+    def any_text(value)
+      set(values: value, any_text: true)
+    end
+
+    def set(payload)
+      payload = {values: payload} unless payload.is_a?(Hash)
+      condition = @condition_class.new(@condition_config.merge(payload))
+      @search.conditions[@name] = condition
+      @search
+    end
+
+    private
+
+    def merge(payload)
+      existing = @search.conditions[@name]
+      existing_attrs = {}
+      existing_attrs = existing.attributes if existing
+      merged = existing_attrs.merge(payload)
+      set(merged)
+    end
+
+  end
+end

data/lib/trample/errors.rb

@@ -0,0 +1,27 @@
+module Trample
+  class ConditionNotFoundError < StandardError
+
+    def initialize(search, condition_name)
+      @search = search
+      @condition_name = condition_name
+    end
+
+    def message
+      "Could not find condition #{@condition_name} in search #{@search.class}"
+    end
+
+  end
+
+  class AggregationNotDefinedError < StandardError
+
+    def initialize(search, agg_name)
+      @search = search
+      @agg_name = agg_name
+    end
+
+    def message
+      "Could not find facet #{@agg_name} in search #{@search.class}"
+    end
+
+  end
+end

data/lib/trample/metadata.rb

@@ -0,0 +1,41 @@
+module Trample
+  class Metadata
+    include Virtus.model
+    extend Forwardable
+
+    class Pagination
+      include Virtus.model
+
+      attribute :total, Integer
+      attribute :current_page, Integer, default: 1
+      attribute :per_page, Integer, default: 20
+    end
+
+    class Sort
+      include Virtus.model
+
+      attribute :att, String
+      attribute :dir, String
+    end
+
+    class Records
+      include Virtus.model
+
+      attribute :load, Boolean, default: false
+      attribute :includes, Hash, default: {}
+    end
+
+    attribute :records, Records, default: ->(_,_) { Records.new }
+    attribute :pagination, Pagination, default: ->(_,_) { Pagination.new }
+    attribute :took, Integer
+    attribute :sort, Array[Sort]
+
+    def_delegators :pagination, :total, :current_page, :per_page
+    def_delegator :sort, :att, :sort_att
+    def_delegator :sort, :dir, :sort_dir
+
+    def total_pages
+      (total.to_f / per_page.to_f).ceil
+    end
+  end
+end

data/lib/trample/railtie.rb

@@ -0,0 +1,9 @@
+module Trample
+  class Railtie < Rails::Railtie
+
+    config.before_initialize do
+      Trample::Search.extend ActiveModel::Naming
+    end
+
+  end
+end

data/lib/trample/results.rb

@@ -0,0 +1,9 @@
+module Trample
+  class Results
+    include Virtus.model
+
+    attribute :total, Integer
+    attribute :took, Integer
+    attribute :entries, Array
+  end
+end

data/lib/trample/search.rb

@@ -0,0 +1,176 @@
+module Trample
+  class Search
+    include Serializable
+    include Virtus.model
+
+    attribute :id, String, default: ->(instance, attr) { SecureRandom.uuid }
+    attribute :conditions, Hash[Symbol => Condition], default: ->(search, attr) { {} }
+    attribute :aggregations, Array[Aggregation], default: ->(search, attr) { {} }
+    attribute :results, Array
+    attribute :metadata, Metadata, default: ->(search, attr) { Metadata.new }
+
+    class << self
+      attr_accessor :_conditions, :_aggs
+      attr_reader :_models
+    end
+    self._conditions = {}
+    self._aggs = {}
+
+    def self.inherited(klass)
+      super
+      klass._conditions = self._conditions.dup
+      klass._aggs = self._aggs.dup
+    end
+
+    def self.condition(name, attrs = {})
+      attrs.merge!(name: name)
+      @_conditions[name] = Condition.new(attrs)
+    end
+
+    def self.aggregation(name, attrs = {})
+      attrs.merge!(name: name)
+      attrs[:order] = @_aggs.keys.length
+      @_aggs[name] = Aggregation.new(attrs)
+      yield @_aggs[name] if block_given?
+    end
+
+    def self.model(*klasses)
+      @_models = klasses
+    end
+
+    def self.paginate(page_params)
+      instance = new
+      instance.paginate(page_params)
+    end
+
+    def paginate(page_params)
+      page_params ||= {}
+      metadata.pagination.current_page = page_params[:number] if page_params[:number]
+      metadata.pagination.per_page = page_params[:size] if page_params[:size]
+      self
+    end
+
+    def sort(*fields)
+      return self if fields.empty?
+
+      sorts = fields.map do |f|
+        if f.to_s.starts_with?('-')
+          f.sub!('-','')
+          {att: f, dir: :desc}
+        else
+          {att: f, dir: :asc}
+        end
+      end
+      self.metadata.sort = sorts
+      self
+    end
+
+    def condition(name)
+      ConditionProxy.new(name, self)
+    end
+
+    def includes(includes)
+      self.metadata.records[:includes] = includes
+    end
+
+    # todo refactor...
+    def agg(*names_or_payloads)
+      names_or_payloads.each do |name_or_payload|
+        name = name_or_payload
+        selections = []
+        if name_or_payload.is_a?(Hash)
+          name = name_or_payload.keys.first if name_or_payload.is_a?(Hash)
+          selections = Array(name_or_payload.values.first)
+        end
+        template = self.class._aggs[name.to_sym]
+        raise AggregationNotDefinedError.new(self, name) unless template
+        agg = self.aggregations.find { |a| a.name.to_sym == name.to_sym }
+
+        if agg.nil?
+          # N.B. deep dup so buckets don't mutate
+          agg = Aggregation.new(deep_dup(template.attributes).merge(name: name.to_sym))
+          agg.bucket_sort = template.bucket_sort
+          self.aggregations << agg
+        end
+
+        selections.each do |key|
+          bucket = agg.find_or_initialize_bucket(key)
+          bucket.selected = true
+        end
+      end
+
+      self
+    end
+
+    # N.B rails may send nil here instead of empty array
+    def aggregations=(aggregation_array)
+      aggregation_array ||= []
+      super([])
+
+      aggregation_array.each do |aggregation_hash|
+        if aggregation_hash[:buckets] # rails converting [] to nil
+          selections = aggregation_hash[:buckets].select { |b| !!b[:selected] }.map { |b| b[:key] }
+          agg(aggregation_hash[:name].to_sym => selections)
+        else
+          agg(aggregation_hash[:name].to_sym => [])
+        end
+      end
+    end
+
+    def aggregations
+      @aggregations.sort! { |a, b| a.order <=> b.order }
+      @aggregations
+    end
+
+    def conditions=(hash)
+      super({})
+      hash.each_pair do |name, value|
+        condition(name).set(value)
+      end
+    end
+
+    def backend
+      @backend ||= Backend::Searchkick.new(metadata, self.class._models)
+    end
+
+    def query!
+      @records = nil
+      hash = backend.query!(conditions, aggregations)
+      self.metadata.took = hash[:took]
+      self.metadata.pagination.total = hash[:total]
+      self.results = hash[:results]
+      if !!metadata.records[:load]
+        records!
+      else
+        self.results
+      end
+    end
+
+    # Todo only works for single-model search atm
+    # N.B. preserves sorting
+    def records
+      @records ||= begin
+                     queried = self.class._models.first.where(id: results.map(&:_id))
+                     queried = queried.includes(metadata.records[:includes])
+                     [].tap do |sorted|
+                       results.each do |result|
+                         model = queried.find { |m| m.id.to_s == result.id.to_s }
+                         sorted << model
+                       end
+                     end
+                   end
+    end
+
+    def records!
+      @records = nil
+      records
+    end
+
+    private
+
+    def deep_dup(o)
+      Marshal.load(Marshal.dump(o))
+    end
+
+  end
+end

data/lib/trample/serializable.rb

@@ -0,0 +1,7 @@
+module Trample
+  module Serializable
+    def read_attribute_for_serialization(name)
+      attributes[name]
+    end
+  end
+end

data/lib/trample/swagger.rb

@@ -0,0 +1,133 @@
+# Convenience methods so you don't have to write tons of
+# swagger documentation for every trample-based endpoint
+
+module Trample
+  module Swagger
+
+    CONDITION_OPTION_WHITELIST = [
+      :single,
+      :range,
+      :prefix,
+      :autocomplete,
+      :search_analyzed,
+      :not,
+      :and,
+      :any_text
+    ]
+
+    def trample_swagger_schema
+      swagger_schema :TrampleSearch do
+        property :data do
+          key :type, :object
+
+          property :attributes do
+            key :type, :object
+
+            property :conditions do
+              key :type, :object
+            end
+
+            property :metadata do
+              key :type, :object
+
+              property :pagination do
+                key :type, :object
+                key :example, {current_page: 1, per_page: 20}
+              end
+            end
+
+            property :aggregations do
+              key :type, :array
+              key :example, []
+
+              items do
+                key :type, :object
+              end
+            end
+          end
+        end
+      end
+
+      swagger_schema :TrampleSearchResponse do
+        allOf do
+          schema do
+            key :'$ref', :TrampleSearch
+          end
+
+          schema do
+            property :results do
+              key :type, :array
+
+              items do
+                key :type, :object
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def trample_swagger(search_class, path)
+      swagger_path "#{path}/new" do
+        operation :get do
+          key :description, "Instantiate default search. See the corresponding PUT operation for valid inputs."
+          key :tags, ['search']
+
+          response 200 do
+            key :description, 'Trample response'
+            schema do
+              key :'$ref', :TrampleSearchResponse
+            end
+          end
+        end
+      end
+
+      swagger_path "#{path}/{id}" do
+        operation :put do
+          description = "<p>Trample search <a target='_blank' href='http://richmolj.github.io/trample'>View Full Trample Documentation</a></p><p><strong>Conditions:</strong></p><ul>"
+          search_class._conditions.each_pair do |name, condition|
+            attrs = condition.attributes.select { |k,v| !!v }.map { |k,v| k }
+            attrs.select! { |a| CONDITION_OPTION_WHITELIST.include?(a) }
+            attrs = attrs.present? ? "(#{attrs.join(', ')})" : ''
+            description << "<li>#{name} #{attrs}</li>"
+          end
+          description << "</ul>"
+
+          if search_class._aggs.present?
+            description << "<p><strong>Aggregations:</strong></p><ul>"
+            search_class._aggs.each_pair do |name, agg|
+              description << "<li>#{name}</li>"
+            end
+            description << "</ul>"
+          end
+
+          key :description, description
+          key :tags, ['search']
+
+          parameter paramType: :path do
+            key :name, :id
+            key :type, :integer
+            key :default, SecureRandom.uuid
+          end
+
+          parameter do
+            key :name, :data
+            key :in, :body
+
+            schema do
+              key :'$ref', :TrampleSearch
+            end
+          end
+
+          response 200 do
+            key :description, 'Trample response'
+            schema do
+              key :'$ref', :TrampleSearchResponse
+            end
+          end
+        end
+      end
+    end
+
+  end
+end