stub_solr 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bfdc89260913319a1d4c3939ee3dfba95feae29d
-  data.tar.gz: 3ebd59479e416bb97557a990302b310eb3e6636a
+  metadata.gz: 3d7ccf1ca8364cbe78d549c7adee20fc57e6657b
+  data.tar.gz: e7373b1aad31088dd937d28cf6c7559acc1bc1fb
 SHA512:
-  metadata.gz: d763e18b42519ef78114699d73b4f95c537210db9e10934ef9253410f154fcb7c4ff2c0434a96fe478e0220af37ed4b56a4ad7647041330de3ce085991ccd2a6
-  data.tar.gz: f0d4c8fb320660ace148fb9b9b626d8c8adfb042df3f7f5b82f4b2c6d7274f0cae4be36424ce75e35d3469a6bdb8175da4792c2b36f9714a42f18cd0a49541f2
+  metadata.gz: c63a06b47829d41038bb6f581742ba546ea37aa3a0e12d5c9accadd8a371abae23b04c8c5daf860eb753ad30397b2c95d204404227d5c9e066bdeef5e60c6ab2
+  data.tar.gz: cd6bfc624908d13a46bdbc8d53c3f350f4823eed7c3a3e4ca5535e21a4d600a931fd66c30bf81fc189518e17612822fdaf79c239bf7e25493bf0ff87e9813536

data/.codeclimate.yml

@@ -0,0 +1,23 @@
+engines:
+  duplication:
+    enabled: true
+    config:
+      languages:
+      - ruby
+  fixme:
+    enabled: true
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+  - "**.js"
+  - "**.jsx"
+  - "**.module"
+  - "**.rb"
+exclude_paths:
+- test/
+- Rakefile
+- gemfiles/
+- dev_tasks/
+- bin/
+- tmp/

data/.rubocop.yml

@@ -6,6 +6,7 @@ AllCops:
     - gemfiels/*
     - test/**/*
     - tmp/**/*
+    - Rakefile
   TargetRubyVersion: 2.3
 
 Rails:
@@ -25,3 +26,6 @@ Style/EmptyLinesAroundClassBody:
 
 Style/EmptyLinesAroundMethodBody:
   Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/README.md

@@ -5,7 +5,7 @@
 
 `Sunspot.session = Sunspot::Rails::StubSessionProxy.new(Sunspot.session)` is enough for most of cases but if you want more than `allow_any_instance_of(Sunspot::Rails::StubSessionProxy::Search).to receive(:results).and_return(myExpectedResults)` this gem can be helpful. `kaminari` for pagination and plain AR to mimic resutls. 
 
-this gem depends on `2.2.6` version of sunspot, sunspot_rails.
+this gem depends on `2.2.x` version of sunspot, sunspot_rails.
 
 ## Installation
 
@@ -15,17 +15,49 @@ Add this line to your application's Gemfile:
 gem 'stub_solr'
 ```
 
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
+## Usage
 
-    $ gem install stub_solr
+`test_helper` file should have `require 'stub_solr'`. Given a sunspot search block as following codes,
 
-## Usage
+```ruby
+class ActivitiesController < ApplicationController
+  def search
+    ...
+    search = Sunspot.search Excercise, Activity do
+      any_of do
+        with :blocked, false
+        without :exhausted, true
+      end
+
+      if min && max
+        any_of do
+          all_of do
+            with :start_limit_number, nil
+            with(:end_limit_number).less_than_or_equal_to max
+          end
+          all_of do
+            with :end_limit_number, nil
+            with(:start_limit_number).greater_than_or_equal_to min
+          end
+          all_of do
+            without(:start_limit_number, nil)
+            without(:end_limit_number, nil)
+            with(:start_limit_number).greater_than_or_equal_to min
+            with(:end_limit_number).less_than_or_equal_to max
+          end
+        end
+      end
+      ## search by text
+      fulltext params[:search] if params[:search].present?
+      order_by :created_at, :asc
+      paginate page: page, per_page: per_page
+    end
+    ...
+  end
+end
+```
 
-`test_helper` file should have `require 'stub_solr'`. In your test file, add setup and teardown like this
+You can write expected results like this. use `concat` for `any_of` block and  `array_1 & array_2` for `all_of` block.
 
 ```ruby
 class ActivitiesControllerTest < ActionDispatch::IntegrationTest
@@ -41,9 +73,15 @@ class ActivitiesControllerTest < ActionDispatch::IntegrationTest
     super
   end
   
-  test 'search with filter' do
-    get search_activities_url(params: { visible: true, search: 'beer' })
-    expected = Activity.where(visible: true).where("title LIKE ?", "%beer%")
+  test 'filter with number range' do
+    pool_1 = Activity.where(blocked: false).to_a.concat(Activity.where(exhausted: false).to_a).uniq
+    target_1 = Activity.where("end_limit_number <= ? AND start_limit_number = ?", 18, nil).to_a
+    target_2 = Activity.where("start_limit_number >= ? AND end_limit_number = ?", 3, nil).to_a
+    target_3 = Activity.where("start_limit_number >= ?", 3).where("end_limit_number <= ?", 18).to_a
+    pool_2 = target_1.concat(target_2).concat(target_3)
+    expected = pool_1 & pool_2
+
+    get search_activities_url(params: { limits: [3, 18] })
     res = ActiveSupport::JSON.decode(response.body)["activities"]
     res.size.must_equal expected.size
   end

data/lib/stub_solr/extra_dsl.rb

@@ -0,0 +1,144 @@
+class Sunspot::Rails::StubSessionProxy
+  # with and fulltext can be called multiple times
+  # based on the block. that's why i am mutating @results
+  #
+  # for all and any block, we need to consult
+  # sunspot/lib/sunspot/dsl/standard_query.rb
+  #
+  class Search
+    def hits
+      self
+    end
+
+    # Added to pass .group_by
+    # Idea is save grouped hash result seperately and then
+    # access it with [] method.
+    #
+    # initial_grouped_hits = initial.hits.group_by(&:class_name)
+    # initial_grouped_hits["Activity"]
+    def [](key)
+      return if @grouped_results.empty? || @grouped_results[key].nil?
+      @group_key = key
+      self
+    end
+
+    # possible situation
+    #
+    # initial_grouped_hits = initial.hits.group_by(&:class_name)
+    # initial_grouped_hits["Activity"].map(&:primary_key)
+    def map(&_pr)
+      return unless @grouped_results[@group_key]
+      @grouped_results[@group_key].map(&:id)
+    end
+
+    # possible situation
+    #
+    # initial_grouped_hits = initial.hits.group_by(&:class_name)
+    def group_by(_ = nil)
+      return self if final_results.empty?
+      @types.each do |type|
+        @grouped_results[type.name] = sorted_temp_result.group_by do |i|
+          i.class.name == type.name
+        end[true]
+      end
+      self
+    end
+
+    def phrase_fields(arg)
+      @operation_context.first[:textsearch_priorities] = arg
+      return self if @operation_context.first[:search_term].empty?
+      fulltext(@operation_context.first[:search_term])
+    end
+
+    def query_phrase_slop(_)
+      fulltext(@operation_context.first[:search_term])
+    end
+
+    # with default `StubSessionProxy`, the results is blank whatever
+    # argument or options you put in the search block
+    def fulltext(term, _opt = {}, &bl)
+      matches = []
+      @operation_context.first[:search_term] = term
+      Sunspot::Util::ContextBoundDelegate
+        .instance_eval_with_context(self, &bl) unless bl.nil?
+      # if there is phrase_fields option then we only search for the field
+      # to mimic the priority search. #string_text_fields
+      @types.each do |type|
+        string_text_fields(type).each do |field|
+          if type.has_attribute?(field.to_sym)
+            matches << type.where(type.arel_table[field.to_sym].
+              matches("%#{term}%")).to_a
+          end
+        end
+      end
+      calculated = (result_for_current_context & matches.flatten.uniq)
+      operation_context_result(calculated)
+      self
+    end
+
+    def order_by(attribute, direction)
+      @operation_context.first[:order_key] = attribute
+      @operation_context.first[:order_direction] = direction
+      self
+    end
+
+    def in_radius(*args)
+      calculated = result_for_current_context.select do |r|
+        distance = r&.location&.distance_from([args[0], args[1]])
+        distance && distance < args[2].to_i
+      end
+      operation_context_result(calculated)
+      self
+    end
+
+    def greater_than(time)
+      calculated = filter(result_for_current_context) do |x|
+        x.read_attribute(@range_search_field) > time
+      end
+      operation_context_result(calculated)
+      self
+    end
+
+    def greater_than_or_equal_to(time)
+      calculated = filter(result_for_current_context) do |x|
+        x.read_attribute(@range_search_field) >= time
+      end
+      operation_context_result(calculated)
+      self
+    end
+
+    def less_than(time)
+      calculated = filter(result_for_current_context) do |x|
+        x.read_attribute(@range_search_field) < time
+      end
+      operation_context_result(calculated)
+      self
+    end
+
+    def less_than_or_equal_to(time)
+      calculated = filter(result_for_current_context) do |x|
+        x.read_attribute(@range_search_field) <= time
+      end
+      operation_context_result(calculated)
+      self
+    end
+
+    def paginate(args = {})
+      @operation_context.first[:page] = args[:page]
+      @operation_context.first[:per_page] = args[:page]
+      self
+    end
+
+    def total
+      @operation_context.last[:result].size
+    end
+
+    def filter(array)
+      array.select do |i|
+        i.read_attribute(@range_search_field) &&
+          !i.read_attribute(@range_search_field).nil? &&
+            yield(i)
+      end.uniq
+    end
+  end
+end

data/lib/stub_solr/search.rb

@@ -0,0 +1,107 @@
+require File.expand_path('search_helper', File.dirname(__FILE__))
+require File.expand_path('extra_dsl', File.dirname(__FILE__))
+class Sunspot::Rails::StubSessionProxy
+  # with and fulltext can be called multiple times
+  # based on the block. that's why i am mutating @results
+  #
+  # for all and any block, we need to consult
+  # sunspot/lib/sunspot/dsl/standard_query.rb
+  #
+  class Search
+    attr_reader :block, :types, :page, :per_page, :grouped_results
+
+    def initialize(results = [], types = [], &block)
+      @types = types
+      @grouped_results= {}
+      @group_key = ''
+      @range_search_field = nil
+      @operation_context = [{
+        operation: 'all', result: results, order_key: nil, order_direction: nil,
+        page: 1, per_page: 30, search_term: '', textsearch_priorities: {}
+      }]
+      @current_index = 0
+      run_proc_block(&block)
+    end
+
+    def final_results
+      @operation_context.last[:result]
+    end
+
+    def results
+      return PaginatedCollection.new if sorted_temp_result.empty?
+      if final_results.is_a? Kaminari::PaginatableArray
+        return sorted_temp_result
+      end
+      Kaminari.paginate_array(sorted_temp_result).
+              page(@operation_context.first[:page]).
+              per(@operation_context.first[:per_page])
+    end
+
+    def any_of(&bl)
+      previous_result = result_for_current_context
+      push(previous_result, :any)
+      Sunspot::Util::ContextBoundDelegate.instance_eval_with_context(self, &bl)
+      after_results = temp_result_for_current_context
+      pop unless @current_index == 0
+      # parent is now current context
+      if parent_temp_result
+        @operation_context[@current_index][:temp_result] =
+          parent_temp_result.concat(after_results)
+      else
+        @operation_context[@current_index][:result] =
+          after_results
+      end
+      self
+    end
+
+    def all_of(&bl)
+      previous_result = result_for_current_context
+      push(previous_result, :all)
+      Sunspot::Util::ContextBoundDelegate.instance_eval_with_context(self, &bl)
+      after_results = result_for_current_context
+      parent_temp_result =
+        @operation_context[@current_index - 1][:temp_result]
+      pop unless @current_index == 0
+      # parent is now current context
+      if parent_temp_result
+        @operation_context[@current_index][:temp_result] =
+          parent_temp_result.concat(after_results)
+      else
+        @operation_context[@current_index][:result] =
+          (previous_result & after_results).uniq
+      end
+      self
+    end
+
+    def with(att, val = 'no_value')
+      # return_early_for_with_blocks(att, val, :with)
+      return self if range_no_value?(att, val) && skip_it(att, val)
+      return self if range_value_nil?(val, att) && deal_with_nil(att, :with)
+      return self if val == 'no_value' || att == :location
+      return self if (att == :search_class) && filter_class
+      matches = if val.class.name == 'Array'
+                  select_result_for_array_val(att)
+                elsif @types.map{ |x| x.has_attribute?(att)}.include?(true)
+                  select_result_attr_is_val(att, val)
+                else
+                  result_for_current_context.select { |x| x.send(att) == val }
+                end
+      operation_context_result(matches)
+      self
+    end
+
+    def without(att, val = 'no_value')
+      # return_early_for_with_blocks(att, val, :without)
+      return self if range_no_value?(att, val) && skip_it(att, val)
+      return self if range_value_nil?(val, att) && deal_with_nil(att, :without)
+      return self if val == 'no_value' || att == :location
+      matches = if val.class.name == 'Array'
+                  select_result_attr_cant_send_val(att, val)
+                else
+                  select_result_attr_is_not_value(att, val)
+                end
+      operation_context_result(matches)
+      self
+    end
+  end
+end

data/lib/stub_solr/search_helper.rb

@@ -0,0 +1,168 @@
+# serach helper
+
+class Sunspot::Rails::StubSessionProxy
+  # with and fulltext can be called multiple times
+  # based on the block. that's why i am mutating @results
+  #
+  # for all and any block, we need to consult
+  # sunspot/lib/sunspot/dsl/standard_query.rb
+  #
+  class Search
+
+    private
+
+    def instance_eval_with_context(&block)
+      Sunspot::Util::ContextBoundDelegate.
+      instance_eval_with_context(self, &block)
+    end
+
+    # iterate the given block and change @operation_context
+    # block may cotain with, without, fulltext, paginate, in_raius, order_by
+    def run_proc_block(&block)
+      result = @operation_context.last[:result]
+      return PaginatedCollection.new if result.empty?
+      instance_eval_with_context(&block)
+      self
+    end
+
+    def current_operation
+      @operation_context[@current_index][:operation]
+    end
+
+    def result_for_current_context
+      @operation_context[@current_index][:result]
+    end
+
+    def temp_result_for_current_context
+      @operation_context[@current_index][:temp_result]
+    end
+
+    def parent_temp_result
+      @operation_context[@current_index - 1][:temp_result]
+    end
+
+    def operation_context_result(after_results)
+      previous_result = result_for_current_context
+      unless current_operation == 'any'
+        return @operation_context[@current_index][:result] =
+          (previous_result & after_results).uniq
+      end
+      @operation_context[@current_index][:result] =
+        previous_result.concat(after_results).uniq
+      if temp_result_for_current_context
+        @operation_context[@current_index][:temp_result] =
+          temp_result_for_current_context.concat(after_results)
+      end
+    end
+
+    def pop
+      @current_index -= 1
+      @operation_context.pop
+    end
+
+    def push(data, type)
+      if type == :any
+        @operation_context.push(operation: 'any', result: data, temp_result: [])
+      else
+        @operation_context.push(operation: 'all', result: data)
+      end
+      @current_index += 1
+    end
+
+    def filter_class
+      matches = result_for_current_context.select { |x| x.class.name == value }
+      operation_context_result(matches)
+    end
+
+    def range_value_nil?(value, attribute)
+      value.nil? && attribute_is_about_range?(attribute)
+    end
+
+    def range_no_value?(attribute, value)
+      (value == 'no_value') && attribute_is_about_range?(attribute)
+    end
+
+    def skip_it(attribute, value)
+      matches = result_for_current_context.select do |x|
+        x.has_attribute?(attribute)
+      end
+      operation_context_result(matches)
+    end
+
+    def deal_with_nil(attribute, operation)
+      matches = if operation == :with
+                  selelct_result_for_nil(attribute)
+                else
+                  select_result_for_not_nil(attribute)
+                end
+      operation_context_result(matches)
+    end
+
+    def string_text_fields(type)
+      pr = @operation_context.first[:textsearch_priorities]
+      return pr.keys unless pr.keys.empty?
+      type.columns_hash.select { |k,v| [:string, :text].include? v.type }.keys
+    end
+
+    def attribute_is_about_range?(attribute)
+      matched = nil
+      Sunspot.session.range_fields.each do |x|
+        if attribute.to_s.include? x
+          matched = true
+          @range_search_field = attribute
+          next
+        end
+      end
+      matched
+    end
+
+    def sorted_temp_result
+      key = @operation_context.first[:order_key]
+      direction = @operation_context.first[:order_direction]
+      return final_results unless direction
+      asc = final_results.sort_by { |x| x[key] }
+      return asc if direction.to_s.downcase.include?('asc')
+      asc.reverse
+    end
+
+    def selelct_result_for_nil(attribute)
+      result_for_current_context.select do |x|
+        x.has_attribute?(attribute) &&
+          x.read_attribute(attribute).nil?
+      end
+    end
+
+    def select_result_for_not_nil(attribute)
+      result_for_current_context.select do |x|
+        x.has_attribute?(attribute) &&
+          !x.read_attribute(attribute).nil?
+      end
+    end
+
+    def select_result_for_array_val(attribute)
+      result_for_current_context.select do |x|
+        value.include?(x.send(attribute))
+      end
+    end
+
+    def select_result_attr_is_val(attribute, value)
+      result_for_current_context.select do |x|
+        x.read_attribute(attribute) == value
+      end
+    end
+
+    def select_result_attr_cant_send_val(attribute, value)
+      result_for_current_context.select do |x|
+        x.has_attribute?(attribute) && !value.include?(x.send(attribute))
+      end
+    end
+
+    def select_result_attr_is_not_value(attribute, value)
+      result_for_current_context.select do |x|
+        x.has_attribute?(attribute) &&
+          !x.read_attribute(attribute).nil? &&
+          (x.read_attribute(attribute) != value)
+      end
+    end
+  end
+end

data/lib/stub_solr/stub_session_proxy.rb

@@ -0,0 +1,27 @@
+require File.expand_path('search', File.dirname(__FILE__))
+# stub solr with "dara" array for testing.
+# if there is no data then it will behave like default blank search
+# this stub uses Kaminari for pagination
+# once the data is given, solr search block will call search
+# and that will create a new Search with arguments.
+# With the search, it passes the given data as @operation_context.
+# And "run_proc_block" method will go through each search conditions
+# in the block. while going through the block, it will change @operation_context
+#
+class Sunspot::Rails::StubSessionProxy
+  attr_reader :block, :data, :range_fields
+
+  def initialize(original_session, data = [])
+    @original_session = original_session
+    @data = data
+    @range_fields = %w[time month created_at start end]
+  end
+
+  def set_range_fields(arr)
+    @range_fields = arr
+  end
+
+  def search(*types, &block)
+    Search.new(@data, types, &block)
+  end
+end

data/lib/stub_solr/version.rb

@@ -1,3 +1,3 @@
 module StubSolr
-  VERSION = "0.0.5"
+  VERSION = '0.0.6'
 end

data/lib/stub_solr.rb

@@ -1,9 +1,14 @@
+## requires all necessary fiels
 require 'kaminari'
+##
+# previous_page method doesn't exist in Kaminari
+# but we use it for pagination
 module Kaminari::PageScopeMethods
   alias_method :previous_page, :prev_page
 end
 require 'sunspot'
 require 'sunspot_rails'
 require 'rails'
-require "stub_solr/version"
-require File.expand_path('stub_solr/sunspot_rails_stub_session_proxy', File.dirname(__FILE__))
+require 'stub_solr/version'
+require File.expand_path('stub_solr/stub_session_proxy',
+  File.dirname(__FILE__))

data/stub_solr.gemspec

@@ -20,9 +20,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
 
   gem.add_dependency 'kaminari', '~> 0.17.0'
-  gem.add_dependency 'sunspot', '~> 2.2.6'
-  gem.add_dependency 'sunspot_solr', '~> 2.2.6'
-  gem.add_dependency 'sunspot_rails', '~> 2.2.6'
+  gem.add_dependency 'sunspot_rails', '~> 2.2.5'
   gem.add_dependency 'rails', '>= 4'
 
   # gem.add_development_dependency 'simplecov', '~> 0.12.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stub_solr
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Jaigouk Kim
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-13 00:00:00.000000000 Z
+date: 2016-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kaminari
@@ -24,48 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.17.0
-- !ruby/object:Gem::Dependency
-  name: sunspot
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.2.6
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.2.6
-- !ruby/object:Gem::Dependency
-  name: sunspot_solr
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.2.6
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.2.6
 - !ruby/object:Gem::Dependency
   name: sunspot_rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.6
+        version: 2.2.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.2.6
+        version: 2.2.5
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -129,6 +101,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rubocop.yml"
 - Gemfile
@@ -141,7 +114,10 @@ files:
 - gemfiles/.bundle/config
 - gemfiles/rails-5.0.0.1
 - lib/stub_solr.rb
-- lib/stub_solr/sunspot_rails_stub_session_proxy.rb
+- lib/stub_solr/extra_dsl.rb
+- lib/stub_solr/search.rb
+- lib/stub_solr/search_helper.rb
+- lib/stub_solr/stub_session_proxy.rb
 - lib/stub_solr/version.rb
 - stub_solr.gemspec
 homepage: https://github.com/jaigouk/stub_solr

data/lib/stub_solr/sunspot_rails_stub_session_proxy.rb

@@ -1,363 +0,0 @@
-
-# stub solr with "dara" array for testing.
-# if there is no data then it will behave like default blank search
-# this stub uses Kaminari for pagination
-# once the data is given, solr search block will call search
-# and that will create a new Search with arguments.
-# With the search, it passes the given data as @operation_context.
-# And "run_proc_block" method will go through each search conditions
-# in the block. while going through the block, it will change @operation_context
-#
-class Sunspot::Rails::StubSessionProxy
-  attr_reader :block, :data, :range_fields
-
-  def initialize(original_session, data = [])
-    @original_session = original_session
-    @data = data
-    @range_fields = %w[time month created_at start end]
-  end
-
-  def set_range_fields(arr)
-    @range_fields = arr
-  end
-
-  def search(*types, &block)
-    Search.new(@data, types, &block)
-  end
-
-  # with and fulltext can be called multiple times
-  # based on the block. that's why i am mutating @results
-  #
-  # for all and any block, we need to consult sunspot/lib/sunspot/dsl/standard_query.rb
-  #
-  class Search
-    attr_reader :block, :types, :page, :per_page, :grouped_results
-    def initialize(results = [], types = [], &block)
-      @facets = {}
-      @search_data = results
-      @block = block
-      @types = types
-      @page = 1
-      @per_page = 30
-      @grouped_results = {}
-      @group_key = ""
-      @range_search_field = nil
-      @operation_context = [{operation: "all", result: @search_data}]
-      @current_context_index = 0
-      @order_key = nil
-      @order_direction = nil
-      @textsearch_priorities = {}
-      @search_term = ""
-      run_proc_block
-    end
-
-    def final_results
-      @operation_context.last[:result]
-    end
-
-    def results
-      return PaginatedCollection.new if sorted_temp_result.empty?
-      return sorted_temp_result if final_results.is_a? Kaminari::PaginatableArray
-      Kaminari.paginate_array(sorted_temp_result).page(@page).per(@per_page)
-    end
-
-    def any_of(&bl)
-      previous_result = result_for_current_context
-      @operation_context.push({operation: "any", result: previous_result, temp_result: []})
-      @current_context_index += 1
-
-      Sunspot::Util::ContextBoundDelegate.instance_eval_with_context(self, &bl)
-      after_results = @operation_context[@current_context_index][:temp_result]
-
-      parent_temp_result = @operation_context[@current_context_index - 1][:temp_result]
-
-
-      unless @current_context_index == 0
-        @current_context_index -= 1
-        @operation_context.pop
-      end
-      # parent is now current context
-      if parent_temp_result
-         @operation_context[@current_context_index][:temp_result] = parent_temp_result.concat(after_results)
-      else
-        @operation_context[@current_context_index][:result] = after_results
-      end
-      self
-    end
-
-    def all_of(&bl)
-      previous_result = result_for_current_context
-      @operation_context.push({operation: "all", result: previous_result})
-      @current_context_index += 1
-
-      Sunspot::Util::ContextBoundDelegate.instance_eval_with_context(self, &bl)
-      after_results = result_for_current_context
-      parent_temp_result = @operation_context[@current_context_index - 1][:temp_result]
-
-      unless @current_context_index == 0
-        @current_context_index -= 1
-        @operation_context.pop
-      end
-
-      # parent is now current context
-      if parent_temp_result
-        @operation_context[@current_context_index][:temp_result] = parent_temp_result.concat(after_results)
-      else
-        @operation_context[@current_context_index][:result] = (previous_result & after_results).uniq
-      end
-
-      self
-    end
-
-    def with(attribute, value = "no_value")
-      skip_no_value(attribute, value)
-
-      if attribute == :search_class
-        matches = result_for_current_context.select {|x| x.class.name == value }
-        operation_context_result(matches)
-        return self
-      end
-
-      if value == nil && attribute_is_about_range?(attribute)
-        matches = result_for_current_context.select {|x| x.has_attribute?(attribute) && (x.read_attribute(attribute) == value)}
-        operation_context_result(matches)
-        return self
-      end
-
-      return self if value == "no_value" || attribute == :location
-
-      matches = if value.class.name == "Array"
-          result_for_current_context.select {|x| value.include?(x.send(attribute)) }
-        elsif @types.map{|x| x.has_attribute?(attribute)}.include?(true)
-          result_for_current_context.select {|x| x.read_attribute(attribute) == value }
-        else
-          result_for_current_context.select {|x| x.send(attribute) == value  }
-        end
-      operation_context_result(matches)
-      self
-    end
-
-    def without(attribute, value = "no_value")
-      skip_no_value(attribute, value)
-      if value == nil && attribute_is_about_range?(attribute)
-        matches = result_for_current_context.select {|x| x.has_attribute?(attribute) && !(x.read_attribute(attribute) == value)}
-        operation_context_result(matches)
-        return self
-      end
-
-      return self if value == "no_value" || attribute == :location
-      matches = if value.class.name == "Array"
-          result_for_current_context.select {|x| x.has_attribute?(attribute) && !value.include?(x.send(attribute)) }
-        else
-          result_for_current_context.select {|x| x.has_attribute?(attribute) && !x.read_attribute(attribute).nil? && (x.read_attribute(attribute) != value) }
-        end
-      operation_context_result(matches)
-      self
-    end
-
-    def hits
-      self
-    end
-
-    # Added to pass .group_by
-    # Idea is save grouped hash result seperately and then
-    # access it with [] method.
-    #
-    # initial_grouped_hits = initial.hits.group_by(&:class_name)
-    # initial_grouped_hits["Activity"]
-    def [](key)
-      return if @grouped_results.empty? || @grouped_results[key].nil?
-      @group_key = key
-      self
-    end
-
-    # possible situation
-    #
-    # initial_grouped_hits = initial.hits.group_by(&:class_name)
-    # initial_grouped_hits["Activity"].map(&:primary_key)
-    def map(&pr)
-      return unless @grouped_results[@group_key]
-      @grouped_results[@group_key].map{|x| x.id}
-    end
-
-    # possible situation
-    #
-    # initial_grouped_hits = initial.hits.group_by(&:class_name)
-    def group_by(class_name = nil)
-      return self if final_results.empty?
-      @types.each do |type|
-        @grouped_results[type.name] = sorted_temp_result.group_by{|i| i.class.name == type.name }[true]
-      end
-      self
-    end
-
-    def phrase_fields(arg)
-      @textsearch_priorities = arg
-      return self if @search_term.empty?
-      fulltext(@search_term)
-    end
-
-    def query_phrase_slop(*args)
-      fulltext(@search_term)
-    end
-
-    # with default `StubSessionProxy`, the results is blank whatever
-    # argument or options you put in the search block
-    def fulltext(term, opt={}, &bl)
-      matches = []
-      @search_term = term
-      Sunspot::Util::ContextBoundDelegate.instance_eval_with_context(self, &bl) if !bl.nil?
-      # if there is phrase_fields option then we only search for the field
-      # to mimic the priority search. #string_text_fields
-      @types.each do |type|
-        string_text_fields(type).each do |field|
-          if type.has_attribute?(field.to_sym)
-            matches << type.where(type.arel_table[field.to_sym].matches("%#{term}%")).to_a
-          end
-        end
-      end
-      calculated = (result_for_current_context & matches.flatten.uniq)
-      operation_context_result(calculated)
-      self
-    end
-
-    def order_by(attribute, direction)
-      @order_key = attribute
-      @order_direction = direction
-      self
-    end
-
-    def in_radius(*args)
-      calculated = result_for_current_context.select do |r|
-        distance = r&.location&.distance_from([args[0], args[1]])
-        distance && distance < args[2].to_i
-      end
-      operation_context_result(calculated)
-      self
-    end
-
-    def greater_than(time)
-      calculated = result_for_current_context.select do |x|
-        has_attribute_and_not_nil(x) &&
-        x.read_attribute(@range_search_field) > time
-      end.uniq
-      operation_context_result(calculated)
-      self
-    end
-
-    def greater_than_or_equal_to(time)
-      calculated = result_for_current_context.select do |x|
-       has_attribute_and_not_nil(x) &&
-       x.read_attribute(@range_search_field) >= time
-      end.uniq
-      operation_context_result(calculated)
-      self
-    end
-
-    def less_than(time)
-      calculated = result_for_current_context.select do |x|
-        has_attribute_and_not_nil(x) &&
-        x.read_attribute(@range_search_field) < time
-      end.uniq
-      operation_context_result(calculated)
-      self
-    end
-
-    def less_than_or_equal_to(time)
-      calculated = result_for_current_context.select do |x|
-       has_attribute_and_not_nil(x) &&
-       x.read_attribute(@range_search_field) <= time
-      end.uniq
-      operation_context_result(calculated)
-      self
-    end
-
-    def paginate(args={})
-      @page = args[:page]
-      @per_page = args[:per_page]
-      self
-    end
-
-    def total
-      @operation_context.last[:result].size
-    end
-
-    private
-
-    # iterate the given block and change @operation_context
-    # block may cotain with, without, fulltext, paginate, in_raius, order_by
-    def run_proc_block
-      result = @operation_context.last[:result]
-      return PaginatedCollection.new if result.empty?
-
-      Sunspot::Util::ContextBoundDelegate.instance_eval_with_context(self, &@block)
-      # @operation_context.last[:result] = @operation_context.last[:result].uniq
-      self
-    end
-
-    def current_operation
-      @operation_context[@current_context_index][:operation]
-    end
-
-    def result_for_current_context
-      @operation_context[@current_context_index][:result]
-    end
-
-    def temp_result_for_current_context
-      @operation_context[@current_context_index][:temp_result]
-    end
-
-    def operation_context_result(after_results)
-      previous_result = result_for_current_context
-      # parent_result = @operation_context[@current_context_index -1][:result]
-      temp_result = @operation_context[@current_context_index][:temp_result]
-      if current_operation == "any"
-        @operation_context[@current_context_index][:result] = previous_result.concat(after_results).uniq
-        if temp_result
-          @operation_context[@current_context_index][:temp_result] = temp_result.concat(after_results)
-        end
-      else
-        @operation_context[@current_context_index][:result] = (previous_result & after_results).uniq
-      end
-    end
-
-    def skip_no_value(attribute, value)
-      if value == "no_value" && attribute_is_about_range?(attribute)
-        matches = result_for_current_context.select {|x| x.has_attribute?(attribute)}
-        operation_context_result(matches)
-        return self
-      end
-    end
-
-    def has_attribute_and_not_nil(x)
-      x.read_attribute(@range_search_field) &&
-      !x.read_attribute(@range_search_field).nil?
-    end
-
-    def string_text_fields(type)
-      return @textsearch_priorities.keys unless @textsearch_priorities.keys.empty?
-      type.columns.collect { |c| {"#{c.type}":"#{c.name}"} }
-        .map{|hash| hash.select{|k,v| [:string, :text].include? k} }.uniq
-        .map{|x| x.values}.flatten
-    end
-
-    def attribute_is_about_range?(attribute)
-      matched = nil
-      Sunspot.session.range_fields.each do |x|
-        if attribute.to_s.include? x
-          matched = true
-          @range_search_field = attribute
-          break
-        end
-      end
-      matched
-    end
-
-    def sorted_temp_result
-      return final_results unless @order_direction
-      asc = final_results.sort_by{|x| x[@order_key]}
-      return  asc if @order_direction.to_s.downcase.include?("asc")
-      asc.reverse
-    end
-  end
-end