brakeman 4.4.0 → 5.0.0

data/bundle/ruby/2.7.0/gems/highline-2.0.3/lib/highline/question/answer_converter.rb

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+require "forwardable"
+
+class HighLine
+  class Question
+    # It provides all answer conversion flow.
+    class AnswerConverter
+      extend Forwardable
+
+      def_delegators :@question,
+                     :answer, :answer=, :check_range,
+                     :directory, :answer_type, :choices_complete
+
+      # It should be initialized with a Question object.
+      # The class will get the answer from {Question#answer}
+      # and then convert it to the proper {Question#answer_type}.
+      # It is mainly used by {Question#convert}
+      #
+      # @param question [Question]
+      def initialize(question)
+        @question = question
+      end
+
+      # Based on the given Question object's settings,
+      # it makes the conversion and returns the answer.
+      # @return [Object] the converted answer.
+      def convert
+        return unless answer_type
+
+        self.answer = convert_by_answer_type
+        check_range
+        answer
+      end
+
+      # @return [HighLine::String] answer converted to a HighLine::String
+      def to_string
+        HighLine::String(answer)
+      end
+
+      # That's a weird name for a method!
+      # But it's working ;-)
+      define_method "to_highline::string" do
+        HighLine::String(answer)
+      end
+
+      # @return [Integer] answer converted to an Integer
+      def to_integer
+        Kernel.send(:Integer, answer)
+      end
+
+      # @return [Float] answer converted to a Float
+      def to_float
+        Kernel.send(:Float, answer)
+      end
+
+      # @return [Symbol] answer converted to an Symbol
+      def to_symbol
+        answer.to_sym
+      end
+
+      # @return [Regexp] answer converted to a Regexp
+      def to_regexp
+        Regexp.new(answer)
+      end
+
+      # @return [File] answer converted to a File
+      def to_file
+        self.answer = choices_complete(answer)
+        File.open(File.join(directory.to_s, answer.last))
+      end
+
+      # @return [Pathname] answer converted to an Pathname
+      def to_pathname
+        self.answer = choices_complete(answer)
+        Pathname.new(File.join(directory.to_s, answer.last))
+      end
+
+      # @return [Array] answer converted to an Array
+      def to_array
+        self.answer = choices_complete(answer)
+        answer.last
+      end
+
+      # @return [Proc] answer converted to an Proc
+      def to_proc
+        answer_type.call(answer)
+      end
+
+      private
+
+      def convert_by_answer_type
+        if answer_type.respond_to? :parse
+          answer_type.parse(answer)
+        elsif answer_type.is_a? Class
+          send("to_#{answer_type.name.downcase}")
+        else
+          send("to_#{answer_type.class.name.downcase}")
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/2.7.0/gems/highline-2.0.3/lib/highline/question_asker.rb

@@ -0,0 +1,150 @@
+# 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
+      question.show_question(@highline)
+
+      begin
+        question.get_response_or_default(@highline)
+        raise NotValidQuestionError unless question.valid_answer?
+
+        question.convert
+
+        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/2.7.0/gems/highline-2.0.3/lib/highline/simulate.rb

@@ -0,0 +1,59 @@
+# coding: utf-8
+
+#--
+# simulate.rb
+#
+#  Created by Andy Rossmeissl on 2012-04-29.
+#  Copyright 2005 Gray Productions. All rights reserved.
+#
+#  This is Free Software.  See LICENSE and COPYING for details.
+#
+# adapted from https://gist.github.com/194554
+
+class HighLine
+  # Simulates Highline input for use in tests.
+  class Simulate
+    # Creates a simulator with an array of Strings as a script
+    # @param strings [Array<String>] preloaded string to be used
+    #   as input buffer when simulating.
+    def initialize(strings)
+      @strings = strings
+    end
+
+    # Simulate StringIO#gets by shifting a string off of the script
+    def gets
+      @strings.shift
+    end
+
+    # Simulate StringIO#getbyte by shifting a single character off of
+    # the next line of the script
+    def getbyte
+      line = gets
+      return if line.empty?
+
+      char = line.slice! 0
+      @strings.unshift line
+      char
+    end
+
+    # The simulator handles its own EOF
+    def eof?
+      false
+    end
+
+    # A wrapper method that temporarily replaces the Highline
+    # instance in HighLine.default_instance with an instance of this object
+    # for the duration of the block
+    #
+    # @param strings [String] preloaded string buffer that
+    #   will feed the input operations when simulating.
+
+    def self.with(*strings)
+      @input = HighLine.default_instance.instance_variable_get :@input
+      HighLine.default_instance.instance_variable_set :@input, new(strings)
+      yield
+    ensure
+      HighLine.default_instance.instance_variable_set :@input, @input
+    end
+  end
+end

data/bundle/ruby/2.7.0/gems/highline-2.0.3/lib/highline/statement.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+require "highline/wrapper"
+require "highline/paginator"
+require "highline/template_renderer"
+
+class HighLine
+  # This class handles proper formatting based
+  # on a HighLine context, applying wrapping,
+  # pagination, indentation and color rendering
+  # when necessary. It's used by {HighLine#render_statement}
+  # @see HighLine#render_statement
+  class Statement
+    # The source object to be stringfied and formatted.
+    attr_reader :source
+
+    # The HighLine context
+    # @return [HighLine]
+    attr_reader :highline
+
+    # The stringfied source object
+    # @return [String]
+    attr_reader :template_string
+
+    # It needs the input String and the HighLine context
+    # @param source [#to_s]
+    # @param highline [HighLine] context
+    def initialize(source, highline)
+      @highline = highline
+      @source   = source
+      @template_string = stringfy(source)
+    end
+
+    # Returns the formated statement.
+    # Applies wrapping, pagination, indentation and color rendering
+    # based on HighLine instance settings.
+    # @return [String] formated statement
+    def statement
+      @statement ||= format_statement
+    end
+
+    # (see #statement)
+    # Delegates to {#statement}
+    def to_s
+      statement
+    end
+
+    def self.const_missing(constant)
+      HighLine.const_get(constant)
+    end
+
+    private
+
+    def stringfy(template_string)
+      String(template_string || "").dup
+    end
+
+    def format_statement
+      return template_string if template_string.empty?
+
+      statement = render_template
+
+      statement = HighLine::Wrapper.wrap(statement, highline.wrap_at)
+      statement = HighLine::Paginator.new(highline).page_print(statement)
+
+      statement = statement.gsub(/\n(?!$)/, "\n#{highline.indentation}") if
+        highline.multi_indent
+
+      statement
+    end
+
+    def render_template
+      # Assigning to a local var so it may be
+      # used inside instance eval block
+
+      template_renderer = TemplateRenderer.new(template, source, highline)
+      template_renderer.render
+    end
+
+    def template
+      @template ||= if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
+        ERB.new(template_string, trim_mode: "%")
+      else
+        ERB.new(template_string, nil, "%")
+      end
+    end
+  end
+end

data/bundle/ruby/2.7.0/gems/highline-2.0.3/lib/highline/string.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+
+require "highline/string_extensions"
+
+class HighLine
+  #
+  # HighLine::String is a subclass of String with convenience methods added
+  # for colorization.
+  #
+  # Available convenience methods include:
+  #   * 'color' method         e.g.  highline_string.color(:bright_blue,
+  #                                                        :underline)
+  #   * colors                 e.g.  highline_string.magenta
+  #   * RGB colors             e.g.  highline_string.rgb_ff6000
+  #                             or   highline_string.rgb(255,96,0)
+  #   * background colors      e.g.  highline_string.on_magenta
+  #   * RGB background colors  e.g.  highline_string.on_rgb_ff6000
+  #                             or   highline_string.on_rgb(255,96,0)
+  #   * styles                 e.g.  highline_string.underline
+  #
+  # Additionally, convenience methods can be chained, for instance the
+  # following are equivalent:
+  #   highline_string.bright_blue.blink.underline
+  #   highline_string.color(:bright_blue, :blink, :underline)
+  #   HighLine.color(highline_string, :bright_blue, :blink, :underline)
+  #
+  # For those less squeamish about possible conflicts, the same convenience
+  # methods can be added to the built-in String class, as follows:
+  #
+  #  require 'highline'
+  #  Highline.colorize_strings
+  #
+  class String < ::String
+    include StringExtensions
+  end
+end

data/bundle/ruby/2.7.0/gems/highline-2.0.3/lib/highline/string_extensions.rb

@@ -0,0 +1,130 @@
+# coding: utf-8
+
+class HighLine #:nodoc:
+  # Returns a HighLine::String from any given String.
+  # @param s [String]
+  # @return [HighLine::String] from the given string.
+  def self.String(s) # rubocop:disable Naming/MethodName
+    HighLine::String.new(s)
+  end
+
+  # HighLine extensions for String class.
+  # Included by HighLine::String.
+  module StringExtensions
+    STYLE_METHOD_NAME_PATTERN = /^(on_)?rgb_([0-9a-fA-F]{6})$/
+
+    # Included hook. Actions to take when being included.
+    # @param base [Class, Module] base class
+    def self.included(base)
+      define_builtin_style_methods(base)
+      define_style_support_methods(base)
+    end
+
+    # At include time, it defines all basic style
+    # support method like #color, #on, #uncolor,
+    # #rgb, #on_rgb and the #method_missing callback
+    # @return [void]
+    # @param base [Class, Module] the base class/module
+    #
+    def self.define_style_support_methods(base)
+      base.class_eval do
+        undef :color if method_defined? :color
+        undef :foreground if method_defined? :foreground
+        def color(*args)
+          self.class.new(HighLine.color(self, *args))
+        end
+        alias_method :foreground, :color
+
+        undef :on if method_defined? :on
+        def on(arg)
+          color(("on_" + arg.to_s).to_sym)
+        end
+
+        undef :uncolor if method_defined? :uncolor
+        def uncolor
+          self.class.new(HighLine.uncolor(self))
+        end
+
+        undef :rgb if method_defined? :rgb
+        def rgb(*colors)
+          color_code = setup_color_code(*colors)
+          color("rgb_#{color_code}".to_sym)
+        end
+
+        undef :on_rgb if method_defined? :on_rgb
+        def on_rgb(*colors)
+          color_code = setup_color_code(*colors)
+          color("on_rgb_#{color_code}".to_sym)
+        end
+
+        # @todo Chain existing method_missing?
+        undef :method_missing if method_defined? :method_missing
+        def method_missing(method, *_args)
+          if method.to_s =~ STYLE_METHOD_NAME_PATTERN
+            color(method)
+          else
+            super
+          end
+        end
+
+        undef :respond_to_missing if method_defined? :respond_to_missing
+        def respond_to_missing?(method_name, include_private = false)
+          method_name.to_s =~ STYLE_METHOD_NAME_PATTERN || super
+        end
+
+        private
+
+        def setup_color_code(*colors)
+          color_code = colors.map do |color|
+            if color.is_a?(Numeric)
+              format("%02x", color)
+            else
+              color.to_s
+            end
+          end.join
+
+          raise "Bad RGB color #{colors.inspect}" unless
+            color_code =~ /^[a-fA-F0-9]{6}/
+
+          color_code
+        end
+      end
+    end
+
+    # At include time, it defines all basic builtin styles.
+    # @param base [Class, Module] base Class/Module
+    def self.define_builtin_style_methods(base)
+      HighLine::COLORS.each do |color|
+        color = color.downcase
+        base.class_eval <<-METHOD_DEFINITION
+          undef :#{color} if method_defined? :#{color}
+          def #{color}
+            color(:#{color})
+          end
+        METHOD_DEFINITION
+
+        base.class_eval <<-METHOD_DEFINITION
+          undef :on_#{color} if method_defined? :on_#{color}
+          def on_#{color}
+            on(:#{color})
+          end
+        METHOD_DEFINITION
+
+        HighLine::STYLES.each do |style|
+          style = style.downcase
+          base.class_eval <<-METHOD_DEFINITION
+            undef :#{style} if method_defined? :#{style}
+            def #{style}
+              color(:#{style})
+            end
+          METHOD_DEFINITION
+        end
+      end
+    end
+  end
+
+  # Adds color support to the base String class
+  def self.colorize_strings
+    ::String.send(:include, StringExtensions)
+  end
+end