progressrus 0.1.6 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a654e74220bfd54eb96f2c18390e8fcc794ae937
-  data.tar.gz: db38bb7f163a7ef1d2cca42fde38a644464e0316
+SHA256:
+  metadata.gz: 564bda7bfb2cfd735379ef412a908303655e1fe2853cd666d6d6fcbcefca5a6b
+  data.tar.gz: 0acaae1e3e6cdd2d69be60b27dfbe5d5185af7f7d6677b5ad0e190918cbab43b
 SHA512:
-  metadata.gz: 80adef7173fa11523e3ea323333d8b4dd50cfdc9b88c41dc85ba718b9c2b5f0e25a97086f9e0e552e9b1878ac4c0e07aefd20e8d9370ca7ffe0f776d7d78a5b1
-  data.tar.gz: 2a4bdbef69f9f31d8675f922ff73d02325c1732d8fb24823b12b6765ca1451cb6f0176af7c45e08b817663d1fa65e613951300480a88941f2818fb045863cc08
+  metadata.gz: 417d841b14a93351ed90ff754706467c42e29663bd076d55b9d7e23bca8ceef7989095f8eab1ce14cfc97caf51ed9497079f79498c775a6f06a4a20358c7417a
+  data.tar.gz: 514c8bcf9fb63500629630255861d590c35cbbdb5ab05c4798a37d30a32ffe51b4a8c59d11cb3f53ccc5d86aafdb52bab48c0c23972596e2a6f96208b9eb557d

data/.travis.yml

@@ -2,5 +2,7 @@ language: ruby
 services:
   - redis-server
 rvm:
-  - 2.0.0
-  - 2.1.1
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7

data/lib/progressrus.rb

@@ -2,29 +2,75 @@ 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/store/progressbar"
 require_relative "progressrus/core_ext/enumerable"
 
 class Progressrus
+  @mutex = Mutex.new
+
+  class InvalidStoreError < StandardError
+    def initialize
+      message = <<~MSG
+        The store needs to implement `persist`, `scope`, `find` and `flush`
+        We have a base class that your store can inherit from:
+          Progressrus::Store::Base
+      MSG
+      super(message)
+    end
+  end
+
+  class StoreNotFoundError < StandardError
+    def initialize(store)
+      message = <<~MSG
+        The store `#{store}` does not exists.
+        Available stores: #{Progressrus.stores.keys.join(', ')}
+      MSG
+      super(message)
+    end
+  end
+
   class << self
+    attr_reader :mutex
+
+    def clear_stores
+      @stores = {}
+    end
+
     def stores
-      @@stores ||= Store.new(Store::Redis.new(::Redis.new(host: ENV["PROGRESSRUS_REDIS_HOST"] || "localhost")))
+      mutex.synchronize do
+        @stores ||= {
+          redis: Store::Redis.new(::Redis.new(host: ENV["PROGRESSRUS_REDIS_HOST"] || "localhost"))
+        }
+      end
     end
 
-    def scope(scope, store: :first)
-      stores.find_by_name(store).scope(scope)
+    def add_store(name, store)
+      validate_store!(store)
+      stores[name] = store
+    end
+
+    def scope(scope, store: :redis)
+      stores[store].scope(scope)
     end
     alias_method :all, :scope
 
-    def find(scope, id, store: :first)
-      stores.find_by_name(store).find(scope, id)
+    def find(scope, id, store: :redis)
+      stores[store].find(scope, id)
+    end
+
+    def flush(scope, id = nil, store: :redis)
+      stores[store].flush(scope, id)
     end
 
-    def flush(scope, id = nil, store: :first)
-      stores.find_by_name(store).flush(scope, id)
+    private
+
+    def validate_store!(store)
+      valid = Store::Base.new.public_methods(false).all? do |method|
+        store.respond_to?(method)
+      end
+      raise InvalidStoreError unless valid
     end
   end
 
@@ -38,7 +84,7 @@ class Progressrus
   attr_writer :params
 
   def initialize(scope: "progressrus", total: nil, name: nil,
-    id: SecureRandom.uuid, params: {}, stores: Progressrus.stores,
+    id: SecureRandom.uuid, params: {}, stores: nil,
     completed_at: nil, started_at: nil, count: 0, failed_at: nil,
     error_count: 0, persist: false, expires_at: nil, persisted: false)
 
@@ -49,7 +95,7 @@ class Progressrus
     @total        = total
     @id           = id
     @params       = params
-    @stores       = stores
+    @stores       = extract_stores(stores)
     @count        = count
     @error_count  = error_count
 
@@ -84,7 +130,7 @@ class Progressrus
   end
 
   def flush
-    stores.each { |store| store.flush(scope, id) }
+    stores.each_value { |store| store.flush(scope, id) }
   end
 
   def status
@@ -160,11 +206,23 @@ class Progressrus
 
   private
 
+  def extract_stores(stores)
+    return Progressrus.stores unless stores
+
+    Array(stores).each_with_object({}) do |store, hash|
+      stored_found = Progressrus.stores[store]
+      raise StoreNotFoundError, store unless stored_found
+
+      hash[store] = stored_found
+    end
+  end
+
   def persist(force: false)
-    stores.each do |store|
+    stores.each_value do |store|
       begin
         store.persist(self, force: force, expires_at: expires_at)
-      rescue Progressrus::Store::BackendError => e
+      rescue Progressrus::Store::BackendError
+        # noop
       end
     end
     @persisted = true

data/lib/progressrus/core_ext/enumerable.rb

@@ -1,5 +1,5 @@
 module Enumerable
-  def with_progress(**args, &block)
+  def with_progress(args = {}, &block)
     if block_given?
       progresser = progress(args)
       begin
@@ -25,7 +25,7 @@ module Enumerable
       # 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))
+      @progress = Progressrus.new(total: total, **args)
     end
   end
 end

data/lib/progressrus/store/redis.rb

@@ -3,7 +3,7 @@ class Progressrus
     class Redis < Base
       BACKEND_EXCEPTIONS = [ ::Redis::BaseError ]
 
-      attr_reader :redis, :interval, :persisted_at, :prefix, :name
+      attr_reader :redis, :interval, :prefix, :name
 
       def initialize(instance, prefix: "progressrus", interval: 1, now: Time.now)
         @name          = :redis
@@ -31,7 +31,7 @@ class Progressrus
       def scope(scope)
         scope = redis.hgetall(key(scope))
         scope.each_pair { |id, value|
-          scope[id] = Progressrus.new(deserialize(value))
+          scope[id] = Progressrus.new(**deserialize(value))
         }
       rescue *BACKEND_EXCEPTIONS => e
         raise Progressrus::Store::BackendError.new(e)
@@ -41,7 +41,7 @@ class Progressrus
         value = redis.hget(key(scope), id)
         return unless value
 
-        Progressrus.new(deserialize(value))
+        Progressrus.new(**deserialize(value))
       rescue *BACKEND_EXCEPTIONS => e
         raise Progressrus::Store::BackendError.new(e)
       end
@@ -59,7 +59,11 @@ class Progressrus
       private
 
       def key(scope)
-        "#{prefix}:#{scope.join(":")}"
+        if prefix.respond_to?(:call)
+          prefix.call(scope)
+        else
+          "#{prefix}:#{scope.join(":")}"
+        end
       end
 
       def deserialize(value)

data/lib/progressrus/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Progressrus
-  VERSION = "0.1.6"
+  VERSION = '1.0.2'
 end

data/progressrus.gemspec

@@ -18,10 +18,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "redis", "~> 3.0"
+  spec.add_dependency "redis", ">= 3.0"
   spec.add_dependency "ruby-progressbar", "~> 1.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"

data/tasks/redis_store.rake

@@ -7,7 +7,7 @@ namespace :progressrus do
     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
+      Progressrus.stores[:redis].flush(scope) if Progressrus.stores[:redis]
     end
   end
 end

data/test/integration_test.rb

@@ -6,7 +6,7 @@ class IntegrationTest < Minitest::Test
   end
 
   def teardown
-    Progressrus.stores.first.flush(@progress.scope)
+    Progressrus.stores[:redis].flush(@progress.scope)
   end
 
   def test_create_tick_and_see_status_in_redis

data/test/progressrus_test.rb

@@ -6,16 +6,23 @@ class ProgressrusTest < Minitest::Test
   end
 
   def teardown
-    Progressrus.stores.default!
+    Progressrus.clear_stores
+    Progressrus.add_store(:redis, Progressrus::Store::Redis.new(::Redis.new(host: ENV["PROGRESSRUS_REDIS_HOST"] || "localhost")))
   end
 
   def test_defaults_to_redis_store
-    assert_instance_of Progressrus::Store::Redis, Progressrus.stores.first
+    assert_instance_of Progressrus::Store::Redis, Progressrus.stores[:redis]
   end
 
   def test_add_to_store
-    Progressrus.stores << Progressrus::Store::Base.new
-    assert_instance_of Progressrus::Store::Base, Progressrus.stores[1]
+    Progressrus.add_store(:test, Progressrus::Store::Base.new)
+    assert_instance_of Progressrus::Store::Base, Progressrus.stores[:test]
+  end
+
+  def test_add_store_raise_error_when_invalid_store
+    assert_raises(Progressrus::InvalidStoreError) do
+      Progressrus.add_store(:test, mock)
+    end
   end
 
   def test_scope_should_initialize_with_symbol_or_string
@@ -33,6 +40,37 @@ class ProgressrusTest < Minitest::Test
     assert_equal 'Wally', progressrus.name
   end
 
+  def test_not_passing_stores_default_to_all_stores
+    progressrus = Progressrus.new(scope: ['walruses', 1])
+    assert_equal Progressrus.stores, progressrus.stores
+  end
+
+  def test_passing_stores
+    mysql = mock_store
+    Progressrus.add_store(:mysql, mysql)
+    progressrus = Progressrus.new(scope: ['walruses', 1], stores: :mysql)
+    assert_equal({ mysql: mysql }, progressrus.stores)
+  end
+
+  def test_passing_multiple_stores
+    Progressrus.clear_stores
+
+    mysql = mock_store
+    redis = mock_store
+
+    Progressrus.add_store(:mysql, mysql)
+    Progressrus.add_store(:redis, redis)
+
+    progressrus = Progressrus.new(scope: ['walruses', 1], stores: %i(mysql redis))
+    assert_equal({ mysql: mysql, redis: redis }, progressrus.stores)
+  end
+
+  def test_passing_non_existing_store_raises_error
+    assert_raises(Progressrus::StoreNotFoundError) do
+      Progressrus.new(scope: ['walruses', 1], stores: :not_found)
+    end
+  end
+
   def test_initialize_without_name_should_use_id
     progressrus = Progressrus.new(id: 'oemg')
     assert_equal 'oemg', progressrus.name
@@ -196,19 +234,20 @@ class ProgressrusTest < Minitest::Test
   end
 
   def test_persist_yields_persist_to_each_store
-    mysql = mock()
+    mysql = mock_store
     mysql.expects(:persist).once
 
-    redis = Progressrus.stores.first
+    redis = Progressrus.stores[:redis]
     redis.expects(:persist).once
 
-    Progressrus.stores << mysql
+    Progressrus.add_store(:mysql, mysql)
 
-    @progress.tick
+    progress = Progressrus.new(scope: :progressrus, total: 100)
+    progress.tick
   end
 
   def test_tick_and_complete_dont_raise_if_store_is_unavailable
-    store = Progressrus.stores.first
+    store = Progressrus.stores[:redis]
     store.redis.expects(:hset).at_least_once.raises(::Redis::BaseError)
     @progress.tick
     @progress.complete
@@ -234,47 +273,32 @@ class ProgressrusTest < Minitest::Test
   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_default_scope_redis_store
+    Progressrus.clear_stores
 
-  def test_support_scope_last
-    Progressrus.stores.clear
+    mysql = mock_store
+    redis = mock_store
 
-    mysql = mock()
-    redis = mock()
-
-    Progressrus.stores << mysql
-    Progressrus.stores << redis
+    Progressrus.add_store(:mysql, mysql)
+    Progressrus.add_store(:redis, redis)
 
     mysql.expects(:scope).never
     redis.expects(:scope).once
 
-    Progressrus.scope(["oemg"], store: :last)
+    Progressrus.scope(["oemg"])
   end
 
   def test_support_scope_by_name
-    Progressrus.stores.clear
+    Progressrus.clear_stores
 
-    mysql = mock()
-    redis = mock()
+    mysql = mock_store
+    redis = mock_store
 
     mysql.stubs(:name).returns(:mysql)
     redis.stubs(:name).returns(:redis)
 
-    Progressrus.stores << mysql
-    Progressrus.stores << redis
+    Progressrus.add_store(:mysql, mysql)
+    Progressrus.add_store(:redis, redis)
 
     mysql.expects(:scope).never
     redis.expects(:scope).once
@@ -427,4 +451,10 @@ class ProgressrusTest < Minitest::Test
 
     refute progress.expired?(now: time)
   end
+
+  private
+
+  def mock_store
+    Progressrus::Store::Base.new
+  end
 end

data/test/store/redis_test.rb

@@ -1,6 +1,11 @@
 require_relative "../test_helper"
 
 class RedisStoreTest < Minitest::Test
+  class PrefixClass
+    def self.call(scope)
+      "custom_prefix:#{scope.join(':')}"
+    end
+  end
   def setup
   	@scope = ["walrus", "1234"]
     @progress = Progressrus.new(
@@ -17,11 +22,19 @@ class RedisStoreTest < Minitest::Test
       name: "oemg-name-two"
     )
 
-    @store = Progressrus::Store::Redis.new(::Redis.new(host: ENV["PROGRESSRUS_REDIS_HOST"] || "localhost"))
+    @redis = ::Redis.new(host: ENV["PROGRESSRUS_REDIS_HOST"] || "localhost")
+
+    @store = Progressrus::Store::Redis.new(@redis)
   end
 
   def teardown
-  	@store.flush(@scope)
+    @store.flush(@scope)
+  end
+
+  def test_prefix_can_be_a_proc
+    store = Progressrus::Store::Redis.new(@redis, prefix: PrefixClass)
+    store.persist(@progress)
+    refute_empty(@redis.hgetall('custom_prefix:walrus:1234'))
   end
 
   def test_persist_should_set_key_value_if_outdated
@@ -99,5 +112,4 @@ class RedisStoreTest < Minitest::Test
     @store.persist(@progress)
     @store.persist(@progress, force: true)
   end
-
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: progressrus
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 1.0.2
 platform: ruby
 authors:
 - Simon Eskildsen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-30 00:00:00.000000000 Z
+date: 2020-05-25 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
@@ -38,20 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.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
@@ -153,7 +139,6 @@ files:
 - 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/progressbar.rb
 - lib/progressrus/store/redis.rb
@@ -185,8 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Monitor the progress of remote, long-running jobs.

data/lib/progressrus/store.rb

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