eac_ruby_utils 0.60.0 → 0.64.0

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

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/speaker/node'
-
-module EacRubyUtils
-  module Console
-    module Speaker
-      class << self
-        def current_node
-          nodes_stack.last
-        end
-
-        def on_node(&block)
-          push
-          yield(*(block.arity.zero? ? [] : [current_node]))
-        ensure
-          pop
-        end
-
-        def push
-          nodes_stack << ::EacRubyUtils::Console::Speaker::Node.new
-          current_node
-        end
-
-        def pop
-          return nodes_stack.pop if nodes_stack.count > 1
-
-          raise "Cannot remove first node (nodes_stack.count: #{nodes_stack.count})"
-        end
-
-        private
-
-        def nodes_stack
-          @nodes_stack ||= [::EacRubyUtils::Console::Speaker::Node.new]
-        end
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/by_reference'
-
-module EacRubyUtils
-  module Console
-    # https://github.com/fazibear/colorize
-    module Speaker
-      STDERR = ::EacRubyUtils::ByReference.new { $stderr }
-      STDIN = ::EacRubyUtils::ByReference.new { $stdin }
-      STDOUT = ::EacRubyUtils::ByReference.new { $stdout }
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/hash_with_indifferent_access'
-require 'ostruct'
-
-module EacRubyUtils
-  module Console
-    module Speaker
-      class List
-        class << self
-          def build(list)
-            return List.new(hash_to_values(list)) if list.is_a?(::Hash)
-            return List.new(array_to_values(list)) if list.is_a?(::Array)
-
-            raise "Invalid list: #{list} (#{list.class})"
-          end
-
-          private
-
-          def hash_to_values(list)
-            list.map { |key, value| ::OpenStruct.new(key: key, label: key, value: value) }
-          end
-
-          def array_to_values(list)
-            list.map { |value| ::OpenStruct.new(key: value, label: value, value: value) }
-          end
-        end
-
-        attr_reader :values
-
-        def initialize(values)
-          @values = values.map do |v|
-            ::OpenStruct.new(key: to_key(v.key), label: to_label(v.label), value: v.value)
-          end
-        end
-
-        def valid_labels
-          values.map(&:label)
-        end
-
-        def valid_value?(value)
-          values.any? { |v| v.key == to_key(value) }
-        end
-
-        def to_key(value)
-          to_label(value).downcase
-        end
-
-        def to_label(value)
-          value.to_s.strip
-        end
-
-        def build_value(value)
-          key = to_key(value)
-          values.each do |v|
-            return v.value if v.key == key
-          end
-          raise "Value not found: \"#{value}\" (#{values})"
-        end
-      end
-    end
-  end
-end