cache_box 0.0.1.pre.preview7 → 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.preview7
+  version: 0.0.1.pre.preview8
 platform: ruby
 authors:
 - Codruț Constantin Gușoi
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-23 00:00:00.000000000 Z
+date: 2020-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -66,7 +66,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.88'
-description: 
+description:
 email:
 - codrut.gusoi+rubygems.org@gmail.com
 executables: []
@@ -76,16 +76,21 @@ files:
 - LICENSE
 - cache_box.gemspec
 - lib/cache_box.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/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:
   homepage_uri: https://gitlab.com/sdwolfz/cache_box_rb
   source_code_uri: https://gitlab.com/sdwolfz/cache_box_rb
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -100,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 local cache.
 test_files: []

data/lib/cache_box/file_storage.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-class CacheBox
-  # A storage backed by files.
-  class FileStorage
-    # Input:
-    #
-    # namespace = Symbol | String # Default: 'namespace'
-    # path      = String # Path; Default: nil
-    #
-    # Output: N/A
-    def initialize(namespace: nil, path: nil)
-      validate_symbol_or_string!(namespace, 'namespace')
-      validate_string!(path, 'path')
-
-      @namespace = namespace.to_s || 'namespace'
-
-      root  = path || File.join(Dir.pwd, '.cache')
-      @path = File.join(root, @namespace)
-    end
-
-    # Output: self
-    def reset!
-      FileUtils.remove_entry_secure(@path, true)
-
-      self
-    end
-
-    # Reads the content.
-    #
-    # Input:
-    #
-    # name = String
-    #
-    # Output: Object # Anything
-    def read!(name)
-      validate_string!(name, 'name')
-
-      file = File.join(@path, name)
-      return unless File.exist?(file)
-
-      Marshal.load(File.read(file))
-    end
-
-    # Input:
-    #
-    # name = String
-    # data = Object # Anything
-    #
-    # Output: self
-    def write!(name, data)
-      validate_string!(name, 'name')
-
-      FileUtils.mkdir_p(@path) unless Dir.exist?(@path)
-
-      content = Marshal.dump(data)
-      file    = File.join(@path, name)
-
-      File.write(file, content)
-
-      self
-    end
-
-    # Input:
-    #
-    # name = String
-    #
-    # Output: self
-    def delete!(name)
-      validate_string!(name, 'name')
-
-      file = File.join(@path, name)
-      FileUtils.remove_entry_secure(file, true)
-
-      self
-    end
-
-    # Input:
-    #
-    # name = String
-    #
-    # Output: true | false
-    def has?(name)
-      validate_string!(name, 'name')
-
-      file = File.join(@path, name)
-      File.file?(file)
-    end
-
-    private
-
-    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
-
-    def validate_string!(arg, name)
-      return if arg.nil? || arg.is_a?(String)
-
-      klass = arg.class
-      value = arg.inspect
-
-      raise(
-        ArgumentError,
-        "#{name} must be a String, got #{klass}: #{value}"
-      )
-    end
-  end
-end

data/lib/cache_box/memory_storage.rb

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-
-class CacheBox
-  # A storage backed by an in memory Hash.
-  class MemoryStorage
-    # Accepts a Hash or any Hash-like object as argument. Will use a plain Hash
-    # if none provided.
-    #
-    # Input:
-    #
-    # state = Hash{...Object => Object} # Default: nil
-    #
-    # Output: N/A
-    def initialize(state = nil)
-      validate!(state)
-
-      @state = state || {}
-    end
-
-    # Accepts a Hash or any Hash-like object as argument. Will use a plain Hash
-    # if none provided.
-    #
-    # Input:
-    #
-    # state = Hash{...Object => Object}
-    #
-    # Output: self
-    def reset!(state = nil)
-      initialize(state)
-
-      self
-    end
-
-    # Input:
-    #
-    # name = String
-    #
-    # Output: Object # Anything
-    def read!(name)
-      validate_string!(name, 'name')
-
-      @state[name]
-    end
-
-    # Input:
-    #
-    # name = String
-    # data = Object # Anything
-    #
-    # Output: self
-    def write!(name, data)
-      validate_string!(name, 'name')
-
-      @state[name] = data
-
-      self
-    end
-
-    # Input:
-    #
-    # name = String
-    #
-    # Output: self
-    def delete!(name)
-      validate_string!(name, 'name')
-
-      @state.delete(name)
-
-      self
-    end
-
-    # Input:
-    #
-    # name = String
-    #
-    # Output: true | false
-    def has?(name)
-      validate_string!(name, 'name')
-
-      @state.key?(name)
-    end
-
-    private
-
-    # Input:
-    #
-    # state = Object # Anything
-    #
-    # Output: N/A
-    def validate!(state)
-      return if state.nil? || state.is_a?(Hash)
-
-      validate_get!(state)
-      validate_set!(state)
-      validate_delete!(state)
-      validate_key!(state)
-    end
-
-    # Input:
-    #
-    # state = Object # Anything
-    #
-    # Output: N/A
-    def validate_get!(state)
-      unless state.respond_to?(:[])
-        raise(ArgumentError, 'Given state object does not respond to `:[]`')
-      end
-
-      arity = state.method(:[]).arity
-      unless arity == 1
-        raise(
-          ArgumentError,
-          "Given state object's `:[]` method arity must be 1, got: #{arity}"
-        )
-      end
-    end
-
-    # Input:
-    #
-    # state = Object # Anything
-    #
-    # Output: N/A
-    def validate_set!(state)
-      unless state.respond_to?(:[]=)
-        raise(ArgumentError, 'Given state object does not respond to `:[]=`')
-      end
-
-      arity = state.method(:[]=).arity
-      unless arity == 2
-        raise(
-          ArgumentError,
-          "Given state object's `:[]=` method arity must be 2, got: #{arity}"
-        )
-      end
-    end
-
-    # Input:
-    #
-    # state = Object # Anything
-    #
-    # Output: N/A
-    def validate_delete!(state)
-      unless state.respond_to?(:delete)
-        raise(ArgumentError, 'Given state object does not respond to `delete`')
-      end
-
-      arity = state.method(:delete).arity
-      unless arity == 1
-        raise(
-          ArgumentError,
-          "Given state object's `:delete` method arity must be 1, got: #{arity}"
-        )
-      end
-    end
-
-    # Input:
-    #
-    # state = Object # Anything
-    #
-    # Output: N/A
-    def validate_key!(state)
-      unless state.respond_to?(:key?)
-        raise(ArgumentError, 'Given state object does not respond to `:key?`')
-      end
-
-      arity = state.method(:key?).arity
-      unless arity == 1
-        raise(
-          ArgumentError,
-          "Given state object's `:key?` method arity must be 1, got: #{arity}"
-        )
-      end
-    end
-
-    # Input:
-    #
-    # arg  = String
-    # name = String
-    #
-    # Output: N/A
-    def validate_string!(arg, name)
-      return if arg.nil? || arg.is_a?(String)
-
-      klass = arg.class
-      value = arg.inspect
-
-      raise(
-        ArgumentError,
-        "#{name} must be a String, got #{klass}: #{value}"
-      )
-    end
-  end
-end