tennis-jobs 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9ee6ec8dbc807f4cb3ade4eac1651624555239b1
+  data.tar.gz: 73978213184591abc3a807957a31b76e81a23817
+SHA512:
+  metadata.gz: 550aad703fa200b1f002ae8cfc84a9d22c55c39b0867885e4ee8a74d776d9241b65f5389fbe2133f31b601a3d49e53b0274d0391c2720d291d58e421931b7818
+  data.tar.gz: aa3f869f0a540088090b4a574d88288bd554931c84a9d0c15e8cf0088e46db21474da52d800c1a8ce7552f16063072efd4681348c59da47be85f63b1dcba01d6

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/coverage/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - "2.2.3"
+branches:
+  only:
+    - master
+script: bundle exec rspec spec
+before_install: gem install bundler -v 1.10.5

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Guardfile

@@ -0,0 +1,12 @@
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Nicolas ZERMATI
+
+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.markdown

@@ -0,0 +1,148 @@
+This small library is intended to help creating asynchronous jobs
+using Ruby and RabbitMQ via the Sneakers gem.
+
+<a href="https://travis-ci.org/nicoolas25/tennis"><img src="https://travis-ci.org/nicoolas25/tennis.svg?branch=master" /></a>
+<a href="https://codeclimate.com/github/nicoolas25/tennis"><img src="https://codeclimate.com/github/nicoolas25/tennis/badges/gpa.svg" /></a>
+<a href="https://codeclimate.com/github/nicoolas25/tennis/coverage"><img src="https://codeclimate.com/github/nicoolas25/tennis/badges/coverage.svg" /></a>
+
+## Features
+
+- Hooks: `.before(symbol, &block)`
+- Serializers: `.serialize(loader:)`
+- Helpers for defering method calls: `object.defer.method(*arguments)`
+
+**Extra**
+
+- A `GenericSerializer` handling classes and ActiveRecord objects
+
+## Examples
+
+Those examples are what we wish to achieve.
+
+The name of the queue is the name of the class by default and can be reset
+using sneakers' `.from_queue` method of the `YourClass::Worker`'s class.
+
+### Hooks
+
+``` ruby
+class MyClass
+  include GenericWorker
+
+  before do
+    puts "Before processing"
+  end
+
+  work do |message|
+    puts "Working with #{message}"
+    ack!
+  end
+end
+
+MyClass.execute("my class")
+# => Before processing
+# => Working with my class
+```
+
+### Serializers
+
+You can provide a Proc for the loader and/or the dumper keywords.
+The dumper will be used when calling `MyClass.execute(message)` receiving
+the `message` as argument. It should return a string. The loader will be
+used when the message is poped from the RabbitMQ queue.
+
+``` ruby
+class MyClass
+  include GenericWorker
+
+  serialize loader: ->(message){ JSON.parse(message) },
+            dumper: ->(message){ JSON.generate(message) }
+
+  work do |message|
+    one, two = message
+    puts "Message is serialized and deserialized correctly"
+    puts "one: #{one}, two: #{two}"
+    ack!
+  end
+end
+
+MyClass.execute([1, "foo"])
+# => Message is serialized and deserialized correctly
+# => one: 1, two: foo
+```
+
+``` ruby
+class MyClass
+  include GenericWorker
+
+  serialize GenericSerializer.new
+
+  work do |message|
+    klass, active_record_object = message
+    puts "Classes can be passed: #{klass.name} - #{klass.class}"
+    puts "Active record object can be passed too: #{active_record_object}"
+    ack!
+  end
+end
+
+MyClass.execute([String, User.find(1)])
+# => Classes can be passed: String - Class
+# => Active record object can be passed too: <User#1 ...>
+```
+
+### Helpers
+
+Any class method can be defered:
+
+``` ruby
+class MyClass
+  include DeferableWorker
+
+  def self.my_method(user)
+    puts "Running my method on #{user}"
+  end
+end
+
+MyClass.defer.my_method(User.find(1))
+# => Running my method on <User#1 ...>
+```
+
+An ActiveRecord::Base instance can be the receiver if it has an `id`:
+
+``` ruby
+class MyModel < ActiveRecord::Base
+  include DeferableWorker
+
+  def my_method
+    puts "Running my method on #{self}"
+  end
+end
+
+instance = MyModel.find(1)
+instance.defer.my_method
+# => Running my method on <MyModel#1 ...>
+```
+
+Handling errors and results for the deferred methods is via `on_error` and
+`on_success` keyword. You must return `ack!` or `reject!` here as in a
+Sneakers' `work` method.
+
+``` ruby
+class MyModel < ActiveRecord::Base
+  include DeferableWorker
+
+  on_error do |exception|
+    puts "I just saved the day handling a #{exception}"
+    reject!
+  end
+
+  def my_method
+    puts "Running my method on #{self}"
+    raise StandardError
+  end
+end
+
+instance = MyModel.find(1)
+instance.defer.my_method
+# => Running my method on <MyModel#1 ...>
+# => I just saved the day handling a StandardError
+```

data/Rakefile

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

data/examples/deferable.rb

@@ -0,0 +1,46 @@
+#
+# Create a client or a worker showing the serialization process.
+#
+# To run this example you should start a worker, then a client in a separate
+# shell. Of course you'll also need a running RabbitMQ server.
+#
+# Use RABBITMQ_URL environment variable if you need to customize the RabbitMQ
+# address.
+#
+
+$LOAD_PATH.unshift("./lib")
+
+require "tennis"
+
+require_relative "example"
+
+class Model
+  include Tennis::Worker::Deferable
+
+  attr_reader :id
+
+  def initialize(id)
+    @id = id
+  end
+
+  def method(numbers)
+    puts "At #{Time.now}, Model##{id} run method with #{numbers.inspect}\n"
+  end
+
+  # Usually the ORM provides this method. Here we're just faking it.
+  def self.find(id)
+    new(id)
+  end
+
+  # Usually the ORM provides this method. Here we're faking it too.
+  def attributes
+    { id: @id }
+  end
+end
+
+Example.new(__FILE__, Model).run do |i|
+  array = Array.new(5) { 1 + rand(5) }
+  print "Press enter to enqueue a random array..." ; gets
+  puts "Calling <Model##{i}>.method(#{array.inspect})"
+  Model.new(i).defer.method(array)
+end

data/examples/example.rb

@@ -0,0 +1,52 @@
+require "logger"
+require "optparse"
+require "sneakers/runner"
+
+class Example
+  def initialize(filename, klass)
+    @filename = filename
+    @klass = klass
+  end
+
+  def run(&client_code)
+    configure_workers
+    parse_options
+    if @options[:client]
+      start_client(client_code)
+    elsif @options[:worker]
+      start_worker
+    end
+  end
+
+  protected
+
+  def configure_workers
+    Tennis.configure do |config|
+      config.async = true
+      config.exchange = "example"
+      config.workers = 1
+      config.logger = Logger.new(STDOUT)
+      config.logger.level = Logger::WARN
+    end
+  end
+
+  def start_client(block, i = 1)
+    block.call(i)
+    start_client(block, i + 1)
+  rescue Interrupt
+    puts "Exiting the client"
+  end
+
+  def start_worker
+    Sneakers::Runner.new([@klass.worker]).run
+  end
+
+  def parse_options
+    @options = {}
+    OptionParser.new do |opts|
+      opts.banner = "Usage: #{@filename}"
+      opts.on("-c", "--client", "Run the client") { @options[:client] = true }
+      opts.on("-w", "--worker", "Run the worker") { @options[:worker] = true }
+    end.parse!
+  end
+end

data/examples/serializer.rb

@@ -0,0 +1,37 @@
+#
+# Create a client or a worker showing the serialization process.
+#
+# To run this example you should start a worker, then a client in a separate
+# shell. Of course you'll also need a running RabbitMQ server.
+#
+# Use RABBITMQ_URL environment variable if you need to customize the RabbitMQ
+# address.
+#
+
+$LOAD_PATH.unshift("./lib")
+
+require "json"
+require "tennis"
+
+require_relative "example"
+
+class SumWorker
+  include Tennis::Worker::Generic
+
+  serialize loader: ->(message){ JSON.parse(message) },
+            dumper: ->(message){ JSON.generate(message) }
+
+  work do |int_array|
+    sum = int_array.inject(0, &:+)
+    puts "At #{Time.now} I received an array. Sum of its elements is: #{sum}"
+    ack!
+  end
+end
+
+Example.new(__FILE__, SumWorker).run do
+  array = Array.new(5) { 1 + rand(5) }
+  print "Press enter to enqueue a random array..." ; gets
+  puts "Sending #{array.inspect} to the #{SumWorker::Worker.queue_name} queue!"
+  SumWorker.execute(array)
+end
+

data/lib/tennis.rb

@@ -0,0 +1,25 @@
+require "sneakers"
+
+module Tennis
+  module Worker
+    autoload :Deferable, "tennis/worker/deferable"
+    autoload :Generic,   "tennis/worker/generic"
+  end
+
+  module Serializer
+    autoload :Generic, "tennis/serializer/generic"
+  end
+
+  autoload :Configuration, "tennis/configuration"
+
+  def self.configure
+    @config = Configuration.new
+    yield @config if block_given?
+    @config.finalize!
+  end
+
+  def self.config
+    @config or fail "You must run Tennis.configure before accessing the configuration"
+  end
+
+end

data/lib/tennis/configuration.rb

@@ -0,0 +1,28 @@
+module Tennis
+  class Configuration
+    DEFAULT = {
+      async: true,
+      exchange: "tennis",
+      workers: 4,
+      logger: STDOUT,
+      sneakers_options: {},
+    }.freeze
+
+    attr_accessor :async, :exchange, :workers, :logger, :sneakers_options
+
+    def initialize(opts = {})
+      DEFAULT.merge(opts).each do |name, value|
+        __send__("#{name}=", value)
+      end
+    end
+
+    def finalize!
+      Sneakers.configure({
+        exchange: exchange,
+        workers: workers,
+        log: logger,
+      }.merge(sneakers_options))
+    end
+
+  end
+end

data/lib/tennis/serializer/generic.rb

@@ -0,0 +1,101 @@
+require "json"
+
+module Tennis
+  module Serializer
+    class Generic
+
+      RECOGNIZED_TYPES = {
+        active_record: "active_record".freeze,
+        class:         "class".freeze,
+      }.freeze
+
+      def load(message)
+        object = JSON.parse(message)
+        deserialize_any(object)
+      end
+
+      def dump(message)
+        JSON.generate(serialize_any(message))
+      end
+
+      private
+
+      def serialize_any(object)
+        visit(object) do |type, object|
+          case type
+          when :object
+            object
+          when :class
+            {
+              _type: RECOGNIZED_TYPES[:class],
+              _class: object.to_s
+            }
+          when :active_record
+            {
+              _type: RECOGNIZED_TYPES[:active_record],
+              _class: object.class.to_s,
+              _id: object.id,
+            }
+          else
+            fail "Unexpected type: #{type} when visiting object"
+          end
+        end
+      end
+
+      def deserialize_any(object)
+        visit(object) do |type, object|
+          case type
+          when :object
+            object
+          when :class
+            Object.const_get(object["_class"])
+          when :active_record
+            klass = Object.const_get(object["_class"])
+            klass.find(object["_id"])
+          else
+            fail "Unexpected type: #{type} when visiting object"
+          end
+        end
+      end
+
+      def visit(object, &block)
+        visit_any(object, block)
+      end
+
+      def visit_any(object, block)
+        if object.kind_of?(Array)
+          visit_array(object, block)
+        elsif is_active_record?(object)
+          block.call(:active_record, object)
+        elsif is_class?(object)
+          block.call(:class, object)
+        elsif object.kind_of?(Hash)
+          visit_hash(object, block)
+        else
+          block.call(:object, object)
+        end
+      end
+
+      def visit_array(array, block)
+        array.map { |element| visit_any(element, block) }
+      end
+
+      def visit_hash(hash, block)
+        hash.each_with_object({}) do |(key, value), new_hash|
+          new_hash[key] = visit_any(value, block)
+        end
+      end
+
+      def is_active_record?(object)
+        object.respond_to?(:attributes) ||
+        object.is_a?(Hash) && object["_type"] == RECOGNIZED_TYPES[:active_record]
+      end
+
+      def is_class?(object)
+        object.is_a?(Class) ||
+        object.is_a?(Hash) && object["_type"] == RECOGNIZED_TYPES[:class]
+      end
+
+    end
+  end
+end

data/lib/tennis/worker/deferable.rb

@@ -0,0 +1,55 @@
+module Tennis
+  module Worker
+    module Deferable
+
+      autoload :Action, "tennis/worker/deferable/action"
+
+      def self.included(base)
+        base.extend DSL
+        base.include Worker::Generic
+        base.serialize Serializer::Generic.new
+        define_work_broker(base)
+      end
+
+      def self.define_work_broker(base)
+        base.work do |message|
+          begin
+            receiver, method, arguments = message
+            result = receiver.__send__(method, *arguments)
+            instance_exec(result, &base._on_success)
+          rescue => exception
+            instance_exec(exception, message, &base._on_error)
+          end
+        end
+      end
+
+      def defer
+        Action.new(self.class, self)
+      end
+
+      module DSL
+
+        def defer
+          Action.new(self, self)
+        end
+
+        def on_error(&block)
+          @_on_error = block
+        end
+
+        def on_success(&block)
+          @_on_success = block
+        end
+
+        def _on_error
+          @_on_error || ->(_, _){ reject! }
+        end
+
+        def _on_success
+          @_on_success || ->(_){ ack! }
+        end
+
+      end
+    end
+  end
+end

data/lib/tennis/worker/deferable/action.rb

@@ -0,0 +1,25 @@
+class Tennis::Worker::Deferable::Action
+  def initialize(worker_class, receiver)
+    @worker_class = worker_class
+    @receiver = receiver
+    _create_methods!
+  end
+
+  private
+
+  def _create_methods!
+    _methods.each do |method|
+      self.define_singleton_method(method) do |*arguments|
+        @worker_class.execute([@receiver, method, arguments])
+      end
+    end
+  end
+
+  def _methods
+    if @receiver.kind_of?(Class)
+      @receiver.methods(false).map(&:to_s)
+    else
+      @receiver.class.instance_methods(false).map(&:to_s)
+    end
+  end
+end

data/lib/tennis/worker/generic.rb

@@ -0,0 +1,56 @@
+module Tennis
+  module Worker
+    module Generic
+
+      autoload :BeforeHook, "tennis/worker/generic/before_hook"
+      autoload :Serialize,  "tennis/worker/generic/serialize"
+
+      def self.included(base)
+        base.extend BeforeHook
+        base.extend Serialize
+        base.extend DSL
+        base.worker = Class.new do
+          @@parent = base
+
+          include Sneakers::Worker
+          from_queue @@parent.name
+
+          def work(message)
+            message = @@parent._apply_serializer(:load, message)
+            @@parent._process_before_hooks(message, self)
+            instance_exec(message, &@@parent._work)
+          end
+        end
+      end
+
+      module DSL
+
+        attr_accessor :worker
+
+        def work(&block)
+          @_work = block
+        end
+
+        def _work
+          @_work ||= ->(_){ ack! }
+        end
+
+        def execute(message)
+          message = _apply_serializer(:dump, message)
+          if Tennis.config.async
+            publisher_opts = worker.queue_opts.select do |opt_name, _|
+              opt_name == :exchange ||
+              opt_name == :exchange_type
+            end
+            publisher = Sneakers::Publisher.new(publisher_opts)
+            publisher.publish(message, to_queue: worker.queue_name)
+            publisher.instance_variable_get(:@bunny).close
+          else
+            worker.new.work(message)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/tennis/worker/generic/before_hook.rb

@@ -0,0 +1,17 @@
+module Tennis::Worker::Generic::BeforeHook
+  def before(&block)
+    if block_given?
+      _before_hooks << block
+    end
+  end
+
+  def _process_before_hooks(message, worker)
+    _before_hooks.each do |hook|
+      hook.call(message, worker)
+    end
+  end
+
+  def _before_hooks
+    @_before_hooks ||= []
+  end
+end

data/lib/tennis/worker/generic/serialize.rb

@@ -0,0 +1,26 @@
+module Tennis::Worker::Generic::Serialize
+  def serialize(object = nil, loader: nil,  dumper: nil)
+    if object
+      _serializers[:load] = object if object.respond_to?(:load)
+      _serializers[:dump] = object if object.respond_to?(:dump)
+    else
+      _serializers[:load] = loader if loader
+      _serializers[:dump] = dumper if dumper
+    end
+  end
+
+  def _apply_serializer(serializer_kind, message)
+    serializer = _serializers[serializer_kind]
+    if serializer.kind_of?(Proc)
+      serializer.call(message)
+    elsif serializer.respond_to?(serializer_kind)
+      serializer.__send__(serializer_kind, message)
+    else
+      fail "Unexpected (de)serializer, it must be a Proc or respond to ##{kind}"
+    end
+  end
+
+  def _serializers
+    @_serializers ||= Hash.new(->(message){ message })
+  end
+end

data/tennis-jobs.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "tennis-jobs"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Nicolas ZERMATI"]
+  spec.email         = ["nicoolas25@gmail.com"]
+
+  spec.summary       = %q{A small background job library on top of sneakers.}
+  spec.description   = %q{A small background job library on top of sneakers.}
+  spec.homepage      = "https://github.com/nicoolas25/tennis"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "sneakers"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "codeclimate-test-reporter"
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: tennis-jobs
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nicolas ZERMATI
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sneakers
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: simplecov
+  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: guard-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: 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: A small background job library on top of sneakers.
+email:
+- nicoolas25@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.markdown
+- Rakefile
+- examples/deferable.rb
+- examples/example.rb
+- examples/serializer.rb
+- lib/tennis.rb
+- lib/tennis/configuration.rb
+- lib/tennis/serializer/generic.rb
+- lib/tennis/worker/deferable.rb
+- lib/tennis/worker/deferable/action.rb
+- lib/tennis/worker/generic.rb
+- lib/tennis/worker/generic/before_hook.rb
+- lib/tennis/worker/generic/serialize.rb
+- tennis-jobs.gemspec
+homepage: https://github.com/nicoolas25/tennis
+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.4.5
+signing_key: 
+specification_version: 4
+summary: A small background job library on top of sneakers.
+test_files: []