elasticsearch-facetedsearch 0.0.4

data/lib/elasticsearch/faceted_search/facet_group.rb

@@ -0,0 +1,101 @@
+require 'forwardable'
+
+module Elasticsearch
+  module FacetedSearch
+    class FacetGroup
+      extend Forwardable
+
+      OPERATOR_MAPPING = {
+        :and => ',',
+        :or => '|'
+      }
+
+      attr_accessor :search, :objects, :key
+
+      def_delegators :search, :class_facets, :execution_type, :search_params
+      # delegate :class_facets, :execution_type, :search_params, to: :search
+
+      def initialize(search, key, objects)
+        self.search = search
+        self.key = key.to_sym
+        self.objects = hit_count_mapping(objects['terms'])
+      end
+
+      def items
+        @items ||= build_items
+      end
+
+      def title
+        class_facets[key][:title]
+      rescue
+        key.to_s.humanize
+      end
+
+      def selected_values
+        v = search_params.fetch(key, '')
+        operator ? v.split(operator).map(&:downcase) : v.downcase
+      end
+
+      def group_params
+        group_params_string.split(operator).dup
+      end
+
+      def group_params_string
+        search_params.fetch(key, '')
+      end
+
+      def type
+        class_facets[key][:type]
+      rescue
+        nil
+      end
+
+      # Returns the string value ',' or '|'
+      #
+      def operator
+        @operator ||= operator_mappings(operator_for)
+      end
+
+      def operator_mappings(i=nil)
+        OPERATOR_MAPPING.fetch(i, nil)
+      end
+
+    private
+
+      def operator_for
+        execution_type(
+          class_facets[key][:type]
+        )
+      end
+
+      def build_items
+        terms_collection.map do |x|
+          FacetItem.new(self, x.merge(count: count(x[:id])))
+        end
+      end
+
+      def terms_collection
+        return mapped_objects unless search.respond_to?(:"#{key}_collection")
+        @terms_collection ||= search.public_send(:"#{key}_collection")
+      end
+
+      # Occationally ElasticSearch will return boolean facets with mix cased characters (T/t & F/f)
+      # This method cleans this result and combines the counts to be correct & valid
+      #
+      def hit_count_mapping(o)
+        @hit_count_mapping ||= o.each_with_object(Hash.new(0)) do |result, hash|
+          term = result['term'].to_s.downcase
+          hash[term] += result['count']
+        end
+      end
+
+      def count(id)
+        objects.fetch(id.to_s.downcase, 0)
+      end
+
+      def mapped_objects
+        objects.map{|k,v| {id: k, term: k, count: v} }
+      end
+    end
+  end
+end

data/lib/elasticsearch/faceted_search/facet_item.rb

@@ -0,0 +1,105 @@
+require 'forwardable'
+
+module Elasticsearch
+  module FacetedSearch
+    class FacetItem
+      extend Forwardable
+
+      attr_accessor :group, :object
+
+      def_delegators :group, :operator_mappings, :operator, :key, :selected_values, :group_params, :type
+      def_delegators :object, :term, :count
+      # delegate :operator_mappings, :operator, :key, :selected_values, :group_params, :type, to: :group
+      # delegate :term, :count, to: :object
+
+      def id
+        object.id.to_s
+      end
+
+      def initialize(group, object)
+        self.group = group
+        self.object = OpenStruct.new(object)
+      end
+
+      def selected?
+        @selected ||= Array(group_params).include?(id)
+      end
+
+      def params_for
+        prefix = selected? ? :remove : :add
+
+        case type
+          when 'multivalue'     then send(:"#{prefix}_multivalue")
+          when 'multivalue_and' then send(:"#{prefix}_multivalue", :and)
+          when 'multivalue_or'  then send(:"#{prefix}_multivalue", :or)
+          when 'exclusive_or'   then send(:"#{prefix}_singlevalue")
+          # else                  raise UnknownSelectableType.new "Unknown selectable type #{selectable_type} for #{@type}"
+        end
+      end
+
+    private
+      def params
+        @params ||= group_params.dup
+      end
+
+      # Removing a value from the parameters
+      # Example:
+      #   group_params = ['1','3','4']
+      #   id = 3
+      # => {key => '1|4'}
+      def remove_multivalue(op=nil)
+        op = operator_mappings(op) || operator
+        p = params.reject{|v| matches?(v) }
+
+        if p.blank?
+          remove_singlevalue
+        else
+          {
+            key => p.reject(&:blank?)
+                         .join( op )
+          }
+        end
+      end
+
+      # Remove a single value from params
+      #
+      def remove_singlevalue
+        {
+          key => nil
+        }
+      end
+
+      # Adding a value to the parameters
+      # Example:
+      #   group_params = ['1','3','4']
+      #   id = 5
+      # => {key => '1|3|4|5'}
+      def add_multivalue(op=nil)
+        op = operator_mappings(op) || operator
+
+        if params.blank?
+          add_singlevalue
+        else
+          {
+            key => (Array(params) + Array(id.to_s)).uniq
+                                     .join( op )
+          }
+        end
+      end
+
+      # Adding a single value to the parameters
+      # Example:
+      #   group_params = ['7']
+      #   id = 5
+      # => {key => '5'}
+      def add_singlevalue
+        { key => id.to_s }
+      end
+
+      def matches?(v)
+        v.to_s == id.to_s
+      end
+
+    end
+  end
+end

data/lib/elasticsearch/faceted_search/pagination.rb

@@ -0,0 +1,27 @@
+module Elasticsearch
+  module FacetedSearch
+    module Pagination
+      def total_count
+        search['hits']['total'].to_i
+      rescue
+        0
+      end
+
+      def total_pages
+        (total_count.to_f / limit_value.to_f).ceil
+      end
+
+      def limit_value
+        limit
+      end
+
+      def limit
+        (search_params[:limit] ||= 32).to_i
+      end
+
+      def current_page
+        (search_params[:page] ||= 1).to_i
+      end
+    end
+  end
+end

data/lib/elasticsearch/faceted_search/sortable.rb

@@ -0,0 +1,62 @@
+module Elasticsearch
+  module FacetedSearch
+    module Sortable
+
+      # Setup by the parent class
+      # https://www.elastic.co/guide/en/elasticsearch/reference/current/search-request-sort.html
+      #
+      # => returns Array or Hash
+      # {
+      #   label: "Relevant",
+      #   value: "relevant",
+      #   search: {...sort value(s) for elasticsearch...},
+      #   default: false
+      # }
+      #
+      def sorts
+        []
+      end
+
+      # Returns current sort hash to use for elasticsearch query
+      #
+      def current_sort_for_search
+        return unless current_sort.present?
+        current_sort[:search]
+      end
+
+      # Returns entire sort hash (Label, value, search....)
+      #
+      def current_sort
+        sorts.select{|x| x.fetch(:value) == selected_sort_value }.first || default_sort
+      end
+
+    private
+
+      # Selected sort value (params || default)
+      # => returns String
+      def selected_sort_value
+        sort_param.present? ? sort_param : default_sort_value
+      end
+
+      # Returns string for sort param even if invalid
+      # rescue required if search params is not a hash
+      #
+      def sort_param
+        search_params[:sort]
+      rescue
+        nil
+      end
+
+      # Returns string value of the default sort signified by
+      # => default: true
+      def default_sort_value
+        default_sort.fetch(:value, nil)
+      end
+
+      # Returns entire hash for sort for the default
+      def default_sort
+        sorts.select{|x| x.fetch(:default, false) }.first
+      end
+    end
+  end
+end

data/lib/elasticsearch/faceted_search/version.rb

@@ -0,0 +1,5 @@
+module Elasticsearch
+  module FacetedSearch
+    VERSION = "0.0.4"
+  end
+end

data/spec/lib/elasticsearch/faceted_search/facet_base_spec.rb

@@ -0,0 +1,256 @@
+require 'spec_helper'
+
+class DummyFacets
+  include Elasticsearch::FacetedSearch::FacetBase
+  facet_exclusive_or(:hd, 'media_hd', 'HD Media')
+
+  #mock
+  def type
+    ['type_here']
+  end
+
+  #mock
+  def filter_hd?
+  end
+
+  #mock
+  def hd_value
+    true
+  end
+end
+
+module Elasticsearch
+  module FacetedSearch
+    describe FacetBase do
+      let(:model) { DummyFacets.new({}) }
+
+      describe "#class_facets" do
+        it "returns class facets" do
+          expect(DummyFacets).to receive(:facets) { {facet: true} }
+          expect(model.class_facets).to eq({facet: true})
+        end
+      end
+
+      describe "#query" do
+
+        it "removes an empty items" do
+          expect(model.query).to eq({:size=>32, :from=>0, :facets=>{:hd=>{:terms=>{:field=>"media_hd", :size=>70}}}})
+        end
+
+        describe "with facets and filters" do
+          it "merges filters when filter_query has value" do
+            expect(model).to receive(:filter_query).at_least(:once) { 'hi' }
+            expect(model).to receive(:facet_query) { nil }
+            expect(model.query).to eq({:size=>32, :from=>0, filter: {and: 'hi'}})
+          end
+
+          it "merges facets when facets has value" do
+            expect(model).to receive(:filter_query) { nil }
+            expect(model).to receive(:facet_query).at_least(:once) { 'hi' }
+            expect(model.query).to eq({:size=>32, :from=>0, facets: 'hi'})
+          end
+
+          it "can merge both hashes" do
+            expect(model).to receive(:filter_query).at_least(:once) { 'hi' }
+            expect(model).to receive(:facet_query).at_least(:once) { 'hi' }
+            expect(model.query).to eq({:size=>32, :from=>0, facets: 'hi', filter: {and: 'hi'}})
+          end
+        end
+        describe "with limits" do
+          before(:each) do
+            expect(model).to receive(:filter_query).at_least(:once) { 'hi' }
+            expect(model).to receive(:facet_query).at_least(:once) { 'hi' }
+          end
+
+          it "returns from params" do
+            expect(model).to receive(:search_params).at_least(:once) { {limit: '10'}}
+            expect(model.query).to eq({:size=>10, :from=>0, :filter=>{:and=>"hi"}, :facets=>"hi"})
+          end
+
+          it "defaults to 32" do
+            expect(model.query).to eq({:size=>32, :from=>0, :filter=>{:and=>"hi"}, :facets=>"hi"})
+          end
+        end
+
+        describe "with page" do
+          before(:each) do
+            expect(model).to receive(:filter_query).at_least(:once) { 'hi' }
+            expect(model).to receive(:facet_query).at_least(:once) { 'hi' }
+            expect(model).to receive(:search_params).at_least(:once) { {page: 10, limit: 3} }
+          end
+
+          it "returns from params" do
+            expect(model.query).to eq({:size=>3, :from=>27, :filter=>{:and=>"hi"}, :facets=>"hi"})
+          end
+        end
+
+        describe "with sort" do
+          before(:each) do
+            expect(model).to receive(:sorts).at_least(:once) {
+              [
+                {
+                  label: "Relevant",
+                  value: "relevant",
+                  search: ["_score"],
+                  default: false
+                },
+                {
+                  label: "updated",
+                  value: "updated",
+                  search: ["updated"],
+                  default: true
+                }
+              ]
+            }
+          end
+          it "has a default sort" do
+            expect(model.query).to eq({:size=>32, :from=>0, :sort=>["updated"], :facets=>{:hd=>{:terms=>{:field=>"media_hd", :size=>70}}}})
+          end
+
+          it "can have a selected sort" do
+            expect(model).to receive(:search_params).at_least(:once) { {sort: 'relevant'} }
+            expect(model.query).to eq({:size=>32, :from=>0, :sort=>["_score"], :facets=>{:hd=>{:terms=>{:field=>"media_hd", :size=>70}}}})
+          end
+        end
+      end
+
+      describe "#facet_query" do
+        it "caches the request" do
+          expect(model).to receive(:build_facets).once {'blah'}
+          2.times { model.facet_query }
+        end
+      end
+
+      describe "#filter_query" do
+        it "caches the request" do
+          expect(model).to receive(:build_filters).once {'blah'}
+          2.times { model.filter_query }
+        end
+      end
+
+      describe "#search_params" do
+        it "returns the params" do
+          expect(model).to receive(:params) { 'boom' }
+          expect(model.search_params).to eq('boom')
+        end
+      end
+
+      describe "#build_facets" do
+        it "is private" do
+          expect {
+            model.build_facets
+          }.to raise_error(NoMethodError)
+        end
+        describe "with filters" do
+          it "equals a specific format" do
+            expect(model).to receive(:filter_query).at_least(:once) { [{terms: {:hello => ['world']}}] }
+            expect(model.send(:build_facets)).to eq(
+              {
+                :hd=>{
+                  :terms=>{
+                    :field=>"media_hd", :size=>70
+                  },
+                  :facet_filter=>{
+                    :and=>[
+                      {:terms=>{:hello=>["world"]}}
+                    ]
+                  }
+                }
+              }
+            )
+          end
+
+          # Added spec due to improper merge on 0.0.2 release
+          # => if this spec is failing, elastic search is going to complain
+          it "has 2 keys" do
+            expect(model).to receive(:filter_query).at_least(:once) { [{terms: {:hello => ['world']}}] }
+            expect(model.send(:build_facets)[:hd].keys).to eq([:terms, :facet_filter])
+          end
+
+          it "can bypass the facet_filter declaration" do
+            expect(model.send(:build_facets, false)).to eq(
+              {
+                :hd=>{
+                  :terms=>{
+                    :field=>"media_hd", :size=>70
+                  }
+                }
+              }
+            )
+          end
+        end
+        describe "without filters" do
+          before(:each) do
+            expect(model).to receive(:filter_query) { [] }
+          end
+          it "equals a specific format" do
+            expect(model.send(:build_facets)).to eq({
+              :hd=>{
+                :terms=>{:field=>"media_hd", :size=>70}
+              }
+            })
+          end
+        end
+      end
+
+      describe "#build_filters" do
+        it "is private" do
+          expect {
+            model.build_filters
+          }.to raise_error(NoMethodError)
+        end
+        describe "with #filter_XX? = true" do
+          before(:each) do
+            expect(model).to receive(:filter_hd?) { true }
+          end
+
+          it "returns filter hash for Elasticsearch" do
+            expect(model.send(:build_filters)).to eq([{:terms=>{"media_hd"=>[true]}}])
+          end
+        end
+
+        describe "with #filter_XX? = false" do
+          before(:each) do
+            expect(model).to receive(:filter_hd?) { false }
+          end
+
+          it "returns an empty array" do
+            expect(model.send(:build_filters)).to be_blank
+          end
+        end
+      end
+
+      describe "#values_for" do
+        it "is private" do
+          expect {
+            model.values_for(:hd)
+          }.to raise_error(NoMethodError)
+        end
+
+        it "always returns an array" do
+          expect(model).to receive(:temp_value) { 'hello' }
+          expect(model.send(:values_for, :temp)).to eq(['hello'])
+        end
+      end
+
+      describe "#execution_type" do
+        it "is private" do
+          expect {
+            model.execution_type('multivalue_or')
+          }.to raise_error(NoMethodError)
+        end
+        it "returns :or when 'multivalue_or'" do
+          expect(model.send(:execution_type, 'multivalue_or')).to eq(:or)
+        end
+
+        it "returns :and when 'multivalue_and'" do
+          expect(model.send(:execution_type, 'multivalue_and')).to eq(:and)
+        end
+
+        it "returns nil when 'exclusive_or'" do
+          expect(model.send(:execution_type, 'exclusive_or')).to be_nil
+        end
+      end
+    end
+  end
+end