cache_box 0.0.1.pre.preview7 → 0.0.1.pre.preview8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e95404d4c91af3089b9d7d5628a3449010007df8784043b3668bc028b3b54c44
-  data.tar.gz: f8fd2afe635ceab0504a2c2aef6b4a27417ad5bdde6564a7a39fd8af9b22840d
+  metadata.gz: 2121d192ceadcf66d3ddcea5bbed36e4b90d5a34749e50b3f23672f61cb8a7ea
+  data.tar.gz: b5c009712c162fa0b761ff4b8998645aed7a09e467e6569fbc785b76ac166b78
 SHA512:
-  metadata.gz: 5c5a41a763a413cef9e294c01e94c18808f3e817bdd4baff7ac4b936225b19f3b7785a43981b9167066123d3fd0d5673e81f5b54c71586a83e64fa39c2907a99
-  data.tar.gz: b2029aca5aa9a5a36a82e7010cb5959787ee214d7a0b1739b8575e95e5c3cfb7a842fde3c9264449d1dcb45dc926180d9eb3bbfd18edcb4b30d0ba2d04a50206
+  metadata.gz: c4c45937029f9096bc8a8224decec4ab72faa98569043b1292d19e050826a92a8be57bdf26612e2800f82712654a444b03c66327e9a4baa5f8110444967397c3
+  data.tar.gz: 97dece56e4b22094415960285047136b15a1e02bea647b0c8b41eb2b762b661ef301f81b7acc376b27cc9027a4c86c7403971656cf824e9e8debc59439922ad0

data/cache_box.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name    = 'cache_box'
-  spec.version = '0.0.1-preview7'
+  spec.version = '0.0.1-preview8'
   spec.authors = ['Codruț Constantin Gușoi']
   spec.email   = ['codrut.gusoi+rubygems.org@gmail.com']
 
@@ -19,9 +19,14 @@ Gem::Specification.new do |spec|
 
   spec.files = [
     'lib/cache_box.rb',
+    'lib/cache_box/helper/validate.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/file_storage.rb',
-    'lib/cache_box/memory_storage.rb',
+    'lib/cache_box/graph.rb',
+    'lib/cache_box/unit.rb',
     'LICENSE',
     'cache_box.gemspec'
   ]

data/lib/cache_box.rb

@@ -3,62 +3,49 @@
 require 'fileutils'
 require 'logger'
 
+require_relative 'cache_box/helper/validate'
+
+require_relative 'cache_box/storage/file'
+require_relative 'cache_box/storage/memory'
+
+require_relative 'cache_box/box'
+require_relative 'cache_box/unit'
+
+require_relative 'cache_box/scheduler/serial'
+
 require_relative 'cache_box/chain'
-require_relative 'cache_box/file_storage'
-require_relative 'cache_box/memory_storage'
+require_relative 'cache_box/graph'
 
 class CacheBox
+  include CacheBox::Helper::Validate
+
   # Input:
   #
-  # namespace = String | Symbol # Default: 'namespace'
+  # namespace = String | Symbol # Default: :namespace
+  # logger    = Logger
+  # storage   = CacheBox::Storage::*
   #
   # Output: N/A
   def initialize(namespace = nil, logger: nil, storage: nil)
-    validate_symbol_or_string!(namespace, 'namespace')
+    namespace ||= :namespace
+    validate_string_or_symbol!(namespace, 'namespace')
 
-    @namespace = namespace&.to_s || 'namespace'
-    @logger    = logger  || Logger.new(STDOUT, level: Logger::INFO)
-    @storage   = storage || FileStorage.new(namespace: @namespace)
-    @state     = { result: {}, stash: {} }
+    @unit = ::CacheBox::Unit.new(namespace, logger: logger, storage: storage)
   end
 
   # Input:
   #
   # name   = String | Symbol # Default: 'name'
-  # args   = Array[...Object]
-  # &block = Proc(Hash{...Object => Object}, *args)
+  # args   = Object
+  # &block = Proc(CacheBox::Box)
   #
   # Output: Object # Anything the &block returns.
-  def with(name = nil, *args)
-    validate_symbol_or_string!(name, 'name')
-    unless block_given?
-      raise(ArgumentError, 'The `:with` method requires a block')
-    end
-
-    name = name&.to_s || 'name'
-    return @state[:result][name] if @state[:result].key?(name)
-
-    data = @storage.read!(name)
-    if data&.key?(:result)
-      @state[:result][name] = data[:result]
-
-      return data[:result]
-    elsif data&.key?(:stash)
-      @state[:stash][name] = data[:stash]
-    end
-
-    stash = @state[:stash][name] || {}
-    begin
-      @state[:result][name] = yield(stash, *args)
-    ensure
-      if @state[:result].key?(name)
-        @state[:stash].delete(name)
-        @storage.write!(name, { result: @state[:result][name] })
-      else
-        @state[:stash][name] = stash
-        @storage.write!(name, { stash: stash })
-      end
-    end
+  def with(name = nil, args = nil, &block)
+    name ||= 'name'
+    validate_string_or_symbol!(name, 'name')
+    validate_block_presence!(block, '#with')
+
+    @unit.with(name, args, nil, &block)
   end
 
   # Input:
@@ -67,20 +54,10 @@ class CacheBox
   #
   # Output: true | false
   def has?(name = nil)
-    validate_symbol_or_string!(name, 'name')
-
-    name = name&.to_s || 'name'
-    return true if @state[:result].key?(name)
+    name ||= 'name'
+    validate_string_or_symbol!(name, 'name')
 
-    data = @storage.read!(name)
-
-    if data&.key?(:result)
-      @state[:result][name] = data[:result]
-    elsif data&.key?(:stash)
-      @state[:stash][name] = data[:stash]
-    end
-
-    @state[:result].key?(name)
+    @unit.has?(name)
   end
 
   # Input:
@@ -89,59 +66,10 @@ class CacheBox
   #
   # Output: self
   def expire!(*names)
-    validate_array_of_symbol_or_string!(names, 'names')
-
-    if names.empty?
-      @state = { result: {}, stash: {} }
+    validate_array_of_string_or_symbol!(names, 'names')
 
-      @storage.reset!
-    else
-      names.each do |name|
-        name = name.to_s
-        @state[:result].delete(name)
-        @state[:stash].delete(name)
-
-        @storage.delete!(name)
-      end
-    end
+    @unit.expire!(*names)
 
     self
   end
-
-  private
-
-  # Input:
-  #
-  # arg  = String | Symbol
-  # name = String
-  #
-  # Output: N/A
-  def validate_symbol_or_string!(arg, name)
-    return if arg.nil? || arg.is_a?(Symbol) || arg.is_a?(String)
-
-    klass = arg.class
-    value = arg.inspect
-
-    raise(ArgumentError, "#{name} must be a Symbol or String, got #{klass}: #{value}")
-  end
-
-  # Input:
-  #
-  # arg  = Array[String | Symbol]
-  # name = String
-  #
-  # Output: N/A
-  def validate_array_of_symbol_or_string!(args, name)
-    args.each do |arg|
-      next if arg.is_a?(Symbol) || arg.is_a?(String)
-
-      klass = arg.class
-      value = arg.inspect
-
-      raise(
-        ArgumentError,
-        "#{name} must each be Symbol or String, got #{klass}: #{value} in #{args}"
-      )
-    end
-  end
 end

data/lib/cache_box/box.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class CacheBox
+  # A container for references needed during execution.
+  class Box
+    attr_reader :namespace, :name, :args, :input, :stash, :logger
+
+    def initialize(namespace:, name:, args:, input:, stash:, logger:)
+      @namespace = namespace
+      @name      = name
+      @args      = args
+      @input     = input
+      @stash     = stash
+      @logger    = logger
+    end
+  end
+end

data/lib/cache_box/chain.rb

@@ -2,43 +2,52 @@
 
 class CacheBox
   class Chain
+    include CacheBox::Helper::Validate
+
     # Input:
     #
     # namespace = String | Symbol # Default: 'namespace'
     #
     # Output: N/A
     def initialize(namespace = nil, logger: nil, storage: nil)
-      namespace ||= 'namespace'
-      logger    ||= Logger.new(STDOUT, level: Logger::INFO)
-      storage   ||= FileStorage.new(namespace: namespace)
+      namespace ||= :namespace
+      validate_string_or_symbol!(namespace, 'namespace')
+
+      logger  ||= Logger.new(STDOUT, level: Logger::INFO)
+      storage ||= ::CacheBox::Storage::File.new(namespace: namespace)
+
+      @unit   = ::CacheBox::Unit.new(namespace, logger: logger, storage: storage)
+      @chain  = []
+      @lookup = Set.new
 
-      @cache = ::CacheBox.new(namespace, logger: logger, storage: storage)
-      @chain = []
-      @set   = Set.new
+      @namespace = namespace
+      @logger    = logger
     end
 
     # Input:
     #
     # name   = String | Symbol
-    # args   = Array[...Object]
+    # input  = Object # Default: nil
     # &block = Proc(Hash{...Object => Object}, *args)
     #
     # Output: self
-    def add(name, *args, &block)
-      validate_add!(name, &block)
+    def add(name, args = nil, &block)
+      validate_string_or_symbol!(name, 'name')
+      validate_block_presence!(block, '#add')
 
-      string_name = name.to_s
-      if @set.include?(string_name)
+      name_o = name
+      name_s = name.to_s
+      if @lookup.include?(name_s)
         raise(
           ArgumentError,
-          "Chain already contains a step named #{name.inspect}"
+          "Chain already contains a step named #{name_o.inspect}"
         )
       else
-        @set << string_name
+        @lookup << name_s
       end
 
       @chain.push(
-        [name, args, proc { |*all| @cache.with(string_name, *all, &block) }]
+        [name_o, proc { |input| @unit.with(name_s, args, input, &block) }]
       )
 
       self
@@ -48,19 +57,19 @@ class CacheBox
     def run!
       work = []
 
-      @chain.reverse_each do |name, args, callable|
-        work.push([name, args, callable])
+      @chain.reverse_each do |name, callable|
+        work.push([name, callable])
 
-        break if @cache.has?(name)
+        break if @unit.has?(name)
       end
 
-      result = nil
-      work.reverse_each do |_name, args, callable|
-        input = []
-        input << result if result
-        input += args   if args
+      result   = nil
+      previous = nil
+      work.reverse_each do |name, callable|
+        result = callable.call(result)
 
-        result = callable.call(*input)
+        @unit.clear(previous) if previous
+        previous = name
       end
 
       result
@@ -72,33 +81,10 @@ class CacheBox
     #
     # Output: self
     def expire!(*names)
-      @cache.expire!(*names)
+      validate_array_of_string_or_symbol!(names, 'names')
+      @unit.expire!(*names)
 
       self
     end
-
-    private
-
-    # Input:
-    #
-    # name   = String | Symbol
-    # &block = Proc
-    #
-    # Output: N/A
-    def validate_add!(name, &block)
-      unless name.is_a?(Symbol) || name.is_a?(String)
-        klass = name.class
-        value = name.inspect
-
-        raise(
-          ArgumentError,
-          "name must be a Symbol or String, got #{klass}: #{value}"
-        )
-      end
-
-      return unless block.nil?
-
-      raise(ArgumentError, 'The `:add` method requires a block')
-    end
   end
 end

data/lib/cache_box/graph.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class CacheBox
+  class Graph
+    include CacheBox::Helper::Validate
+
+    # Input:
+    #
+    # namespace = String | Symbol # Default: 'namespace'
+    # scheduler = CacheBox::Scheduler::*
+    # storage   = CacheBox::Storage::*
+    # logger    = Logger
+    #
+    # Output: N/A
+    def initialize(namespace = nil, scheduler: nil, storage: nil, logger: nil)
+      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)
+      @scheduler = scheduler || ::CacheBox::Scheduler::Serial.new(logger: @logger)
+      @unit      = ::CacheBox::Unit.new(@namespace, logger: @logger, storage: @storage)
+
+      @nodes = {}
+    end
+
+    # Input:
+    #
+    # edge   = String |
+    #          Symbol |
+    #          Hash{String | Symbol => String | Symbol | Array[String | Symbol]}
+    # args   = Object
+    # &block = Proc(Hash{...Object => Object}, *args)
+    #
+    # Output: self
+    def node(edge, args = nil, &block)
+      validate_edge!(edge)
+      validate_block_presence!(block, '#node')
+
+      @scheduler.add(edge)
+      name_o = extract_name(edge)
+      name_s = name_o.to_s
+
+      @nodes[name_s] = [
+        name_o,
+        proc { |input| @unit.with(name_s, args, input, &block) }
+      ]
+
+      self
+    end
+
+    # Input: N/A
+    #
+    # Output: Object # Anything the last block in the chain returns.
+    def run!
+      @scheduler.run!(@nodes, @unit)
+    end
+
+    # Input:
+    #
+    # name = Array[String | Symbol] # Default: []
+    #
+    # Output: self
+    def expire!(*names)
+      validate_array_of_string_or_symbol!(names, 'names')
+      @unit.expire!(*names)
+
+      self
+    end
+
+    private
+
+    # Input:
+    #
+    # edge = String |
+    #        Symbol |
+    #        Hash{String | Symbol => String | Symbol | Array[String | Symbol]}
+    #
+    # Output: String
+    def extract_name(edge)
+      return edge.to_s if edge.is_a?(Symbol) || edge.is_a?(String)
+
+      edge.keys.first.to_s
+    end
+  end
+end