avm-tools 0.99.1 → 0.102.2

data/vendor/eac_config/lib/eac_config/load_path.rb

@@ -6,17 +6,6 @@ require 'eac_ruby_utils/core_ext'
 module EacConfig
   class LoadPath
     ENTRY_PATH = ::EacConfig::EntryPath.assert(%w[load_path])
-    PATH_SEPARATOR = ':'
-
-    class << self
-      def paths_to_string(paths)
-        paths.map(&:to_s).join(PATH_SEPARATOR)
-      end
-
-      def string_to_paths(string)
-        string.to_s.split(PATH_SEPARATOR)
-      end
-    end
 
     common_constructor :node
 
@@ -26,11 +15,14 @@ module EacConfig
 
     # @return [Array<String>]
     def paths
-      self.class.string_to_paths(entry.value)
+      r = entry.value
+      r.is_a?(::Array) ? r : []
     end
 
     def push(new_path)
-      entry.value = self.class.paths_to_string(paths + [new_path])
+      entry.value = paths + [new_path]
     end
+
+    delegate :to_s, to: :paths
   end
 end

data/vendor/eac_config/lib/eac_config/node.rb

@@ -5,10 +5,13 @@ 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'
 
 module EacConfig
   module Node
+    attr_accessor :write_node
+
     common_concern do
       enable_abstract_methods
       include ::Comparable
@@ -31,7 +34,11 @@ module EacConfig
     # Return a entry which search values only in the self node.
     # @return [EacConfig::NodeEntry]
     def self_entry(path)
-      ::EacConfig::NodeEntry.new(self, path)
+      self_entry_class.new(self, path)
+    end
+
+    def self_entry_class
+      self.class.const_get('Entry')
     end
 
     # @return [Array<EacConfig::Node>]
@@ -47,7 +54,7 @@ module EacConfig
     private
 
     def load_node(node_path)
-      self.class.new(node_path.to_pathname.expand_path(path.parent))
+      ::EacConfig::NodeUri.new(node_path, url).instanciate
     end
   end
 end

data/vendor/eac_config/lib/eac_config/node_entry.rb

@@ -7,33 +7,12 @@ 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
 
-    def found?
-      paths_hash.key?(to_paths_hash_key)
-    end
-
-    def value
-      paths_hash[to_paths_hash_key]
-    end
-
-    def value=(a_value)
-      paths_hash[to_paths_hash_key] = a_value
-      node.persist_data(paths_hash.root.to_h)
-    end
-
-    private
-
-    # @return [EacConfig::PathsHash]
-    def paths_hash_uncached
-      ::EacConfig::PathsHash.new(node.data)
-    end
-
-    def to_paths_hash_key
-      path.parts.join('.')
-    end
+    abstract_methods :found?, :value, :value=
   end
 end

data/vendor/eac_config/lib/eac_config/node_uri.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module EacConfig
+  class NodeUri
+    enable_simple_cache
+    common_constructor :source, :loader_uri, default: [nil]
+
+    def available_node_classes
+      require 'eac_config/envvars_node'
+      require 'eac_config/yaml_file_node'
+      [::EacConfig::EnvvarsNode, ::EacConfig::YamlFileNode]
+    end
+
+    def instanciate
+      available_node_classes.lazy.map { |k| k.from_uri(self) }.find(&:present?) ||
+        raise("No class mapped for \"#{to_addressable}\"")
+    end
+
+    delegate :to_s, to: :to_addressable
+
+    private
+
+    def to_addressable_uncached
+      r = ::Addressable::URI.parse(source)
+      path = r.path.to_pathname
+      r.path = path.expand_path(loader_uri_path_directory).to_path if path.relative?
+      r.scheme = 'file' if r.scheme.blank?
+      r
+    end
+
+    def loader_uri_path_directory
+      r = loader_uri.path
+      raise ".loader_uri \"#{loader_uri}\" has no path (Source: \"#{source}\")" if r.blank?
+
+      r.to_pathname.parent
+    end
+  end
+end

data/vendor/eac_config/lib/eac_config/old_configs.rb

@@ -8,6 +8,7 @@ require 'eac_config/paths_hash'
 require 'eac_ruby_utils/simple_cache'
 
 module EacConfig
+  # @deprecated Use {EacConfig::YamlFileNode} instead.
   class OldConfigs
     include ::EacRubyUtils::SimpleCache
 

data/vendor/eac_config/lib/eac_config/version.rb

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

data/vendor/eac_config/lib/eac_config/yaml_file_node.rb

@@ -7,20 +7,27 @@ require 'eac_ruby_utils/yaml'
 
 module EacConfig
   class YamlFileNode
+    require_sub __FILE__
     include ::EacConfig::Node
 
+    class << self
+      def from_uri(uri)
+        return new(uri.to_addressable.path) if uri.to_addressable.scheme == 'file'
+      end
+    end
+
     common_constructor :path do
       self.path = path.to_pathname
     end
 
     def data
-      @data ||= ::EacRubyUtils::Yaml.load_file(assert_path)
+      @data ||= ::EacRubyUtils::Yaml.load_file(assert_path) || {}
     end
 
     def persist_data(new_data)
       path.parent.mkpath
       ::EacRubyUtils::Yaml.dump_file(path, new_data)
-      reset_cache(:data)
+      @data = nil
     end
 
     def url

data/vendor/eac_config/lib/eac_config/yaml_file_node/entry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+require 'eac_config/node_entry'
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  class YamlFileNode
+    class Entry < ::EacConfig::NodeEntry
+      enable_simple_cache
+
+      def found?
+        paths_hash.key?(to_paths_hash_key)
+      end
+
+      def value
+        paths_hash[to_paths_hash_key]
+      end
+
+      def value=(a_value)
+        paths_hash[to_paths_hash_key] = a_value
+        node.persist_data(paths_hash.root.to_h)
+      end
+
+      private
+
+      # @return [EacConfig::PathsHash]
+      def paths_hash_uncached
+        ::EacConfig::PathsHash.new(node.data)
+      end
+
+      def to_paths_hash_key
+        path.parts.join('.')
+      end
+    end
+  end
+end

data/vendor/eac_config/spec/lib/eac_config/envvars_node/entry_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'eac_config/envvars_node/entry'
+
+RSpec.describe ::EacConfig::EnvvarsNode::Entry do
+  describe '#entry_key_to_envvar_name' do
+    {
+      'a.entry.value' => 'A_ENTRY_VALUE',
+      'appli-cation_0.var_one' => 'APPLICATION_0_VAR_ONE'
+    }.each do |input, expected_result|
+      it { expect(described_class.entry_path_to_envvar_name(input)).to eq(expected_result) }
+    end
+  end
+end

data/vendor/eac_config/spec/lib/eac_config/envvars_node_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'eac_config/envvars_node'
+
+RSpec.describe ::EacConfig::EnvvarsNode do
+  let(:instance) { described_class.new }
+
+  before do
+    ENV['COMMON'] = 'AAA'
+    ENV['BLANK'] = ''
+    ENV.delete('NO_EXIST')
+  end
+
+  context 'with common entry' do
+    let(:entry) { instance.entry('common') }
+
+    it { expect(entry).to be_a(::EacConfig::Entry) }
+    it { expect(entry.value).to eq('AAA') }
+    it { expect(entry.found_node).to eq(instance) }
+    it { expect(entry).to be_found }
+  end
+
+  context 'with blank entry' do
+    let(:entry) { instance.entry('blank') }
+
+    it { expect(entry).to be_a(::EacConfig::Entry) }
+    it { expect(entry.value).to eq('') }
+    it { expect(entry.found_node).to eq(instance) }
+    it { expect(entry).to be_found }
+  end
+
+  context 'with not existing entry' do
+    let(:entry) { instance.entry('no.exist') }
+
+    it { expect(entry).to be_a(::EacConfig::Entry) }
+    it { expect(entry.value).to eq(nil) }
+    it { expect(entry.found_node).to eq(nil) }
+    it { expect(entry).not_to be_found }
+  end
+end

data/vendor/eac_config/spec/lib/eac_config/yaml_file_node_spec_files/storage1.yaml

@@ -1,4 +1,6 @@
 ---
 common: AAA
-load_path: storage1_1.yaml:%%STORAGE1_2_ABSOLUTE_PATH%%
+load_path:
+  - storage1_1.yaml
+  - %%STORAGE1_2_ABSOLUTE_PATH%%
 storage1: storage1

data/vendor/eac_config/spec/lib/eac_config/yaml_file_node_spec_files/storage1_2.yaml

@@ -1,3 +1,4 @@
 ---
-load_path: ./storage1_2/storage1_2_1.yaml
+load_path:
+  - ./storage1_2/storage1_2_1.yaml
 storage1_2: storage1_2

data/vendor/eac_git/lib/eac_git/executables.rb

@@ -20,6 +20,10 @@ module EacGit
         r
       end
 
+      def tar_uncached
+        env.executable('tar', '--version')
+      end
+
       module GitCommandExtensions
         def command(*args)
           super(*args).envvar('PATH', path_with_git_subrepo)

data/vendor/eac_git/lib/eac_git/local.rb

@@ -39,13 +39,17 @@ module EacGit
       ::EacGit::Executables.git.command('-C', root_path.to_path, *args)
     end
 
+    def raise_error(message)
+      raise "#{root_path}: #{message}"
+    end
+
     def rev_parse(ref, required = false)
       r = command('rev-parse', ref).execute!(exit_outputs: { 128 => nil, 32_768 => nil })
       r.strip! if r.is_a?(String)
       return r if r.present?
       return nil unless required
 
-      raise "Reference \"#{ref}\" not found"
+      raise_error "Reference \"#{ref}\" not found"
     end
 
     def subrepo(subpath)

data/vendor/eac_git/lib/eac_git/local/commit/archive.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacGit
+  class Local
+    class Commit
+      module Archive
+        # @return [EacRubyUtils::Envs::Command]
+        def archive_to_dir(path)
+          path = path.to_pathname
+          repo.command('archive', '--format=tar', hash).pipe(
+            ::EacGit::Executables.tar.command('-xC', path)
+          )
+        end
+      end
+    end
+  end
+end

data/vendor/eac_git/lib/eac_git/local/subrepo.rb

@@ -12,7 +12,8 @@ module EacGit
 
       common_constructor :local, :subpath do
         self.subpath = subpath.to_pathname
-        raise "Config file \"#{config_absolute_path}\" not found" unless config_absolute_path.file?
+        local.raise_error "Config file \"#{config_absolute_path}\" not found" unless
+          config_absolute_path.file?
       end
 
       def command(subrepo_subcommand, *subrepo_subcommand_args)

data/vendor/eac_git/lib/eac_git/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacGit
-  VERSION = '0.4.2'
+  VERSION = '0.6.0'
 end

data/vendor/eac_ruby_base0/eac_ruby_base0.gemspec

@@ -12,9 +12,9 @@ Gem::Specification.new do |s|
 
   s.files = Dir['{lib}/**/*']
 
-  s.add_dependency 'eac_cli', '~> 0.15', '>= 0.15.1'
+  s.add_dependency 'eac_cli', '~> 0.20'
   s.add_dependency 'eac_ruby_gems_utils', '~> 0.8'
-  s.add_dependency 'eac_ruby_utils', '~> 0.64'
+  s.add_dependency 'eac_ruby_utils', '~> 0.67'
 
   s.add_development_dependency 'eac_ruby_gem_support', '~> 0.2'
 end

data/vendor/eac_ruby_base0/lib/eac_ruby_base0/application.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'eac_ruby_base0/application_xdg'
 require 'eac_ruby_gems_utils/gem'
 require 'eac_ruby_utils/core_ext'
 require 'eac_ruby_utils/filesystem_cache'
@@ -21,16 +22,8 @@ module EacRubyBase0
       vendor_gems + [self_gem]
     end
 
-    { cache: '.cache', config: '.config', data: '.local/share' }.each do |item, subpath|
-      xdg_env_method_name = "#{item}_xdg_env"
-
-      define_method xdg_env_method_name do
-        ENV["XDG_#{item.upcase}_HOME"].if_present(&:to_pathname)
-      end
-
-      define_method "#{item}_dir" do
-        (send(xdg_env_method_name) || home_dir.join(subpath)).join(name)
-      end
+    ::EacRubyBase0::ApplicationXdg::DIRECTORIES.each_key do |item|
+      delegate "#{item}_xdg_env", "#{item}_dir", to: :app_xdg
     end
 
     def fs_cache
@@ -40,7 +33,7 @@ module EacRubyBase0
     end
 
     def home_dir
-      @home_dir ||= (options[OPTION_HOME_DIR] || ENV.fetch('HOME')).to_pathname
+      app_xdg.user_home_dir
     end
 
     def name
@@ -53,6 +46,10 @@ module EacRubyBase0
 
     private
 
+    def app_xdg_uncached
+      ::EacRubyBase0::ApplicationXdg.new(name, options[OPTION_HOME_DIR])
+    end
+
     def self_gem_uncached
       ::EacRubyGemsUtils::Gem.new(gemspec_dir)
     end

data/vendor/eac_ruby_base0/lib/eac_ruby_base0/application_xdg.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EacRubyBase0
+  # https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+  class ApplicationXdg
+    class << self
+      # @return [Pathname]
+      def user_home_dir_from_env
+        ENV.fetch('HOME').to_pathname
+      end
+    end
+
+    DIRECTORIES = { cache: '.cache', config: '.config', data: '.local/share',
+                    state: '.local/state' }.freeze
+
+    common_constructor :app_name, :user_home_dir, default: [nil] do
+      self.user_home_dir ||= self.class.user_home_dir_from_env
+    end
+
+    DIRECTORIES.each do |item, subpath|
+      xdg_env_method_name = "#{item}_xdg_env"
+
+      define_method xdg_env_method_name do
+        ENV["XDG_#{item.upcase}_HOME"].if_present(&:to_pathname)
+      end
+
+      define_method "#{item}_dir" do
+        (send(xdg_env_method_name) || user_home_dir.join(subpath)).join(app_name)
+      end
+    end
+  end
+end