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

data/lib/cache_box/storage/file.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+class CacheBox
+  module Storage
+    # A storage backed by files.
+    class File
+      LOCK = Mutex.new
+
+      # 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!
+        LOCK.synchronize do
+          FileUtils.remove_entry_secure(@path, true)
+        end
+
+        self
+      end
+
+      # Reads the content.
+      #
+      # Input:
+      #
+      # name = String
+      #
+      # Output: Object # Anything
+      def read!(name)
+        validate_string!(name, 'name')
+
+        LOCK.synchronize do
+          file = ::File.join(@path, name)
+          return unless ::File.exist?(file)
+
+          Marshal.load(::File.read(file))
+        end
+      end
+
+      # Input:
+      #
+      # name = String
+      # data = Object # Anything
+      #
+      # Output: self
+      def write!(name, data)
+        validate_string!(name, 'name')
+
+        content = Marshal.dump(data)
+        file    = ::File.join(@path, name)
+
+        LOCK.synchronize do
+          FileUtils.mkdir_p(@path)
+
+          ::File.write(file, content)
+        end
+
+        self
+      end
+
+      # Input:
+      #
+      # name = String
+      #
+      # Output: self
+      def delete!(name)
+        validate_string!(name, 'name')
+
+        LOCK.synchronize do
+          file = ::File.join(@path, name)
+          FileUtils.remove_entry_secure(file, true)
+        end
+
+        self
+      end
+
+      # Input:
+      #
+      # name = String
+      #
+      # Output: true | false
+      def has?(name)
+        validate_string!(name, 'name')
+
+        LOCK.synchronize do
+          file = ::File.join(@path, name)
+          ::File.file?(file)
+        end
+      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
+end

data/lib/cache_box/storage/memory.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+class CacheBox
+  module Storage
+    # A storage backed by an in memory Hash.
+    class Memory
+      LOCK = Mutex.new
+
+      # 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)
+
+        LOCK.synchronize do
+          @state = state || {}
+        end
+      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')
+
+        LOCK.synchronize do
+          @state[name]
+        end
+      end
+
+      # Input:
+      #
+      # name = String
+      # data = Object # Anything
+      #
+      # Output: self
+      def write!(name, data)
+        validate_string!(name, 'name')
+
+        LOCK.synchronize do
+          @state[name] = data
+        end
+
+        self
+      end
+
+      # Input:
+      #
+      # name = String
+      #
+      # Output: self
+      def delete!(name)
+        validate_string!(name, 'name')
+
+        LOCK.synchronize do
+          @state.delete(name)
+        end
+
+        self
+      end
+
+      # Input:
+      #
+      # name = String
+      #
+      # Output: true | false
+      def has?(name)
+        validate_string!(name, 'name')
+
+        LOCK.synchronize do
+          @state.key?(name)
+        end
+      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
+end

data/lib/cache_box/unit.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+class CacheBox
+  class Unit
+    include CacheBox::Helper::Validate
+
+    LOCK = Mutex.new
+
+    # 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_o = namespace
+      @namespace_s = namespace.to_s
+      @logger      = logger  || Logger.new(STDOUT, level: Logger::INFO)
+      @storage     = storage || ::CacheBox::Storage::File.new(namespace: @namespace_o)
+
+      LOCK.synchronize do
+        @state = { result: ::CacheBox::Stash.new, stash: ::CacheBox::Stash.new }
+      end
+    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
+      box    = nil
+
+      LOCK.synchronize do
+        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_o.dup,
+          name:      name_o.dup,
+          args:      args,
+          input:     input,
+          stash:     @state[:stash][name] || ::CacheBox::Stash.new,
+          logger:    @logger
+        )
+      end
+
+      begin
+        result = block.call(box)
+
+        LOCK.synchronize do
+          @state[:result][name_s] = result
+        end
+      ensure
+        LOCK.synchronize do
+          if @state[:result].key?(name_s)
+            @state[:stash].delete(name_s)
+            @storage.write!(name_s, { result: @state[:result][name_s] })
+          else
+            stash = box.stash
+            stash.with do |state|
+              dump = { stash: state }
+
+              @state[:stash][name_s] = stash
+              @storage.write!(name_s, dump)
+            end
+          end
+        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
+
+      LOCK.synchronize do
+        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
+    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
+
+      LOCK.synchronize do
+        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
+    end
+
+    # Input:
+    #
+    # name = Array[String | Symbol] # Default: []
+    #
+    # Output: self
+    def expire!(*names)
+      validate_array_of_string_or_symbol!(names, 'names')
+
+      if names.empty?
+        LOCK.synchronize do
+          @state = { result: ::CacheBox::Stash.new, stash: ::CacheBox::Stash.new }
+
+          @storage.reset!
+        end
+      else
+        LOCK.synchronize do
+          names.each do |name_o|
+            name_s = name_o.to_s
+
+            @state[:result].delete(name_s)
+            @state[:stash].delete(name_s)
+
+            @storage.delete!(name_s)
+          end
+        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?
+        LOCK.synchronize do
+          @state = { result: ::CacheBox::Stash.new, stash: ::CacheBox::Stash.new }
+        end
+      else
+        LOCK.synchronize do
+          names.each do |name_o|
+            name_s = name_o.to_s
+
+            @state[:result].delete(name_s)
+            @state[:stash].delete(name_s)
+          end
+        end
+      end
+
+      self
+    end
+  end
+end