cache_box 0.0.1.pre.preview3 → 0.0.1.pre.preview8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 111176139c5bc21c2938a934ceda7d643ad1dedeed2055c7bf53782d7eabd599
-  data.tar.gz: ebcb405c0f2de33d53ae26d758a6f80c049793fe0dda8db1c482ea6660ddb455
+  metadata.gz: 2121d192ceadcf66d3ddcea5bbed36e4b90d5a34749e50b3f23672f61cb8a7ea
+  data.tar.gz: b5c009712c162fa0b761ff4b8998645aed7a09e467e6569fbc785b76ac166b78
 SHA512:
-  metadata.gz: 51b2fd10d3484697d46ea07ec50d5a5ff6304f3abc22ed77546bc3702410519b38c0c47e549d183f1c74e860a170715fdef4c127b1cf9da2aaf665f0d88a7ef5
-  data.tar.gz: 67ee7653c76f8bcc9b20af7c461d9bafac6408852a6a1279eb033ff22eafbfbd7fc33dfff421a6131a5c15967e29e7604c7007d6461687a0134b1dda07081f98
+  metadata.gz: c4c45937029f9096bc8a8224decec4ab72faa98569043b1292d19e050826a92a8be57bdf26612e2800f82712654a444b03c66327e9a4baa5f8110444967397c3
+  data.tar.gz: 97dece56e4b22094415960285047136b15a1e02bea647b0c8b41eb2b762b661ef301f81b7acc376b27cc9027a4c86c7403971656cf824e9e8debc59439922ad0

data/cache_box.gemspec

@@ -2,19 +2,31 @@
 
 Gem::Specification.new do |spec|
   spec.name    = 'cache_box'
-  spec.version = '0.0.1-preview3'
+  spec.version = '0.0.1-preview8'
   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/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/unit.rb',
     'LICENSE',
     'cache_box.gemspec'
   ]

data/lib/cache_box.rb

@@ -1,198 +1,75 @@
 # 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/box'
+require_relative 'cache_box/unit'
 
-    self
-  end
+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[:store][name]    = data[:store] 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[:store] = @state[:store][: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