serially 0.1.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDBkOWU0MjdmOTI2YmUxNDM3YzJiOTY1MWEyNzRlODc1YmQzYmNjZA==
+  data.tar.gz: !binary |-
+    NmE3MjZkYTRiNWFiZWU3N2I5NGY2ZTRkZDliMmQ0ZmFlZWY5ZmVmMg==
+SHA512:
+  metadata.gz: !binary |-
+    ODk0MjVkODJmMGYwZDRkNjJjMDE5YmI1NzA1YTQwZWQxYjRmOGY5NmVjMzE2
+    N2U5NTQxZTU3Y2RmODM0M2RlYTJhNmVmODM4MTk0NTcwYTMwMGZkMjhmZmEy
+    ZWIwNjQ0NDM2Mzg5NDcwNjQ4MmI0YmZjZmRlMDAxZWNmODMzMjQ=
+  data.tar.gz: !binary |-
+    ZmNjYWQ1M2Y0MzAxMDJhZmM3NTI3MTU2NWUzOTc3ODM1Yzg1YWU0ZTcyMmZh
+    ZTkyNTcyNzgwNWM5ZjE1ZDA4MjIxYjEwNGFlYWUwOGNjZTY5MDFlY2Q1ZGYx
+    MTRhODQyNjg5NzE5ODVhZjhhZDA5MDlkMjQyZjcxZWQ3M2Q4OWU=

data/.gitignore

@@ -0,0 +1,12 @@
+.idea/*
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+log/*
+.rvmrc

data/.pryrc

@@ -0,0 +1,49 @@
+require './spec/active_record_helper'
+
+class SimpleClass
+      include Serially
+
+      serially do
+        task :enrich
+        task :validate
+        task :refund
+        task :archive
+      end
+end
+
+class SimpleSubClass < SimpleClass
+  include Serially
+
+  serially do
+    task :zip
+    task :send
+    task :acknowledge
+  end
+end
+
+class SimpleModel < ActiveRecord::Base
+  include Serially
+
+  self.table_name =  'simple_items'
+
+  serially do
+    task :model_step1
+    task :model_step2
+    task :model_step3
+  end
+end
+
+def create_simple
+    simple = SimpleClass.new
+    simple
+end
+
+def create_sub
+    simple = SimpleSubClass.new
+    simple
+end
+
+def create_model
+    simple = SimpleModel.create(title: 'IAmSimple')
+    simple
+end

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--profile

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in serially.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Mike Polischuk
+
+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,204 @@
+# Serially
+
+[![Build Status](https://circleci.com/gh/mikemarsian/serially.svg?&style=shield&circle-token=93a8f2925ebdd64032108118ef6e17eb3848d767)](https://circleci.com/gh/mikemarsian/serially)
+[![Code Climate](https://codeclimate.com/github/mikemarsian/serially/badges/gpa.svg)](https://codeclimate.com/github/mikemarsian/serially)
+
+Have you ever had a class that required a series of background tasks to run serially, strictly one after another? Than Serially is for you.
+All background jobs are scheduled using resque in a queue called `serially`, and Serially makes sure that for every instance of your class, only one task runs at a time.
+Different instances of the same class do not interfere with each other and their tasks can run in parallel.
+Serially works for both plain ruby classes and ActiveRecord models. In case of the latter, all task runs results are written to `serially_tasks` table which you can interrogate pragmatically using `Serially::TaskRun` model.
+
+See [this rails demo app][1] that showcases how Serially gem can be used.
+
+Note: this gem is in active development and currently is not intended to run in production.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'serially'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install serially
+
+## Optional ActiveRecord Setup
+
+If you use ActiveRecord, you can generate a migration that creates `serially_task_runs` table, which would be used to write the results of all your task runs.
+
+    $ rails generate serially:install
+    $ rake db:migrate
+
+## Usage
+```ruby
+class Post < ActiveRecord::Base
+     include Serially
+
+     serially do
+        task :draft
+        task :review
+        task :publish
+        task :promote
+     end
+
+     def draft
+        puts "Post #{self.id} drafted"
+        true
+     end
+
+     def review
+        puts "Post #{self.id} reviewed by staff"
+        [true, 'reviewed by staff']
+     end
+
+     def publish
+        puts "Post #{self.id} not published - bibliography is missing"
+        [false, 'bibliography is missing']
+     end
+
+     def promote
+        puts "Post #{self.id} promoted"
+        true
+     end
+   end
+```
+
+After creating a Post, you can run `post.serially.start!` to schedule your Post tasks to run serially. They will run one after the other in the scope of the same `Serially::Worker` job.
+An example run:
+```ruby
+post1 = Post.create(title: 'Critique of Pure Reason', author: 'Immanuel Kant') #=> <Post id: 1, title: 'Critique of Pure Reason'...>
+post2 = Post.create(title: 'The Social Contract', author: 'Jean-Jacques Rousseau') #=> <Post id: 2, title: 'The Social Contract'...>
+post1.serially.start!
+post2.serially.start!
+```
+The resulting resque log may look something like this:
+```
+Post 1 drafted
+Post 1 reviewed by staff
+Post 2 drafted
+Post 1 not published - bibliography is missing
+Post 2 reviewed by staff
+Post 2 not published - bibliography is missing
+```
+
+### Task Return Values
+
+* A task should at minimum return a boolean value, signifying whether that task finished successfully or not
+* A task can also return a string with details of the task completion
+* If a task returns _false_, the execution stops and the next tasks in the chain won't be performed for current instance
+
+### Inspecting Task Runs
+
+You can inspect task runs results using the provided `Serially::TaskRun` model and its associated `serially_task_runs` table.
+Running `Serially::TaskRun.all` for the above example, will show something like this:
+```
++----+------------+---------+-----------+----------------+----------------------+---------------------+
+| id | item_class | item_id | task_name | status         | result_message       | finished_at         |
++----+------------+---------+-----------+----------------+----------------------+---------------------+
+| 1  | Post       | 1       | draft     | finished_ok    |                      | 2015-12-31 09:17:17 |
+| 2  | Post       | 1       | review    | finished_ok    | reviewed by staff    | 2015-12-31 09:17:17 |
+| 3  | Post       | 2       | draft     | finished_ok    |                      | 2015-12-31 09:17:17 |
+| 4  | Post       | 1       | publish   | finished_error | bibliography missing | 2015-12-31 09:17:17 |
+| 5  | Post       | 2       | review    | finished_ok    |                      | 2015-12-31 09:17:17 |
+| 6  | Post       | 2       | publish   | finished_error | bibliography missing | 2015-12-31 09:17:17 |
++----+------------+---------+-----------+----------------+----------------------+---------------------+
+```
+Notice that the _promote_ task didn't run at all, since the _publish_ task that ran before it returned _false_ for both posts.
+
+
+### Blocks
+In addition to instance methods, you can pass a block as a task callback, and you can mix both syntaxes in your class:
+
+```ruby
+class Post < ActiveRecord::Base
+     include Serially
+
+     serially do
+        task :draft
+        task :review do |post|
+            puts "Reviewing #{post.id}"
+        end
+        task :publish do |post|
+            puts "Publishing #{post.id}"
+        end
+     end
+
+     def draft
+        puts "Drafting #{self.id}"
+     end
+end
+```
+
+## Customize Plain Ruby Class Instantiation
+Before the first task runs, Serially creates an instance of your class, on which your task callbacks are then called. By default, instances of plain ruby classes
+are created using simple `new`. If your class has a custom `initialize` method that you want to be called when creating instance of your class, it's easy to achieve. All you need to do is to implement
+`instance_id` method that can return any number of arguments, which will be passed as-is to 'initialize`.
+
+```ruby
+class Post
+     include Serially
+
+     attr_accessor :title
+
+     def initialize(title)
+        @title = title
+     end
+
+     def instance_id
+        @title
+     end
+
+
+     serially do
+        # ...
+     end
+end
+
+class Post
+     include Serially
+
+     attr_accessor :title
+     attr_accessor :author
+
+     def initialize(title, author)
+        @title = title
+        @author = author
+     end
+
+     def instance_id
+        [@title, @author]
+     end
+
+
+     serially do
+        # ...
+     end
+end
+```
+
+### ActiveRecord Model Instantiation
+For ActiveRecord objects, `instance_id` will return the DB id as expected, and overwriting this method isn't recommended.
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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/mikemarsian/serially.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+[1]: https://github.com/mikemarsian/serially-demo

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "serially"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+
+# require "irb"
+# IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/circle.yml

@@ -0,0 +1,7 @@
+machine:
+  pre:
+    - rvm use ruby-1.9.3-p551
+    - gem install bundler
+database:
+  override:
+    - echo "no database setup"

data/lib/generators/serially/install/install_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Serially
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+      desc "Add the migrations for Serially"
+
+      def self.next_migration_number(path)
+        next_migration_number = current_migration_number(path) + 1
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
+
+      def copy_migrations
+        migration_template "create_serially_task_runs.rb", "db/migrate/create_serially_task_runs.rb"
+      end
+    end
+  end
+end

data/lib/generators/serially/install/templates/create_serially_task_runs.rb

@@ -0,0 +1,15 @@
+class CreateSeriallyTaskRuns < ActiveRecord::Migration
+  def change
+    create_table :serially_task_runs do |t|
+      t.string  :item_class,          null: false
+      t.string :item_id,        null: false
+      t.string :task_name,        null: false
+      t.integer  :status,         default: 0
+      t.datetime :finished_at
+      t.text     :result_message
+      t.timestamps null: false
+    end
+
+    add_index :serially_task_runs, [:item_class, :item_id]
+  end
+end

data/lib/serially/base.rb

@@ -0,0 +1,12 @@
+module Serially
+  class Base
+    def initialize(task_manager)
+      @task_manager = task_manager
+    end
+
+    # DSL
+    def task(name, task_options = {}, &block)
+      @task_manager.add_task(name, task_options, &block)
+    end
+  end
+end

data/lib/serially/errors.rb

@@ -0,0 +1,7 @@
+module Serially
+
+  class ArgumentError < RuntimeError; end
+
+  class ConfigurationError < RuntimeError; end
+
+end

data/lib/serially/instance_base.rb

@@ -0,0 +1,20 @@
+module Serially
+  class InstanceBase
+    extend Forwardable
+
+    def initialize(instance)
+      @instance = instance
+      @task_manager = Serially::TaskManager[instance.class]
+    end
+
+    # delegate instance methods to task_manager
+    def_delegator :@task_manager, :tasks
+
+    def start!
+      Serially::Worker.enqueue(@instance.class, @instance.instance_id)
+    end
+
+    private
+
+  end
+end

data/lib/serially/serially.rb

@@ -0,0 +1,68 @@
+module Serially
+
+    def self.included(receiver)
+      receiver.extend Serially::ClassMethods
+      # remove any task_manager that might have been inherited - inclusion takes precedence
+      Serially::TaskManager[receiver] = nil
+      super
+    end
+
+    module ClassMethods
+      # make sure inheritance works with Serially
+      def inherited(subclass)
+        Serially::TaskManager[subclass] = Serially::TaskManager[self].clone_for(subclass)
+        super
+      end
+
+      def serially(*args, &block)
+        options = args[0] || {}
+
+        # If TaskManager for current including class doesn't exist, create it
+        task_manager = Serially::TaskManager.new(self, options)
+        Serially::TaskManager[self] ||= task_manager
+
+        # create a new base, and resolve DSL
+        @serially = Serially::Base.new(task_manager)
+        if block
+          @serially.instance_eval(&block)
+        else
+          raise Serially::ConfigurationError.new("Serially is defined without a block of tasks definitions in class #{self}")
+        end
+
+        # return Serially::Base
+        @serially
+      end
+
+      def is_active_record?
+        self < ActiveRecord::Base
+      end
+
+      # override this to provide a custom way of creating instances of your class
+      def create_instance(*args)
+        args = args.flatten
+        if self.is_active_record?
+          if args.count == 1
+            args[0].is_a?(Fixnum) ? self.where(id: args[0]).first : self.where(args[0]).first
+          else
+            raise Serially::ArgumentError.new("Serially: default implementation of ::create_instance expects to receive either id or hash")
+          end
+        else
+          begin
+            args.blank? ? new : new(*args)
+          rescue StandardError => exc
+            raise Serially::ArgumentError.new("Serially: since no implementation of ::create_instance is provided in #{self}, tried to call new, but failed with provided arguments: #{args}")
+          end
+        end
+      end
+    end
+
+    # this is the entry point for all instance-level access to Serially
+    def serially
+      @serially ||= Serially::InstanceBase.new(self)
+    end
+
+    # override this to provide a custom way of fetching id of your class' instance
+    def instance_id
+      self.respond_to?(:id) ? self.id : self.object_id
+    end
+end

data/lib/serially/task.rb

@@ -0,0 +1,55 @@
+module Serially
+  class Task
+
+    attr_accessor :name, :klass, :options, :run_block
+
+    def initialize(task_name, options, task_manager, &run_block)
+      @name = task_name.to_sym
+      @klass = task_manager.klass
+      @options = options
+      @run_block = run_block
+      @task_manager = task_manager
+    end
+
+    def ==(task)
+      if task.is_a? Symbol
+        name == task
+      else
+        name == task.name && self.klass == task.klass
+      end
+    end
+
+    def <=>(task)
+      if task.is_a? Symbol
+        name <=> task
+      else
+        name <=> task.name
+      end
+    end
+
+    def to_s
+      name.to_s
+    end
+
+    # <i>args</i> - arguments needed to create an instance of your class. If you don't provide custom implementation for create_instance,
+    # pass instance_id or hash of arguments,
+    def run!(*args)
+      instance = args[0].blank? ? instance = @klass.send(:create_instance) : @klass.send(:create_instance, *args)
+      if instance
+        if !@run_block && !instance.respond_to?(@name)
+          raise Serially::ConfigurationError.new("Serially task #{@name} in class #{@klass} doesn't have an implementation method or a block to run")
+        end
+        begin
+          status, msg = @run_block ? @run_block.call(instance) : instance.send(@name)
+        rescue StandardError => exc
+          return [false, "Serially: task '#{@name}' raised exception: #{exc.message}"]
+        end
+      else
+        return [false, "Serially: instance couldn't be created, task '#{@name}'' not started"]
+      end
+      # returns true (unless status == nil/false/[]) and '' (unless msg is a not empty string)
+      [status.present?, msg.to_s]
+    end
+
+  end
+end

data/lib/serially/task_manager.rb

@@ -0,0 +1,45 @@
+module Serially
+  class TaskManager
+
+    # the following two methods provide the storage of all task managers
+    def self.[](klass)
+      (@task_managers ||= {})[klass.to_s]
+    end
+
+    def self.[]=(klass, task_manager)
+      (@task_managers ||= {})[klass.to_s] = task_manager
+    end
+
+    attr_accessor :tasks, :options, :klass
+
+    def initialize(klass, options = {})
+      @klass = klass
+      @options = options
+      # Hash is ordered since Ruby 1.9
+      @tasks = {}
+    end
+
+    def clone_for(new_klass)
+      new_mgr = TaskManager.new(new_klass, self.options)
+      self.each { |task| new_mgr.add_task(task.name, task.options, &task.run_block) }
+      new_mgr
+    end
+
+
+    def add_task(task_name, task_options, &block)
+      raise Serially::ConfigurationError.new("Task #{task_name} is already defined in class #{@klass}") if @tasks.include?(task_name)
+      raise Serially::ConfigurationError.new("Task name #{task_name} defined in class #{@klass} is not a symbol") if !task_name.is_a?(Symbol)
+      @tasks[task_name] = Serially::Task.new(task_name, task_options, self, &block)
+    end
+
+    # Allow iterating over tasks
+    def each
+      return enum_for(:each) unless block_given?  # return Enumerator
+
+      @tasks.values.each do |task|
+        yield task
+      end
+    end
+
+  end
+end

data/lib/serially/task_run.rb

@@ -0,0 +1,42 @@
+require 'active_record'
+
+module Serially
+  class TaskRun < ActiveRecord::Base
+    enum status: { pending: 0, started: 1, started_async: 2, finished_ok: 3, finished_error: 4 }
+
+    self.table_name = 'serially_task_runs'
+
+    validates :item_class, :item_id, :task_name, presence: true
+    validates :task_name, uniqueness: { scope: [:item_class, :item_id] }
+
+    def self.create_from_hash!(args = {})
+      task_run = TaskRun.new do |t|
+        t.item_class = args[:item_class] if args[:item_class].present?
+        t.item_id = args[:item_id] if args[:item_id].present?
+        t.status = args[:status] if args[:status].present?
+        t.task_name = args[:task_name] if args[:task_name].present?
+      end
+      task_run.save!
+      task_run
+    end
+
+    def finished?
+      finished_ok? || finished_error?
+    end
+
+    def self.write_task_run(task, item_id, success, msg)
+      task_run = TaskRun.where(item_class: task.klass, item_id: item_id, task_name: task.name).first_or_initialize
+      if task_run.finished?
+        Resque.logger.warn("Serially: task '#{task.name}' for #{task.klass}/#{item_id} finished already, not saving this task run")
+        false
+      else
+        saved = task_run.tap {|t|
+          t.status = success ? TaskRun.statuses[:finished_ok] : TaskRun.statuses[:finished_error]
+          t.result_message = msg
+          t.finished_at = DateTime.now
+        }.save
+        saved
+      end
+    end
+  end
+end

data/lib/serially/task_run_writer.rb

@@ -0,0 +1,10 @@
+module Serially
+  class TaskRunWriter
+
+    # called by TaskRunner, after each task has finished running
+    def update(task, item_id, success, msg)
+      TaskRun.write_task_run(task, item_id, success, msg)
+    end
+
+  end
+end

data/lib/serially/task_runner.rb

@@ -0,0 +1,43 @@
+require 'observer'
+
+module Serially
+  class TaskRunner
+    include Observable
+
+    def initialize(task_run_observer = nil)
+      add_observer(task_run_observer) if task_run_observer
+    end
+
+    def run!(item_class, item_id = nil)
+      last_run = []
+      Serially::TaskManager[item_class].each do |task|
+        # if task.async?
+        #   started_async_task = SerialTasksManager.begin_task(task)
+        #   # if started async task successfully, exit the loop, otherwise go to next task
+        #   break if started_async_task
+        # else
+        #started_async_task = false
+
+        success, msg = task.run!(item_id)
+        last_run = [task, success, msg]
+
+        # write result log to DB
+        changed
+        notify_observers(task, item_id, success, msg)
+        # if task didn't complete successfully, exit
+        break if !success
+      end
+      # if started_async_task
+      #   msg = "SerialTasksManager: started async task for #{item_class}/#{item_id}. Worker is exiting..."
+      # else
+      #   msg = "SerialTasksManager: no available tasks found for #{item_class}/#{item_id}. Worker is exiting..."
+      # end
+
+      # If we are here, it means that no more tasks were found
+      success = last_run[1]
+      msg = success ? "Serially: finished all tasks for #{item_class}/#{item_id}. Serially::Worker is exiting..." :
+                      "Serially: task '#{last_run[0]}' for #{item_class}/#{item_id} finished with success: #{last_run[1]}, message: #{last_run[2]}"
+      msg
+    end
+  end
+end

data/lib/serially/version.rb

@@ -0,0 +1,3 @@
+module Serially
+  VERSION = "0.1.1"
+end

data/lib/serially/worker.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+require 'resque'
+require 'resque-lonely_job'
+
+module Serially
+  class Worker
+    # LonelyJob ensures that only one job a time runs per item_class/item_id (such as Invoice/34599), which
+    # effectively means that for every invoice there is only one job a time, which ensures invoice jobs are processed serially
+    extend Resque::Plugins::LonelyJob
+
+    @queue = 'serially'
+    def self.queue
+      @queue
+    end
+
+    # this ensures that for item_class=Invoice, and item_id=34500, only one job will run at a time
+    def self.redis_key(item_class, item_id, *args)
+      "serially:#{item_class}_#{item_id}"
+    end
+
+    def self.perform(item_class, item_id)
+      Resque.logger.info("Serially: starting running tasks for #{item_class}/#{item_id}...")
+      item_class = item_class.constantize if item_class.is_a?(String)
+      writer = TaskRunWriter.new if item_class.is_active_record?
+      result_str = TaskRunner.new(writer).run!(item_class, item_id)
+      Resque.logger.info(result_str)
+    end
+
+    def self.enqueue(item_class, item_id)
+      Resque.enqueue(Serially::Worker, item_class.to_s, item_id)
+    end
+
+    def self.enqueue_batch(item_class, items)
+      items.each {|item| enqueue(item_class.to_s, item.instance_id)}
+    end
+  end
+end

data/lib/serially.rb

@@ -0,0 +1,11 @@
+require "serially/version"
+require 'serially/errors'
+require 'serially/serially'
+require 'serially/base'
+require 'serially/instance_base'
+require 'serially/task'
+require 'serially/task_manager'
+require 'serially/task_runner'
+require 'serially/task_run'
+require 'serially/task_run_writer'
+require 'serially/worker'

data/serially.gemspec

@@ -0,0 +1,43 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'serially/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "serially"
+  spec.version       = Serially::VERSION
+  spec.authors       = ["Mike Polischuk"]
+  spec.email         = ["mike@polischuk.net"]
+
+  spec.summary       = %q{Allows any plain ruby class or ActiveRecord model to define a series of background tasks that will be run serially, strictly one
+                        after another, as a single, long-running resque job}
+  spec.homepage      = "http://github.com/mikemarsian/serially"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'resque', '~> 1.2'
+  spec.add_dependency 'resque-lonely_job'
+  spec.add_dependency 'activerecord', '~> 4.2'
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", '~> 3.0'
+  spec.add_development_dependency "rspec_junit_formatter", '0.2.2'
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-debugger"
+  spec.add_development_dependency 'database_cleaner'
+  spec.add_development_dependency 'sqlite3'
+
+  spec.description   = <<desc
+Have you ever had a class that required a series of background tasks to run serially, strictly one after another? Than Serially is for you.
+All background jobs are scheduled using resque and Serially makes sure that for every instance of your class, only one task runs at a time.
+Different instances of the same class do not interfere with each other and their tasks can run in parallel.
+Serially works for both plain ruby classes and ActiveRecord models. In case of the latter, all task runs results are written to serially_tasks table which you can interrogate pragmatically using Serially::TaskRun model.
+desc
+
+end

metadata

@@ -0,0 +1,240 @@
+--- !ruby/object:Gem::Specification
+name: serially
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Mike Polischuk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: resque-lonely_job
+  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: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+- !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: pry-debugger
+  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: database_cleaner
+  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: sqlite3
+  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: ! 'Have you ever had a class that required a series of background tasks
+  to run serially, strictly one after another? Than Serially is for you.
+
+  All background jobs are scheduled using resque and Serially makes sure that for
+  every instance of your class, only one task runs at a time.
+
+  Different instances of the same class do not interfere with each other and their
+  tasks can run in parallel.
+
+  Serially works for both plain ruby classes and ActiveRecord models. In case of the
+  latter, all task runs results are written to serially_tasks table which you can
+  interrogate pragmatically using Serially::TaskRun model.
+
+'
+email:
+- mike@polischuk.net
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .pryrc
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- circle.yml
+- lib/generators/serially/install/install_generator.rb
+- lib/generators/serially/install/templates/create_serially_task_runs.rb
+- lib/serially.rb
+- lib/serially/base.rb
+- lib/serially/errors.rb
+- lib/serially/instance_base.rb
+- lib/serially/serially.rb
+- lib/serially/task.rb
+- lib/serially/task_manager.rb
+- lib/serially/task_run.rb
+- lib/serially/task_run_writer.rb
+- lib/serially/task_runner.rb
+- lib/serially/version.rb
+- lib/serially/worker.rb
+- serially.gemspec
+homepage: http://github.com/mikemarsian/serially
+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.3
+signing_key: 
+specification_version: 4
+summary: Allows any plain ruby class or ActiveRecord model to define a series of background
+  tasks that will be run serially, strictly one after another, as a single, long-running
+  resque job
+test_files: []