avm-tools 0.47.0 → 0.52.0

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string'
+require 'yaml'
+require 'eac_ruby_utils/configs/file'
+require 'eac_ruby_utils/patches/hash/sym_keys_hash'
+require 'eac_ruby_utils/paths_hash'
+require 'eac_ruby_utils/simple_cache'
+
+module EacRubyUtils
+  class Configs
+    include ::EacRubyUtils::SimpleCache
+
+    attr_reader :configs_key, :options
+
+    # Valid options: [:storage_path]
+    def initialize(configs_key, options = {})
+      @configs_key = configs_key
+      @options = options.to_sym_keys_hash.freeze
+      load
+    end
+
+    delegate :clear, to: :file
+
+    delegate :save, to: :file
+
+    delegate :load, to: :file
+
+    def []=(entry_key, entry_value)
+      write_entry(entry_key, entry_value)
+    end
+
+    def write_entry(entry_key, entry_value)
+      file.write(entry_key, entry_value)
+    end
+
+    def [](entry_key)
+      read_entry(entry_key)
+    end
+
+    def read_entry(entry_key)
+      file.read(entry_key)
+    end
+
+    delegate :autosave?, to: :file
+
+    private
+
+    attr_accessor :data
+
+    def file_uncached
+      ::EacRubyUtils::Configs::File.new(
+        storage_path, options
+      )
+    end
+
+    def storage_path_uncached
+      path = options_storage_path || default_storage_path
+      return path if ::File.exist?(path) && ::File.size(path).positive?
+
+      ::FileUtils.mkdir_p(::File.dirname(path))
+      ::File.write(path, {}.to_yaml)
+      path
+    end
+
+    def options_storage_path
+      options[:storage_path]
+    end
+
+    def default_storage_path
+      ::File.join(ENV['HOME'], '.config', configs_key, 'settings.yml')
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/configs/file.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string'
+require 'yaml'
+require 'eac_ruby_utils/patches/hash/sym_keys_hash'
+require 'eac_ruby_utils/paths_hash'
+require 'eac_ruby_utils/simple_cache'
+
+module EacRubyUtils
+  class Configs
+    class File
+      include ::EacRubyUtils::SimpleCache
+
+      attr_reader :path, :options
+
+      # Valid options: [:autosave]
+      def initialize(path, options = {})
+        @path = path
+        @options = options.to_sym_keys_hash.freeze
+        load
+      end
+
+      def clear
+        self.data = ::EacRubyUtils::PathsHash.new({})
+      end
+
+      def save
+        ::FileUtils.mkdir_p(::File.dirname(path))
+        ::File.write(path, data.to_h.to_yaml)
+      end
+
+      def load
+        self.data = if ::File.exist?(path) && ::File.size(path).positive?
+                      ::EacRubyUtils::PathsHash.new(YAML.load_file(path))
+                    else
+                      {}
+                    end
+      end
+
+      def []=(entry_key, entry_value)
+        write(entry_key, entry_value)
+      end
+
+      def write(entry_key, entry_value)
+        data[entry_key] = entry_value
+        save if autosave?
+      end
+
+      def [](entry_key)
+        read(entry_key)
+      end
+
+      def read(entry_key)
+        data[entry_key]
+      end
+
+      def autosave?
+        options[:autosave] ? true : false
+      end
+
+      private
+
+      attr_accessor :data
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# 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/gems/eac_ruby_utils/lib/eac_ruby_utils/console/configs.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/common_constructor'
+require 'eac_ruby_utils/configs'
+require 'eac_ruby_utils/console/speaker'
+require 'eac_ruby_utils/options_consumer'
+require 'eac_ruby_utils/patches/object/asserts'
+require 'eac_ruby_utils/simple_cache'
+
+module EacRubyUtils
+  module Console
+    class Configs
+      include ::EacRubyUtils::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
+
+      STORE_PASSWORDS_KEY = 'core.store_passwords'
+
+      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 = {})
+        options = options.merge(noecho: true)
+        if store_passwords?
+          read_entry(entry_key, options)
+        else
+          looped_entry_value_from_input(entry_key, options)
+        end
+      end
+
+      def read_entry(entry_key, options = {})
+        options = ReadEntryOptions.new(options)
+        unless options[:noenv]
+          envvar_value = envvar_read_entry(entry_key)
+          return envvar_value if envvar_value.present?
+        end
+        stored_value = configs.read_entry(entry_key)
+        return stored_value if stored_value
+        return read_entry_from_console(entry_key, options) unless options[:noinput]
+
+        raise "No value found for entry \"#{entry_key}\"" if options[:required]
+      end
+
+      def store_passwords?
+        read_entry(
+          STORE_PASSWORDS_KEY,
+          before_input: -> { store_password_banner },
+          validator: ->(entry_value) { %w[yes no].include?(entry_value) }
+        ) == 'yes'
+      end
+
+      protected
+
+      def envvar_read_entry(entry_key)
+        ENV[self.class.entry_key_to_envvar_name(entry_key)]
+      end
+
+      def read_entry_from_console(entry_key, options)
+        options[:before_input].call if options[:before_input].present?
+        entry_value = looped_entry_value_from_input(entry_key, options)
+        configs.write_entry(entry_key, entry_value)
+        entry_value
+      end
+
+      def store_password_banner
+        infom 'Do you wanna to store passwords?'
+        infom "Warning: the passwords will be store in clear text in \"#{configs.storage_path}\""
+        infom 'Enter "yes" or "no"'
+      end
+
+      def looped_entry_value_from_input(entry_key, options)
+        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
+
+      class ReadEntryOptions
+        include ::EacRubyUtils::SimpleCache
+        ::EacRubyUtils::CommonConstructor.new(:options).setup_class(self)
+
+        DEFAULT_VALUES = {
+          before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
+          required: true, validator: nil
+        }.freeze
+
+        def [](key)
+          values.fetch(key.to_sym)
+        end
+
+        def request_input_options
+          values.slice(:bool, :list, :noecho)
+        end
+
+        private
+
+        def values_uncached
+          consumer = ::EacRubyUtils::OptionsConsumer.new(options)
+          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/gems/eac_ruby_utils/lib/eac_ruby_utils/console/docopt_runner.rb

@@ -0,0 +1,39 @@
+# 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
+
+      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/gems/eac_ruby_utils/lib/eac_ruby_utils/console/docopt_runner/_class_methods.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Console
+    class DocoptRunner
+      DOCOPT_ERROR_EXIT_CODE = 0x22220000
+
+      class << self
+        def run(options = {})
+          new(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/gems/eac_ruby_utils/lib/eac_ruby_utils/console/docopt_runner/_doc.rb

@@ -0,0 +1,25 @@
+# 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/gems/eac_ruby_utils/lib/eac_ruby_utils/console/docopt_runner/_settings.rb

@@ -0,0 +1,19 @@
+# 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/gems/eac_ruby_utils/lib/eac_ruby_utils/console/docopt_runner/_subcommands.rb

@@ -0,0 +1,139 @@
+# 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
+        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.new(
+            argv: subcommand_args,
+            program_name: subcommand_program,
+            parent: self
+          )
+        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
+          (setting_value(:subcommands, false) || auto_available_subcommands).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