cache_box 0.0.1.pre.preview5 → 0.0.1.pre.preview10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2696a6649dcad9e95fd86414bda8423a5616be25bf26d305a453f2b51e451b6
-  data.tar.gz: fa0a66aa95e7fe7f22cfd4b432f17fd7f6fb803ad48ad4c867a0069da511ff21
+  metadata.gz: c4b54107afc5c33e03caf7c0f60ed4dd43146b3538d3ed6e4542bdfc2793e42c
+  data.tar.gz: 31a851d0e5ad63dc56ff016843c285807ccf4ac52d3ff758b13d792ef08a1964
 SHA512:
-  metadata.gz: 187afed6548e4184dd5b8468f4f12bc4de6a7ded494e17dca21429097054c9b57f362a4ad4ddc0e07e849f95c61641826b8f4920417791da6d22e59c063f5eea
-  data.tar.gz: c0a15319d4d63e135d216fe50cefc4256ccb0b465d642a7595b75c021733fee554c45d704cc3ecfe2d18f819e887c268fcaa9557d2ae1b59df110253f5b7d895
+  metadata.gz: d6c14872969670696c93c1beb26a4decbad6b6ad314046899a3ed1e78dfbc52ae5a7d14de2277480bb75a225610918316ca2f1a0c490c46b9cd49a4692f01de3
+  data.tar.gz: 2ef2894c33f1c0bba7a145da432992a89771bf9c85dc4590f8dcded28c4b395762a2008fd19ee96528bfab65fa0e20299a4d91db61846d2a2ae0968a9c7ace65

data/cache_box.gemspec

@@ -2,19 +2,34 @@
 
 Gem::Specification.new do |spec|
   spec.name    = 'cache_box'
-  spec.version = '0.0.1-preview5'
+  spec.version = '0.0.1-preview10'
   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,197 +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')
+  def has?(name = nil)
+    name ||= 'name'
+    validate_string_or_symbol!(name, 'name')
 
-    name = name.to_s
-    return true if @state[:result].key?(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')
+  def expire!(*names)
+    validate_array_of_string_or_symbol!(names, 'names')
 
-    name = name.to_s
-    @state[:complete].delete(name)
-    @state[:result].delete(name)
-    @state[:storage].delete(name)
-
-    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] if data.key?(:complete)
-      @state[:result][name]   = data[:result]   if data.key?(:result)
-      @state[:storage][name]  = data[:storage]  if data.key?(:storage)
-    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 = {}
-    data[:complete] = @state[:complete][name] if @state[:complete][name]
-    data[:result]   = @state[:result][name]   if @state[:result][name]
-    data[:storage]  = @state[:storage][name]  if @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