brakeman 4.5.0 → 4.5.1

data/bundle/ruby/2.5.0/gems/highline-2.0.2/lib/highline/builtin_styles.rb

@@ -0,0 +1,129 @@
+# coding: utf-8
+
+class HighLine
+  # Builtin Styles that are included at HighLine initialization.
+  # It has the basic styles like :bold and :underline.
+  module BuiltinStyles
+    # Included callback
+    # @param base [Class, Module] base class
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Basic styles' ANSI escape codes like :bold => "\e[1m"
+    STYLE_LIST = {
+      erase_line: "\e[K",
+      erase_char: "\e[P",
+      clear:      "\e[0m",
+      reset:      "\e[0m",
+      bold:       "\e[1m",
+      dark:       "\e[2m",
+      underline:  "\e[4m",
+      underscore: "\e[4m",
+      blink:      "\e[5m",
+      reverse:    "\e[7m",
+      concealed:  "\e[8m"
+    }.freeze
+
+    STYLE_LIST.each do |style_name, code|
+      style = String(style_name).upcase
+
+      const_set style, code
+      const_set style + "_STYLE",
+                Style.new(name: style_name, code: code, builtin: true)
+    end
+
+    # Basic Style names like CLEAR, BOLD, UNDERLINE
+    STYLES = %w[CLEAR RESET BOLD DARK UNDERLINE
+                UNDERSCORE BLINK REVERSE CONCEALED].freeze
+
+    # A Hash with the basic colors an their ANSI escape codes.
+    COLOR_LIST = {
+      black:   { code: "\e[30m", rgb: [0, 0, 0] },
+      red:     { code: "\e[31m", rgb: [128, 0, 0] },
+      green:   { code: "\e[32m", rgb: [0, 128, 0] },
+      blue:    { code: "\e[34m", rgb: [0, 0, 128] },
+      yellow:  { code: "\e[33m", rgb: [128, 128, 0] },
+      magenta: { code: "\e[35m", rgb: [128, 0, 128] },
+      cyan:    { code: "\e[36m", rgb: [0, 128, 128] },
+      white:   { code: "\e[37m", rgb: [192, 192, 192] },
+      gray:    { code: "\e[37m", rgb: [192, 192, 192] },
+      grey:    { code: "\e[37m", rgb: [192, 192, 192] },
+      none:    { code: "\e[38m", rgb: [0, 0, 0] }
+    }.freeze
+
+    COLOR_LIST.each do |color_name, attributes|
+      color = String(color_name).upcase
+
+      style = Style.new(
+        name: color_name,
+        code: attributes[:code],
+        rgb:  attributes[:rgb],
+        builtin: true
+      )
+
+      const_set color + "_STYLE", style
+    end
+
+    # The builtin styles basic colors like black, red, green.
+    BASIC_COLORS =
+      %w[BLACK RED GREEN YELLOW BLUE
+         MAGENTA CYAN WHITE GRAY GREY NONE].freeze
+
+    colors = BASIC_COLORS.dup
+    BASIC_COLORS.each do |color|
+      bright_color = "BRIGHT_#{color}"
+      colors << bright_color
+      const_set bright_color + "_STYLE", const_get(color + "_STYLE").bright
+
+      light_color = "LIGHT_#{color}"
+      colors << light_color
+      const_set light_color + "_STYLE", const_get(color + "_STYLE").light
+    end
+
+    # The builtin styles' colors like LIGHT_RED and BRIGHT_BLUE.
+    COLORS = colors
+
+    colors.each do |color|
+      const_set color, const_get("#{color}_STYLE").code
+      const_set "ON_#{color}_STYLE", const_get("#{color}_STYLE").on
+      const_set "ON_#{color}", const_get("ON_#{color}_STYLE").code
+    end
+
+    ON_NONE_STYLE.rgb = [255, 255, 255] # Override; white background
+
+    # BuiltinStyles class methods to be extended.
+    module ClassMethods
+      # Regexp to match against RGB style constant names.
+      RGB_COLOR_PATTERN = /^(ON_)?(RGB_)([A-F0-9]{6})(_STYLE)?$/
+
+      # const_missing callback for automatically respond to
+      # builtin constants (without explicitly defining them)
+      # @param name [Symbol] missing constant name
+      def const_missing(name)
+        raise NameError, "Bad color or uninitialized constant #{name}" unless
+          name.to_s =~ RGB_COLOR_PATTERN
+
+        on = Regexp.last_match(1)
+        suffix = Regexp.last_match(4)
+
+        code_name = if suffix
+                      Regexp.last_match(1).to_s +
+                        Regexp.last_match(2) +
+                        Regexp.last_match(3)
+                    else
+                      name.to_s
+                    end
+
+        style_name = code_name + "_STYLE"
+        style = Style.rgb(Regexp.last_match(3))
+        style = style.on if on
+
+        const_set(style_name, style)
+        const_set(code_name, style.code)
+
+        suffix ? style : style.code
+      end
+    end
+  end
+end

data/bundle/ruby/2.5.0/gems/{highline-1.7.10 → highline-2.0.2}/lib/highline/color_scheme.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+
+#--
 # color_scheme.rb
 #
 # Created by Jeremy Hinegardner on 2007-01-24
@@ -8,16 +11,15 @@
 class HighLine
   #
   # ColorScheme objects encapsulate a named set of colors to be used in the
-  # HighLine.colors() method call.  For example, by applying a ColorScheme that
+  # {HighLine.color} method call.  For example, by applying a ColorScheme that
   # has a <tt>:warning</tt> color then the following could be used:
   #
-  #   colors("This is a warning", :warning)
+  #   color("This is a warning", :warning)
   #
   # A ColorScheme contains named sets of HighLine color constants.
   #
-  # Example: Instantiating a color scheme, applying it to HighLine,
-  # and using it:
-  #
+  # @example Instantiating a color scheme, applying it to HighLine,
+  #   and using it:
   #   ft = HighLine::ColorScheme.new do |cs|
   #          cs[:headline]        = [ :bold, :yellow, :on_black ]
   #          cs[:horizontal_line] = [ :bold, :white ]
@@ -46,63 +48,78 @@ class HighLine
     # converted to <tt>:symbols</tt> and values are converted to HighLine
     # constants.
     #
-    def initialize( h = nil )
-      @scheme = Hash.new
-      load_from_hash(h) unless h.nil?
+    # @param h [Hash]
+    def initialize(h = nil)
+      @scheme = {}
+      load_from_hash(h) if h
       yield self if block_given?
     end
 
     # Load multiple colors from key/value pairs.
-    def load_from_hash( h )
+    # @param h [Hash]
+    def load_from_hash(h)
       h.each_pair do |color_tag, constants|
         self[color_tag] = constants
       end
     end
 
     # Does this color scheme include the given tag name?
-    def include?( color_tag )
+    # @param color_tag [#to_sym]
+    # @return [Boolean]
+    def include?(color_tag)
       @scheme.keys.include?(to_symbol(color_tag))
     end
 
     # Allow the scheme to be accessed like a Hash.
-    def []( color_tag )
+    # @param color_tag [#to_sym]
+    # @return [Style]
+    def [](color_tag)
       @scheme[to_symbol(color_tag)]
     end
 
     # Retrieve the original form of the scheme
-    def definition( color_tag )
+    # @param color_tag [#to_sym]
+    def definition(color_tag)
       style = @scheme[to_symbol(color_tag)]
       style && style.list
     end
 
     # Retrieve the keys in the scheme
+    # @return [Array] of keys
     def keys
       @scheme.keys
     end
 
     # Allow the scheme to be set like a Hash.
-    def []=( color_tag, constants )
-      @scheme[to_symbol(color_tag)] = HighLine::Style.new(:name=>color_tag.to_s.downcase.to_sym,
-                                                          :list=>constants, :no_index=>true)
+    # @param color_tag [#to_sym]
+    # @param constants [Array<Symbol>] Array of Style symbols
+    def []=(color_tag, constants)
+      @scheme[to_symbol(color_tag)] =
+        HighLine::Style.new(name: color_tag.to_s.downcase.to_sym,
+                            list: constants,
+                            no_index: true)
     end
 
     # Retrieve the color scheme hash (in original definition format)
+    # @return [Hash] scheme as Hash. It may be reused in a new ColorScheme.
     def to_hash
-      @scheme.inject({}) { |hsh, pair| key, value = pair; hsh[key] = value.list; hsh }
+      @scheme.each_with_object({}) do |pair, hsh|
+        key, value = pair
+        hsh[key] = value.list
+      end
     end
 
-
     private
 
     # Return a normalized representation of a color name.
-    def to_symbol( t )
+    def to_symbol(t)
       t.to_s.downcase
     end
 
     # Return a normalized representation of a color setting.
-    def to_constant( v )
+    def to_constant(v)
       v = v.to_s if v.is_a?(Symbol)
-      if v.is_a?(::String) then
+      if v.is_a?(::String)
         HighLine.const_get(v.upcase)
       else
         v
@@ -112,23 +129,23 @@ class HighLine
 
   # A sample ColorScheme.
   class SampleColorScheme < ColorScheme
+    SAMPLE_SCHEME = {
+      critical: [:yellow, :on_red],
+      error: [:bold, :red],
+      warning: [:bold, :yellow],
+      notice: [:bold, :magenta],
+      info: [:bold, :cyan],
+      debug: [:bold, :green],
+      row_even: [:cyan],
+      row_odd: [:magenta]
+    }.freeze
     #
     # Builds the sample scheme with settings for <tt>:critical</tt>,
     # <tt>:error</tt>, <tt>:warning</tt>, <tt>:notice</tt>, <tt>:info</tt>,
     # <tt>:debug</tt>, <tt>:row_even</tt>, and <tt>:row_odd</tt> colors.
     #
-    def initialize( h = nil )
-      scheme = {
-        :critical => [ :yellow, :on_red  ],
-        :error    => [ :bold,   :red     ],
-        :warning  => [ :bold,   :yellow  ],
-        :notice   => [ :bold,   :magenta ],
-        :info     => [ :bold,   :cyan    ],
-        :debug    => [ :bold,   :green   ],
-        :row_even => [ :cyan    ],
-        :row_odd  => [ :magenta ]
-      }
-      super(scheme)
+    def initialize(_h = nil)
+      super(SAMPLE_SCHEME)
     end
   end
 end

data/bundle/ruby/2.5.0/gems/highline-2.0.2/lib/highline/compatibility.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+unless STDIN.respond_to? :getbyte
+  # HighLine adds #getbyte alias to #getc when #getbyte is not available.
+  class IO
+    # alias to #getc when #getbyte is not available
+    alias getbyte getc
+  end
+
+  # HighLine adds #getbyte alias to #getc when #getbyte is not available.
+  class StringIO
+    # alias to #getc when #getbyte is not available
+    alias getbyte getc
+  end
+end
+
+unless "".respond_to? :each_line
+  # HighLine adds #each_line alias to #each when each_line is not available.
+  class String
+    # alias to #each when each_line is not available.
+    alias each_line each
+  end
+end

data/bundle/ruby/2.5.0/gems/highline-2.0.2/lib/highline/custom_errors.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+class HighLine
+  # Internal HighLine errors.
+  module CustomErrors
+    # An error that responds to :explanation_key
+    class ExplainableError < StandardError
+      # Explanation key as Symbol or nil. Used to
+      # select the proper error message to be displayed.
+      # @return [nil, Symbol] explanation key to get the
+      #   proper error message.
+      def explanation_key
+        nil
+      end
+    end
+
+    # Bare Question error
+    class QuestionError < ExplainableError
+      # (see ExplainableError#explanation_key)
+      def explanation_key
+        nil
+      end
+    end
+
+    # Invalid Question error
+    class NotValidQuestionError < ExplainableError
+      # (see ExplainableError#explanation_key)
+      def explanation_key
+        :not_valid
+      end
+    end
+
+    # Out of Range Question error
+    class NotInRangeQuestionError < ExplainableError
+      # (see ExplainableError#explanation_key)
+      def explanation_key
+        :not_in_range
+      end
+    end
+
+    # Unconfirmed Question error
+    class NoConfirmationQuestionError < ExplainableError
+      # (see ExplainableError#explanation_key)
+      def explanation_key
+        nil
+      end
+    end
+
+    # Unavailable auto complete error
+    class NoAutoCompleteMatch < ExplainableError
+      # (see ExplainableError#explanation_key)
+      def explanation_key
+        :no_completion
+      end
+    end
+  end
+end

data/bundle/ruby/2.5.0/gems/highline-2.0.2/lib/highline/import.rb

@@ -0,0 +1,48 @@
+# coding: utf-8
+
+# import.rb
+#
+#  Created by James Edward Gray II on 2005-04-26.
+#  Copyright 2005 Gray Productions. All rights reserved.
+#
+#  This is Free Software.  See LICENSE and COPYING for details.
+
+require "highline"
+require "forwardable"
+
+#
+# <tt>require "highline/import"</tt> adds shortcut methods to Kernel, making
+# {HighLine#agree}, {HighLine#ask}, {HighLine#choose} and {HighLine#say}
+# globally available.  This is handy for
+# quick and dirty input and output.  These methods use HighLine.default_instance
+# which is initialized to use <tt>$stdin</tt> and <tt>$stdout</tt> (you are free
+# to change this).
+# Otherwise, these methods are identical to their {HighLine} counterparts,
+# see that class for detailed explanations.
+#
+module Kernel
+  extend Forwardable
+  def_instance_delegators :HighLine, :agree, :ask, :choose, :say
+end
+
+# When requiring 'highline/import' HighLine adds {#or_ask} to Object so
+#   it is globally available.
+class Object
+  #
+  # Tries this object as a _first_answer_ for a HighLine::Question.  See that
+  # attribute for details.
+  #
+  # *Warning*:  This Object will be passed to String() before set.
+  #
+  # @param args [Array<#to_s>]
+  # @param details [lambda] block to be called with the question
+  #   instance as argument.
+  # @return [String] answer
+  def or_ask(*args, &details)
+    ask(*args) do |question|
+      question.first_answer = String(self)
+
+      yield(question) if details
+    end
+  end
+end

data/bundle/ruby/2.5.0/gems/highline-2.0.2/lib/highline/io_console_compatible.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+require "stringio"
+require "tempfile"
+
+#
+# On tests, we try to simulate input output with
+# StringIO, Tempfile and File objects.
+#
+# For this to be accomplished, we have to do some
+# tweaking so that they respond adequately to the
+# called methods during tests.
+#
+
+module IOConsoleCompatible
+  def getch
+    getc
+  end
+
+  attr_accessor :echo
+
+  def winsize
+    [24, 80]
+  end
+end
+
+class Tempfile
+  include IOConsoleCompatible
+end
+
+class File
+  include IOConsoleCompatible
+end
+
+class StringIO
+  include IOConsoleCompatible
+end