progressrus 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4cbd4fa76b6a27688c4f385cb897bbd743a5e970
+  data.tar.gz: 0d51ce787ed6e0f5dcf5ab9b01992b84882bd490
+SHA512:
+  metadata.gz: d6d9455550209e99c6d714184566f99c651a223b79d30aeeb11b3b80d017f0ded87507735c38215f974380419d82b6883050b06a6fae4b4b8a5e1769c718d675
+  data.tar.gz: c2dbc7c4f6f292f08dffe50cd5e159d57bf81926ada214a3f49d568b811f47a3f2cd2b8be8235fa939ac9d1851b56c69687da12a829cf2b7b02c15f210fe8bf6

data/.gitignore

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

data/.travis.yml

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

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in resque-pace.gemspec
+gemspec
+
+gem 'coveralls', require: false

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Simon Eskildsen
+
+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,113 @@
+# Progressrus [![Build Status](https://travis-ci.org/Sirupsen/progressrus.png?branch=master)](https://travis-ci.org/Sirupsen/progressrus) [![Coverage Status](https://coveralls.io/repos/Sirupsen/progressrus/badge.png?branch=master)](https://coveralls.io/r/Sirupsen/progressrus?branch=master)
+
+`Progressrus` provides progress status of long-running jobs. The progress is
+stored in persistence layer. Progressrus currently ships with a Redis adapter,
+but is written in an agnostic way, where multiple layers can be used at the same
+time. For example, one a message queue adapter too for real-time updates.
+
+Think of Progressrus as a progress bar where instead of flushing the progress to
+`stdout`, it's pushed to one or more data stores. It can be used with a
+background job engine or just about anything where you need to show the progress
+in a different location than the long-running operation.
+
+It works by instructing `Progressrus` about the finishing point (total). When
+the job makes progress towards the total, the job calls `tick`. With ticks
+second(s) apart (configurable) the progress is updated in the data store(s). This
+prevents a job processing e.g. 100 records to hit the data store 100 times.
+Combination of adapters is planned, so you can publish to some kind of real-time
+data source, Redis and even stdout at the same time.
+
+`Progressrus` keeps track of the jobs in some scope. This could be a `user_id`.
+This makes it easy to find the jobs and their progress for a specific user,
+without worrying about keeping e.g. the Resque job ids around.
+
+`Progressrus` will update the data store with the progress of the job. The key
+for a user with `user_id` `3421` would be: `progressrus:user:3421`. For the
+Redis data store, the key is a Redis hash where the Redis `job_id` is the key
+and the value is a `json` object with information about the progress, i.e.:
+
+```redis
+redis> HGETALL progressrus:user:3421
+1) "4bacc11a-dda3-405e-b0aa-be8678d16037"
+2) "{"count\":94,\"total\":100,\"started_at\":\"2013-12-08 10:53:41 -0500\"}"
+```
+
+## Usage
+
+Instrument by creating a `Progressrus` object with the `scope` and `total` amount of
+records to be processed:
+
+```ruby
+class MaintenanceProcessRecords
+  def self.perform(record_ids, user_id)
+    Record.where(id: record_ids)
+      .enum_for(:find_each)
+      .with_progress(scope: [:user, user_id], total: # get this somehow, unless you're on rails 4.1) do |record|
+      record.do_expensive_things
+    end
+  end
+end
+```
+
+You can also use the slightly more flexible lower-level API, which is useful in
+some cases:
+
+```ruby
+class MaintenanceProcessRecords
+  def self.perform(record_ids, user_id)
+    # Construct the pace object.
+    progress = Progressrus.new(scope: [:user, user_id], total: record_ids.count)
+
+    # Start processing the records!
+    Record.where(id: record_ids).find_each do |record|
+      begin
+        record.do_expensive_things
+
+        # Does a single tick, updates the data store every x seconds this is called.
+        progress.tick
+      rescue
+        # Increments the error count if the above failed
+        progress.error
+      end
+    end
+
+    # Force an update to the data store and set :completed_at to Time.now
+    progress.complete
+  end
+end
+```
+
+## Querying Ticks by scope
+
+To query for the progress of jobs for a specific scope:
+
+```ruby
+> Progressrus.all(["walrus", '1234'])
+#=> [
+  #<Progressrus::Progress:0x007f0fdc8ab888 @scope=["walrus", "1234"], @total=50, @id="narwhal", @interval=2, @params={:count=>0, :started_at=>"2013-12-12 18:09:44 +0000", :completed_at=>nil, :name=>"oemg-test-2"}, @count=0, @error_count=0, @started_at=2013-12-12 18:09:44 +0000, @persisted_at=2013-12-12 18:09:41 +0000, @store=#<Progressrus::Store::Redis:0x007f0fdc894c28 @redis=#<Redis client v3.0.6 for redis://127.0.0.1:6379/0>, @options={:expire=>1800, :prefix=>"progressrus"}>, @completed_at=nil>,
+  #<Progressrus::Progress:0x007f0fdc8ab4a0 @scope=["walrus", "1234"], @total=100, @id="oemg", @interval=2, @params={:count=>0, :started_at=>"2013-12-12 18:09:44 +0000", :completed_at=>nil, :name=>"oemg-test"}, @count=0, @error_count=0, @started_at=2013-12-12 18:09:44 +0000, @persisted_at=2013-12-12 18:09:41 +0000, @store=#<Progressrus::Store::Redis:0x007f0fdc894c28 @redis=#<Redis client v3.0.6 for redis://127.0.0.1:6379/0>, @options={:expire=>1800, :prefix=>"progressrus"}>, @completed_at=nil>
+]
+```
+
+The `Progressrus` objects contain useful methods such as `#percentage` to return how
+many percent done the job is and `#eta` to return a `Time` object estimation of
+when the job will be complete.  The scope is completely independent from the job
+itself, which means you can have jobs from multiple sources in the same scope.
+
+## Querying Progress by scope and id
+
+To query for the progress of a specific job:
+
+```ruby
+> Progressrus.find(["walrus", '1234'], 'narwhal')
+#=> #<Progressrus::Progress:0x007f0fdc8ab888 @scope=["walrus", "1234"], @total=50, @id="narwhal", @interval=2, @params={:count=>0, :started_at=>"2013-12-12 18:09:44 +0000", :completed_at=>nil, :name=>"oemg-test-2"}, @count=0, @error_count=0, @started_at=2013-12-12 18:09:44 +0000, @persisted_at=2013-12-12 18:09:41 +0000, @store=#<Progressrus::Store::Redis:0x007f0fdc894c28 @redis=#<Redis client v3.0.6 for redis://127.0.0.1:6379/0>, @options={:expire=>1800, :prefix=>"progressrus"}>, @completed_at=nil>
+```
+
+## Todo
+
+* Tighter Resque/Sidekiq/DJ integration
+* Rack interface
+* SQL adapter
+* Document adapter-specific options
+* Enumerable integration for higher-level API
+* Documentation on how to do sharding

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Dir.glob('tasks/*.rake').each { |r| load r}
+
+task :default => :test
+
+desc 'Run the test suite.'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/lib/progressrus.rb

@@ -0,0 +1,156 @@
+require 'json'
+require 'securerandom'
+require 'redis'
+require 'time'
+require_relative "progressrus/store"
+require_relative "progressrus/store/base"
+require_relative "progressrus/store/redis"
+require_relative "progressrus/core_ext/enumerable"
+
+class Progressrus
+  class << self
+    def stores
+      @@stores ||= Store.new(Store::Redis.new(::Redis.new(host: ENV["PROGRESSRUS_REDIS_HOST"] || "localhost")))
+    end
+
+    def scope(scope, store: :first)
+      stores.find_by_name(store).scope(scope)
+    end
+    alias_method :all, :scope
+
+    def find(scope, id, store: :first)
+      stores.find_by_name(store).find(scope, id)
+    end
+
+    def flush(scope, id = nil, store: :first)
+      stores.find_by_name(store).flush(scope, id)
+    end
+  end
+
+  attr_reader :name, :scope, :total, :id, :params, :store, :count,
+    :started_at, :completed_at, :failed_at, :stores, :error_count
+
+  alias_method :completed?, :completed_at
+  alias_method :started?,   :started_at
+  alias_method :failed?,    :failed_at
+
+  attr_writer :params
+
+  def initialize(scope: "progressrus", total: nil, name: nil,
+    id: SecureRandom.uuid, params: {}, stores: Progressrus.stores,
+    completed_at: nil, started_at: nil, count: 0, failed_at: nil,
+    error_count: 0, persist: false)
+
+    raise ArgumentError, "Total cannot be zero or negative." if total && total <= 0
+
+    @name         = name || id
+    @scope        = Array(scope).map(&:to_s)
+    @total        = total
+    @id           = id
+    @params       = params
+    @stores       = stores
+    @count        = count
+    @error_count  = error_count
+
+    @started_at   = parse_time(started_at)
+    @completed_at = parse_time(completed_at)
+    @failed_at    = parse_time(failed_at)
+
+    persist(force: true) if persist
+  end
+
+  def tick(ticks = 1, now: Time.now)
+    @started_at ||= now if ticks >= 1
+    @count += ticks
+    persist
+  end
+
+  def error(ticks = 1, now: Time.now)
+    @error_count ||= 0
+    @error_count += ticks
+  end
+
+  def count=(new_count, **args)
+    tick(new_count - @count, *args)
+  end
+
+  def complete(now: Time.now)
+    @started_at ||= now
+    @completed_at = now
+    persist(force: true)
+  end
+
+  def flush
+    stores.each { |store| store.flush(scope, id) }
+  end
+
+  def status
+    return :completed if completed?
+    return :failed if failed?
+    return :running if running?
+    :started
+  end
+
+  def running?
+    count > 0
+  end
+
+  def fail(now: Time.now)
+    @started_at ||= now
+    @failed_at = now
+    persist(force: true)
+  end
+
+  def to_serializeable
+    {
+      name:         name,
+      id:           id,
+      scope:        scope,
+      started_at:   started_at,
+      completed_at: completed_at,
+      failed_at:    failed_at,
+      count:        count,
+      total:        total,
+      params:       params,
+      error_count:  error_count
+    }
+  end
+
+  def total=(new_total)
+    raise ArgumentError, "Total cannot be zero or negative." if new_total <= 0
+    @total = new_total
+  end
+
+  def total
+    @total ||= 1
+  end
+
+  def elapsed(now: Time.now)
+    now - started_at
+  end
+
+  def percentage
+    count.to_f / total
+  end
+
+  def eta(now: Time.now)
+    return nil if count.to_i == 0
+
+    processed_per_second = (count.to_f / elapsed(now: now))
+    left = (total - count)
+    seconds_to_finished = left / processed_per_second
+    now + seconds_to_finished
+  end
+
+  private
+  def persist(force: false)
+    stores.each { |store| store.persist(self, force: force) }
+  end
+
+  def parse_time(time)
+    return Time.parse(time) if time.is_a?(String)
+    time
+  end
+end
+
+require 'progressrus/railtie' if defined?(Rails)

data/lib/progressrus/core_ext/enumerable.rb

@@ -0,0 +1,31 @@
+module Enumerable
+  def with_progress(**args, &block)
+    if block_given?
+      progresser = progress(args)
+      begin
+        ret = each { |*o|
+          res = yield(*o)
+          progresser.tick
+          res
+        }
+      rescue
+        progresser.fail
+        raise
+      end
+      progresser.complete
+      ret
+    else
+      enum_for(:with_progress, args)
+    end
+  end
+
+  private
+  def progress(args)
+    @progress ||= begin
+      # Lazily read the size, for some enumerable this may be quite expensive and
+      # using this method should come with a warning in the documentation.
+      total = self.size unless args[:total]
+      @progress = Progressrus.new({total: total}.merge(args))
+    end
+  end
+end

data/lib/progressrus/railtie.rb

@@ -0,0 +1,7 @@
+class Progressrus
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.expand_path('../../../tasks/redis_store.rake', __FILE__)
+    end
+  end
+end

data/lib/progressrus/server.rb

@@ -0,0 +1,11 @@
+require 'sinatra/base'
+
+class Progressrus
+  class Server < Sinatra::Base
+    get '/' do
+      "Hello World"
+    end
+
+    run! if app_file == $0
+  end
+end

data/lib/progressrus/store.rb

@@ -0,0 +1,24 @@
+class Progressrus
+  class Store < Array
+    def initialize(default)
+      @default = default
+      self << default
+    end
+
+    def default
+      @default
+    end
+
+    def default!
+      clear
+      self << default
+    end
+
+    def find_by_name(name)
+      return first if name == :first
+      return last  if name == :last
+
+      find { |store| store.name == name }
+    end
+  end
+end

data/lib/progressrus/store/base.rb

@@ -0,0 +1,23 @@
+class Progressrus
+  class Store
+    class NotImplementedError < StandardError; end
+
+    class Base
+      def persist(progress)
+        raise NotImplementedError
+      end
+
+      def scope(scope)
+        raise NotImplementedError
+      end
+
+      def find(scope, id)
+        raise NotImplementedError
+      end
+
+      def flush(scope, id = nil)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/progressrus/store/redis.rb

@@ -0,0 +1,61 @@
+class Progressrus
+  class Store
+    class Redis < Base
+      attr_reader :redis, :interval, :persisted_at, :prefix, :name
+
+      def initialize(instance, prefix: "progressrus", interval: 1, now: Time.now)
+        @name          = :redis
+        @redis         = instance
+        @persisted_ats = Hash.new({})
+        @interval      = interval
+        @prefix        = prefix
+      end
+
+      def persist(progress, now: Time.now, force: false)
+        if outdated?(progress) || force
+          redis.hset(key(progress.scope), progress.id, progress.to_serializeable.to_json)
+          @persisted_ats[progress.scope][progress.id] = now
+        end
+      end
+
+      def scope(scope)
+        scope = redis.hgetall(key(scope))
+        scope.each_pair { |id, value|
+          scope[id] = Progressrus.new(deserialize(value))
+        }
+      end
+
+      def find(scope, id)
+        value = redis.hget(key(scope), id)
+        return unless value
+
+        Progressrus.new(deserialize(value))
+      end
+
+      def flush(scope, id = nil)
+        if id
+          redis.hdel(key(scope), id)
+        else
+          redis.del(key(scope))
+        end
+      end
+
+      private
+      def key(scope)
+        "#{prefix}:#{scope.join(":")}"
+      end
+
+      def deserialize(value)
+        JSON.parse(value, symbolize_names: true)
+      end
+
+      def outdated?(progress, now: Time.now)
+        (now - interval).to_i >= persisted_at(progress).to_i
+      end
+
+      def persisted_at(progress)
+        @persisted_ats[progress.scope][progress.id]
+      end
+    end
+  end
+end

data/lib/progressrus/version.rb

@@ -0,0 +1,3 @@
+class Progressrus
+  VERSION = "0.0.1"
+end

data/progressrus.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'progressrus/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "progressrus"
+  spec.version       = Progressrus::VERSION
+  spec.authors       = ["Simon Eskildsen"]
+  spec.email         = ["sirup@sirupsen.com"]
+  spec.description   = %q{Monitor the progress of remote, long-running jobs.}
+  spec.summary       = %q{Monitor the progress of remote, long-running jobs.}
+  spec.homepage      = "https://github.com/Sirupsen/progressrus"
+  spec.license       = "MIT"
+
+  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 "redis", "~> 3.0"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "mocha", "~> 0.14"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "pry-byebug"
+end

data/tasks/redis_store.rake

@@ -0,0 +1,13 @@
+require_relative '../lib/progressrus'
+require 'rake'
+
+namespace :progressrus do
+  namespace :store do
+    desc "Flushes the current Progressrus.store."
+    task :flush, :environment do |t, args|
+      scope = *args
+      raise ArgumentError.new("Must pass [scope] to progressrus:store:flush[scope(,parts)] task.") unless scope.length > 0
+      Progressrus.stores.first.flush(scope) if Progressrus.stores.first
+    end
+  end
+end

data/test/integration_test.rb

@@ -0,0 +1,65 @@
+require_relative "test_helper"
+
+class IntegrationTest < Minitest::Unit::TestCase
+  def setup
+    @progress = Progressrus.new(scope: "walrus", total: 20)
+  end
+
+  def teardown
+    Progressrus.stores.first.flush(@progress.scope)
+  end
+
+  def test_create_tick_and_see_status_in_redis
+    @progress.tick
+
+    ticks = Progressrus.scope(["walrus"]).values
+
+    assert_equal 1, ticks.length
+
+    tick = ticks.first
+    assert_equal 20, tick.total
+    assert_equal 1, tick.count
+  end
+
+  def test_create_multiple_ticks_and_see_them_in_redis
+    @progress.tick
+
+    progress2 = Progressrus.new(scope: ["walrus"], total: 50)
+    progress2.tick
+
+    ticks = Progressrus.scope(["walrus"]).values
+
+    assert_equal 2, ticks.length
+
+    assert_equal [20, 50], ticks.map(&:total).sort
+    assert_equal [1,1], ticks.map(&:count)
+  end
+
+  def test_tick_on_enumerable
+    a = (0..10)
+    b = a.with_progress(scope: "walrus").map(&:to_i)
+
+    ticks = Progressrus.scope(["walrus"]).values
+
+    assert_equal a.to_a, b
+    assert_equal 1, ticks.length
+    assert_equal a.size, ticks.first.total
+    assert_equal a.size, ticks.first.count
+    assert_instance_of Time, ticks.first.completed_at
+  end
+
+  def test_tick_on_enumerable_calls_fail_on_exception
+    a = (0..10)
+
+    assert_raises ArgumentError do
+      a.with_progress(scope: "walrus").each do
+        raise ArgumentError
+      end
+    end
+
+    ticks = Progressrus.scope(["walrus"]).values
+
+    assert_equal 0, ticks.first.count
+    assert_instance_of Time, ticks.first.failed_at
+  end
+end

data/test/progressrus_test.rb

@@ -0,0 +1,377 @@
+require_relative "test_helper"
+
+class ProgressrusTest < Minitest::Unit::TestCase
+  def setup
+    @progress = Progressrus.new(scope: :progressrus, total: 100)
+  end
+
+  def teardown
+    Progressrus.stores.default!
+  end
+
+  def test_defaults_to_redis_store
+    assert_instance_of Progressrus::Store::Redis, Progressrus.stores.first
+  end
+
+  def test_add_to_store
+    Progressrus.stores << Progressrus::Store::Base.new
+    assert_instance_of Progressrus::Store::Base, Progressrus.stores[1]
+  end
+
+  def test_scope_should_initialize_with_symbol_or_string
+    progressrus = Progressrus.new(scope: :walrus)
+    assert_equal ['walrus'], progressrus.scope
+  end
+
+  def test_scope_should_initialize_with_array
+    progressrus = Progressrus.new(scope: ['walruses', 1])
+    assert_equal ['walruses', '1'], progressrus.scope
+  end
+
+  def test_initialize_with_name_should_use_name
+    progressrus = Progressrus.new(name: 'Wally')
+    assert_equal 'Wally', progressrus.name
+  end
+
+  def test_initialize_without_name_should_use_id
+    progressrus = Progressrus.new(id: 'oemg')
+    assert_equal 'oemg', progressrus.name
+  end
+
+  def test_initialize_with_persist
+    Progressrus.any_instance.expects(:persist).with(force: true).once
+    progressrus = Progressrus.new(persist: true)
+  end
+
+  def test_tick_should_set_started_at_if_not_already_set_and_tick_greater_than_zero
+    @progress.tick
+    assert @progress.started_at
+  end
+
+  def test_tick_should_not_set_started_at_if_zero_but_persist
+    @progress.expects(:persist).once
+    @progress.tick(0)
+    refute @progress.started_at
+  end
+
+  def test_tick_should_increment_count_by_one_if_not_specified
+    @progress.tick
+    assert_equal 1, @progress.count
+  end
+
+  def test_tick_should_increment_count
+    @progress.tick(50)
+    assert_equal 50, @progress.count
+  end
+
+  def test_error_should_not_call_tick
+    @progress.expects(:tick).never
+    @progress.error
+  end
+
+  def test_error_should_increment_error_count_by_one_if_amount_not_specified
+    @progress.error
+    assert_equal 1, @progress.error_count
+  end
+
+  def test_error_should_increment_error_count
+    @progress.error(25)
+    assert_equal 25, @progress.error_count
+  end
+
+  def test_eta_should_return_nil_if_no_count
+    progress = Progressrus.new
+    assert_equal nil, progress.eta
+  end
+
+  def test_eta_should_return_time_in_future_based_on_time_elapsed
+    time = Time.now
+    @progress.tick(10, now: time - 10)
+
+    eta = @progress.eta(now: time)
+
+    assert_equal time + 90, eta
+    assert_instance_of Time, eta
+  end
+
+  def test_percentage_should_return_the_percentage_as_a_fraction
+    @progress.tick(50)
+
+    assert_equal 0.5, @progress.percentage
+  end
+
+  def test_percentage_with_no_count_should_be_zero
+    assert_equal 0, @progress.percentage
+  end
+
+  def test_percentage_should_be_able_to_return_more_than_1
+    @progress.tick(120)
+
+    assert_equal 1.2, @progress.percentage
+  end
+
+  def test_percentage_should_be_0_if_total_0
+    assert_equal 0, @progress.percentage
+  end
+
+  def test_elapsed_should_return_the_delta_between_now_and_started_at
+    time = Time.now
+    @progress.tick(10, now: time - 10)
+
+    elapsed = @progress.elapsed(now: time)
+
+    assert_equal 10, elapsed
+  end
+
+  def test_to_serializeable_set_total_to_1_if_no_total
+    @progress.instance_variable_set(:@total, nil)
+    assert_equal 1, @progress.to_serializeable[:total]
+  end
+
+  def test_total_when_total_is_nil_is_1
+    @progress.instance_variable_set(:@total, nil)
+    assert_equal 1, @progress.total
+  end
+
+  def test_to_serializeable_should_return_a_hash_of_options
+    progress = Progressrus.new(
+      name: 'Wally',
+      id: 'oemg',
+      scope: ['walruses', 'forall'],
+      total: 100,
+      params: { job_id: 'oemg' }
+    )
+
+    serialization = {
+      name: 'Wally',
+      id: 'oemg',
+      scope: ['walruses', 'forall'],
+      total: 100,
+      params: { job_id: 'oemg' },
+      started_at: nil,
+      completed_at: nil,
+      failed_at: nil,
+      count: 0,
+      error_count: 0
+    }
+
+    assert_equal serialization, progress.to_serializeable
+  end
+
+  def test_complete_should_set_completed_at_and_persist
+    now = Time.now
+    @progress.expects(:persist)
+
+    @progress.complete(now: Time.now)
+
+    assert_equal now.to_i, @progress.completed_at.to_i
+  end
+
+  def test_should_not_be_able_to_set_total_to_0
+    assert_raises ArgumentError do
+      @progress.total = 0
+    end
+  end
+
+  def test_should_not_be_able_to_set_total_to_a_negative_number
+    assert_raises ArgumentError do
+      @progress.total = -1
+    end
+  end
+
+  def test_persist_yields_persist_to_each_store
+    mysql = mock()
+    mysql.expects(:persist).once
+
+    redis = Progressrus.stores.first
+    redis.expects(:persist).once
+
+    Progressrus.stores << mysql
+
+    @progress.tick
+  end
+
+  def test_should_not_be_able_to_initialize_with_total_0
+    assert_raises ArgumentError do
+      Progressrus.new(total: 0)
+    end
+  end
+
+  def test_should_not_be_able_to_initialize_with_total_as_a_negative_number
+    assert_raises ArgumentError do
+      Progressrus.new(total: -1)
+    end
+  end
+
+  def test_date_fields_should_deserialize_properly
+    @progress.tick(1)
+    @progress.complete
+    progress = Progressrus.find(@progress.scope, @progress.id)
+    assert_instance_of Time, progress.started_at
+    assert_instance_of Time, progress.completed_at
+  end
+
+
+  def test_default_scope_on_first
+    Progressrus.stores.clear
+
+    mysql = mock()
+    redis = mock()
+
+    Progressrus.stores << mysql
+    Progressrus.stores << redis
+
+    mysql.expects(:scope).once
+    redis.expects(:scope).never
+
+    Progressrus.scope(["oemg"])
+  end
+
+  def test_support_scope_last
+    Progressrus.stores.clear
+
+    mysql = mock()
+    redis = mock()
+
+    Progressrus.stores << mysql
+    Progressrus.stores << redis
+
+    mysql.expects(:scope).never
+    redis.expects(:scope).once
+
+    Progressrus.scope(["oemg"], store: :last)
+  end
+
+  def test_support_scope_by_name
+    Progressrus.stores.clear
+
+    mysql = mock()
+    redis = mock()
+
+    mysql.stubs(:name).returns(:mysql)
+    redis.stubs(:name).returns(:redis)
+
+    Progressrus.stores << mysql
+    Progressrus.stores << redis
+
+    mysql.expects(:scope).never
+    redis.expects(:scope).once
+
+    Progressrus.all(["oemg"], store: :redis)
+  end
+
+  def test_find_should_find_a_progressrus_by_scope_and_id
+    @progress.tick
+    progress = Progressrus.find(@progress.scope, @progress.id)
+
+    assert_instance_of Progressrus, progress
+  end
+
+  def test_completed_should_set_started_at_if_never_ticked
+    refute @progress.started_at
+    @progress.complete
+
+    assert_instance_of Time, @progress.started_at
+    assert_instance_of Time, @progress.completed_at
+  end
+
+  def test_able_to_set_count
+    @progress.count = 100
+    assert_equal 100, @progress.count
+  end
+
+  def test_call_persist_after_setting_count
+    @progress.expects(:persist).once
+
+    @progress.count = 100
+  end
+
+  def test_set_started_at_if_not_set
+    @progress.instance_variable_set(:@started_at, nil)
+    @progress.count = 100
+
+    assert_instance_of Time, @progress.started_at
+  end
+
+  def test_flush_should_flush_a_progressrus_by_scope_and_id
+    @progress.tick
+
+    Progressrus.flush(@progress.scope, @progress.id)
+
+    assert_nil Progressrus.find(@progress.scope, @progress.id)
+  end
+
+  def test_flush_should_flush_a_progressrus_scope_without_an_id
+    @progress.tick
+
+    Progressrus.flush(@progress.scope)
+
+    assert_equal({}, Progressrus.scope(@progress.scope))
+  end
+
+  def test_flush_instance_of_progressrus
+    @progress.tick
+
+    @progress.flush
+
+    assert_nil Progressrus.find(@progress.scope, @progress.id)
+  end
+
+  def test_call_with_progress_on_enumerable_as_final_in_chain
+    a = [1,2,3]
+    Progressrus.any_instance.expects(:tick).times(a.count)
+
+    b = []
+    a.each.with_progress do |number|
+      b << number
+    end
+
+    assert_equal a, b
+  end
+
+  def test_call_with_progress_on_enumerable_in_middle_of_chain
+    a = [1,2,3]
+    Progressrus.any_instance.expects(:tick).times(a.count)
+
+    b = a.each.with_progress.map { |number| number }
+
+    assert_equal a, b
+  end
+
+  def test_fail_should_set_failed_at_and_persist
+    now = Time.now
+    @progress.expects(:persist)
+
+    @progress.fail(now: now)
+
+    assert_equal now.to_i, @progress.failed_at.to_i
+  end
+
+  def test_status_returns_completed_when_job_is_completed
+    @progress.complete
+
+    assert_equal :completed, @progress.status
+  end
+
+  def test_status_returns_failed_when_job_has_failed
+    @progress.fail
+
+    assert_equal :failed, @progress.status
+  end
+
+  def test_status_returns_running_when_job_hasnt_failed_or_completed
+    @progress.tick
+
+    assert_equal :running, @progress.status
+  end
+
+  def test_status_returns_started_when_job_hasnt_ticked
+    assert_equal :started, @progress.status
+  end
+
+  def test_running_returns_true_when_job_has_ticked
+    @progress.tick
+
+    assert @progress.running?
+  end
+end

data/test/store/base_test.rb

@@ -0,0 +1,31 @@
+require_relative "../test_helper"
+
+class BaseStoreTest < Minitest::Unit::TestCase
+  def setup
+    @base = Progressrus::Store::Base.new
+  end
+
+  def test_persist_raises_not_implemented
+    assert_raises Progressrus::Store::NotImplementedError do
+      @base.persist(nil)
+    end
+  end
+
+  def test_scope_raises_not_implemented
+    assert_raises Progressrus::Store::NotImplementedError do
+      @base.scope(nil)
+    end
+  end
+
+  def test_find_raises_not_implemented
+    assert_raises Progressrus::Store::NotImplementedError do
+      @base.find(nil, nil)
+    end
+  end
+
+  def test_flush_raises_not_implemented
+    assert_raises Progressrus::Store::NotImplementedError do
+      @base.flush(nil)
+    end
+  end
+end

data/test/store/redis_test.rb

@@ -0,0 +1,100 @@
+require_relative "../test_helper"
+
+class RedisStoreTest < Minitest::Unit::TestCase
+  def setup
+  	@scope = ["walrus", "1234"]
+    @progress = Progressrus.new(
+      scope: @scope,
+      id: "oemg",
+      total: 100,
+      name: "oemg-name"
+    )
+
+  	@another_progress = Progressrus.new(
+      scope: @scope,
+      id: "oemg-two",
+      total: 100,
+      name: "oemg-name-two"
+    )
+
+    @store = Progressrus::Store::Redis.new(::Redis.new(host: ENV["PROGRESSRUS_REDIS_HOST"] || "localhost"))
+  end
+
+  def teardown
+  	@store.flush(@scope)
+  end
+
+  def test_persist_should_set_key_value_if_outdated
+  	@store.persist(@progress)
+
+  	assert_equal 'oemg', @store.find(['walrus', '1234'], 'oemg').id
+  end
+
+  def test_persist_should_not_set_key_value_if_not_outdated
+  	@store.redis.expects(:hset).once
+
+  	@store.persist(@progress)
+  	@store.persist(@progress)
+  end
+
+  def test_scope_should_return_progressruses_indexed_by_id
+  	@store.persist(@progress)
+  	@store.persist(@another_progress)
+  	actual = @store.scope(@scope)
+
+  	assert_equal @progress.id, actual['oemg'].id
+  	assert_equal @another_progress.id, actual['oemg-two'].id
+  end
+
+  def test_scope_should_return_an_empty_hash_if_nothing_is_found
+  	assert_equal({}, @store.scope(@scope))
+  end
+
+  def test_find_should_return_a_single_progressrus_for_scope_and_id
+  	@store.persist(@progress)
+
+  	assert_equal @progress.id, @store.find(@scope, 'oemg').id
+  end
+
+  def test_find_should_return_nil_if_nothing_is_found
+  	assert_equal nil, @store.find(@scope, 'oemg')
+  end
+
+  def test_flush_should_delete_by_scope
+  	@store.persist(@progress)
+  	@store.persist(@another_progress)
+
+  	@store.flush(@scope)
+
+  	assert_equal({}, @store.scope(@scope))
+  end
+
+  def test_flush_should_delete_by_scope_and_id
+	  @store.persist(@progress)
+  	@store.persist(@another_progress)
+
+	  @store.flush(@scope, 'oemg')
+
+  	assert_equal nil, @store.find(@scope, 'oemg')
+  	assert @store.find(@scope, 'oemg-two')
+  end
+
+  def test_initializes_name_to_redis
+  	assert_equal :redis, @store.name
+  end
+
+  def test_persist_should_not_write_by_default
+    @store.redis.expects(:hset).once
+
+    @store.persist(@progress)
+    @store.persist(@progress)
+  end
+
+  def test_persist_should_write_if_forced
+    @store.redis.expects(:hset).twice
+
+    @store.persist(@progress)
+    @store.persist(@progress, force: true)
+  end
+
+end

data/test/tasks/redis_store_rake_test.rb

@@ -0,0 +1,13 @@
+require_relative '../test_helper'
+
+class StoreRakeTest < Minitest::Unit::TestCase
+  def setup
+    load File.expand_path("../../../tasks/redis_store.rake", __FILE__)
+    Rake::Task.define_task(:environment)
+  end
+
+  def test_store_flush_should_flush_the_store_with_mutli_key_scopes
+    Progressrus::Store::Redis.any_instance.expects(:flush).with([1, 'test'])
+    Rake::Task['progressrus:store:flush'].invoke(1,'test')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'minitest/unit'
+require 'minitest/autorun'
+require "mocha/setup"
+require 'pry'
+require 'byebug'
+require 'pry-byebug'
+
+require_relative "../lib/progressrus.rb"

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: progressrus
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Simon Eskildsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+- !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: 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: 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'
+description: Monitor the progress of remote, long-running jobs.
+email:
+- sirup@sirupsen.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/progressrus.rb
+- lib/progressrus/core_ext/enumerable.rb
+- lib/progressrus/railtie.rb
+- lib/progressrus/server.rb
+- lib/progressrus/store.rb
+- lib/progressrus/store/base.rb
+- lib/progressrus/store/redis.rb
+- lib/progressrus/version.rb
+- progressrus.gemspec
+- tasks/redis_store.rake
+- test/integration_test.rb
+- test/progressrus_test.rb
+- test/store/base_test.rb
+- test/store/redis_test.rb
+- test/tasks/redis_store_rake_test.rb
+- test/test_helper.rb
+homepage: https://github.com/Sirupsen/progressrus
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Monitor the progress of remote, long-running jobs.
+test_files:
+- test/integration_test.rb
+- test/progressrus_test.rb
+- test/store/base_test.rb
+- test/store/redis_test.rb
+- test/tasks/redis_store_rake_test.rb
+- test/test_helper.rb