brakeman 5.2.2 → 7.1.1

data/bundle/ruby/3.1.0/gems/highline-3.1.2/lib/highline/question_asker.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+class HighLine
+  # Deals with the task of "asking" a question
+  class QuestionAsker
+    # @return [Question] question to be asked
+    attr_reader :question
+
+    include CustomErrors
+
+    # To do its work QuestionAsker needs a Question
+    # to be asked and a HighLine context where to
+    # direct output.
+    #
+    # @param question [Question] question to be asked
+    # @param highline [HighLine] context
+    def initialize(question, highline)
+      @question = question
+      @highline = highline
+    end
+
+    #
+    # Gets just one answer, as opposed to #gather_answers
+    #
+    # @return [String] answer
+    def ask_once
+      # If in readline mode, let reline take care of the prompt
+      question.show_question(@highline) unless question.readline
+
+      begin
+        question.get_response_or_default(@highline)
+        raise NotValidQuestionError unless question.valid_answer?
+
+        question.convert
+        question.check_range
+
+        if question.confirm
+          confirmation = @highline.send(:confirm, question)
+          raise NoConfirmationQuestionError unless confirmation
+        end
+      rescue ExplainableError => e
+        explain_error(e.explanation_key)
+        retry
+      rescue ArgumentError => error
+        case error.message
+        when /ambiguous/
+          # the assumption here is that OptionParser::Completion#complete
+          # (used for ambiguity resolution) throws exceptions containing
+          # the word 'ambiguous' whenever resolution fails
+          explain_error(:ambiguous_completion)
+          retry
+        when /invalid value for/
+          explain_error(:invalid_type)
+          retry
+        else
+          raise
+        end
+      end
+
+      question.answer
+    end
+
+    ## Multiple questions
+
+    #
+    # Collects an Array/Hash full of answers as described in
+    # HighLine::Question.gather().
+    #
+    # @return [Array, Hash] answers
+    def gather_answers
+      verify_match = question.verify_match
+      answers = []
+
+      # when verify_match is set this loop will repeat until unique_answers == 1
+      loop do
+        answers = gather_answers_based_on_type
+
+        break unless verify_match &&
+                     (@highline.send(:unique_answers, answers).size > 1)
+
+        explain_error(:mismatch)
+      end
+
+      verify_match ? @highline.send(:last_answer, answers) : answers
+    end
+
+    # Gather multiple integer values based on {Question#gather} count
+    # @return [Array] answers
+    def gather_integer
+      gather_with_array do |answers|
+        (question.gather - 1).times { answers << ask_once }
+      end
+    end
+
+    # Gather multiple values until any of them matches the
+    # {Question#gather} Regexp.
+    # @return [Array] answers
+    def gather_regexp
+      gather_with_array do |answers|
+        answers << ask_once until answer_matches_regex(answers.last)
+        answers.pop
+      end
+    end
+
+    # Gather multiple values and store them on a Hash
+    # with keys provided by the Hash on {Question#gather}
+    # @return [Hash]
+    def gather_hash
+      sorted_keys = question.gather.keys.sort_by(&:to_s)
+      sorted_keys.each_with_object({}) do |key, answers|
+        @highline.key = key
+        answers[key]  = ask_once
+      end
+    end
+
+    private
+
+    ## Delegate to Highline
+    def explain_error(explanation_key) # eg: :not_valid, :not_in_range
+      @highline.say(question.final_response(explanation_key))
+      @highline.say(question.ask_on_error_msg)
+    end
+
+    def gather_with_array
+      [].tap do |answers|
+        answers << ask_once
+        question.template = ""
+
+        yield answers
+      end
+    end
+
+    def answer_matches_regex(answer)
+      if question.gather.is_a?(::String) || question.gather.is_a?(Symbol)
+        answer.to_s == question.gather.to_s
+      elsif question.gather.is_a?(Regexp)
+        answer.to_s =~ question.gather
+      end
+    end
+
+    def gather_answers_based_on_type
+      case question.gather
+      when Integer
+        gather_integer
+      when ::String, Symbol, Regexp
+        gather_regexp
+      when Hash
+        gather_hash
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/highline-3.1.2/lib/highline/terminal/io_console.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class HighLine
+  class Terminal
+    # io/console option for HighLine::Terminal.
+    # It's the most used terminal.
+    # TODO: We're rescuing when not a terminal.
+    #       We should make a more robust implementation.
+    class IOConsole < Terminal
+      # (see Terminal#terminal_size)
+      def terminal_size
+        output.winsize.reverse
+      rescue Errno::ENOTTY
+      end
+
+      # (see Terminal#raw_no_echo_mode)
+      def raw_no_echo_mode
+        input.echo = false
+      rescue Errno::ENOTTY
+      end
+
+      # (see Terminal#restore_mode)
+      def restore_mode
+        input.echo = true
+      rescue Errno::ENOTTY
+      end
+
+      # (see Terminal#get_character)
+      def get_character
+        input.getch(intr: true) # from ruby io/console
+      rescue Errno::ENOTTY
+        input.getc
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/highline-3.1.2/lib/highline/terminal/unix_stty.rb

@@ -0,0 +1,53 @@
+# coding: utf-8
+
+class HighLine
+  class Terminal
+    # HighLine::Terminal option that uses external "stty" program
+    # to control terminal options.
+    class UnixStty < Terminal
+      # A Unix savvy method using stty to fetch the console columns, and rows.
+      # ... stty does not work in JRuby
+      # @return (see Terminal#terminal_size)
+      def terminal_size
+        begin
+          require "io/console"
+          winsize = begin
+                      IO.console.winsize.reverse
+                    rescue NoMethodError
+                      nil
+                    end
+          return winsize if winsize
+        rescue LoadError
+        end
+
+        if !@output.tty?
+          [80, 24]
+        elsif /solaris/ =~ RUBY_PLATFORM &&
+           `stty` =~ /\brows = (\d+).*\bcolumns = (\d+)/
+          [Regexp.last_match(2), Regexp.last_match(1)].map(&:to_i)
+        elsif `stty size` =~ /^(\d+)\s(\d+)$/
+          [Regexp.last_match(2).to_i, Regexp.last_match(1).to_i]
+        else
+          [80, 24]
+        end
+      end
+
+      # (see Terminal#raw_no_echo_mode)
+      def raw_no_echo_mode
+        save_stty 
+        system "stty raw -echo -icanon isig" if input.tty?
+      end
+
+      # (see Terminal#restore_mode)
+      def restore_mode
+        restore_stty
+        print "\r"
+      end
+
+      # (see Terminal#get_character)
+      def get_character(input = STDIN)
+        input.getc
+      end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/highline-3.1.2/lib/highline/terminal.rb

@@ -0,0 +1,192 @@
+# coding: utf-8
+
+#--
+# terminal.rb
+#
+#  Originally created by James Edward Gray II on 2006-06-14 as
+#  system_extensions.rb.
+#  Copyright 2006 Gray Productions. All rights reserved.
+#
+#  This is Free Software.  See LICENSE and COPYING for details.
+
+require "highline/compatibility"
+
+class HighLine
+  # Basic Terminal class which HighLine will direct
+  # input and output to.
+  # The specialized Terminals all decend from this HighLine::Terminal class
+  class Terminal
+    # Probe for and return a suitable Terminal instance
+    # @param input [IO] input stream
+    # @param output [IO] output stream
+    def self.get_terminal(input, output)
+      # First of all, probe for io/console
+      begin
+        require "io/console"
+        require "highline/terminal/io_console"
+        terminal = HighLine::Terminal::IOConsole.new(input, output)
+      rescue LoadError
+        require "highline/terminal/unix_stty"
+        terminal = HighLine::Terminal::UnixStty.new(input, output)
+      end
+
+      terminal.initialize_system_extensions
+      terminal
+    end
+
+    # @return [IO] input stream
+    attr_reader :input
+
+    # @return [IO] output stream
+    attr_reader :output
+
+    # Creates a terminal instance based on given input and output streams.
+    # @param input [IO] input stream
+    # @param output [IO] output stream
+    def initialize(input, output)
+      @input  = input
+      @output = output
+    end
+
+    # An initialization callback.
+    # It is called by {.get_terminal}.
+    def initialize_system_extensions; end
+
+    # @return [Array<Integer, Integer>] two value terminal
+    #   size like [columns, lines]
+    def terminal_size
+      [80, 24]
+    end
+
+    # Enter Raw No Echo mode.
+    def raw_no_echo_mode; end
+
+    # Yieds a block to be executed in Raw No Echo mode and
+    # then restore the terminal state.
+    def raw_no_echo_mode_exec
+      raw_no_echo_mode
+      yield
+    ensure
+      restore_mode
+    end
+
+    # Restore terminal to its default mode
+    def restore_mode; end
+
+    # Get one character from the terminal
+    # @return [String] one character
+    def get_character; end # rubocop:disable Naming/AccessorMethodName
+
+    # Get one line from the terminal and format accordling.
+    # Use readline if question has readline mode set.
+    # @param question [HighLine::Question]
+    # @param highline [HighLine]
+    def get_line(question, highline)
+      raw_answer =
+        if question.readline
+          get_line_with_readline(question, highline)
+        else
+          get_line_default(highline)
+        end
+
+      question.format_answer(raw_answer)
+    end
+
+    # Get one line using #readline_read
+    # @param (see #get_line)
+    def get_line_with_readline(question, highline)
+      require "reline" # load only if needed
+
+      raw_answer = readline_read(question, highline)
+
+      if !raw_answer && highline.track_eof?
+        raise EOFError, "The input stream is exhausted."
+      end
+
+      raw_answer || ""
+    end
+
+    # Use readline to read one line
+    # @param question [HighLine::Question] question from where to get
+    #   autocomplete candidate strings
+    def readline_read(question, highline)
+      # prep auto-completion
+      unless question.selection.empty?
+        Reline.completion_proc = lambda do |str|
+          question.selection.grep(/\A#{Regexp.escape(str)}/)
+        end
+      end
+
+      # TODO: Check if this is still needed after Reline
+      # work-around ugly readline() warnings
+      old_verbose = $VERBOSE
+      $VERBOSE    = nil
+
+      raw_answer  = run_preserving_stty do
+        prompt = highline.render_and_ident_statement(question)
+        Reline.readline(prompt, true)
+      end
+
+      $VERBOSE = old_verbose
+
+      raw_answer
+    end
+
+    # Get one line from terminal using default #gets method.
+    # @param highline (see #get_line)
+    def get_line_default(highline)
+      raise EOFError, "The input stream is exhausted." if highline.track_eof? &&
+                                                          highline.input.eof?
+      highline.input.gets
+    end
+
+    # @!group Enviroment queries
+
+    # Running on JRuby?
+    def jruby?
+      defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+    end
+
+    # Running on Rubinius?
+    def rubinius?
+      defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
+    end
+
+    # Running on Windows?
+    def windows?
+      defined?(RUBY_PLATFORM) && (RUBY_PLATFORM =~ /mswin|mingw|cygwin/)
+    end
+
+    # @!endgroup
+
+    # Returns the class name as String. Useful for debuggin.
+    # @return [String] class name. Ex: "HighLine::Terminal::IOConsole"
+    def character_mode
+      self.class.name
+    end
+
+    private
+
+    # Yield a block using stty shell commands to preserve the terminal state.
+    def run_preserving_stty
+      save_stty
+      yield
+    ensure
+      restore_stty
+    end
+
+    # Saves terminal state using shell stty command.
+    def save_stty
+      @stty_save = begin
+                     `stty -g`.chomp if input.tty?
+                   rescue StandardError
+                     nil
+                   end
+    end
+
+    # Restores terminal state using shell stty command.
+    def restore_stty
+      system("stty", @stty_save) if @stty_save
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/highline-3.1.2/lib/highline/version.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+
+class HighLine
+  # The version of the installed library.
+  VERSION = "3.1.2".freeze
+end