ehbrs-tools 0.3.0

data/vendor/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 unless entry_value.present?
+          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/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/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)
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require 'io/console'
+require 'eac_ruby_utils/patches/hash/options_consumer'
+require 'eac_ruby_utils/console/speaker/_class_methods'
+require 'eac_ruby_utils/console/speaker/list'
+require 'eac_ruby_utils/console/speaker/node'
+
+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
+      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