cache_box 0.0.1.pre.preview4 → 0.0.1.pre.preview9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7a45edfdfa06cb3d977c5329ac5510a4c5a9a8baa56246f74afe7c33ec5f987
-  data.tar.gz: fbfca06a3ec00307db2e79428f38e8ba2b92b70853ad8df067c39cb916430664
+  metadata.gz: ca77451aab70af003b3741b676a17715213ffef2fc7caeeca3fce5aa960001a9
+  data.tar.gz: d43ccd11cb493f00c84131cf22eb69bf1e45794736ecf7bd650c043260effeb0
 SHA512:
-  metadata.gz: 357b4f7e1a1792adf8366b97e58048b2acd102d3d6fbf5628f57eceb89e336ebbbad50d8dab335d34a15b1e88458c73e6c502542a6005c7549233a0e154c1c96
-  data.tar.gz: 9fad5c9ee9fa09ee7688904d7e03e1d4fd30c10229b2401ff711cf24437c51e30653d60dcaef30722199ff60c8e23cd42aaeb159d13e7e4baec4c7d359f5c31e
+  metadata.gz: 7e83cbd1efe8a0027d8ba3c8032d94400b75c968d78df484390a9168dded13fcd9b8e2625f9ce2a1c605bf672c967018375f18f0ca35e2fb85f82e6d0e4ae489
+  data.tar.gz: 55771fa58ca7e96b81b45e26ba7164e45435d04bea0010f8ce76696861e056d6a3c9ca06633673834d28b1bd8eaf59a5ecaa90b421d348f2355cbc5054fef790

data/cache_box.gemspec

@@ -2,19 +2,34 @@
 
 Gem::Specification.new do |spec|
   spec.name    = 'cache_box'
-  spec.version = '0.0.1-preview4'
+  spec.version = '0.0.1-preview9'
   spec.authors = ['Codruț Constantin Gușoi']
-  spec.email   = ['codrut.gusoi+git-commit@gmail.com']
+  spec.email   = ['codrut.gusoi+rubygems.org@gmail.com']
 
-  spec.summary  = 'A simple, fast, and easy to use file backed cache.'
+  spec.summary  = 'A simple, fast, and easy to use local cache.'
   spec.homepage = 'https://gitlab.com/sdwolfz/cache_box_rb'
-  spec.license  = 'BSD 3-clause'
+  spec.license  = 'BSD-3-Clause'
+
+  spec.metadata = {
+    'homepage_uri'    => 'https://gitlab.com/sdwolfz/cache_box_rb',
+    'source_code_uri' => 'https://gitlab.com/sdwolfz/cache_box_rb'
+  }
 
   spec.required_ruby_version = Gem::Requirement.new('>= 2.5.0')
 
   spec.files = [
     'lib/cache_box.rb',
-    'lib/cache_box_chain.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'
   ]
@@ -24,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

@@ -1,198 +1,77 @@
 # frozen_string_literal: true
 
 require 'fileutils'
-require_relative 'cache_box_chain'
+require 'logger'
 
-class CacheBox
-  # Input:
-  #
-  # namespace = String | Symbol # Default: :namespace
-  #
-  # Output: N/A
-  def initialize(namespace = :namespace)
-    validate!(namespace, 'namespace')
+require_relative 'cache_box/helper/validate'
 
-    @namespace = namespace
-    @state     = { complete: {}, result: {}, storage: {} }
-    @root      = File.join(Dir.pwd, '.cache')
-    @directory = File.join(@root, @namespace.to_s)
-  end
+require_relative 'cache_box/storage/file'
+require_relative 'cache_box/storage/memory'
 
-  # Input:
-  #
-  # namespace = String | Symbol # Default: :namespace
-  #
-  # Output: self
-  def reset!(namespace = :namespace)
-    initialize(namespace)
+require_relative 'cache_box/stash'
+require_relative 'cache_box/box'
+require_relative 'cache_box/unit'
 
-    self
-  end
+require_relative 'cache_box/scheduler/concurrent'
+require_relative 'cache_box/scheduler/serial'
+
+require_relative 'cache_box/chain'
+require_relative 'cache_box/graph'
+
+class CacheBox
+  include CacheBox::Helper::Validate
 
   # Input:
   #
-  # name   = String | Symbol # Default: :name
-  # args   = Array[...Object]
-  # &block = Proc(*args)
+  # namespace = String | Symbol # Default: :namespace
+  # logger    = Logger
+  # storage   = CacheBox::Storage::*
   #
-  # Output: Object # Anything the &block returns.
-  def with(name = :name, *args)
-    validate!(name, 'name')
-
-    name   = name.to_s
-    file   = File.join(@directory, name)
-    result = find!(name, file)
-    return result unless result.nil?
-
-    result = yield(*args)
-
-    @state[:complete][name] = true
-    @state[:result][name]   = result
-    @state[:storage].delete(name)
-    store!(name, file)
+  # Output: N/A
+  def initialize(namespace = nil, logger: nil, storage: nil)
+    namespace ||= :namespace
+    validate_string_or_symbol!(namespace, 'namespace')
 
-    result
+    @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)
+  # name   = String | Symbol # Default: 'name'
+  # args   = Object
+  # &block = Proc(CacheBox::Box)
   #
   # Output: Object # Anything the &block returns.
-  def with_many(name = :name, *args)
-    validate!(name, 'name')
-
-    name   = name.to_s
-    file   = File.join(@directory, name)
-    result = find!(name, file)
-    return result unless result.nil?
-
-    storage = @state[:storage][name] || {}
-    begin
-      result = yield(storage, *args)
-
-      @state[:complete][name] = true
-      @state[:result][name]   = result
-      @state[:storage].delete(name)
-      store!(name, file)
-
-      result
-    ensure
-      unless @state[:complete][name]
-        @state[:storage][name] = storage
-      end
-
-      store!(name, file)
-    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:
   #
-  # name = String | Symbol # Default: :name
+  # name = String | Symbol # Default: 'name'
   #
   # Output: true | false
-  def has?(name = :name)
-    validate!(name, 'name')
-
-    name = name.to_s
-    return true if @state[:result].key?(name)
+  def has?(name = nil)
+    name ||= 'name'
+    validate_string_or_symbol!(name, 'name')
 
-    file = File.join(@directory, name)
-    load!(name, file)
-
-    @state[:result].key?(name)
-  end
-
-  # Output: self
-  def expire!
-    @state = { complete: {}, result: {}, storage: {} }
-    FileUtils.remove_entry_secure(@directory, true)
-
-    self
+    @unit.has?(name)
   end
 
   # Input:
   #
-  # name = String | Symbol # Default: :name
+  # name = Array[String | Symbol] # Default: []
   #
   # Output: self
-  def expire(name = :name)
-    validate!(name, 'name')
-
-    name = name.to_s
-    @state[:complete].delete(name)
-    @state[:result].delete(name)
-    @state[:storage].delete(name)
+  def expire!(*names)
+    validate_array_of_string_or_symbol!(names, 'names')
 
-    file = File.join(@directory, name)
-    FileUtils.remove_entry_secure(file, true)
+    @unit.expire!(*names)
 
     self
   end
-
-  private
-
-  # Input:
-  #
-  # arg  = String | Symbol
-  # name = String
-  #
-  # Output: N/A
-  def validate!(arg, name)
-    return if 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:
-  #
-  # name = String
-  # file = String # Path
-  #
-  # Output: N/A
-  def load!(name, file)
-    if File.exist?(file)
-      data = Marshal.load(File.read(file))
-
-      @state[:complete][name] = data[:complete]
-      @state[:result][name]   = data[:result]
-      @state[:storage][name]  = data[:storage] unless data[:complete]
-    end
-  end
-
-  # Input:
-  #
-  # name = String
-  # file = String # Path
-  #
-  # Output: Object # Anything
-  def find!(name, file)
-    load!(name, file)
-
-    @state[:result][name]
-  end
-
-  # Input:
-  #
-  # file = String # Path
-  #
-  # Output: N/A
-  def store!(name, file)
-    data = {
-      complete: @state[:complete][name],
-      result:   @state[:result][name],
-    }
-    data[:storage] = @state[:storage][name] unless @state[:complete][name]
-
-    content = Marshal.dump(data)
-
-    directory = File.dirname(file)
-    FileUtils.mkdir_p(directory) unless Dir.exist?(directory)
-    File.write(file, content)
-  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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+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
+      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
+
+      @namespace = namespace
+      @logger    = logger
+    end
+
+    # Input:
+    #
+    # name   = String | Symbol
+    # input  = Object # Default: nil
+    # &block = Proc(Hash{...Object => Object}, *args)
+    #
+    # Output: self
+    def add(name, args = nil, &block)
+      validate_string_or_symbol!(name, 'name')
+      validate_block_presence!(block, '#add')
+
+      name_o = name
+      name_s = name.to_s
+      if @lookup.include?(name_s)
+        raise(
+          ArgumentError,
+          "Chain already contains a step named #{name_o.inspect}"
+        )
+      else
+        @lookup << name_s
+      end
+
+      @chain.push(
+        [name_o, proc { |input| @unit.with(name_s, args, input, &block) }]
+      )
+
+      self
+    end
+
+    # Output: Object # Anything the last block in the chain returns.
+    def run!
+      work = []
+
+      @chain.reverse_each do |name, callable|
+        work.push([name, callable])
+
+        break if @unit.has?(name)
+      end
+
+      result   = nil
+      previous = nil
+      work.reverse_each do |name, callable|
+        result = callable.call(result)
+
+        @unit.clear(previous) if previous
+        previous = name
+      end
+
+      result
+    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
+  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