avm-tools 0.95.0 → 0.99.1

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs/password_entry_reader.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs/entry_reader'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      class PasswordEntryReader < ::EacRubyUtils::Console::Configs::EntryReader
-        ENTRY_KEY = 'core.store_passwords'
-
-        def initialize(console_configs, entry_key, options = {})
-          super(console_configs, entry_key, options.merge(noecho: true,
-                                                          store: console_configs.store_passwords?))
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs/read_entry_options.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      class ReadEntryOptions
-        enable_simple_cache
-        common_constructor :options do
-          self.options = options.to_h.symbolize_keys
-                                .assert_valid_keys(DEFAULT_VALUES.keys).freeze
-        end
-
-        DEFAULT_VALUES = {
-          before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
-          required: true, store: true, validator: nil
-        }.freeze
-
-        delegate :to_h, to: :options
-
-        def [](key)
-          values.fetch(key.to_sym)
-        end
-
-        def request_input_options
-          values.slice(:bool, :list, :noecho)
-        end
-
-        private
-
-        def values_uncached
-          consumer = options.to_options_consumer
-          r = {}
-          DEFAULT_VALUES.each do |key, default_value|
-            value = consumer.consume(key)
-            value = default_value if value.nil?
-            r[key] = value
-          end
-          consumer.validate
-          r
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs/store_passwords_entry_reader.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs/entry_reader'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      class StorePasswordsEntryReader < ::EacRubyUtils::Console::Configs::EntryReader
-        ENTRY_KEY = 'core.store_passwords'
-
-        def initialize(console_configs)
-          super(console_configs, ENTRY_KEY,
-            before_input: -> { banner },
-            validator: ->(entry_value) { %w[yes no].include?(entry_value) }
-          )
-        end
-
-        def banner
-          infom 'Do you wanna to store passwords?'
-          infom 'Warning: the passwords will be store in clear text in ' \
-            "\"#{console_configs.configs.storage_path}\""
-          infom 'Enter "yes" or "no"'
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/docopt_runner.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/hash/slice'
-require 'docopt'
-require 'eac_ruby_utils/contextualizable'
-require 'eac_ruby_utils/patches/hash/sym_keys_hash'
-Dir["#{__dir__}/#{::File.basename(__FILE__, '.*')}/_*.rb"].sort.each do |partial|
-  require partial
-end
-
-module EacRubyUtils
-  module Console
-    class DocoptRunner
-      include ::EacRubyUtils::Contextualizable
-
-      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
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/docopt_runner/_class_methods.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Console
-    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) # rubocop:disable Rails/Exit
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/docopt_runner/_doc.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Console
-    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
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/docopt_runner/_settings.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/settings_provider'
-
-module EacRubyUtils
-  module Console
-    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
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/docopt_runner/_subcommands.rb

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string/inflections'
-require 'shellwords'
-
-module EacRubyUtils
-  module Console
-    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?(::EacRubyUtils::Console::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 < ::EacRubyUtils::Console::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
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/speaker.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require 'colorize'
-require 'io/console'
-require 'eac_ruby_utils/patches/hash/options_consumer'
-require 'eac_ruby_utils/require_sub'
-::EacRubyUtils.require_sub __FILE__
-
-module EacRubyUtils
-  module Console
-    # https://github.com/fazibear/colorize
-    module Speaker
-      def on_speaker_node(&block)
-        ::EacRubyUtils::Console::Speaker.on_node(&block)
-      end
-
-      def puts(string = '')
-        string.to_s.each_line do |line|
-          current_node.stderr.puts(current_node.stderr_line_prefix.to_s + line)
-        end
-      end
-
-      def out(string = '')
-        current_node.stdout.write(string.to_s)
-      end
-
-      def fatal_error(string)
-        puts "ERROR: #{string}".white.on_red
-        Kernel.exit 1 # rubocop:disable Rails/Exit
-      end
-
-      def title(string)
-        string = string.to_s
-        puts(('-' * (8 + string.length)).green)
-        puts("--- #{string} ---".green)
-        puts(('-' * (8 + string.length)).green)
-        puts
-      end
-
-      def info(string)
-        puts string.to_s.white
-      end
-
-      def infom(string)
-        puts string.to_s.light_yellow
-      end
-
-      def warn(string)
-        puts string.to_s.yellow
-      end
-
-      # Options:
-      #   +bool+ ([Boolean], default: +false+): requires a answer "yes" or "no".
-      #   +list+ ([Hash] or [Array], default: +nil+): requires a answer from a list.
-      #   +noecho+ ([Boolean], default: +false+): does not output answer.
-      def request_input(question, options = {})
-        bool, list, noecho = options.to_options_consumer.consume_all(:bool, :list, :noecho)
-        if list
-          request_from_list(question, list, noecho)
-        elsif bool
-          request_from_bool(question, noecho)
-        else
-          request_string(question, noecho)
-        end
-      end
-
-      def infov(*args)
-        r = []
-        args.each_with_index do |v, i|
-          if i.even?
-            r << "#{v}: ".cyan
-          else
-            r.last << v.to_s
-          end
-        end
-        puts r.join(', ')
-      end
-
-      def success(string)
-        puts string.to_s.green
-      end
-
-      private
-
-      def list_value(list, input)
-        values = list_values(list)
-        return input, true unless values
-        return input, false unless values.include?(input)
-      end
-
-      def list_values(list)
-        if list.is_a?(::Hash)
-          list.keys.map(&:to_s)
-        elsif list.is_a?(::Array)
-          list.map(&:to_s)
-        end
-      end
-
-      def request_from_bool(question, noecho)
-        request_from_list(question, { yes: true, y: true, no: false, n: false }, noecho)
-      end
-
-      def request_from_list(question, list, noecho)
-        list = ::EacRubyUtils::Console::Speaker::List.build(list)
-        loop do
-          input = request_string("#{question} [#{list.valid_labels.join('/')}]", noecho)
-          return list.build_value(input) if list.valid_value?(input)
-
-          warn "Invalid input: \"#{input}\" (Valid: #{list.valid_labels.join(', ')})"
-        end
-      end
-
-      def request_string(question, noecho)
-        current_node.stderr.write "#{question}: ".to_s.yellow
-        noecho ? request_string_noecho : request_string_echo
-      end
-
-      def request_string_noecho
-        r = current_node.stdin.noecho(&:gets).chomp.strip
-        current_node.stderr.write("\n")
-        r
-      end
-
-      def request_string_echo
-        current_node.stdin.gets.chomp.strip
-      end
-
-      def current_node
-        ::EacRubyUtils::Console::Speaker.current_node
-      end
-    end
-  end
-end