eac_tools 0.97.1 → 0.97.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0dc56d7a88a3a1fd5cb8efd27325816b4cf1b5fafb2260e7cbb6a6b68433336
-  data.tar.gz: bccb162a86dc9fdf69a58d2f1479a936e36b0e5072217472a342afd0d147899d
+  metadata.gz: 100674b2b84fad4d62d2071a22db9723492c6966038794b1a9cd3160849d89e0
+  data.tar.gz: a1872d982a0df4f9b3fffc8f7ee75f5269d7afa0c6e67e7f2aad3316fe482973
 SHA512:
-  metadata.gz: 12ccbcc6f9bbba861c6b2181e196d3027bf2b26a8666257111726d6eae65f0989ae04f7d21f0f92253fc56aa98f442f5c367dcc8f4f42261f6188bf38353edb4
-  data.tar.gz: 036deadc4dffcccaaae3eab04490ef3f18fbecaffa745b0b10ed91219351a2a6bb963bf11a9b1f28de6e9ee2e76a0c31e53c7ced46332a114ff8c7b6643a3aad
+  metadata.gz: 96d68091e4e96925ebcd835f9f7cad9175e1d56e713df2457fe7b090256de9efbb1a67538dd6974758c04d20830a74eccff4b61dac1b1e46630ce2d0785c4367
+  data.tar.gz: ee73917df41a40ccc988fca28acf837b327cfff995a73c17feed66852c3230171a8349df3e7de01c1638732ad43acbd76cc5aefd3fa461346a265ab79c1d6787

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    eac_tools (0.97.1)
+    eac_tools (0.97.2)
       avm (~> 0.94)
       avm-eac_asciidoctor_base0 (~> 0.25)
       avm-eac_generic_base0 (~> 0.13)
@@ -21,16 +21,24 @@ PATH
       avm-eac_wordpress_base0 (~> 0.3, >= 0.3.2)
       avm-git (~> 0.18)
       avm-tools (~> 0.162)
-      eac_ruby_utils (~> 0.123)
+      eac_ruby_utils (~> 0.124)
 
 PATH
-  remote: sub/avm-eac_rails_base1
+  remote: sub/eac_config
   specs:
-    avm-eac_rails_base1 (0.10.2)
-      avm (~> 0.94)
-      avm-eac_ruby_base1 (~> 0.35, >= 0.35.1)
-      avm-eac_webapp_base0 (~> 0.20, >= 0.20.1)
-      eac_ruby_utils (~> 0.123)
+    eac_config (0.14.3)
+      addressable (~> 2.8, >= 2.8.7)
+      eac_ruby_utils (~> 0.124)
+
+PATH
+  remote: sub/eac_ruby_utils
+  specs:
+    eac_ruby_utils (0.124.0)
+      activesupport (>= 4, < 7)
+      addressable (~> 2.8, >= 2.8.7)
+      bundler
+      filesize (~> 0.2)
+      net-ssh (~> 4.2)
 
 GEM
   remote: https://rubygems.org/
@@ -89,6 +97,11 @@ GEM
     avm-eac_rails_base0 (0.11.1)
       avm-eac_rails_base1 (~> 0.10)
       eac_ruby_utils (~> 0.121)
+    avm-eac_rails_base1 (0.10.2)
+      avm (~> 0.94)
+      avm-eac_ruby_base1 (~> 0.35, >= 0.35.1)
+      avm-eac_webapp_base0 (~> 0.20, >= 0.20.1)
+      eac_ruby_utils (~> 0.123)
     avm-eac_redmine_base0 (0.22.3)
       avm (~> 0.92)
       avm-eac_generic_base0 (~> 0.13)
@@ -154,9 +167,6 @@ GEM
       eac_config (~> 0.14, >= 0.14.2)
       eac_ruby_utils (~> 0.122)
       tty-table (~> 0.12)
-    eac_config (0.14.2)
-      addressable (~> 2.8, >= 2.8.6)
-      eac_ruby_utils (~> 0.121)
     eac_docker (0.7.0)
       eac_ruby_utils (~> 0.112)
       eac_templates (~> 0.3, >= 0.3.2)
@@ -191,12 +201,6 @@ GEM
       rubocop (~> 1.60, >= 1.60.1)
       rubocop-rails (~> 2.23, >= 2.23.1)
       rubocop-rspec (~> 2.26, >= 2.26.1)
-    eac_ruby_utils (0.123.0)
-      activesupport (>= 4, < 7)
-      addressable (~> 2.8, >= 2.8.7)
-      bundler
-      filesize (~> 0.2)
-      net-ssh (~> 4.2)
     eac_templates (0.7.1)
       eac_config (~> 0.14, >= 0.14.2)
       eac_ruby_utils (~> 0.122)
@@ -221,16 +225,16 @@ GEM
     htmlbeautifier (1.4.3)
     i18n (1.14.6)
       concurrent-ruby (~> 1.0)
-    json (2.7.6)
+    json (2.8.2)
     language_server-protocol (3.17.0.3)
     minitar (0.12.1)
-    minitest (5.25.1)
+    minitest (5.25.2)
     multipart-post (2.4.1)
     net-ssh (4.2.0)
     os (1.1.4)
     parallel (1.26.3)
     parseconfig (1.1.2)
-    parser (3.3.5.1)
+    parser (3.3.6.0)
       ast (~> 2.4.1)
       racc
     parslet (2.0.0)
@@ -257,17 +261,17 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
     rspec-support (3.13.1)
-    rubocop (1.68.0)
+    rubocop (1.69.0)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 2.4, < 3.0)
-      rubocop-ast (>= 1.32.2, < 2.0)
+      rubocop-ast (>= 1.36.1, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.33.1)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.36.2)
       parser (>= 3.3.1.0)
     rubocop-capybara (2.21.0)
       rubocop (~> 1.41)
@@ -310,8 +314,9 @@ PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
-  avm-eac_rails_base1!
+  eac_config!
   eac_ruby_gem_support (~> 0.10)
+  eac_ruby_utils!
   eac_tools!
 
 BUNDLED WITH

data/lib/eac_tools/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacTools
-  VERSION = '0.97.1'
+  VERSION = '0.97.2'
 end

data/sub/eac_config/eac_config.gemspec

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+require 'eac_config/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'eac_config'
+  s.version     = EacConfig::VERSION
+  s.authors     = ['Put here the authors']
+  s.summary     = 'Put here de description.'
+
+  s.files = Dir['{lib}/**/*']
+  s.required_ruby_version = '>= 2.7.0'
+
+  s.add_dependency 'addressable', '~> 2.8', '>= 2.8.7'
+  s.add_dependency 'eac_ruby_utils', '~> 0.124'
+
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.10'
+end

data/sub/eac_config/lib/eac_config/entries.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  class Entries
+    require_sub __FILE__
+    enable_simple_cache
+    common_constructor :root_node, :path do
+      self.path = ::EacConfig::EntryPath.assert(path)
+    end
+
+    def to_s
+      "#{self.class}[RootNode: #{root_node}, Path: #{path}]"
+    end
+
+    private
+
+    # @return [Array<EacConfig::Entries>]
+    def node_entries_uncached
+      node_entries_from_root + node_entries_from_load_path
+    end
+
+    # @return [Array<EacConfig::Entries>]
+    def node_entries_from_load_path_uncached
+      root_node.recursive_loaded_nodes.flat_map { |loaded_node| loaded_node.self_entries(path) }
+    end
+
+    # @return [Array<EacConfig::Entries>]
+    def node_entries_from_root_uncached
+      root_node.self_entries(path)
+    end
+  end
+end

data/sub/eac_config/lib/eac_config/entry/not_found_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  class Entry
+    class NotFoundError < ::RuntimeError
+      def initialize(entry)
+        super("Entry #{entry} not found")
+      end
+    end
+  end
+end

data/sub/eac_config/lib/eac_config/entry.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  class Entry
+    require_sub __FILE__
+    enable_simple_cache
+    common_constructor :root_node, :path do
+      self.path = ::EacConfig::EntryPath.assert(path)
+    end
+
+    def found?
+      node_entry.if_present(false, &:found?)
+    end
+
+    def found_node
+      node_entry.if_present(&:node)
+    end
+
+    def secret_value
+      node_entry.if_present(&:secret_value)
+    end
+
+    def to_s
+      "#{self.class}[RootNode: #{root_node}, Path: #{path}]"
+    end
+
+    def value
+      node_entry.if_present(&:value)
+    end
+
+    def value!
+      return value if found?
+
+      raise ::EacConfig::Entry::NotFoundError, self
+    end
+
+    def value=(a_value)
+      write_node.self_entry(path).value = a_value
+    end
+
+    def write_node
+      root_node.write_node || root_node
+    end
+
+    private
+
+    def node_entry_uncached
+      node_entry_from_root || node_entry_from_load_path
+    end
+
+    def node_entry_from_load_path_uncached
+      root_node.recursive_loaded_nodes.lazy.map { |loaded_node| loaded_node.self_entry(path) }
+        .find(&:found?)
+    end
+
+    def node_entry_from_root_uncached
+      e = root_node.self_entry(path)
+      e.found? ? e : nil
+    end
+  end
+end

data/sub/eac_config/lib/eac_config/entry_path.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  class EntryPath
+    PART_SEPARATOR = '.'
+
+    class << self
+      def assert(source)
+        source.is_a?(self) ? source : new(build_parts(source))
+      end
+
+      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
+
+    common_constructor :parts, default: [[]] do
+      self.parts = ::Array.new(parts).freeze
+    end
+
+    compare_by :parts
+    delegate :any?, :count, :each, :each_value, :each_with_index, :empty?, :fetch, :first, :index,
+             :inject, :last, :map, :size, to: :parts
+
+    # @return [EacConfig::EntryPath]
+    def +(other)
+      self.class.new(parts + self.class.assert(other).parts)
+    end
+
+    def [](*args)
+      slice(*args)
+    end
+
+    def slice(*args)
+      r = parts.slice(*args)
+      r.is_a?(::Enumerable) ? self.class.new(r) : r
+    end
+
+    def to_s
+      "#{self.class}[#{to_string}]"
+    end
+
+    # @return [String]
+    def to_string
+      parts.join(PART_SEPARATOR)
+    end
+
+    # @param part [String]
+    # @return [EacConfig::EntryPath]
+    def with_first(part)
+      new_parts = parts.dup
+      new_parts.unshift(part)
+      self.class.new(new_parts)
+    end
+
+    # @return [EacConfig::EntryPath]
+    def without_first
+      new_parts = parts.dup
+      new_parts.shift
+      self.class.new(new_parts)
+    end
+
+    # @return [EacConfig::EntryPath]
+    def with_last(part)
+      self.class.new(parts + [part])
+    end
+
+    # @return [EacConfig::EntryPath]
+    def without_last
+      new_parts = parts.dup
+      new_parts.pop
+      self.class.new(new_parts)
+    end
+  end
+end

data/sub/eac_config/lib/eac_config/envvars_node/entry.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+require 'eac_config/node_entry'
+require 'eac_ruby_utils/blank_not_blank'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/yaml'
+
+module EacConfig
+  class EnvvarsNode
+    class Entry < ::EacConfig::NodeEntry
+      class << self
+        def entry_path_to_envvar_name(path)
+          ::EacConfig::EntryPath.assert(path).parts.join('_').gsub(/[^a-z0-9_]/i, '')
+            .gsub(/\A_+/, '').gsub(/_+\z/, '').gsub(/_{2,}/, '_').upcase
+        end
+
+        def from_value(string)
+          return nil if string.nil?
+          return ::EacRubyUtils::Yaml.load(string) if string.start_with?('---')
+
+          string
+        end
+
+        def to_value(object)
+          return nil if object.nil?
+          return object if object.is_a?(String)
+
+          ::EacRubyUtils::Yaml.dump(object)
+        end
+      end
+
+      enable_simple_cache
+
+      def found?
+        ENV.key?(envvar_name)
+      end
+
+      def value
+        self.class.from_value(ENV.fetch(envvar_name, nil))
+      end
+
+      def value=(a_value)
+        ENV[envvar_name] = self.class.to_value(a_value)
+      end
+
+      private
+
+      def envvar_name_uncached
+        self.class.entry_path_to_envvar_name(path)
+      end
+    end
+  end
+end

data/sub/eac_config/lib/eac_config/envvars_node.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'addressable'
+require 'eac_config/node'
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  # A node that read/write entries from environment variables.
+  class EnvvarsNode
+    require_sub __FILE__
+    include ::EacConfig::Node
+
+    URI = ::Addressable::URI.parse('self://envvars')
+
+    class << self
+      def from_uri(uri)
+        new if uri == URI
+      end
+    end
+
+    # @param path [EacConfig::EntryPath]
+    # @return [Array<EacConfig::Entries>]
+    def self_entries(_path)
+      []
+    end
+
+    def url
+      URI
+    end
+
+    def to_s
+      "#{self.class}[ObjectId: #{object_id}]}"
+    end
+  end
+end

data/sub/eac_config/lib/eac_config/load_nodes_search.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  class LoadNodesSearch
+    common_constructor :root_node do
+      add_next_pending until pending.empty?
+    end
+
+    def result
+      added
+    end
+
+    private
+
+    def added
+      @added ||= []
+    end
+
+    def add_next_pending
+      current = pending.pop
+      current.self_loaded_nodes.each do |loaded_node|
+        next if added.include?(loaded_node)
+
+        added << loaded_node
+        pending.push(loaded_node)
+      end
+    end
+
+    def pending
+      @pending ||= begin
+        r = Queue.new
+        r.push(root_node)
+        r
+      end
+    end
+  end
+end

data/sub/eac_config/lib/eac_config/load_path.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  class LoadPath
+    ENTRY_PATH = ::EacConfig::EntryPath.assert(%w[load_path])
+
+    common_constructor :node
+
+    def entry
+      node.self_entry(ENTRY_PATH)
+    end
+
+    # @return [Array<String>]
+    def paths
+      r = entry.value
+      r.is_a?(::Array) ? r : []
+    end
+
+    def push(new_path)
+      entry.value = paths + [new_path]
+    end
+
+    delegate :to_s, to: :paths
+  end
+end

data/sub/eac_config/lib/eac_config/node.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'eac_config/entries'
+require 'eac_config/entry'
+require 'eac_config/entry_path'
+require 'eac_config/load_path'
+require 'eac_config/load_nodes_search'
+require 'eac_config/node_entry'
+require 'eac_config/node_uri'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/context'
+
+module EacConfig
+  module Node
+    class << self
+      def context
+        @context ||= ::EacRubyUtils::Context.new
+      end
+    end
+
+    attr_accessor :write_node
+
+    common_concern do
+      acts_as_abstract :self_entries
+      include ::Comparable
+    end
+
+    # @return [Array<EacConfig::Entries>]
+    def entries(path)
+      ::EacConfig::Entries.new(self, path)
+    end
+
+    def entry(path)
+      ::EacConfig::Entry.new(self, path)
+    end
+
+    # @return [[EacConfig::IncludePath]]
+    def load_path
+      @load_path ||= ::EacConfig::LoadPath.new(self)
+    end
+
+    # @return [Addressable::URI]
+    def url
+      raise_abstract_method(__method__)
+    end
+
+    # Return a entry which search values only in the self node.
+    # @return [EacConfig::NodeEntry]
+    def self_entry(path)
+      self_entry_class.new(self, path)
+    end
+
+    def self_entry_class
+      self.class.const_get('Entry')
+    end
+
+    # @return [Array<EacConfig::Node>]
+    def self_loaded_nodes
+      load_path.paths.flat_map { |node_path| load_nodes(node_path) }
+    end
+
+    # @return [Array<EacConfig::Node>]
+    def recursive_loaded_nodes
+      ::EacConfig::LoadNodesSearch.new(self).result
+    end
+
+    # @return [EacConfig::PrefixedPathNode]
+    def with_prefix(path_prefix)
+      require 'eac_config/prefixed_path_node'
+      ::EacConfig::PrefixedPathNode.new(self, path_prefix)
+    end
+
+    private
+
+    # @param node_path [String]
+    # @return [Array<EacConfig::Node>]
+    def load_nodes(node_path)
+      ::EacConfig::NodeUri.new(node_path, url).instanciate
+    end
+  end
+end

data/sub/eac_config/lib/eac_config/node_entry.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+require 'eac_config/paths_hash'
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  # A entry which search values only in the source node.
+  class NodeEntry
+    enable_abstract_methods
+    enable_simple_cache
+    common_constructor :node, :path do
+      self.path = ::EacConfig::EntryPath.assert(path)
+    end
+    compare_by :node, :path
+
+    abstract_methods :found?, :value, :value=
+
+    def secret_value
+      value
+    end
+
+    # @return [String]
+    def to_s
+      "#{self.class}[Node: #{node}, Path: #{path}]"
+    end
+  end
+end

data/sub/eac_config/lib/eac_config/node_uri/instanciate_single.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EacConfig
+  class NodeUri
+    class InstanciateSingle
+      acts_as_instance_method
+      enable_simple_cache
+      common_constructor :node_uri, :instance_uri
+
+      # @return [Array<Class>]
+      def available_node_classes
+        require 'eac_config/envvars_node'
+        require 'eac_config/yaml_file_node'
+        [::EacConfig::EnvvarsNode, ::EacConfig::YamlFileNode]
+      end
+
+      # @return [EacConfig::Node]
+      def result
+        available_node_classes.lazy.map { |k| k.from_uri(self) }.find(&:present?) ||
+          raise("No class mapped for \"#{to_addressable}\"")
+      end
+
+      # @return [Addressable::URI]
+      def to_addressable
+        instance_uri.to_uri
+      end
+    end
+  end
+end