cache_box 0.0.1.pre.preview8 → 0.0.1.pre.preview9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2121d192ceadcf66d3ddcea5bbed36e4b90d5a34749e50b3f23672f61cb8a7ea
-  data.tar.gz: b5c009712c162fa0b761ff4b8998645aed7a09e467e6569fbc785b76ac166b78
+  metadata.gz: ca77451aab70af003b3741b676a17715213ffef2fc7caeeca3fce5aa960001a9
+  data.tar.gz: d43ccd11cb493f00c84131cf22eb69bf1e45794736ecf7bd650c043260effeb0
 SHA512:
-  metadata.gz: c4c45937029f9096bc8a8224decec4ab72faa98569043b1292d19e050826a92a8be57bdf26612e2800f82712654a444b03c66327e9a4baa5f8110444967397c3
-  data.tar.gz: 97dece56e4b22094415960285047136b15a1e02bea647b0c8b41eb2b762b661ef301f81b7acc376b27cc9027a4c86c7403971656cf824e9e8debc59439922ad0
+  metadata.gz: 7e83cbd1efe8a0027d8ba3c8032d94400b75c968d78df484390a9168dded13fcd9b8e2625f9ce2a1c605bf672c967018375f18f0ca35e2fb85f82e6d0e4ae489
+  data.tar.gz: 55771fa58ca7e96b81b45e26ba7164e45435d04bea0010f8ce76696861e056d6a3c9ca06633673834d28b1bd8eaf59a5ecaa90b421d348f2355cbc5054fef790

data/cache_box.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name    = 'cache_box'
-  spec.version = '0.0.1-preview8'
+  spec.version = '0.0.1-preview9'
   spec.authors = ['Codruț Constantin Gușoi']
   spec.email   = ['codrut.gusoi+rubygems.org@gmail.com']
 
@@ -20,12 +20,15 @@ Gem::Specification.new do |spec|
   spec.files = [
     'lib/cache_box.rb',
     'lib/cache_box/helper/validate.rb',
+    'lib/cache_box/scheduler/base.rb',
+    'lib/cache_box/scheduler/concurrent.rb',
     'lib/cache_box/scheduler/serial.rb',
     'lib/cache_box/storage/file.rb',
     'lib/cache_box/storage/memory.rb',
     'lib/cache_box/box.rb',
     'lib/cache_box/chain.rb',
     'lib/cache_box/graph.rb',
+    'lib/cache_box/stash.rb',
     'lib/cache_box/unit.rb',
     'LICENSE',
     'cache_box.gemspec'
@@ -36,4 +39,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry-byebug', '~> 3.9'
   spec.add_development_dependency 'rake',       '~> 13.0'
   spec.add_development_dependency 'rubocop',    '~> 0.88'
+  spec.add_development_dependency 'simplecov',  '~> 0.18'
 end

data/lib/cache_box.rb

@@ -8,9 +8,11 @@ require_relative 'cache_box/helper/validate'
 require_relative 'cache_box/storage/file'
 require_relative 'cache_box/storage/memory'
 
+require_relative 'cache_box/stash'
 require_relative 'cache_box/box'
 require_relative 'cache_box/unit'
 
+require_relative 'cache_box/scheduler/concurrent'
 require_relative 'cache_box/scheduler/serial'
 
 require_relative 'cache_box/chain'

data/lib/cache_box/scheduler/base.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+class CacheBox
+  module Scheduler
+    class Base
+      include CacheBox::Helper::Validate
+
+      # Input:
+      #
+      # logger = Logger
+      #
+      # Output: N/A
+      def initialize(logger: nil)
+        @logger = logger || Logger.new(STDOUT, level: Logger::INFO)
+
+        @lookup = {}
+        @needs  = {}
+        @feeds  = {}
+        @roots  = []
+        @leaves = []
+      end
+
+      # Input:
+      #
+      # edge = String |
+      #        Symbol |
+      #        Hash{String | Symbol => String | Symbol | Array[String | Symbol]}
+      #
+      # Output: self
+      def add(edge)
+        validate_edge!(edge)
+
+        needs_o = extract_needs(edge)
+        needs_s = needs_o.map(&:to_s)
+        needs_s.each_with_index do |arg, index|
+          next if @lookup.key?(arg)
+
+          raise(
+            ArgumentError,
+            "Graph does not contain required node #{needs_o[index].inspect}"
+          )
+        end
+
+        name_o = extract_name(edge)
+        name_s = name_o.to_s
+        if @lookup.key?(name_s)
+          raise(
+            ArgumentError,
+            "Graph already contains a node named #{name_o.inspect}"
+          )
+        end
+
+        @lookup[name_s] = name_o
+        @needs[name_s]  = needs_s
+
+        @leaves << name_s
+        needs_s.each do |need_s|
+          existing = @feeds[need_s]
+
+          @feeds[need_s] = existing ? existing << name_s : [name_s]
+          @leaves.delete(need_s)
+        end
+        @roots << name_s if needs_s == []
+
+        self
+      end
+
+      # Input:
+      #
+      # nodes = Hash{...String => Array[String | Symbol, Proc(Object)]}
+      # unit  = CacheBox::Unit
+      #
+      # Output: Hash{...String | Symbol => Object}
+      def run!(_nodes, _unit)
+        raise(
+          NotImplementedError,
+          'The `#run/2` method needs to be implemented in your subclass!'
+        )
+      end
+
+      private
+
+      # Input: String | Symbol | Hash[1 String | Symbol => Object]
+      #
+      # Output: String | Symbol
+      def extract_name(edge)
+        return edge.dup if edge.is_a?(Symbol) || edge.is_a?(String)
+
+        edge.keys.first.dup
+      end
+
+      # Input: ?
+      #
+      # Output: Array[...String | Symbol]
+      def extract_needs(edge)
+        return [] unless edge.is_a?(Hash)
+
+        name  = edge.keys.first
+        needs = edge[name]
+
+        if needs.is_a?(Array)
+          needs.map(&:dup)
+        else
+          [needs.dup]
+        end
+      end
+    end
+  end
+end

data/lib/cache_box/scheduler/concurrent.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+class CacheBox
+  module Scheduler
+    class Concurrent < Base
+
+      # TODO: write and use a thread pool
+
+      # Input:
+      #
+      # nodes = Hash{...String => Array[String | Symbol, Proc(Object)]}
+      # unit  = CacheBox::Unit
+      #
+      # Output: Hash{...String | Symbol => Object}
+      def run!(nodes, unit)
+        work    = @roots.dup
+        threads = []
+
+        condition = ConditionVariable.new
+
+        condition_lock = Mutex.new
+        scheduler_lock = Mutex.new
+
+        scheduler = Thread.new do
+          condition_lock.synchronize do
+            index = 0
+            loop do
+              stop = false
+
+              scheduler_lock.synchronize do
+                loop do
+                  break if index >= work.size
+
+                  name_s = work[index]
+                  thread = Thread.new do
+                    callable = nodes[name_s][1]
+                    needs    = @needs[name_s]
+                    input    = {}
+
+                    scheduler_lock.synchronize do
+                      needs.each do |need|
+                        next unless unit.has?(need)
+
+                        input[@lookup[need]] = unit.result(need)
+                      end
+                    end
+
+                    callable.call(input)
+
+                    scheduler_lock.synchronize do
+                      @feeds[name_s]&.each do |feed|
+                        work.push(feed) unless work.include?(feed)
+                      end
+
+                      threads.delete(Thread.current)
+                    end
+
+                    condition_lock.synchronize do
+                      condition.signal
+                    end
+                  end
+                  threads << thread
+
+                  index += 1
+                end
+
+                stop = true if threads.empty?
+              end
+
+              break if stop
+
+              condition.wait(condition_lock)
+            end
+          end
+        end
+
+        scheduler.join
+
+        result = {}
+        @leaves.each do |name_s|
+          next unless unit.has?(name_s)
+
+          result[@lookup[name_s]] = unit.result(name_s)
+        end
+        result
+      end
+    end
+  end
+end

data/lib/cache_box/scheduler/serial.rb

@@ -1,93 +1,52 @@
 # frozen_string_literal: true
 
+require_relative 'base'
+
 class CacheBox
   module Scheduler
-    class Serial
-      include CacheBox::Helper::Validate
-
+    class Serial < Base
       # Input:
       #
-      # logger = Logger
-      #
-      # Output: N/A
-      def initialize(logger: nil)
-        @logger = logger || Logger.new(STDOUT, level: Logger::INFO)
-
-        @edges  = {}
-        @names  = {}
-        @leaves = {}
-        @plan   = []
-      end
-
-      # Input:
-      #
-      # edge = String |
-      #        Symbol |
-      #        Hash{String | Symbol => String | Symbol | Array[String | Symbol]}
+      # nodes = Hash{...String => Array[String | Symbol, Proc(Object)]}
+      # unit  = CacheBox::Unit
       #
-      # Output: self
-      def add(edge)
-        validate_edge!(edge)
-
-        needs_o = extract_needs(edge)
-        needs_s = needs_o.map(&:to_s)
-        needs_s.each_with_index do |arg, index|
-          next if @edges.key?(arg)
-
-          raise(
-            ArgumentError,
-            "Graph does not contain required node #{needs_o[index].inspect}"
-          )
-        end
+      # Output: Hash{...String | Symbol => Object}
+      def run!(nodes, unit)
+        plan = @leaves.dup.reverse
 
-        name_o = extract_name(edge)
-        name_s = name_o.to_s
-        if @edges.key?(name_s)
-          raise(
-            ArgumentError,
-            "Graph already contains a node named #{name_o.inspect}"
-          )
-        else
-          @edges[name_s] = needs_s
-        end
-        @names[name_s] = name_o
+        plan_index = 0
+        loop do
+          name_s = plan[plan_index]
 
-        add_to_plan(name_s, needs_s)
+          unless unit.has?(name_s)
+            needs = @needs[name_s]
+            needs.reverse_each { |need| plan << need }
+          end
 
-        @leaves[name_s] = name_o
-        needs_s.each do |need_s|
-          @leaves.delete(need_s)
+          plan_index += 1
+          break if plan_index >= plan.size
         end
 
-        self
-      end
+        sequence = plan.reverse
+        sequence.each_with_index do |name_s, index|
+          next if unit.has?(name_s)
 
-      # Input:
-      #
-      # nodes = Hash{...String => Array[String | Symbol, Proc(Object)]}
-      # unit  = CacheBox::Unit
-      #
-      # Output: Hash{...String | Symbol => Object}
-      def run!(nodes, unit)
-        sequence = @plan.flatten
-        sequence.each_with_index do |name, index|
-          next if unit.has?(name)
-
-          callable = nodes[name][1]
-          needs    = @edges[name]
+          callable = nodes[name_s][1]
+          needs    = @needs[name_s]
           input    = {}
 
           needs.each do |need|
             next unless unit.has?(need)
 
-            input[@names[need]] = unit.result(need)
+            input[@lookup[need]] = unit.result(need)
           end
           callable.call(input)
 
           needs.each do |need|
             needed = false
+
             sequence[(index + 1)..-1].each do |item|
-              needed = true if @edges[item].include?(need)
+              needed = true if @needs[item].include?(need)
             end
 
             unit.clear(need) unless needed
@@ -95,65 +54,13 @@ class CacheBox
         end
 
         result = {}
-        @leaves.each do |name_s, name_o|
+        @leaves.each do |name_s|
           next unless unit.has?(name_s)
 
-          result[name_o] = unit.result(name_s)
+          result[@lookup[name_s]] = unit.result(name_s)
         end
         result
       end
-
-      private
-
-      # Input: ?
-      #
-      # Output: ?
-      def add_to_plan(name, from)
-        result = 0
-
-        from.each do |node|
-          @plan.each_with_index do |row, index|
-            next unless row.include?(node)
-
-            result = index >= result ? index + 1 : result
-            break
-          end
-        end
-
-        @plan.each do |row|
-          next unless row.include?(from)
-
-          row.push(name)
-          break
-        end
-
-        if (row = @plan[result])
-          row.push(name)
-        else
-          @plan.push([name])
-        end
-      end
-
-      # Input: String | Symbol | Hash[1 String | Symbol => Object]
-      #
-      # Output: String | Symbol
-      def extract_name(edge)
-        return edge if edge.is_a?(Symbol) || edge.is_a?(String)
-
-        edge.keys.first
-      end
-
-      # Input: ?
-      #
-      # Output: Array[...String | Symbol]
-      def extract_needs(edge)
-        return [] unless edge.is_a?(Hash)
-
-        name  = edge.keys.first
-        needs = edge[name]
-
-        needs.is_a?(Array) ? needs : [needs]
-      end
     end
   end
 end

data/lib/cache_box/stash.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class CacheBox
+  # A thread safe, in memory, key value storage.
+  #
+  # The object itself is thread safe but it's contents is not.
+  class Stash
+    def initialize(state = nil)
+      @lock  = Mutex.new
+      @state = state || {}
+    end
+
+    def [](key)
+      @lock.synchronize do
+        @state[key]
+      end
+    end
+
+    def []=(key, value)
+      @lock.synchronize do
+        @state[key] = value
+      end
+    end
+
+    def delete(key)
+      @lock.synchronize do
+        @state.delete(key)
+      end
+    end
+
+    def key?(key)
+      @lock.synchronize do
+        @state.key?(key)
+      end
+    end
+
+    def with
+      @lock.synchronize do
+        yield(@state)
+      end
+    end
+  end
+end

data/lib/cache_box/storage/file.rb

@@ -4,6 +4,8 @@ class CacheBox
   module Storage
     # A storage backed by files.
     class File
+      LOCK = Mutex.new
+
       # Input:
       #
       # namespace = Symbol | String # Default: 'namespace'
@@ -22,7 +24,9 @@ class CacheBox
 
       # Output: self
       def reset!
-        FileUtils.remove_entry_secure(@path, true)
+        LOCK.synchronize do
+          FileUtils.remove_entry_secure(@path, true)
+        end
 
         self
       end
@@ -37,10 +41,12 @@ class CacheBox
       def read!(name)
         validate_string!(name, 'name')
 
-        file = ::File.join(@path, name)
-        return unless ::File.exist?(file)
+        LOCK.synchronize do
+          file = ::File.join(@path, name)
+          return unless ::File.exist?(file)
 
-        Marshal.load(::File.read(file))
+          Marshal.load(::File.read(file))
+        end
       end
 
       # Input:
@@ -52,12 +58,14 @@ class CacheBox
       def write!(name, data)
         validate_string!(name, 'name')
 
-        FileUtils.mkdir_p(@path) unless Dir.exist?(@path)
-
         content = Marshal.dump(data)
         file    = ::File.join(@path, name)
 
-        ::File.write(file, content)
+        LOCK.synchronize do
+          FileUtils.mkdir_p(@path)
+
+          ::File.write(file, content)
+        end
 
         self
       end
@@ -70,8 +78,10 @@ class CacheBox
       def delete!(name)
         validate_string!(name, 'name')
 
-        file = ::File.join(@path, name)
-        FileUtils.remove_entry_secure(file, true)
+        LOCK.synchronize do
+          file = ::File.join(@path, name)
+          FileUtils.remove_entry_secure(file, true)
+        end
 
         self
       end
@@ -84,8 +94,10 @@ class CacheBox
       def has?(name)
         validate_string!(name, 'name')
 
-        file = ::File.join(@path, name)
-        ::File.file?(file)
+        LOCK.synchronize do
+          file = ::File.join(@path, name)
+          ::File.file?(file)
+        end
       end
 
       private

data/lib/cache_box/storage/memory.rb

@@ -4,6 +4,8 @@ class CacheBox
   module Storage
     # A storage backed by an in memory Hash.
     class Memory
+      LOCK = Mutex.new
+
       # Accepts a Hash or any Hash-like object as argument. Will use a plain Hash
       # if none provided.
       #
@@ -15,7 +17,9 @@ class CacheBox
       def initialize(state = nil)
         validate!(state)
 
-        @state = state || {}
+        LOCK.synchronize do
+          @state = state || {}
+        end
       end
 
       # Accepts a Hash or any Hash-like object as argument. Will use a plain Hash
@@ -40,7 +44,9 @@ class CacheBox
       def read!(name)
         validate_string!(name, 'name')
 
-        @state[name]
+        LOCK.synchronize do
+          @state[name]
+        end
       end
 
       # Input:
@@ -52,7 +58,9 @@ class CacheBox
       def write!(name, data)
         validate_string!(name, 'name')
 
-        @state[name] = data
+        LOCK.synchronize do
+          @state[name] = data
+        end
 
         self
       end
@@ -65,7 +73,9 @@ class CacheBox
       def delete!(name)
         validate_string!(name, 'name')
 
-        @state.delete(name)
+        LOCK.synchronize do
+          @state.delete(name)
+        end
 
         self
       end
@@ -78,7 +88,9 @@ class CacheBox
       def has?(name)
         validate_string!(name, 'name')
 
-        @state.key?(name)
+        LOCK.synchronize do
+          @state.key?(name)
+        end
       end
 
       private

data/lib/cache_box/unit.rb

@@ -4,6 +4,8 @@ class CacheBox
   class Unit
     include CacheBox::Helper::Validate
 
+    LOCK = Mutex.new
+
     # Input:
     #
     # namespace = String | Symbol # Default: :namespace
@@ -13,11 +15,14 @@ class CacheBox
       namespace ||= :namespace
       validate_string_or_symbol!(namespace, 'namespace')
 
-      @namespace = namespace
-      @logger    = logger  || Logger.new(STDOUT, level: Logger::INFO)
-      @storage   = storage || ::CacheBox::Storage::File.new(namespace: @namespace)
+      @namespace_o = namespace
+      @namespace_s = namespace.to_s
+      @logger      = logger  || Logger.new(STDOUT, level: Logger::INFO)
+      @storage     = storage || ::CacheBox::Storage::File.new(namespace: @namespace_o)
 
-      @state = { result: {}, stash: {} }
+      LOCK.synchronize do
+        @state = { result: ::CacheBox::Stash.new, stash: ::CacheBox::Stash.new }
+      end
     end
 
     # Input:
@@ -35,39 +40,50 @@ class CacheBox
 
       name_o = name
       name_s = name.to_s
+      box    = nil
 
-      return @state[:result][name_s] if @state[:result].key?(name_s)
+      LOCK.synchronize do
+        return @state[:result][name_s] if @state[:result].key?(name_s)
 
-      data = @storage.read!(name_s)
-      if data&.key?(:result)
-        @state[:result][name_s] = data[:result]
+        data = @storage.read!(name_s)
+        if data&.key?(:result)
+          @state[:result][name_s] = data[:result]
 
-        return data[:result]
-      elsif data&.key?(:stash)
-        @state[:stash][name_s] = data[:stash]
-      end
+          return data[:result]
+        elsif data&.key?(:stash)
+          @state[:stash][name_s] = data[:stash]
+        end
 
-      box = ::CacheBox::Box.new(
-        namespace: @namespace.dup,
-        name:      name_o.dup,
-        args:      args,
-        input:     input,
-        stash:     @state[:stash][name] || {},
-        logger:    @logger
-      )
+        box = ::CacheBox::Box.new(
+          namespace: @namespace_o.dup,
+          name:      name_o.dup,
+          args:      args,
+          input:     input,
+          stash:     @state[:stash][name] || ::CacheBox::Stash.new,
+          logger:    @logger
+        )
+      end
 
       begin
-        @state[:result][name_s] = block.call(box)
+        result = block.call(box)
+
+        LOCK.synchronize do
+          @state[:result][name_s] = result
+        end
       ensure
-        if @state[:result].key?(name_s)
-          @state[:stash].delete(name_s)
-          @storage.write!(name_s, { result: @state[:result][name_s] })
-        else
-          stash = box.stash
-          dump  = { stash: stash }
-
-          @state[:stash][name_s] = stash
-          @storage.write!(name_s, dump)
+        LOCK.synchronize do
+          if @state[:result].key?(name_s)
+            @state[:stash].delete(name_s)
+            @storage.write!(name_s, { result: @state[:result][name_s] })
+          else
+            stash = box.stash
+            stash.with do |state|
+              dump = { stash: state }
+
+              @state[:stash][name_s] = stash
+              @storage.write!(name_s, dump)
+            end
+          end
         end
       end
     end
@@ -82,17 +98,19 @@ class CacheBox
       validate_string_or_symbol!(name, 'name')
       name = name.to_s
 
-      return true if @state[:result].key?(name)
+      LOCK.synchronize do
+        return true if @state[:result].key?(name)
 
-      data = @storage.read!(name)
+        data = @storage.read!(name)
 
-      if data&.key?(:result)
-        @state[:result][name] = data[:result]
-      elsif data&.key?(:stash)
-        @state[:stash][name] = data[:stash]
-      end
+        if data&.key?(:result)
+          @state[:result][name] = data[:result]
+        elsif data&.key?(:stash)
+          @state[:stash][name] = data[:stash]
+        end
 
-      @state[:result].key?(name)
+        @state[:result].key?(name)
+      end
     end
 
     # Input:
@@ -105,17 +123,19 @@ class CacheBox
       validate_string_or_symbol!(name, 'name')
       name = name.to_s
 
-      return @state[:result][name] if @state[:result].key?(name)
+      LOCK.synchronize do
+        return @state[:result][name] if @state[:result].key?(name)
 
-      data = @storage.read!(name)
+        data = @storage.read!(name)
 
-      if data&.key?(:result)
-        @state[:result][name] = data[:result]
-      elsif data&.key?(:stash)
-        @state[:stash][name] = data[:stash]
-      end
+        if data&.key?(:result)
+          @state[:result][name] = data[:result]
+        elsif data&.key?(:stash)
+          @state[:stash][name] = data[:stash]
+        end
 
-      @state[:result][name]
+        @state[:result][name]
+      end
     end
 
     # Input:
@@ -127,16 +147,21 @@ class CacheBox
       validate_array_of_string_or_symbol!(names, 'names')
 
       if names.empty?
-        @state = { result: {}, stash: {} }
+        LOCK.synchronize do
+          @state = { result: ::CacheBox::Stash.new, stash: ::CacheBox::Stash.new }
 
-        @storage.reset!
+          @storage.reset!
+        end
       else
-        names.each do |name|
-          name = name.to_s
-          @state[:result].delete(name)
-          @state[:stash].delete(name)
+        LOCK.synchronize do
+          names.each do |name_o|
+            name_s = name_o.to_s
 
-          @storage.delete!(name)
+            @state[:result].delete(name_s)
+            @state[:stash].delete(name_s)
+
+            @storage.delete!(name_s)
+          end
         end
       end
 
@@ -152,13 +177,17 @@ class CacheBox
       validate_array_of_string_or_symbol!(names, 'names')
 
       if names.empty?
-        @state = { result: {}, stash: {} }
+        LOCK.synchronize do
+          @state = { result: ::CacheBox::Stash.new, stash: ::CacheBox::Stash.new }
+        end
       else
-        names.each do |name_o|
-          name_s = name_o.to_s
+        LOCK.synchronize do
+          names.each do |name_o|
+            name_s = name_o.to_s
 
-          @state[:result].delete(name_s)
-          @state[:stash].delete(name_s)
+            @state[:result].delete(name_s)
+            @state[:stash].delete(name_s)
+          end
         end
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cache_box
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre.preview8
+  version: 0.0.1.pre.preview9
 platform: ruby
 authors:
 - Codruț Constantin Gușoi
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-26 00:00:00.000000000 Z
+date: 2020-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -66,7 +66,21 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.88'
-description:
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+description: 
 email:
 - codrut.gusoi+rubygems.org@gmail.com
 executables: []
@@ -80,7 +94,10 @@ files:
 - lib/cache_box/chain.rb
 - lib/cache_box/graph.rb
 - lib/cache_box/helper/validate.rb
+- lib/cache_box/scheduler/base.rb
+- lib/cache_box/scheduler/concurrent.rb
 - lib/cache_box/scheduler/serial.rb
+- lib/cache_box/stash.rb
 - lib/cache_box/storage/file.rb
 - lib/cache_box/storage/memory.rb
 - lib/cache_box/unit.rb
@@ -90,7 +107,7 @@ licenses:
 metadata:
   homepage_uri: https://gitlab.com/sdwolfz/cache_box_rb
   source_code_uri: https://gitlab.com/sdwolfz/cache_box_rb
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -105,8 +122,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.1.3
-signing_key:
+rubygems_version: 3.1.2
+signing_key: 
 specification_version: 4
 summary: A simple, fast, and easy to use local cache.
 test_files: []