avm-tools 0.97.0 → 0.101.0

data/vendor/avm-eac_asciidoctor_base0/lib/avm/eac_asciidoctor_base0/sources/runner/build.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'avm/eac_asciidoctor_base0/sources/build'
+require 'eac_ruby_base0/core_ext'
+require 'os'
+
+module Avm
+  module EacAsciidoctorBase0
+    module Sources
+      class Runner
+        class Build
+          runner_with :help do
+            desc 'Build the project'
+            arg_opt '-d', '--target-dir', 'Directory to build'
+            bool_opt '--open', 'Show the result.'
+          end
+
+          def run
+            start_banner
+            build.run
+            open
+          end
+
+          private
+
+          def build_uncached
+            ::Avm::EacAsciidoctorBase0::Sources::Build.new(runner_context.call(:project),
+                                                           target_directory: parsed.target_dir)
+          end
+
+          def default_target_directory
+            runner_context.call(:project).root.join('build')
+          end
+
+          def open
+            return unless parsed.open?
+
+            infom "Opening \"#{open_path}\"..."
+            ::EacRubyUtils::Envs.local.command(OS.open_file_command, open_path).system!
+          end
+
+          def open_path
+            build.source_files.first.target_path
+          end
+
+          def start_banner
+            runner_context.call(:project_banner)
+            infov 'Target directory', build.target_directory
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/avm-eac_asciidoctor_base0/lib/avm/eac_asciidoctor_base0/version.rb

@@ -2,6 +2,6 @@
 
 module Avm
   module EacAsciidoctorBase0
-    VERSION = '0.1.0'
+    VERSION = '0.2.1'
   end
 end

data/vendor/eac_cli/eac_cli.gemspec

@@ -12,7 +12,10 @@ Gem::Specification.new do |s|
 
   s.files = Dir['{lib}/**/*', 'Gemfile']
 
-  s.add_dependency 'eac_ruby_utils', '~> 0.55'
+  s.add_dependency 'colorize', '~> 0.8.1'
+  s.add_dependency 'docopt', '~> 0.6.1'
+  s.add_dependency 'eac_config', '~> 0.3'
+  s.add_dependency 'eac_ruby_utils', '~> 0.64'
 
   s.add_development_dependency 'eac_ruby_gem_support', '~> 0.2'
 end

data/vendor/eac_cli/lib/eac_cli/config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_config/envvars_node'
+require 'eac_config/yaml_file_node'
+
+module EacCli
+  class Config
+    require_sub __FILE__
+    attr_reader :sub
+
+    def initialize(sub_node)
+      @sub = sub_node
+    end
+
+    def entry(path, options = {})
+      ::EacCli::Config::Entry.new(self, path, options)
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/config/entry.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'eac_cli/speaker'
+require 'eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Config
+    class Entry
+      require_sub __FILE__, include_modules: true
+      enable_listable
+      enable_simple_cache
+      include ::EacCli::Speaker
+
+      common_constructor :config, :path, :options do
+        self.path = ::EacConfig::EntryPath.assert(path)
+        self.options = ::EacCli::Config::Entry::Options.new(options)
+      end
+
+      def value
+        return sub_value_to_return if sub_entry.found?
+        return nil unless options.required?
+
+        puts "|#{sub_entry.path}|"
+
+        input_value
+      end
+
+      delegate :value=, to: :sub_entry
+
+      private
+
+      def sub_value_to_return
+        sub_entry.value.presence || ::EacRubyUtils::BlankNotBlank.instance
+      end
+
+      def sub_entry_uncached
+        config.sub.entry(path)
+      end
+
+      def input_value_uncached
+        r = send("#{options.type}_value")
+        sub_entry.value = r if options.store?
+        r
+      end
+    end
+  end
+end

data/vendor/{eac_ruby_utils/lib/eac_ruby_utils/console/configs/read_entry_options.rb → eac_cli/lib/eac_cli/config/entry/options.rb}

@@ -2,21 +2,26 @@
 
 require 'eac_ruby_utils/core_ext'
 
-module EacRubyUtils
-  module Console
-    class Configs
-      class ReadEntryOptions
+module EacCli
+  class Config
+    class Entry
+      class Options
         enable_simple_cache
-        common_constructor :options do
-          self.options = options.to_h.symbolize_keys
-                                .assert_valid_keys(DEFAULT_VALUES.keys).freeze
-        end
+        enable_listable
+
+        lists.add_symbol :type, :undefined
 
         DEFAULT_VALUES = {
           before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
-          required: true, store: true, validator: nil
+          required: true, store: true, type: TYPE_UNDEFINED, validator: nil
         }.freeze
 
+        lists.add_symbol :option, *DEFAULT_VALUES.keys
+
+        common_constructor :options do
+          self.options = self.class.lists.option.hash_keys_validate!(options)
+        end
+
         delegate :to_h, to: :options
 
         def [](key)
@@ -27,6 +32,12 @@ module EacRubyUtils
           values.slice(:bool, :list, :noecho)
         end
 
+        DEFAULT_VALUES.each do |attr, default_value|
+          define_method(attr.to_s + ([true, false].include?(default_value) ? '?' : '')) do
+            self[attr]
+          end
+        end
+
         private
 
         def values_uncached

data/vendor/eac_cli/lib/eac_cli/config/entry/undefined.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Config
+    class Entry
+      module Undefined
+        private
+
+        def undefined_value
+          loop do
+            entry_value = undefined_value_no_loop
+            next unless options[:validator].if_present(true) { |v| v.call(entry_value) }
+
+            return entry_value
+          end
+        end
+
+        def undefined_value_no_loop
+          request_input("Value for entry \"#{path}\"", options.request_input_options)
+        end
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/default_runner.rb

@@ -7,7 +7,7 @@ module EacCli
   module DefaultRunner
     common_concern do
       include ::EacCli::RunnerWith::Help
-      enable_console_speaker
+      enable_speaker
       enable_simple_cache
     end
   end

data/vendor/eac_cli/lib/eac_cli/definition/help_formatter.rb

@@ -27,7 +27,7 @@ module EacCli
 
       def positional_argument(positional)
         if positional.subcommand?
-          ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
+          ::EacCli::DocoptRunner::SUBCOMMANDS_MACRO
         else
           r = "<#{positional.name}>"
           r += '...' if positional.repeat?
@@ -52,7 +52,7 @@ module EacCli
       end
 
       def self_usage_arguments
-        [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
+        [::EacCli::DocoptRunner::PROGRAM_MACRO] +
           definition.options_argument.if_present([]) { |_v| ['[options]'] } +
           self_usage_arguments_options +
           self_usage_arguments_positional

data/vendor/eac_cli/lib/eac_cli/definition/positional_argument.rb

@@ -6,9 +6,10 @@ module EacCli
   class Definition
     class PositionalArgument
       DEFAULT_REQUIRED = true
+      DEFAULT_VISIBLE = true
 
       enable_listable
-      lists.add_symbol :option, :optional, :repeat, :required, :subcommand
+      lists.add_symbol :option, :optional, :repeat, :required, :subcommand, :visible
       common_constructor :name, :options, default: [{}] do
         options.assert_valid_keys(self.class.lists.option.values)
       end
@@ -51,6 +52,10 @@ module EacCli
       def to_s
         "#{self.class.name.demodulize}[#{identifier}]"
       end
+
+      def visible?
+        options.key?(OPTION_VISIBLE) ? options.fetch(OPTION_VISIBLE) : DEFAULT_VISIBLE
+      end
     end
   end
 end

data/vendor/eac_cli/lib/eac_cli/docopt/doc_builder.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/console/docopt_runner'
+require 'eac_cli/docopt_runner'
 
 module EacCli
   module Docopt

data/vendor/eac_cli/lib/eac_cli/docopt/doc_builder/alternative.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/console/docopt_runner'
+require 'eac_cli/docopt_runner'
 
 module EacCli
   module Docopt
@@ -11,7 +11,7 @@ module EacCli
 
         def to_s
           (
-            [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
+            [::EacCli::DocoptRunner::PROGRAM_MACRO] +
               alternative.options_argument?.if_present([]) { |_v| ['[options]'] } +
               options +
               positionals
@@ -31,12 +31,14 @@ module EacCli
         end
 
         def positionals
-          alternative.positional.map { |p| positional(p) }
+          alternative.positional.map { |p| positional(p) }.reject(&:blank?)
         end
 
         def positional(positional)
+          return unless positional.visible?
+
           if positional.subcommand?
-            ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
+            ::EacCli::DocoptRunner::SUBCOMMANDS_MACRO
           else
             r = "<#{positional.name}>"
             r += '...' if positional.repeat?

data/vendor/eac_cli/lib/eac_cli/docopt/runner_extension.rb

@@ -3,7 +3,7 @@
 require 'eac_cli/docopt/doc_builder'
 require 'eac_cli/docopt/runner_context_replacement'
 require 'eac_cli/runner'
-require 'eac_ruby_utils/console/docopt_runner'
+require 'eac_cli/docopt_runner'
 
 module EacCli
   module Docopt
@@ -16,7 +16,7 @@ module EacCli
 
       class << self
         def check(klass)
-          return unless klass < ::EacRubyUtils::Console::DocoptRunner
+          return unless klass < ::EacCli::DocoptRunner
 
           ::EacCli::Runner.alias_runner_class_methods(klass, '', 'eac_cli')
           ::EacCli::Runner.alias_runner_class_methods(klass, 'original', '')

data/vendor/eac_cli/lib/eac_cli/docopt_runner.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'docopt'
+
+module EacCli
+  class DocoptRunner
+    require_sub __FILE__
+    include ::EacCli::DocoptRunner::Context
+
+    class << self
+      def create(settings = {})
+        new(settings)
+      end
+    end
+
+    attr_reader :settings
+
+    def initialize(settings = {})
+      @settings = settings.with_indifferent_access.freeze
+      check_subcommands
+    end
+
+    def options
+      @options ||= ::Docopt.docopt(target_doc, docopt_options)
+    end
+
+    def parent
+      settings[:parent]
+    end
+
+    protected
+
+    def docopt_options
+      settings.slice(:version, :argv, :help, :options_first).to_sym_keys_hash
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/docopt_runner/_class_methods.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module EacCli
+  class DocoptRunner
+    DOCOPT_ERROR_EXIT_CODE = 0xC0
+
+    class << self
+      def run(options = {})
+        create(options).send(:run)
+      rescue Docopt::Exit => e
+        STDERR.write(e.message + "\n")
+        ::Kernel.exit(DOCOPT_ERROR_EXIT_CODE)
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/docopt_runner/_doc.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module EacCli
+  class DocoptRunner
+    PROGRAM_MACRO = '__PROGRAM__'
+
+    def source_doc
+      setting_value(:doc)
+    end
+
+    def target_doc
+      source_doc.gsub(PROGRAM_MACRO, target_program_name).strip + "\n"
+    end
+
+    def source_program_name
+      setting_value(:program_name, false)
+    end
+
+    def target_program_name
+      [source_program_name, ENV['PROGRAM_NAME'], $PROGRAM_NAME].find(&:present?)
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/docopt_runner/_settings.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/settings_provider'
+
+module EacCli
+  class DocoptRunner
+    include ::EacRubyUtils::SettingsProvider
+
+    attr_reader :settings
+
+    private
+
+    def setting_value(key, required = true)
+      super(key, required: required, order: %w[method settings_object constant])
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/docopt_runner/_subcommands.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'shellwords'
+
+module EacCli
+  class DocoptRunner
+    SUBCOMMAND_ARG = '<subcommand>'
+    SUBCOMMAND_ARGS_ARG = '<subcommand-args>'
+    SUBCOMMANDS_MACRO = '__SUBCOMMANDS__'
+
+    def subcommands?
+      source_doc.include?(SUBCOMMANDS_MACRO)
+    end
+
+    def check_subcommands
+      return unless subcommands?
+
+      singleton_class.include(SubcommandsSupport)
+      check_subcommands_arg
+      return if singleton_class.method_defined?(:run)
+
+      singleton_class.send(:alias_method, :run, :run_with_subcommand)
+    end
+
+    module SubcommandsSupport
+      EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME = :extra_available_subcommands
+
+      def check_subcommands_arg
+        if subcommand_arg_as_list?
+          singleton_class.include(SubcommandsSupport::SubcommandArgAsList)
+        else
+          singleton_class.include(SubcommandsSupport::SubcommandArgAsArg)
+        end
+      end
+
+      def run_with_subcommand
+        if subcommand_name
+          check_valid_subcommand
+          subcommand_run
+        else
+          run_without_subcommand
+        end
+      end
+
+      def subcommand
+        @subcommand ||= subcommand_class_name(subcommand_name).constantize.create(
+          argv: subcommand_args,
+          program_name: subcommand_program,
+          parent: self
+        )
+      end
+
+      def subcommand_run
+        if !subcommand.is_a?(::EacCli::DocoptRunner) &&
+           subcommand.respond_to?(:run_run)
+          subcommand.run_run
+        else
+          subcommand.run
+        end
+      end
+
+      def target_doc
+        super.gsub(SUBCOMMANDS_MACRO,
+                   "#{target_doc_subcommand_arg} [#{SUBCOMMAND_ARGS_ARG}...]") +
+          "\n" + subcommands_target_doc
+      end
+
+      def docopt_options
+        super.merge(options_first: true)
+      end
+
+      def subcommand_class_name(subcommand)
+        "#{self.class.name}::#{subcommand.underscore.camelize}"
+      end
+
+      def subcommand_arg_as_list?
+        setting_value(:subcommand_arg_as_list, false) || false
+      end
+
+      def subcommand_args
+        options.fetch(SUBCOMMAND_ARGS_ARG)
+      end
+
+      def subcommand_program
+        subcommand_name
+      end
+
+      def available_subcommands
+        r = ::Set.new(setting_value(:subcommands, false) || auto_available_subcommands)
+        if respond_to?(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME, true)
+          r += send(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME)
+        end
+        r.sort
+      end
+
+      def auto_available_subcommands
+        self.class.constants
+            .map { |name| self.class.const_get(name) }
+            .select { |c| c.instance_of? Class }
+            .select { |c| c < ::EacCli::DocoptRunner }
+            .map { |c| c.name.demodulize.underscore.dasherize }
+      end
+
+      def run_without_subcommand
+        "Method #{__method__} should be overrided in #{self.class.name}"
+      end
+
+      protected
+
+      def check_valid_subcommand
+        return if available_subcommands.include?(subcommand_name)
+
+        raise ::Docopt::Exit, "\"#{subcommand_name}\" is not a valid subcommand" \
+          " (Valid: #{available_subcommands.join(', ')})"
+      end
+
+      module SubcommandArgAsArg
+        def target_doc_subcommand_arg
+          SUBCOMMAND_ARG
+        end
+
+        def subcommand_name
+          options.fetch(SUBCOMMAND_ARG)
+        end
+
+        def subcommands_target_doc
+          available_subcommands.inject("Subcommands:\n") do |a, e|
+            a + "  #{e}\n"
+          end
+        end
+      end
+
+      module SubcommandArgAsList
+        def target_doc_subcommand_arg
+          '(' + available_subcommands.join('|') + ')'
+        end
+
+        def subcommand_name
+          available_subcommands.each do |subcommand|
+            return subcommand if options.fetch(subcommand)
+          end
+          nil
+        end
+
+        def subcommands_target_doc
+          "\n"
+        end
+      end
+    end
+  end
+end