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

data/lib/cache_box/unit.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+class CacheBox
+  class Unit
+    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')
+
+      @namespace = namespace
+      @logger    = logger  || Logger.new(STDOUT, level: Logger::INFO)
+      @storage   = storage || ::CacheBox::Storage::File.new(namespace: @namespace)
+
+      @state = { result: {}, stash: {} }
+    end
+
+    # Input:
+    #
+    # name   = String | Symbol # Default: 'name'
+    # args   = Object
+    # input  = Object
+    # &block = Proc(CacheBox::Box)
+    #
+    # Output: Object # Anything the &block returns.
+    def with(name = nil, args = nil, input = nil, &block)
+      name ||= 'name'
+      validate_string_or_symbol!(name, 'name')
+      validate_block_presence!(block, '#with')
+
+      name_o = name
+      name_s = name.to_s
+
+      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]
+
+        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
+      )
+
+      begin
+        @state[:result][name_s] = block.call(box)
+      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)
+        end
+      end
+    end
+
+    # Input:
+    #
+    # name = String | Symbol # Default: 'name'
+    #
+    # Output: true | false
+    def has?(name = nil)
+      name ||= 'name'
+      validate_string_or_symbol!(name, 'name')
+      name = name.to_s
+
+      return true if @state[:result].key?(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)
+    end
+
+    # Input:
+    #
+    # name = String | Symbol # Default: 'name'
+    #
+    # Output: true | false
+    def result(name = nil)
+      name ||= 'name'
+      validate_string_or_symbol!(name, 'name')
+      name = name.to_s
+
+      return @state[:result][name] if @state[:result].key?(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][name]
+    end
+
+    # Input:
+    #
+    # name = Array[String | Symbol] # Default: []
+    #
+    # Output: self
+    def expire!(*names)
+      validate_array_of_string_or_symbol!(names, 'names')
+
+      if names.empty?
+        @state = { result: {}, stash: {} }
+
+        @storage.reset!
+      else
+        names.each do |name|
+          name = name.to_s
+          @state[:result].delete(name)
+          @state[:stash].delete(name)
+
+          @storage.delete!(name)
+        end
+      end
+
+      self
+    end
+
+    # Input:
+    #
+    # name = Array[String | Symbol] # Default: []
+    #
+    # Output: self
+    def clear(*names)
+      validate_array_of_string_or_symbol!(names, 'names')
+
+      if names.empty?
+        @state = { result: {}, stash: {} }
+      else
+        names.each do |name_o|
+          name_s = name_o.to_s
+
+          @state[:result].delete(name_s)
+          @state[:stash].delete(name_s)
+        end
+      end
+
+      self
+    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.preview3
+  version: 0.0.1.pre.preview8
 platform: ruby
 authors:
 - Codruț Constantin Gușoi
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-19 00:00:00.000000000 Z
+date: 2020-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -66,9 +66,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.88'
-description: 
+description:
 email:
-- codrut.gusoi+git-commit@gmail.com
+- codrut.gusoi+rubygems.org@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -76,12 +76,21 @@ files:
 - LICENSE
 - cache_box.gemspec
 - lib/cache_box.rb
-- lib/cache_box_chain.rb
+- lib/cache_box/box.rb
+- lib/cache_box/chain.rb
+- lib/cache_box/graph.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/unit.rb
 homepage: https://gitlab.com/sdwolfz/cache_box_rb
 licenses:
-- BSD 3-clause
-metadata: {}
-post_install_message: 
+- BSD-3-Clause
+metadata:
+  homepage_uri: https://gitlab.com/sdwolfz/cache_box_rb
+  source_code_uri: https://gitlab.com/sdwolfz/cache_box_rb
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -96,8 +105,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.1.3
+signing_key:
 specification_version: 4
-summary: A simple, fast, and easy to use file backed cache.
+summary: A simple, fast, and easy to use local cache.
 test_files: []

data/lib/cache_box_chain.rb

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-class CacheBox
-  class Chain
-    # Input:
-    #
-    # namespace = String | Symbol # Default: :namespace
-    #
-    # Output: N/A
-    def initialize(namespace = :namespace)
-      @cache = ::CacheBox.new(namespace)
-      @chain = []
-    end
-
-    # Input:
-    #
-    # namespace = String | Symbol # Default: :namespace
-    #
-    # Output: self
-    def reset!(namespace = :namespace)
-      @cache.reset!(namespace)
-      @chain = []
-
-      self
-    end
-
-    # Input:
-    #
-    # name   = String | Symbol
-    # args   = Array[...Object]
-    # &block = Proc(*args)
-    #
-    # Output: self
-    def chain(name, *args, &block)
-      validate_chain!(name, &block)
-
-      @chain.push(
-        [name, args, proc { |*all| @cache.with(name, *all, &block) }]
-      )
-
-      self
-    end
-
-    # Input:
-    #
-    # name   = String | Symbol
-    # args   = Array[...Object]
-    # &block = Proc(Hash{...Object => Object}, *args)
-    #
-    # Output: self
-    def chain_many(name, *args, &block)
-      validate_chain!(name, &block)
-
-      @chain.push(
-        [name, args, proc { |*all| @cache.with_many(name, *all, &block) }]
-      )
-
-      self
-    end
-
-    # Input:
-    #
-    # all = nil | :all # Default: nil
-    #
-    # Output: Object # Anything the last block in the chain returns.
-    def run!(all = nil)
-      validate_run!(all)
-
-      if all
-        run_all
-      else
-        run_chain
-      end
-    end
-
-    # Output: self
-    def expire!
-      @cache.expire!
-
-      self
-    end
-
-    # Input:
-    #
-    # names = ...(String | Symbol)
-    #
-    # Output: self
-    def expire(*names)
-      names.each do |name|
-        @cache.expire(name)
-      end
-
-      self
-    end
-
-    private
-
-    # Input:
-    #
-    # name   = String | Symbol
-    # &block = Proc
-    #
-    # Output: N/A
-    def validate_chain!(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 a String, got #{klass}: #{value}"
-        )
-      end
-
-      return unless block.nil?
-
-      raise(
-        ArgumentError,
-        'The `#chain/2` method needs to be called with a block'
-      )
-    end
-
-    # Input:
-    #
-    # arg = nil | :all
-    #
-    # Output: N/A
-    def validate_run!(arg)
-      return if arg.nil? || arg == :all
-
-      klass = arg.class
-      value = arg.inspect
-
-      raise(
-        ArgumentError,
-        'The `run!` method only accepts `nil` or the Symbol `:all` as an ' \
-        "argument, got #{klass}: #{value}"
-      )
-    end
-
-    # Output: Object # Anything the last callable returns.
-    def run_all
-      result = nil
-      @chain.each do |_name, args, callable|
-        input = []
-        input << result if result
-        input += args if args
-
-        result = callable.call(*input)
-      end
-
-      result
-    end
-
-    # Output: Object # Anything the last executed callable returns.
-    def run_chain
-      work = []
-
-      @chain.reverse_each do |name, args, callable|
-        work.push([name, args, callable])
-
-        break if @cache.has?(name)
-      end
-
-      result = nil
-      work.reverse_each do |_name, args, callable|
-        input = []
-        input << result if result
-        input += args if args
-
-        result = callable.call(*input)
-      end
-
-      result
-    end
-  end
-end