avm-tools 0.96.0 → 0.100.0

data/lib/eac_launcher/ruby/gem/specification.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/object'
-
-module EacLauncher
-  module Ruby
-    module Gem
-      class Specification
-        class << self
-          def parse_version_file(file)
-            s = ::File.read(file)
-            m = /VERSION\s*=\s*[\'\"]([^\'\"]+)[\'\"]/.match(s)
-            m ? m[1] : nil
-          end
-        end
-
-        attr_reader :gemspec_file
-
-        def initialize(gemspec_file)
-          @gemspec_file = gemspec_file
-        end
-
-        def version
-          v = self.class.parse_version_file(version_file)
-          return v if v.present?
-
-          raise "Version not found on file \"#{version_file}\""
-        end
-
-        def name
-          ::File.basename(gemspec_file).gsub(/\.gemspec\z/, '')
-        end
-
-        def full_name
-          "#{name}-#{version}"
-        end
-
-        def to_s
-          full_name
-        end
-
-        private
-
-        def gem_root
-          ::File.dirname(gemspec_file)
-        end
-
-        def version_file
-          f = ::File.join(gem_root, 'lib', *namespace_parts, 'version.rb')
-          return f if ::File.exist?(f)
-
-          raise "Version file \"#{f}\" does not exist"
-        end
-
-        def namespace_parts
-          name.split('-')
-        end
-      end
-    end
-  end
-end

data/lib/eac_launcher/vendor.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_launcher/vendor/github'

data/lib/eac_launcher/vendor/github.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module EacLauncher
-  module Vendor
-    module Github
-      class << self
-        def to_ssh_url(url)
-          return nil if url.blank?
-
-          url_no_dot_git = url.gsub(/\.git\z/, '')
-
-          m = %r{\Ahttps://github.com/([^/]+)/([^/]+)\z}.match(url_no_dot_git.to_s)
-          m ? "git@github.com:#{m[1]}/#{m[2]}.git" : url
-        end
-      end
-    end
-  end
-end

data/lib/eac_launcher/version.rb

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

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

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs'
-require 'eac_ruby_utils/console/docopt_runner'
-require 'eac_ruby_utils/console/speaker'

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/configs'
-require 'eac_ruby_utils/core_ext'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      require_sub __FILE__
-      enable_console_speaker
-
-      class << self
-        def entry_key_to_envvar_name(entry_key)
-          ::EacRubyUtils::Console::Configs::EntryReader.entry_key_to_envvar_name(entry_key)
-        end
-      end
-
-      attr_reader :configs
-
-      def initialize(configs_key, options = {})
-        options.assert_argument(::Hash, 'options')
-        @configs = ::EacRubyUtils::Configs.new(configs_key, options.merge(autosave: true))
-      end
-
-      def read_password(entry_key, options = {})
-        ::EacRubyUtils::Console::Configs::PasswordEntryReader.new(self, entry_key, options).read
-      end
-
-      def read_entry(entry_key, options = {})
-        ::EacRubyUtils::Console::Configs::EntryReader.new(self, entry_key, options).read
-      end
-
-      def store_passwords?
-        ::EacRubyUtils::Console::Configs::StorePasswordsEntryReader.new(self) == 'yes'
-      end
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/configs/read_entry_options'
-require 'eac_ruby_utils/core_ext'
-
-module EacRubyUtils
-  module Console
-    class Configs
-      class EntryReader
-        enable_console_speaker
-
-        class << self
-          def entry_key_to_envvar_name(entry_key)
-            path = if entry_key.is_a?(::Array)
-                     entry_key
-                   else
-                     ::EacRubyUtils::PathsHash.parse_entry_key(entry_key)
-                   end
-            path.join('_').gsub(/[^a-z0-9_]/i, '').gsub(/\A_+/, '').gsub(/_+\z/, '')
-                .gsub(/_{2,}/, '_').upcase
-          end
-        end
-
-        common_constructor :console_configs, :entry_key, :options do
-          self.options = ::EacRubyUtils::Console::Configs::ReadEntryOptions.new(options)
-        end
-
-        def read
-          %w[envvars storage console].each do |suffix|
-            value = send("read_from_#{suffix}")
-            return value if value.present?
-          end
-          return nil unless options[:required]
-
-          raise "No value found for entry \"#{entry_key}\""
-        end
-
-        def read_from_storage
-          console_configs.configs.read_entry(entry_key)
-        end
-
-        def read_from_envvars
-          return if options[:noenv]
-
-          env_entry_key = self.class.entry_key_to_envvar_name(entry_key)
-          return unless ENV.key?(env_entry_key)
-
-          ENV.fetch(env_entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
-        end
-
-        def read_from_console
-          return if options[:noinput]
-
-          options[:before_input].if_present(&:call)
-          entry_value = looped_entry_value_from_input
-          console_configs.configs.write_entry(entry_key, entry_value) if options[:store]
-          entry_value
-        end
-
-        private
-
-        def looped_entry_value_from_input
-          loop do
-            entry_value = entry_value_from_input(entry_key, options)
-            next if entry_value.blank?
-            next if options[:validator] && !options[:validator].call(entry_value)
-
-            return entry_value
-          end
-        end
-
-        def entry_value_from_input(entry_key, options)
-          entry_value = request_input("Value for entry \"#{entry_key}\"",
-                                      options.request_input_options)
-          warn('Entered value is blank') if entry_value.blank?
-          entry_value
-        end
-      end
-    end
-  end
-end

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/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