eac_config 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 84f6dfb659545033cf9bd7ad9514ef8328ec32c13af6d3534c8cb884e716a3ee
+  data.tar.gz: a8fa8b10e98000122b2a9e479443d0975d55decf95a060474eaad7ecfa8f4dee
+SHA512:
+  metadata.gz: 2d4c70a6acb8e033017a646ae5c1c1c3afe1b470fabcb194c8c8177fba8229d17abf13a504e58adf49983161a457a0d11b83ae1bc49a4917f80412672a9f518f
+  data.tar.gz: 383d7fb5e5812d1491dc73104c679b78b25c16b3e353591c3c37b2f467a3e1bd5f84de346bdb79c044a829dea0f7e32c898508dc1bd12bec42e290079efa74ca

data/lib/eac_config.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  require_sub __FILE__
+end

data/lib/eac_config/entry.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  class Entry
+    common_constructor :source_node, :path, :found, :value
+
+    def found?
+      found
+    end
+  end
+end

data/lib/eac_config/entry_path.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  class EntryPath
+    PART_SEPARATOR = '.'
+
+    class << self
+      def build_parts(source)
+        return validate_parts!(source.split(PART_SEPARATOR)) if source.is_a?(::String)
+        return validate_parts!(source.flat_map { |part| build_parts(part) }) if
+        source.is_a?(::Enumerable)
+
+        build_parts(source.to_s)
+      end
+
+      def validate_parts!(parts)
+        parts.assert_argument(::Enumerable, 'parts')
+        parts.each_with_index do |part, index|
+          raise ::ArgumentError, "Part #{index} of #{parts} is blank" if part.blank?
+          raise ::ArgumentError, "Part #{index} is not a string" unless part.is_a?(::String)
+        end
+      end
+    end
+
+    attr_reader :parts
+
+    def initialize(*parts)
+      @parts = self.class.build_parts(parts).freeze
+    end
+  end
+end

data/lib/eac_config/entry_search.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry'
+require 'eac_config/paths_hash'
+
+module EacConfig
+  class EntrySearch
+    enable_simple_cache
+    common_constructor :node, :path
+
+    private
+
+    # @return [EacConfig::Entry]
+    def result_uncached
+      if paths_hash.key?(to_paths_hash_key)
+        ::EacConfig::Entry.new(node, path, true, paths_hash.fetch(to_paths_hash_key))
+      else
+        ::EacConfig::Entry.new(nil, path, false, nil)
+      end
+    end
+
+    # @return [EacConfig::PathsHash]
+    def paths_hash_uncached
+      ::EacConfig::PathsHash.new(node.data)
+    end
+
+    def to_paths_hash_key
+      path.parts.join('.')
+    end
+  end
+end

data/lib/eac_config/manager.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  class Manager
+    common_constructor :root_node
+
+    # @return [EacConfig::Entry]
+    def entry(*parts)
+      root_node.entry(*parts)
+    end
+  end
+end

data/lib/eac_config/paths_hash.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  class PathsHash
+    require_sub __FILE__
+
+    class << self
+      def parse_entry_key(entry_key)
+        r = entry_key.to_s.strip
+        raise ::EacConfig::PathsHash::EntryKeyError, 'Entry key cannot start or end with dot' if
+        r.start_with?('.') || r.end_with?('.')
+
+        r = r.split('.').map(&:strip)
+        if r.empty?
+          raise ::EacConfig::PathsHash::EntryKeyError, "Entry key \"#{entry_key}\" is empty"
+        end
+        return r.map(&:to_sym) unless r.any?(&:blank?)
+
+        raise ::EacConfig::PathsHash::EntryKeyError,
+              "Entry key \"#{entry_key}\" has at least one blank part"
+      end
+    end
+
+    attr_reader :root
+
+    def initialize(source_hash = {})
+      @root = Node.new(source_hash)
+    end
+
+    def [](entry_key)
+      root.read_entry(::EacConfig::PathsHash::PathSearch.parse_entry_key(entry_key))
+    end
+
+    def []=(entry_key, entry_value)
+      root.write_entry(
+        ::EacConfig::PathsHash::PathSearch.parse_entry_key(entry_key), entry_value
+      )
+    end
+
+    def fetch(entry_key)
+      root.fetch(::EacConfig::PathsHash::PathSearch.parse_entry_key(entry_key))
+    end
+
+    def key?(entry_key)
+      root.entry?(::EacConfig::PathsHash::PathSearch.parse_entry_key(entry_key))
+    end
+
+    delegate :to_h, to: :root
+
+    private
+
+    attr_reader :data
+  end
+end

data/lib/eac_config/paths_hash/entry_key_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module EacConfig
+  class PathsHash
+    class EntryKeyError < StandardError
+    end
+  end
+end

data/lib/eac_config/paths_hash/node.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_config/paths_hash/entry_key_error'
+
+module EacConfig
+  class PathsHash
+    class Node
+      PATH_SEARCH_UNENDED_ERROR_MESSAGE = 'Path search is not a Node and is not ended'
+
+      def initialize(source_hash)
+        source_hash.assert_argument(Hash, 'source_hash')
+        @data = source_hash.map { |k, v| [k.to_sym, v.is_a?(Hash) ? Node.new(v) : v] }.to_h
+      end
+
+      def entry?(path_search)
+        return false unless data.key?(path_search.cursor)
+        return true if path_search.ended?
+        return data.fetch(path_search.cursor).entry?(path_search.succeeding) if
+          data.fetch(path_search.cursor).is_a?(Node)
+
+        false # Paths continue and there is not available nodes
+      end
+
+      def fetch(path_search)
+        if data.key?(path_search.cursor)
+          node = data.fetch(path_search.cursor)
+          return (node.is_a?(Node) ? node.to_h : node) if path_search.ended?
+          return nil if node.blank?
+          return node.fetch(path_search.succeeding) if node.is_a?(Node)
+        end
+
+        path_search.raise_error(PATH_SEARCH_UNENDED_ERROR_MESSAGE)
+      end
+
+      def to_h
+        data.map { |k, v| [k, v.is_a?(Node) ? v.to_h : v] }.to_h
+      end
+
+      def read_entry(path_search)
+        node = data[path_search.cursor]
+        return (node.is_a?(Node) ? node.to_h : node) if path_search.ended?
+        return nil if node.blank?
+        return node.read_entry(path_search.succeeding) if node.is_a?(Node)
+
+        path_search.raise_error(PATH_SEARCH_UNENDED_ERROR_MESSAGE)
+      end
+
+      def write_entry(path_search, value)
+        if path_search.ended?
+          data[path_search.cursor] = value.is_a?(Hash) ? self.class.new(value) : value
+        else
+          assert_data_node(path_search.cursor).write_entry(path_search.succeeding, value)
+        end
+      end
+
+      private
+
+      attr_reader :data
+
+      def assert_data_node(key)
+        data[key] = self.class.new({}) unless data[key].is_a?(Node)
+        data[key]
+      end
+    end
+  end
+end

data/lib/eac_config/paths_hash/path_search.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module EacConfig
+  class PathsHash
+    class PathSearch
+      class << self
+        def parse_entry_key(string)
+          new(::EacConfig::PathsHash.parse_entry_key(string), [])
+        end
+      end
+
+      common_constructor :current, :previous do
+        self.current = current.assert_argument(Array, 'current').freeze
+        self.previous = previous.assert_argument(Array, 'previous')
+        raise ::EacConfig::PathsHash::EntryKeyError, 'Current is empty' if current.empty?
+      end
+
+      def cursor
+        current.first
+      end
+
+      def ended?
+        current.count <= 1
+      end
+
+      def raise_error(message)
+        raise ::EacConfig::PathsHash::EntryKeyError, "#{message} (#{self})"
+      end
+
+      def succeeding
+        self.class.new(current[1..-1], previous + [cursor])
+      end
+
+      def to_s
+        "#{self.class}[Current: #{current}, Previous: #{previous}]"
+      end
+    end
+  end
+end

data/lib/eac_config/readable_node.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module EacConfig
+  module ReadableNode
+  end
+end

data/lib/eac_config/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EacConfig
+  VERSION = '0.1.0'
+end

data/lib/eac_config/writeable_node.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module EacConfig
+  module WriteableNode
+  end
+end

data/lib/eac_config/yaml_file_node.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry'
+require 'eac_config/entry_search'
+require 'eac_config/readable_node'
+require 'eac_config/writeable_node'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/yaml'
+
+module EacConfig
+  class YamlFileNode
+    include ::EacConfig::ReadableNode
+    include ::EacConfig::WriteableNode
+
+    common_constructor :path do
+      self.path = path.to_pathname
+    end
+
+    def data
+      @data ||= ::EacRubyUtils::Yaml.load_file(path)
+    end
+
+    def entry(*path)
+      ::EacConfig::EntrySearch.new(self, ::EacConfig::EntryPath.new(*path)).result
+    end
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: eac_config
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Put here the authors
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eac_ruby_utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.62'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.62'
+- !ruby/object:Gem::Dependency
+  name: eac_ruby_gem_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/eac_config.rb
+- lib/eac_config/entry.rb
+- lib/eac_config/entry_path.rb
+- lib/eac_config/entry_search.rb
+- lib/eac_config/manager.rb
+- lib/eac_config/paths_hash.rb
+- lib/eac_config/paths_hash/entry_key_error.rb
+- lib/eac_config/paths_hash/node.rb
+- lib/eac_config/paths_hash/path_search.rb
+- lib/eac_config/readable_node.rb
+- lib/eac_config/version.rb
+- lib/eac_config/writeable_node.rb
+- lib/eac_config/yaml_file_node.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key: 
+specification_version: 4
+summary: Put here de description.
+test_files: []