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

data/lib/cache_box/helper/validate.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+class CacheBox
+  module Helper
+    # Common validation methods.
+    module Validate
+      # Input:
+      #
+      # arg  = String | Symbol
+      # name = String
+      #
+      # Output: arg
+      def validate_string_or_symbol!(arg, name)
+        return arg 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:
+      #
+      # args = Array[String | Symbol]
+      # name = String
+      #
+      # Output: args
+      def validate_array_of_string_or_symbol!(args, name)
+        unless args.is_a?(Array)
+          klass = args.class
+          value = args.inspect
+
+          raise(
+            ArgumentError,
+            "#{name} must be an Array, got #{klass}: #{value}"
+          )
+        end
+
+        args.each do |arg|
+          next if arg.is_a?(Symbol) || arg.is_a?(String)
+
+          klass = arg.class
+          value = arg.inspect
+
+          raise(
+            ArgumentError,
+            "#{name} must contain Symbol or String, got #{klass}: #{value} in #{args}"
+          )
+        end
+
+        args
+      end
+
+      # Input:
+      #
+      # block = &block
+      # name  = String
+      #
+      # Output: N/A
+      def validate_block_presence!(block, name)
+        return block if block
+
+        raise(ArgumentError, "The `#{name}` method requires a block")
+      end
+
+      # Input:
+      #
+      # edge = String |
+      #        Symbol |
+      #        Hash{1 String | Symbol => String | Symbol | Array[...String | Symbol]}
+      #
+      # Output: edge
+      def validate_edge!(edge)
+        return edge if edge.is_a?(Symbol) || edge.is_a?(String)
+
+        if edge.is_a?(Hash)
+          validate_hash_edge!(edge)
+
+          edge
+        else
+          klass = edge.class
+          value = edge.inspect
+
+          raise(
+            ArgumentError,
+            "edge has an unknown structure; #{klass}: #{value}"
+          )
+        end
+      end
+
+      private
+
+      # Input:
+      #
+      # edge = Hash{1 String | Symbol => String | Symbol | Array[...String | Symbol]}
+      #
+      # Output: edge
+      def validate_hash_edge!(edge)
+        if (size = edge.size) != 1
+          raise(
+            ArgumentError,
+            "edge must have one mapping, got #{size}: #{edge.inspect}"
+          )
+        end
+
+        name  = edge.keys.first
+        needs = edge[name]
+
+        validate_string_or_symbol!(name, 'edge name')
+        validate_needs!(needs)
+
+        edge
+      end
+
+      # Input:
+      #
+      # arg = String | Symbol | Array[...String | Symbol]
+      #
+      # Output: arg
+      def validate_needs!(arg)
+        return arg if arg.is_a?(Symbol) || arg.is_a?(String)
+
+        if arg.is_a?(Array)
+          validate_array_of_string_or_symbol!(arg, 'edge needs')
+
+          arg
+        else
+          klass = arg.class
+          value = arg.inspect
+
+          raise(
+            ArgumentError,
+            "edge needs has an unknown structure; #{klass}: #{value}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cache_box/scheduler/serial.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+class CacheBox
+  module Scheduler
+    class Serial
+      include CacheBox::Helper::Validate
+
+      # Input:
+      #
+      # logger = Logger
+      #
+      # Output: N/A
+      def initialize(logger: nil)
+        @logger = logger || Logger.new(STDOUT, level: Logger::INFO)
+
+        @edges  = {}
+        @names  = {}
+        @leaves = {}
+        @plan   = []
+      end
+
+      # Input:
+      #
+      # edge = String |
+      #        Symbol |
+      #        Hash{String | Symbol => String | Symbol | Array[String | Symbol]}
+      #
+      # Output: self
+      def add(edge)
+        validate_edge!(edge)
+
+        needs_o = extract_needs(edge)
+        needs_s = needs_o.map(&:to_s)
+        needs_s.each_with_index do |arg, index|
+          next if @edges.key?(arg)
+
+          raise(
+            ArgumentError,
+            "Graph does not contain required node #{needs_o[index].inspect}"
+          )
+        end
+
+        name_o = extract_name(edge)
+        name_s = name_o.to_s
+        if @edges.key?(name_s)
+          raise(
+            ArgumentError,
+            "Graph already contains a node named #{name_o.inspect}"
+          )
+        else
+          @edges[name_s] = needs_s
+        end
+        @names[name_s] = name_o
+
+        add_to_plan(name_s, needs_s)
+
+        @leaves[name_s] = name_o
+        needs_s.each do |need_s|
+          @leaves.delete(need_s)
+        end
+
+        self
+      end
+
+      # Input:
+      #
+      # nodes = Hash{...String => Array[String | Symbol, Proc(Object)]}
+      # unit  = CacheBox::Unit
+      #
+      # Output: Hash{...String | Symbol => Object}
+      def run!(nodes, unit)
+        sequence = @plan.flatten
+        sequence.each_with_index do |name, index|
+          next if unit.has?(name)
+
+          callable = nodes[name][1]
+          needs    = @edges[name]
+          input    = {}
+
+          needs.each do |need|
+            next unless unit.has?(need)
+
+            input[@names[need]] = unit.result(need)
+          end
+          callable.call(input)
+
+          needs.each do |need|
+            needed = false
+            sequence[(index + 1)..-1].each do |item|
+              needed = true if @edges[item].include?(need)
+            end
+
+            unit.clear(need) unless needed
+          end
+        end
+
+        result = {}
+        @leaves.each do |name_s, name_o|
+          next unless unit.has?(name_s)
+
+          result[name_o] = unit.result(name_s)
+        end
+        result
+      end
+
+      private
+
+      # Input: ?
+      #
+      # Output: ?
+      def add_to_plan(name, from)
+        result = 0
+
+        from.each do |node|
+          @plan.each_with_index do |row, index|
+            next unless row.include?(node)
+
+            result = index >= result ? index + 1 : result
+            break
+          end
+        end
+
+        @plan.each do |row|
+          next unless row.include?(from)
+
+          row.push(name)
+          break
+        end
+
+        if (row = @plan[result])
+          row.push(name)
+        else
+          @plan.push([name])
+        end
+      end
+
+      # Input: String | Symbol | Hash[1 String | Symbol => Object]
+      #
+      # Output: String | Symbol
+      def extract_name(edge)
+        return edge if edge.is_a?(Symbol) || edge.is_a?(String)
+
+        edge.keys.first
+      end
+
+      # Input: ?
+      #
+      # Output: Array[...String | Symbol]
+      def extract_needs(edge)
+        return [] unless edge.is_a?(Hash)
+
+        name  = edge.keys.first
+        needs = edge[name]
+
+        needs.is_a?(Array) ? needs : [needs]
+      end
+    end
+  end
+end

data/lib/cache_box/storage/file.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+class CacheBox
+  module Storage
+    # A storage backed by files.
+    class File
+      # 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
+end

data/lib/cache_box/storage/memory.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+class CacheBox
+  module Storage
+    # A storage backed by an in memory Hash.
+    class Memory
+      # 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
+end