chewy_resque 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2561d103b0c172673e93d9e6e3e5d94bc96a1a56
+  data.tar.gz: 270b2ce4fec791cb27a6fbbf664e308c807dc94d
+SHA512:
+  metadata.gz: 5296adaa7587deabc268e6141a8c940bcb0864f34ed1c758d91cee0901e76bf4bc351938ef23ba105deda1f03e0df1313e127463604be946a49ac5142b56cf1d
+  data.tar.gz: 479a7a117c8e05b837ab46d677b3891590018f296aff90ff445e6068f29982fcc32dc3fab1f10bb1f4d33b775bcb9c4adb349888df519c81d5c4ed9b93287c8c

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+services:
+  - redis
+rvm:
+  - 2.0.0
+  - 2.1.2

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in chewy_kiqqer.gemspec
+gem 'chewy', github: 'toptal/chewy', branch: 'master'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Daniel Hahn
+
+MIT License
+
+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,71 @@
+# ChewyResque
+
+[![Build Status](https://travis-ci.org/razum2um/chewy_resque.svg?branch=master)](https://travis-ci.org/razum2um/chewy_kiqqer)
+[![Code Climate](https://codeclimate.com/github/razum2um/chewy_resque.png)](https://codeclimate.com/github/razum2um/chewy_kiqqer)
+[![Test Coverage](https://codeclimate.com/github/razum2um/chewy_resque/coverage.png)](https://codeclimate.com/github/razum2um/chewy_kiqqer)
+
+This is an alternative udpate/callback mechanism for [Chewy](https://github.com/toptal/chewy). It queues the updates as [Resque](https://github.com/resque/resque) jobs.
+
+You can pass backrefs like with the standard chewy mechanism, but the job itself will always receive an array of ids.
+
+It is possible to install more multiple update hooks.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'chewy_resque'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install chewy_resque
+
+## Usage
+
+Just add the module and set it up:
+
+    class User < ActiveRecord::Base
+      include ChewyResque::Mixin
+
+      async_update_index index: 'users#user', backref: :something
+    end
+
+Giving a backref is also optional (also check the chewy docs for the concept). The backref is the element
+which will be indexed. The default is to use the current record.
+
+    # use the current record for the backref
+    ... backref: :self
+    # call a method on the current record to get the backref
+    ... backref: :some_method
+    # Pass a proc. It will be called with the current record to get the backref
+    ... backref: -> (rec) { |rec| rec.do_something }
+
+## Update handling
+
+The resque does *not* use Chewy's `atomic` update, since that functionality is deeply linked with Chewy's syncronous update mechanism.
+
+
+However, if you have multiple database transactions, the resque will still queue multiple jobs. The same is true when you enqueue jobs manually.
+
+ChewyResque uses locking via redis to ensure that all updates for one database record are run sequentially. This prevents race conditions which could lead to outdated data being written to the index otherwise.
+
+## Logging
+
+Logging is disabled by default, but you can set `ChewyResque.logger` if you need log output (e.g. `ChewyResque.logger = Rails.logger`). ChewyResque uses ActiveSupport notifications, which you can also subscribe to.
+See `log_subscriber.rb` for more info.
+
+## Acknoledgements
+
+This gem is heavily borrowed from [chewy_kiqqer](https://github.com/averell23/chewy_kiqqer).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+task default: :spec
+
+RSpec::Core::RakeTask.new(:spec)
+
+Bundler.require
+
+task :default => :spec

data/chewy_resque.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chewy_resque/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "chewy_resque"
+  spec.version       = ChewyResque::VERSION
+  spec.authors       = ["Vlad Bokov"]
+  spec.email         = ["bokov.vlad@gmail.com"]
+  spec.description   = %q{Resque integration for chewy and resque}
+  spec.summary       = %q{Small helper gem that allows you to automatically run all chewy index updates in resque}
+  spec.homepage      = ""
+  spec.license       = "Apache V2"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'resque', '~> 1.24'
+  spec.add_dependency 'chewy'
+  spec.add_dependency 'mlanett-redis-lock'
+  spec.add_dependency 'activesupport', '>= 3.2.0'
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "kaminari"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "codeclimate-test-reporter"
+end

data/lib/chewy_resque.rb

@@ -0,0 +1,13 @@
+require 'active_support/notifications'
+require 'active_support/log_subscriber'
+
+require "chewy_resque/version"
+require "chewy_resque/mixin"
+require "chewy_resque/worker"
+require "chewy_resque/index"
+require "chewy_resque/config"
+require "chewy_resque/log_subscriber"
+
+require "chewy_resque/railtie" if defined?(::Rails)
+
+ChewyResque::LogSubscriber.attach_to 'chewy_resque'

data/lib/chewy_resque/config.rb

@@ -0,0 +1,23 @@
+require 'logger'
+
+module ChewyResque
+
+  def self.logger
+    @logger || Logger.new(STDOUT)
+  end
+
+  def self.logger=(value)
+    @logger = value
+  end
+
+  # Locking scope for redis locks. Only necessary if
+  # one redis instances locks more than one application
+  def self.locking_scope=(value)
+    @locking_scope = value
+  end
+
+  def self.locking_scope
+    @locking_scope || 'chewy'
+  end
+
+end

data/lib/chewy_resque/index.rb

@@ -0,0 +1,36 @@
+require 'active_support/core_ext/object/blank'
+require 'resque'
+
+module ChewyResque
+  class Index
+
+    attr_reader :index_name
+
+    def initialize(backref: :self, index: nil, queue: nil, only_if: nil)
+      @only_if = only_if
+      @index_name = index
+      @backref_method = backref
+      @queue = queue
+    end
+
+    def enqueue(object)
+      return if @only_if.respond_to?(:call) && @only_if.call(object)
+      if (ids = backref_ids(object).compact).present?
+        Resque.enqueue_to(@queue || Resque.queue_from_class(ChewyResque::Worker),
+                          ChewyResque::Worker,
+                          @index_name,
+                          ids)
+      end
+    end
+
+    def backref(object)
+      return @backref_method.call(object) if @backref_method.respond_to?(:call)
+      return object if @backref_method.to_s == 'self'
+      object.send(@backref_method)
+    end
+
+    def backref_ids(object)
+      Array.wrap(backref(object)).map { |object| object.respond_to?(:id) ? object.id : object.to_i }
+    end
+  end
+end

data/lib/chewy_resque/log_subscriber.rb

@@ -0,0 +1,23 @@
+module ChewyResque
+
+  class LogSubscriber < ActiveSupport::LogSubscriber
+
+    def perform(event)
+      info "ChewyResque job ran on #{event.payload[:index_name]} with ids #{event.payload[:ids]} - duration #{event.duration}"
+    end
+
+    def index(event)
+      debug "ChewyResque index updated on #{event.payload[:index_name]} with ids #{event.payload[:ids]} - duration #{event.duration}"
+    end
+
+    def queue_jobs(event)
+      debug "ChewyResque queued jobs from #{event.payload[:class]} #{event.payload[:id]}"
+    end
+
+    def logger
+      ChewyResque.logger
+    end
+
+  end
+
+end

data/lib/chewy_resque/mixin.rb

@@ -0,0 +1,52 @@
+require 'active_support/concern'
+require 'active_support/core_ext/array/wrap'
+
+module ChewyResque
+
+  def self.default_queue=(queue)
+    @default_queue = queue
+  end
+
+  def self.default_queue
+    @default_queue || 'default'
+  end
+
+  module Mixin
+
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :indexers
+      self.indexers = []
+    end
+
+    module ClassMethods
+
+      def async_update_index(index, queue: nil, backref: :self, only_if: nil)
+        install_chewy_hooks if indexers.empty? # Only install them once
+        indexers << ChewyResque::Index.new(index: index, queue: queue, backref: backref, only_if: only_if)
+      end
+
+      def install_chewy_hooks
+        after_commit :queue_chewy_jobs
+      end
+    end
+
+    def queue_chewy_jobs
+      ActiveSupport::Notifications.instrument('queue_jobs.chewy_resque', class: self.class.name, id: self.id) do
+        self.class.indexers or return
+        self.class.indexers.each do |idx|
+          begin
+            idx.enqueue(self)
+          rescue => e
+            # ResqueSpec stubs all exeptions from here in tests, even no logs
+            if ChewyResque.logger.respond_to? :error
+              ChewyResque.logger.error "Cannot update index #{idx.index_name}: #{e}\n#{e.backtrace}"
+            end
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chewy_resque/railtie.rb

@@ -0,0 +1,7 @@
+module ChewyResque
+  class Railtie < Rails::Railtie
+    initializer 'chewy_resque.logging' do |app|
+      ChewyResque.logger = Rails.logger
+    end
+  end
+end

data/lib/chewy_resque/version.rb

@@ -0,0 +1,3 @@
+module ChewyResque
+  VERSION = "0.1.0"
+end

data/lib/chewy_resque/worker.rb

@@ -0,0 +1,45 @@
+require 'chewy'
+require 'resque'
+require 'redis-lock'
+
+module ChewyResque
+  class Worker
+    def self.queue
+      ChewyResque::locking_scope
+    end
+
+    def self.perform(index_name, ids)
+      ActiveSupport::Notifications.instrument('perform.chewy_resque', index_name: index_name, ids: ids) do
+        with_lock(index_name, ids)
+      end
+    end
+
+    def self.with_lock(index_name, ids)
+      lock_name = "chewy-resque:#{ChewyResque.locking_scope}:#{index_name}-#{ids.join('-')}"
+      Resque.redis.lock(lock_name, life: 60, acquire: 5) { index(index_name, ids) }
+    end
+
+    def self.index(index_name, ids)
+      ActiveSupport::Notifications.instrument('index.chewy_resque', index_name: index_name, ids: ids) do
+        with_strategy do
+          Chewy.derive_type(index_name).update_index(ids)
+        end
+      end
+    end
+
+    def self.with_strategy
+      if Chewy.respond_to?(:strategy) && Chewy.strategy.current.name == :base
+        # production
+        begin
+          Chewy.strategy(:atomic)
+          yield
+        ensure
+          Chewy.strategy.pop
+        end
+      else
+        # 0.6.2 or test
+        yield
+      end
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'config' do
+  context '#logger' do
+
+    after(:each) { ChewyResque.logger = nil }
+
+    it 'can be set from the outside' do
+      ChewyResque.logger = :nolog
+      expect(ChewyResque.logger).to eq(:nolog)
+    end
+
+  end
+
+  context '#locking_scope' do
+
+    after(:each) { ChewyResque.locking_scope = nil }
+
+    it 'can be set from the outside' do
+      ChewyResque.locking_scope = '42'
+      expect(ChewyResque.locking_scope).to eq('42')
+    end
+
+    it 'has a default' do
+      expect(ChewyResque.locking_scope).to eq('chewy')
+    end
+
+  end
+end

data/spec/index_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe ChewyResque::Index do
+
+  context 'compute the backref' do
+
+    it 'defaults to the corresponding object' do
+      object = Object.new
+      idx = ChewyResque::Index.new
+      expect(idx.backref(object)).to eq object
+    end
+
+    it 'can run a random method' do
+      object = double(foobar: :backref)
+      idx = ChewyResque::Index.new(backref: :foobar)
+      expect(idx.backref(object)).to eq :backref
+    end
+
+    it 'can use a proc' do
+      object = double(foobar: :my_backref)
+      idx = ChewyResque::Index.new(backref: -> (r) { r.foobar })
+      expect(idx.backref(object)).to eq :my_backref
+    end
+
+    context 'turning backrefs into ids' do
+      let(:idx) { ChewyResque::Index.new }
+
+      it 'uses the ids of the objects' do
+        expect(idx.backref_ids([double(id: 3), double(id: 6)])).to eq [3, 6]
+      end
+
+      it 'turns everything else into ints' do
+        expect(idx.backref_ids([3, '6'])).to eq [3, 6]
+      end
+
+    end
+
+    context 'queue the job' do
+      it 'queues the job with the settings from the index' do
+        object = double(id: 24)
+        idx = ChewyResque::Index.new index: 'foo#bar',
+                                     queue: 'hello'
+
+        expect(Resque).to receive(:enqueue_to).with('hello', ChewyResque::Worker, 'foo#bar', [24])
+        idx.enqueue object
+      end
+    end
+
+  end
+
+end

data/spec/log_subscriber_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe ChewyResque::LogSubscriber do
+
+  let(:subscriber) { ChewyResque::LogSubscriber.new }
+  let(:logger) { Logger.new(nil) }
+
+  it 'logs a perform with the default logger' do
+    expect {
+      subscriber.perform(double(payload: { index_name: 'foo', ids: [1,2] }, duration: 0.2))
+    }.to_not raise_error
+  end
+
+  it 'logs a perform event' do
+    allow(subscriber).to receive(:logger).and_return(logger)
+    expect(logger).to receive(:info)
+    expect {
+      subscriber.perform(double(payload: { index_name: 'foo', ids: [1,2] }, duration: 0.2))
+    }.to_not raise_error
+  end
+
+  it 'logs an index event' do
+    allow(subscriber).to receive(:logger).and_return(logger)
+    expect(logger).to receive(:debug)
+    expect {
+      subscriber.index(double(payload: { index_name: 'foo', ids: [1,2] }, duration: 0.2))
+    }.to_not raise_error
+  end
+
+  it 'log a queue_jobs event' do
+    allow(subscriber).to receive(:logger).and_return(logger)
+    expect(logger).to receive(:debug)
+    expect {
+      subscriber.queue_jobs(double(payload: { class: 'Huha', id: 123 }))
+    }.to_not raise_error
+  end
+
+end

data/spec/mixin_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+class Gummi
+  include ChewyResque::Mixin
+
+  def self.after_commit(*args) ; end
+
+  def id ; 17 ; end
+
+end
+
+class GummiSubclass < Gummi
+end
+
+describe ChewyResque::Mixin do
+
+  before(:each) { Gummi.indexers.clear }
+
+  context '#update_index' do
+
+    it 'installs the hooks if nothing was installed yet' do
+      expect(Gummi).to receive(:install_chewy_hooks)
+      Gummi.async_update_index('xxx')
+    end
+
+    it 'does not install the hooks twice' do
+      expect(Gummi).to receive(:install_chewy_hooks).once
+      Gummi.async_update_index('xxx')
+      Gummi.async_update_index('xxx')
+    end
+
+    it 'installs the indexer' do
+      expect(ChewyResque::Index).to receive(:new)
+                        .with(index: 'some#thing', queue: :medium, backref: :foobar, only_if: nil)
+                        .and_return(:idx)
+      Gummi.async_update_index('some#thing', queue: :medium, backref: :foobar)
+      expect(Gummi.indexers).to eq [:idx]
+    end
+
+    it 'installs the indexer' do
+      Gummi.async_update_index('some#thing', queue: :medium, backref: :foobar)
+      expect(GummiSubclass.indexers.size).to eq 1
+      expect(GummiSubclass.indexers).to equal(Gummi.indexers)
+    end
+
+  end
+
+  context '#install hooks' do
+
+    it 'installs the hooks' do
+      expect(Gummi).to receive(:after_commit).with(:queue_chewy_jobs)
+      Gummi.install_chewy_hooks
+    end
+
+  end
+
+  context '#queue_chewy_jobs' do
+
+    let(:record) { Gummi.new }
+
+    it 'queues the job' do
+      idx = double
+      expect(idx).to receive(:enqueue).with(record)
+      allow(Gummi).to receive(:indexers).and_return([idx])
+      record.queue_chewy_jobs
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+ENV['REDIS_NAMESPACE_QUIET'] ||= '1'
+
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'chewy_resque'
+require 'chewy'
+
+RSpec.configure do |config|
+  config.before do
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::ERROR
+    ChewyResque.logger = logger
+  end
+end
+

data/spec/worker_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe ChewyResque::Worker do
+
+  let(:worker) { ChewyResque::Worker.new }
+  let(:lock) { double(acquire!: true, release!: true) }
+
+  before(:each) { allow(worker).to receive(:lock).and_return(lock) }
+
+  it 'calls the indexing with chewy' do
+    index = double
+    expect(Chewy).to receive(:derive_type).with('foo#bar').and_return(index)
+    expect(index).to receive(:update_index).with([17])
+
+    worker.class.perform('foo#bar', [17])
+  end
+
+end

metadata

@@ -0,0 +1,212 @@
+--- !ruby/object:Gem::Specification
+name: chewy_resque
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vlad Bokov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
+- !ruby/object:Gem::Dependency
+  name: chewy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mlanett-redis-lock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Resque integration for chewy and resque
+email:
+- bokov.vlad@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- chewy_resque.gemspec
+- lib/chewy_resque.rb
+- lib/chewy_resque/config.rb
+- lib/chewy_resque/index.rb
+- lib/chewy_resque/log_subscriber.rb
+- lib/chewy_resque/mixin.rb
+- lib/chewy_resque/railtie.rb
+- lib/chewy_resque/version.rb
+- lib/chewy_resque/worker.rb
+- spec/config_spec.rb
+- spec/index_spec.rb
+- spec/log_subscriber_spec.rb
+- spec/mixin_spec.rb
+- spec/spec_helper.rb
+- spec/worker_spec.rb
+homepage: ''
+licenses:
+- Apache V2
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Small helper gem that allows you to automatically run all chewy index updates
+  in resque
+test_files:
+- spec/config_spec.rb
+- spec/index_spec.rb
+- spec/log_subscriber_spec.rb
+- spec/mixin_spec.rb
+- spec/spec_helper.rb
+- spec/worker_spec.rb