stub_solr 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0dfd9c8199e4ab5c50789791f3149ed9e2c89aac
+  data.tar.gz: e9ac7ef59532089aabee78d66df601068287b42c
+SHA512:
+  metadata.gz: edcf6aaa16e0bbdca4f64e9ee76a3c1599d320461214d67c17063f682b9a392ee9df14dcd14709d3900294b023a8171e9515896fffeea9b515d298cf6c8d50dd
+  data.tar.gz: 13badb963b7b8303ea4476d99e379622e1b9b22c0be94ef345cfd0b011637eea64b09974702b67a23ff55d3a9600238d16f4fe5252dd62284aaea3b57bff9af0

data/.gitignore

@@ -0,0 +1,14 @@
+*.gem
+sunspot-solr.pid
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/*
+.DS_Store
+.byebug_history
+/gemfiles/*.lock

data/.rubocop.yml

@@ -0,0 +1,27 @@
+
+AllCops:
+  Exclude:
+    - bin/**/*
+    - dev_tasks/*
+    - gemfiels/*
+    - test/**/*
+    - tmp/**/*
+  TargetRubyVersion: 2.3
+
+Rails:
+  Enabled: true
+
+DotPosition:
+  EnforcedStyle: trailing
+
+Style/EmptyLinesAroundBlockBody:
+  Enabled: false
+
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Style/EmptyLinesAroundMethodBody:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,12 @@
+sudo: false
+language: ruby
+cache: bundler
+
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.12.5
+
+env:
+  - GEM=sunspot
+  - GEM=sunspot_rails RAILS=5.0.0.1
+  - GEM=sunspot_solr

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+platforms :ruby_19 do
+  gem 'mime-types', '~> 2.6'
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jaigouk Kim
+
+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,79 @@
+# StubSolr
+
+`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.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'stub_solr'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stub_solr
+
+## Usage
+
+`test_helper` file should have `require 'stub_solr'`. In your test file, add setup and teardown like this
+
+```ruby
+class ActivitiesControllerTest < ActionDispatch::IntegrationTest
+  def setup
+    Sunspot.session = Sunspot::Rails::StubSessionProxy.new(
+      Sunspot.session, Activity.all.to_a.concat(Excercise.all.to_a)
+    )
+    super
+  end
+
+  def teardown
+    Sunspot.session = ::Sunspot.session.original_session
+    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%")
+    res = ActiveSupport::JSON.decode(response.body)["activities"]
+    res.size.must_equal expected.size
+  end
+end
+```
+
+For searching, it finds all string / text fields for given classes and use them.
+
+For range search like `greater_than`, it uses array to check an attribute is for range search. by default, it's `%w[time month created_at start end]` but you can change that.
+
+```ruby
+  def setup
+    Sunspot.session = Sunspot::Rails::StubSessionProxy.new(
+      Sunspot.session, Activity.all.to_a.concat(Excercise.all.to_a)
+    )
+    Sunspot.session.set_range_fields(%w[time month created_at departure arrival])
+    super
+  end
+```
+    
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jaigouk/stub_solr.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/file_list'
+
+TO_CLEAN = Rake::FileList.new do |fl|
+  fl.include 'tmp/**/*'
+  fl.include '**/.bundle'
+  fl.exclude 'tmp/.gitkeep'
+end
+
+CLEAN.include TO_CLEAN
+
+task :environment do
+end
+
+FileList['dev_tasks/*.rake'].each { |file| load(file) }
+task :default => [:spec]
+
+desc 'Install bleeding edge gems locally'
+task :install do
+  system "rm *.gem"
+  system "gem build *.gemspec"
+  system "gem install *.gem"
+end
+
+desc 'Release to Rubygems.org'
+task :release do
+  require File.expand_path('../lib/stub_solr/version', __FILE__)
+
+  version_tag = "v#{StubSolr::VERSION}"
+  system "git tag -am 'Release version #{StubSolr::VERSION}' '#{version_tag}'"
+  system "git push origin #{version_tag}:#{version_tag}"
+
+  system "gem build stub_solr.gemspec"
+  system "gem push stub_solr-#{StubSolr::VERSION}.gem"
+  FileUtils.rm("stub_solr-#{StubSolr::VERSION}.gem")
+end

data/dev_tasks/release.rake

@@ -0,0 +1,4 @@
+namespace :release do
+  desc 'Release gem on GitHub'
+  task :all => [:release]
+end

data/dev_tasks/spec.rake

@@ -0,0 +1,107 @@
+require 'fileutils'
+require 'rake'
+
+desc 'Run spec suite in all Rails versions'
+task :spec do
+  puts "Running default task"
+  versions = if ENV['RAILS']
+               ENV['RAILS'].split(",")
+             else
+               rails_all_versions
+             end
+
+  versions.each do |version|
+    puts "Running specs against Rails #{version}..."
+
+    ENV['VERSION'] = version
+    reenable_spec_tasks
+    Rake::Task['spec:run_with_rails'].invoke
+  end
+end
+
+
+namespace :spec do
+  def rails_app_path(version)
+    File.join(File.dirname(__FILE__), "..", "tmp", "rails_#{version.gsub(".", "_")}_app")
+  end
+
+  def gemfile_path(version)
+    File.join(File.dirname(__FILE__), "..", "gemfiles", "rails-#{version}")
+  end
+
+  def vendor_path(version)
+    File.expand_path("vendor/bundle", rails_app_path(version))
+  end
+
+  def rails_template_path
+    File.join(File.dirname(__FILE__), "..", "test", "rails_template")
+  end
+
+  def version
+    ENV['VERSION']
+  end
+
+  task :run_with_rails => [:set_gemfile, :generate_rails_app, :initialize_database, :setup_rails_app, :run]
+
+  task :set_gemfile do
+    ENV['BUNDLE_PATH']    = vendor_path(version)
+    ENV['BUNDLE_GEMFILE'] = gemfile_path(version)
+    unless File.exist?(ENV['BUNDLE_PATH'])
+      puts "Installing gems for Rails #{version} (this will only be done once)..."
+      sh("bundle install #{ENV['BUNDLE_ARGS']}") || exit(1)
+    end
+  end
+
+  task :generate_rails_app do
+    app_path = rails_app_path(version)
+
+    unless File.exist?(File.expand_path("config/environment.rb", app_path))
+      puts "Generating Rails #{version} application..."
+      sh("bundle exec rails _#{version}_ new \"#{app_path}\" --force --skip-git --skip-javascript --skip-gemfile --skip-sprockets") || exit(1)
+    end
+  end
+
+  task :initialize_database do
+    if ENV['DB'] == 'postgres'
+      sh "bundle exec rake db:test:prepare"
+    end
+  end
+
+  task :setup_rails_app do
+    FileUtils.cp_r File.join(rails_template_path, "."), rails_app_path(version)
+  end
+
+  # task :load_fixtures do
+  #   puts "loading fixtures..."
+  #   sh "bundle exec rake db:fixtures:load RAILS_ENV=test FIXTURES_DIR='test/fixtures'"
+  # end
+
+  task :run do
+    ENV['BUNDLE_GEMFILE'] = gemfile_path(version)
+    ENV['RAILS_ROOT']     = rails_app_path(version)
+
+    sh "bundle exec ruby -I test #{ENV['SPEC'] || 'test/*_spec.rb'}"
+  end
+end
+
+
+def rails_all_versions
+  versions = []
+  puts "getting rails versions to test"
+  Dir.glob(File.join(File.dirname(__FILE__), "..", "gemfiles", "rails-*")).each do |gemfile|
+    if !gemfile.end_with?(".lock") && gemfile =~ /rails-([0-9.]+)/
+      versions << $1
+    end
+  end
+
+  puts versions.to_s
+  versions
+end
+
+def reenable_spec_tasks
+  Rake::Task.tasks.each do |task|
+    if task.name =~ /spec:/
+      task.reenable
+    end
+  end
+end

data/gemfiles/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_DISABLE_SHARED_GEMS: "true"

data/gemfiles/rails-5.0.0.1

@@ -0,0 +1,22 @@
+source 'https://rubygems.org'
+gem 'rails', '~> 5.0.0.1'
+gem 'sunspot', '2.2.6'
+gem 'sunspot_solr', '2.2.6'
+gem 'sunspot_rails', '2.2.6'
+gem 'kaminari'
+gem 'rake', '11.2.0'
+
+group :test do
+  gem 'minitest-rails'
+  gem 'minitest-reporters'
+  gem 'byebug'
+  gem 'stub_solr', :path => File.expand_path('../..', __FILE__)
+end
+
+group :postgres do
+  gem 'pg'
+end
+
+group :sqlite do
+  gem 'sqlite3'
+end

data/lib/stub_solr/sunspot_rails_stub_session_proxy.rb

@@ -0,0 +1,363 @@
+
+# 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

data/lib/stub_solr/version.rb

@@ -0,0 +1,3 @@
+module StubSolr
+  VERSION = "0.0.4"
+end

data/lib/stub_solr.rb

@@ -0,0 +1,9 @@
+require 'kaminari'
+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__))

data/stub_solr.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+require File.expand_path('../lib/stub_solr/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'stub_solr'
+  gem.version       = StubSolr::VERSION
+  gem.authors       = ['Jaigouk Kim']
+  gem.email         = ['ping@jaigouk.kim']
+
+  gem.summary       = %q{stub sunspot to test }
+  gem.description   = %q{overrided StubSessionProxy with AR queries to mimic sunspot }
+  gem.homepage      = 'https://github.com/jaigouk/stub_solr'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  gem.bindir        = 'bin'
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.require_paths = ['lib']
+  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 'rails', '>= 4'
+
+  # gem.add_development_dependency 'simplecov', '~> 0.12.0'
+  gem.add_development_dependency 'bundler', '~> 1.12'
+  gem.add_development_dependency 'minitest', '~> 5.0'
+  gem.add_development_dependency 'minitest-reporters', '~> 1.1.11'
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: stub_solr
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Jaigouk Kim
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.6
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.11
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.11
+description: 'overrided StubSessionProxy with AR queries to mimic sunspot '
+email:
+- ping@jaigouk.kim
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dev_tasks/release.rake
+- dev_tasks/spec.rake
+- 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/version.rb
+- stub_solr.gemspec
+homepage: https://github.com/jaigouk/stub_solr
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: stub sunspot to test
+test_files: []