eac_tools 0.121.0 → 0.123.0

data/sub/eac_config/spec/lib/eac_config/old_configs_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+RSpec.describe EacConfig::OldConfigs do
+  let(:configs_key) { 'configsspec' }
+  let(:storage_path) do
+    file = Tempfile.new(configs_key)
+    path = file.path
+    file.close
+    file.unlink
+    path
+  end
+  let(:instance) { described_class.new(configs_key, storage_path: storage_path) }
+
+  describe '#storage_path' do
+    it { expect(instance.storage_path).to eq(storage_path) }
+  end
+
+  describe '#write' do
+    let(:entry_key) { 'parent.child' }
+
+    before do
+      instance[entry_key] = 'value1'
+      instance.save
+    end
+
+    it { expect(YAML.load_file(storage_path)).to eq(parent: { child: 'value1' }) }
+  end
+
+  describe '#read' do
+    let(:present_key) { 'a.present.key' }
+    let(:blank_key) { 'a.blank.key' }
+
+    before do
+      instance[present_key] = 'A value'
+      instance[blank_key] = ''
+      instance.save
+      instance.load
+    end
+
+    it { expect(instance[present_key]).to be_present }
+    it { expect(instance[blank_key]).to be_present }
+  end
+end

data/sub/eac_config/spec/lib/eac_config/paths_hash_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+RSpec.describe EacConfig::PathsHash do
+  let(:source_hash) do
+    {
+      parent: {
+        child1: {
+          child1_1: 'v1_1', # rubocop:disable Naming/VariableNumber
+          child1_2: 'v1_2' # rubocop:disable Naming/VariableNumber
+        },
+        child2: 'v2'
+      }
+    }
+  end
+  let(:instance) { described_class.new(source_hash) }
+
+  describe '#[]' do
+    {
+      'parent.child1.child1_1' => 'v1_1',
+      'parent.child1.child1_2' => 'v1_2',
+      'parent.child2' => 'v2',
+      'no_exist' => nil,
+      'parent.child1' => {
+        child1_1: 'v1_1', # rubocop:disable Naming/VariableNumber
+        child1_2: 'v1_2' # rubocop:disable Naming/VariableNumber
+      }
+    }.each do |entry_key, expected_value|
+      it { expect(instance[entry_key]).to eq(expected_value) }
+    end
+
+    ['.only_suffix', '', '.', 'only_prefx.', 'empty..part'].each do |entry_key|
+      it "invalid entry key \"#{entry_key}\" raises EntryKeyError" do
+        expect { instance[entry_key] }.to raise_error(EacConfig::PathsHash::EntryKeyError)
+      end
+    end
+  end
+
+  describe '#[]=' do
+    let(:source_hash) { {} }
+
+    before do
+      instance['a.b.c'] = '123'
+    end
+
+    it { expect(instance.to_h).to eq(a: { b: { c: '123' } }) }
+  end
+
+  describe '#key?' do
+    {
+      'parent.child1.child1_1' => true,
+      'parent.child1.child1_2' => true,
+      'parent.child1.child1_2.no_exist' => false,
+      'parent.child1.child1_3' => false,
+      'parent.child2' => true,
+      'no_exist' => false,
+      'parent.child1' => true
+    }.each do |entry_key, expected_value|
+      it { expect(instance.key?(entry_key)).to eq(expected_value) }
+    end
+  end
+end

data/sub/eac_config/spec/lib/eac_config/yaml_file_node_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+RSpec.describe EacConfig::YamlFileNode do
+  storages = %w[1 1_1 1_2 1_2_1].map do |suffix|
+    key = "storage#{suffix}"
+    subpath = "#{key}.yaml"
+    subpath = "storage1_2/#{subpath}" if suffix == '1_2_1'
+    EacRubyUtils::Struct.new(suffix: suffix, key: key, subpath: subpath.to_pathname)
+  end
+
+  let(:fixtures_dir) { Pathname.new(__dir__).join('yaml_file_node_spec_files') }
+  let(:instance) { storage1 }
+
+  storages.each do |storage|
+    let(storage.key) { described_class.new(fixtures_dir.join(storage.subpath)) }
+  end
+
+  describe '#entry' do
+    context 'with common entry' do
+      let(:entry) { instance.entry('common') }
+
+      it { expect(entry.value).to eq('AAA') }
+      it { expect(entry.found_node).to eq(instance) }
+      it { expect(entry).to be_found }
+    end
+
+    storages.each do |storage|
+      context "with entry in loaded path \"#{storage.subpath}\"" do
+        let(:entry) { instance.entry(storage.key) }
+        let(:storage_node) { send(storage.key) }
+
+        it { expect(entry).to be_a(EacConfig::Entry) }
+        it { expect(entry).to be_found }
+        it { expect(entry.value).to eq(storage.key) }
+        it { expect(entry.found_node.url).to eq(storage_node.url) }
+      end
+    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 be_nil }
+      it { expect(entry.found_node).to be_nil }
+      it { expect(entry).not_to be_found }
+    end
+  end
+
+  describe '#entries' do
+    context 'when search path is "common"' do
+      let(:path) { 'common' }
+      let(:actual) { instance.entries(path).node_entries }
+      let(:expected) { [EacConfig::YamlFileNode::Entry.new(storage1, path)] }
+
+      it { expect(actual).to eq(expected) }
+    end
+
+    context 'when search path is "same.path"' do
+      let(:path) { 'same.path' }
+      let(:actual) { instance.entries(path).node_entries }
+      let(:expected) do
+        [storage1_1, storage1_2_1].map do |n|
+          EacConfig::YamlFileNode::Entry.new(n, 'same.path')
+        end
+      end
+
+      it { expect(actual).to eq(expected) }
+    end
+
+    context 'when search path is "*.search_me"' do
+      let(:path) { '*.search_me' }
+      let(:actual) { instance.entries(path).node_entries }
+      let(:expected) do
+        [
+          [storage1, 'storage1_a'], [storage1, 'storage1_b'],
+          [storage1_2, 'storage1_2_a'], [storage1_2, 'storage1_2_b'], [storage1_2, 'storage1_2_c']
+        ].map do |args|
+          EacConfig::YamlFileNode::Entry.new(args[0], "#{args[1]}.search_me")
+        end
+      end
+
+      it { expect(actual).to eq(expected) }
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+---
+common: AAA
+load_path:
+  - storage1_1.yaml
+  - storage1_2.yaml
+storage1: storage1
+storage1_a:
+  search_me: 1_a
+storage1_b:
+  search_me: 1_b

data/sub/eac_config/spec/lib/eac_config/yaml_file_node_spec_files/storage1_1.yaml

@@ -0,0 +1,4 @@
+---
+storage1_1: storage1_1
+same:
+  path: SAME_PATH_1_1

data/sub/eac_config/spec/lib/eac_config/yaml_file_node_spec_files/storage1_2/storage1_2_1.yaml

@@ -0,0 +1,4 @@
+---
+storage1_2_1: storage1_2_1
+same:
+  path: SAME_PATH_1_2_1

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

@@ -0,0 +1,10 @@
+---
+load_path:
+  - ./storage1_2/storage1_2_1.yaml
+storage1_2: storage1_2
+storage1_2_a:
+  search_me: 1_2_a
+storage1_2_b:
+  search_me: 1_2_a
+storage1_2_c:
+  search_me: 1_2_a

data/sub/eac_config/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'eac_config'
+require 'eac_ruby_gem_support'
+EacRubyUtils::Rspec.default_setup_create(File.expand_path('..', __dir__))

data/sub/eac_ruby_base0/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.local
+Gemfile.lock

data/sub/eac_ruby_base0/.gitrepo

@@ -0,0 +1,7 @@
+[subrepo]
+  cmdver = 0.4.9
+  commit = 0e92adc8d772d22604cab274855132c31baa03f0
+  method = merge
+  parent = bed291a0ae271a2c80953038b898483049cfb970
+  branch = master
+  remote = https://github.com/esquilo-azul/eac_ruby_base0.git

data/sub/eac_ruby_base0/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/sub/eac_ruby_base0/.rubocop.yml

@@ -0,0 +1,3 @@
+---
+inherit_gem:
+  eac_ruby_gem_support: ".rubocop.yml"

data/sub/eac_ruby_base0/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+local_gemfile = File.join(File.dirname(__FILE__), 'Gemfile.local')
+eval_gemfile local_gemfile if File.exist?(local_gemfile)

data/sub/eac_ruby_base0/eac_ruby_base0.gemspec

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+require 'eac_ruby_base0/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'eac_ruby_base0'
+  s.version     = EacRubyBase0::VERSION
+  s.authors     = ['Put here the authors']
+  s.summary     = 'Put here de description.'
+
+  s.files = Dir['{lib}/**/*']
+  s.required_ruby_version = '>= 3.2' # rubocop:disable Gemspec/RequiredRubyVersion
+
+  s.add_dependency 'avm-eac_ruby_base1', '~> 0.45'
+  s.add_dependency 'eac_cli', '~> 0.47', '>= 0.47.1'
+  s.add_dependency 'eac_fs', '~> 0.20', '>= 0.20.3'
+  s.add_dependency 'eac_ruby_base1', '~> 0.1', '>= 0.1.1'
+
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.15'
+end

data/sub/eac_ruby_base0/lib/eac_ruby_base0/application.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module EacRubyBase0
+  class Application
+    enable_simple_cache
+    enable_listable
+    lists.add_symbol :option, :name, :home_dir
+
+    common_constructor :gemspec_dir, :options, default: [{}] do
+      self.gemspec_dir = gemspec_dir.to_pathname
+      self.options = options.symbolize_keys.assert_valid_keys(self.class.lists.option.values).freeze
+    end
+
+    delegate :version, to: :self_gem
+
+    def all_gems
+      sub_gems + [self_gem]
+    end
+
+    # @return [EacCli::Config]
+    def build_config(path = nil)
+      envvar_node = ::EacConfig::EnvvarsNode.new
+      file_node = ::EacConfig::YamlFileNode.new(path || config_default_path)
+      envvar_node.load_path.push(file_node.url)
+      envvar_node.write_node = file_node
+      ::EacCli::Config.new(envvar_node)
+    end
+
+    # @return [EacCli::Config]
+    def config_default_path
+      config_dir.join('eac_config.yaml')
+    end
+
+    ::EacRubyBase0::ApplicationXdg::DIRECTORIES.each_key do |item|
+      delegate "#{item}_xdg_env", "#{item}_dir", to: :app_xdg
+    end
+
+    ::EacFs::Contexts::TYPES.each do |type|
+      class_eval <<CODE, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
+  # @return [EacFs::StorageTree]
+  def self_fs_#{type}
+    @self_fs_#{type} ||= ::EacFs::StorageTree.new(#{type}_dir.join('eac_fs'))
+  end
+CODE
+    end
+
+    def home_dir
+      app_xdg.user_home_dir
+    end
+
+    def name
+      options[OPTION_NAME] || self_gem.gem_name
+    end
+
+    def vendor_dir
+      gemspec_dir.join('sub')
+    end
+
+    private
+
+    def app_xdg_uncached
+      ::EacRubyBase0::ApplicationXdg.new(name, options[OPTION_HOME_DIR])
+    end
+
+    # @return [Avm::EacRubyBase1::Sources::Base]
+    def self_gem_uncached
+      ::Avm::EacRubyBase1::Sources::Base.new(gemspec_dir)
+    end
+
+    def sub_gems_uncached
+      r = []
+      vendor_dir.children.each do |c|
+        vgem = ::Avm::EacRubyBase1::Sources::Base.new(c)
+        r << vgem if vgem.gemfile_path.exist?
+      end
+      r
+    end
+  end
+end

data/sub/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
+        Dir.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

data/sub/eac_ruby_base0/lib/eac_ruby_base0/error_presenter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module EacRubyBase0
+  class ErrorPresenter
+    enable_memoized
+    enable_speaker
+    common_constructor :the_error
+
+    # @return [EacRubyBase0::ErrorPresenter, nil]
+    memoize def cause
+      the_error.cause.if_present { |v| self.class.new(v) }
+    end
+
+    # @return [String]
+    def full_backtrace_message
+      the_error.backtrace.map { |v| "#{v}\n" }.join
+    end
+
+    # @return [String]
+    def full_message
+      self_full_message + cause.if_present('') do |e|
+        "#{'-' * 16}\n#{e.full_message}"
+      end
+    end
+
+    # @return [String]
+    def message
+      "#{the_error.message} (#{the_error.class})"
+    end
+
+    # @return [Pathname]
+    def log_path
+      @log_path ||= ::EacRubyUtils::Fs::Temp.file.to_pathname.tap { |e| e.write(full_message) }
+    end
+
+    # @return [String]
+    def self_full_message
+      "Error class: #{the_error.class}\n" \
+      "Message: #{the_error.message}\n" \
+      "Backtrace:\n" + the_error.backtrace.map { |v| "#{v}\n" }.join
+    end
+
+    # @return [void]
+    def show
+      show_message
+      show_log_file
+    end
+
+    # @return [void]
+    def show_message(caused_by = false) # rubocop:disable Style/OptionalBooleanParameter
+      prefix = caused_by ? 'Caused by: ' : ''
+      error [prefix, message].join
+      cause.if_present { |v| v.show_message(true) }
+    end
+
+    # @return [void]
+    def show_log_file
+      infov 'Full log', log_path
+    end
+  end
+end

data/sub/eac_ruby_base0/lib/eac_ruby_base0/jobs_runner.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module EacRubyBase0
+  module JobsRunner
+    common_concern do
+      enable_speaker
+      include ::EacRubyUtils::SettingsProvider
+    end
+
+    def run_job(job)
+      return unless run_job?(job)
+
+      infom "Running job \"#{job}\"..."
+      send(job)
+    end
+
+    def run_job?(job)
+      the_method = "run_#{job}?"
+      respond_to?(the_method, true) ? send(the_method) : true
+    end
+
+    def run_jobs(*jobs)
+      jobs = setting_value(:jobs) if jobs.empty?
+      r = nil
+      jobs.each { |job| r = run_job(job) }
+      success 'Done'
+      r
+    end
+  end
+end

data/sub/eac_ruby_base0/lib/eac_ruby_base0/patches/class/jobs_runner.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Class
+  def enable_jobs_runner
+    ::EacRubyUtils.patch_module(self, ::EacRubyBase0::JobsRunner)
+  end
+end

data/sub/eac_ruby_base0/lib/eac_ruby_base0/rspec/setup.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module EacRubyBase0
+  module Rspec
+    module Setup
+      def self.extended(obj)
+        obj.disable_input_request
+        obj.stub_eac_config_node
+      end
+    end
+  end
+end

data/sub/eac_ruby_base0/lib/eac_ruby_base0/runner/contexts.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module EacRubyBase0
+  module Runner
+    module Contexts
+      def on_context(&block)
+        top_block = block
+        available_contexts.each do |context|
+          next if context.object.any?
+
+          last_block = top_block
+          top_block = proc { context.object.on(context.builder.call, &last_block) }
+        end
+        top_block.call
+      end
+
+      private
+
+      # @return [Array<EacRubyUtils::Struct>]
+      def available_contexts
+        (filesystem_available_contexts + [
+          [:config, ::EacConfig::Node.context,
+           -> { runner_context.call(:application).build_config }],
+          [:speaker, ::EacRubyUtils::Speaker.context, -> { build_speaker }]
+        ]).map { |row| available_context_row_to_struct(row) }
+      end
+
+      def available_context_row_to_struct(row)
+        %i[type object builder].zip(row).to_h.to_struct
+      end
+
+      def build_speaker
+        options = {}
+        options[:err_out] = ::StringIO.new if parsed.quiet?
+        options[:in_in] = ::EacCli::Speaker::InputBlocked.new if parsed.no_input?
+        ::EacCli::Speaker.new(options)
+      end
+
+      def filesystem_available_contexts
+        ::EacFs::Contexts::TYPES.map do |type|
+          key = :"fs_#{type}"
+          [key, ::EacFs::Contexts.send(type), -> { application.send("self_#{key}") }]
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_base0/lib/eac_ruby_base0/runner/prepend.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module EacRubyBase0
+  module Runner
+    module Prepend
+      ERROR_EXIT_CODE = 113
+      DISABLE_RESCUE_ENVVAR = 'DISABLE_RESCUE'
+
+      # @return [Boolean]
+      def disable_rescue?
+        ::ENV.fetch(DISABLE_RESCUE_ENVVAR, false).to_bool
+      end
+
+      def run
+        on_rescue_errors do
+          if parsed.version?
+            show_version
+          else
+            run_with_subcommand
+          end
+        end
+      end
+
+      def run_run
+        on_context { super }
+      end
+
+      protected
+
+      # @return [void]
+      def on_rescue_errors
+        yield
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        raise e if disable_rescue?
+
+        ::EacRubyBase0::ErrorPresenter.new(e).show
+        exit ERROR_EXIT_CODE
+      end
+    end
+  end
+end

data/sub/eac_ruby_base0/lib/eac_ruby_base0/runner.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module EacRubyBase0
+  module Runner
+    enable_speaker
+    common_concern do
+      include ::EacCli::RunnerWith::Help
+      include ::EacCli::RunnerWith::Subcommands
+      include ::EacRubyBase0::Runner::Contexts
+      prepend ::EacRubyBase0::Runner::Prepend
+
+      runner_definition do
+        bool_opt '-q', '--quiet', 'Quiet mode.'
+        bool_opt '-I', '--no-input', 'Fail if a input is requested.'
+        subcommands
+        alt do
+          bool_opt '-V', '--version', 'Show version.', usage: true, required: true
+        end
+      end
+    end
+
+    def application_version
+      runner_context.call(:application).version.to_s
+    end
+
+    def show_version
+      out("#{application_version}\n")
+    end
+  end
+end

data/sub/eac_ruby_base0/lib/eac_ruby_base0/version.rb

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

data/sub/{avm/lib/avm.rb → eac_ruby_base0/lib/eac_ruby_base0.rb}

@@ -2,10 +2,8 @@
 
 require 'eac_ruby_base1'
 EacRubyBase1::RootModuleSetup.perform __FILE__ do
-  ignore 'rspec/shared_examples/*'
-  require 'eac_docker'
-  require 'eac_fs'
+  require 'avm/eac_ruby_base1'
   require 'eac_cli'
   require 'eac_config'
-  require 'rspec'
+  require 'eac_fs'
 end

data/sub/eac_ruby_base0/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_base0'
+require 'eac_ruby_gem_support'
+EacRubyUtils::Rspec.default_setup_create(File.expand_path('..', __dir__))