brakeman 4.3.1 → 5.0.0

data/bundle/ruby/2.5.0/gems/highline-1.7.10/lib/highline/simulate.rb

@@ -1,48 +0,0 @@
-# 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
-    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.dup
-      if line.length > 0
-        char = line.slice! 0
-        @strings.unshift line
-        char
-      end
-    end
-
-    # The simulator handles its own EOF
-    def eof?
-      false
-    end
-
-    # A wrapper method that temporarily replaces the Highline instance in $terminal with an instance of this object for the duration of the block
-    def self.with(*strings)
-      @input = $terminal.instance_variable_get :@input
-      $terminal.instance_variable_set :@input, new(strings)
-      yield
-    ensure
-      $terminal.instance_variable_set :@input, @input
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/highline-1.7.10/lib/highline/string_extensions.rb

@@ -1,111 +0,0 @@
-# Extensions for class String
-#
-# 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 HighLine
-  def self.String(s)
-    HighLine::String.new(s)
-  end
-
-  module StringExtensions
-    def self.included(base)
-      HighLine::COLORS.each do |color|
-        color = color.downcase
-        base.class_eval <<-END
-          undef :#{color} if method_defined? :#{color}
-          def #{color}
-            color(:#{color})
-          end
-        END
-
-        base.class_eval <<-END
-          undef :on_#{color} if method_defined? :on_#{color}
-          def on_#{color}
-            on(:#{color})
-          end
-        END
-        HighLine::STYLES.each do |style|
-          style = style.downcase
-          base.class_eval <<-END
-            undef :#{style} if method_defined? :#{style}
-            def #{style}
-              color(:#{style})
-            end
-          END
-        end
-      end
-
-      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 = colors.map{|color| color.is_a?(Numeric) ? '%02x'%color : color.to_s}.join
-          raise "Bad RGB color #{colors.inspect}" unless color_code =~ /^[a-fA-F0-9]{6}/
-          color("rgb_#{color_code}".to_sym)
-        end
-
-        undef :on_rgb if method_defined? :on_rgb
-        def on_rgb(*colors)
-          color_code = colors.map{|color| color.is_a?(Numeric) ? '%02x'%color : color.to_s}.join
-          raise "Bad RGB color #{colors.inspect}" unless color_code =~ /^[a-fA-F0-9]{6}/
-          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, &blk)
-          if method.to_s =~ /^(on_)?rgb_([0-9a-fA-F]{6})$/
-            color(method)
-          else
-            raise NoMethodError, "undefined method `#{method}' for #<#{self.class}:#{'%#x'%self.object_id}>"
-          end
-        end
-      end
-    end
-  end
-
-  class HighLine::String < ::String
-    include StringExtensions
-  end
-
-  def self.colorize_strings
-    ::String.send(:include, StringExtensions)
-  end
-end

data/bundle/ruby/2.5.0/gems/highline-1.7.10/lib/highline/style.rb

@@ -1,192 +0,0 @@
-# color_scheme.rb
-#
-# Created by Richard LeBer on 2011-06-27.
-# Copyright 2011.  All rights reserved
-#
-# This is Free Software.  See LICENSE and COPYING for details
-
-class HighLine
-
-  def self.Style(*args)
-    args = args.compact.flatten
-    if args.size==1
-      arg = args.first
-      if arg.is_a?(Style)
-        Style.list[arg.name] || Style.index(arg)
-      elsif arg.is_a?(::String) && arg =~ /^\e\[/ # arg is a code
-        if styles = Style.code_index[arg]
-          styles.first
-        else
-          Style.new(:code=>arg)
-        end
-      elsif style = Style.list[arg]
-        style
-      elsif HighLine.color_scheme && HighLine.color_scheme[arg]
-        HighLine.color_scheme[arg]
-      elsif arg.is_a?(Hash)
-        Style.new(arg)
-      elsif arg.to_s.downcase =~ /^rgb_([a-f0-9]{6})$/
-        Style.rgb($1)
-      elsif arg.to_s.downcase =~ /^on_rgb_([a-f0-9]{6})$/
-        Style.rgb($1).on
-      else
-        raise NameError, "#{arg.inspect} is not a defined Style"
-      end
-    else
-      name = args
-      Style.list[name] || Style.new(:list=>args)
-    end
-  end
-
-  class Style
-
-    def self.index(style)
-      if style.name
-        @@styles ||= {}
-        @@styles[style.name] = style
-      end
-      if !style.list
-        @@code_index ||= {}
-        @@code_index[style.code] ||= []
-        @@code_index[style.code].reject!{|indexed_style| indexed_style.name == style.name}
-        @@code_index[style.code] << style
-      end
-      style
-    end
-
-    def self.rgb_hex(*colors)
-      colors.map do |color|
-        color.is_a?(Numeric) ? '%02x'%color : color.to_s
-      end.join
-    end
-
-    def self.rgb_parts(hex)
-      hex.scan(/../).map{|part| part.to_i(16)}
-    end
-
-    def self.rgb(*colors)
-      hex = rgb_hex(*colors)
-      name = ('rgb_' + hex).to_sym
-      if style = list[name]
-        style
-      else
-        parts = rgb_parts(hex)
-        new(:name=>name, :code=>"\e[38;5;#{rgb_number(parts)}m", :rgb=>parts)
-      end
-    end
-
-    def self.rgb_number(*parts)
-      parts = parts.flatten
-      16 + parts.inject(0) {|kode, part| kode*6 + (part/256.0*6.0).floor}
-    end
-
-    def self.ansi_rgb_to_hex(ansi_number)
-      raise "Invalid ANSI rgb code #{ansi_number}" unless (16..231).include?(ansi_number)
-      parts = (ansi_number-16).to_s(6).rjust(3,'0').scan(/./).map{|d| (d.to_i*255.0/6.0).ceil}
-      rgb_hex(*parts)
-    end
-
-    def self.list
-      @@styles ||= {}
-    end
-
-    def self.code_index
-      @@code_index ||= {}
-    end
-
-    def self.uncolor(string)
-      string.gsub(/\e\[\d+(;\d+)*m/, '')
-    end
-
-    attr_reader :name, :list
-    attr_accessor :rgb, :builtin
-
-    # Single color/styles have :name, :code, :rgb (possibly), :builtin
-    # Compound styles have :name, :list, :builtin
-    def initialize(defn = {})
-      @definition = defn
-      @name    = defn[:name]
-      @code    = defn[:code]
-      @rgb     = defn[:rgb]
-      @list    = defn[:list]
-      @builtin = defn[:builtin]
-      if @rgb
-        hex = self.class.rgb_hex(@rgb)
-        @name ||= 'rgb_' + hex
-      elsif @list
-        @name ||= @list
-      end
-      self.class.index self unless defn[:no_index]
-    end
-
-    def dup
-      self.class.new(@definition)
-    end
-
-    def to_hash
-      @definition
-    end
-
-    def color(string)
-      code + string + HighLine::CLEAR
-    end
-
-    def code
-      if @list
-        @list.map{|element| HighLine.Style(element).code}.join
-      else
-        @code
-      end
-    end
-
-    def red
-      @rgb && @rgb[0]
-    end
-
-    def green
-      @rgb && @rgb[1]
-    end
-
-    def blue
-      @rgb && @rgb[2]
-    end
-
-    def variant(new_name, options={})
-      raise "Cannot create a variant of a style list (#{inspect})" if @list
-      new_code = options[:code] || code
-      if options[:increment]
-        raise "Unexpected code in #{inspect}" unless new_code =~ /^(.*?)(\d+)(.*)/
-        new_code = $1 + ($2.to_i + options[:increment]).to_s + $3
-      end
-      new_rgb = options[:rgb] || @rgb
-      self.class.new(self.to_hash.merge(:name=>new_name, :code=>new_code, :rgb=>new_rgb))
-    end
-
-    def on
-      new_name = ('on_'+@name.to_s).to_sym
-      self.class.list[new_name] ||= variant(new_name, :increment=>10)
-    end
-
-    def bright
-      create_bright_variant(:bright)
-    end
-
-    def light
-      create_bright_variant(:light)
-    end
-
-    private
-
-    def create_bright_variant(variant_name)
-      raise "Cannot create a #{name} variant of a style list (#{inspect})" if @list
-      new_name = ("#{variant_name}_"+@name.to_s).to_sym
-      new_rgb = @rgb == [0,0,0] ? [128, 128, 128] : @rgb.map {|color|  color==0 ? 0 : [color+128,255].min }
-
-      find_style(new_name) or variant(new_name, :increment=>60, :rgb=>new_rgb)
-    end
-
-    def find_style(name)
-      self.class.list[name]
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/highline-1.7.10/lib/highline/system_extensions.rb

@@ -1,254 +0,0 @@
-# system_extensions.rb
-#
-#  Created by James Edward Gray II on 2006-06-14.
-#  Copyright 2006 Gray Productions. All rights reserved.
-#
-#  This is Free Software.  See LICENSE and COPYING for details.
-
-require "highline/compatibility"
-
-class HighLine
-  module SystemExtensions
-    JRUBY = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-
-    if JRUBY
-      JRUBY_OVER_17 = JRUBY_VERSION =~ /^1.7/ || JRUBY_VERSION =~ /^9/
-
-      def initialize_system_extensions
-        require 'java'
-        require 'readline'
-        if JRUBY_OVER_17
-          java_import 'jline.console.ConsoleReader'
-
-          input = @input && @input.to_inputstream
-          output = @output && @output.to_outputstream
-
-          @java_console = ConsoleReader.new(input, output)
-          @java_console.set_history_enabled(false)
-          @java_console.set_bell_enabled(true)
-          @java_console.set_pagination_enabled(false)
-          @java_terminal = @java_console.getTerminal
-        elsif JRUBY_VERSION =~ /^1.6/
-          java_import 'java.io.OutputStreamWriter'
-          java_import 'java.nio.channels.Channels'
-          java_import 'jline.ConsoleReader'
-          java_import 'jline.Terminal'
-
-          @java_input = Channels.newInputStream(@input.to_channel)
-          @java_output = OutputStreamWriter.new(Channels.newOutputStream(@output.to_channel))
-          @java_terminal = Terminal.getTerminal
-          @java_console = ConsoleReader.new(@java_input, @java_output)
-          @java_console.setUseHistory(false)
-          @java_console.setBellEnabled(true)
-          @java_console.setUsePagination(false)
-        end
-      end
-    end
-
-    extend self
-
-    #
-    # This section builds character reading and terminal size functions
-    # to suit the proper platform we're running on.  Be warned:  Here be
-    # dragons!
-    #
-    if RUBY_PLATFORM =~ /mswin(?!ce)|mingw|bccwin/i
-      begin
-        require "fiddle"
-
-        module WinAPI
-          include Fiddle
-          Handle = RUBY_VERSION >= "2.0.0" ? Fiddle::Handle : DL::Handle
-          Kernel32 = Handle.new("kernel32")
-          Crt = Handle.new("msvcrt") rescue Handle.new("crtdll")
-
-          def self._getch
-            @@_m_getch ||= Function.new(Crt["_getch"], [], TYPE_INT)
-            @@_m_getch.call
-          end
-
-          def self.GetStdHandle(handle_type)
-            @@get_std_handle ||= Function.new(Kernel32["GetStdHandle"], [-TYPE_INT], -TYPE_INT)
-            @@get_std_handle.call(handle_type)
-          end
-
-          def self.GetConsoleScreenBufferInfo(cons_handle, lp_buffer)
-            @@get_console_screen_buffer_info ||=
-              Function.new(Kernel32["GetConsoleScreenBufferInfo"], [TYPE_LONG, TYPE_VOIDP], TYPE_INT)
-            @@get_console_screen_buffer_info.call(cons_handle, lp_buffer)
-          end
-        end
-      rescue LoadError
-        require "dl/import"
-
-        module WinAPI
-          if defined?(DL::Importer)
-            # Ruby 1.9
-            extend DL::Importer
-          else
-            # Ruby 1.8
-            extend DL::Importable
-          end
-          begin
-            dlload "msvcrt", "kernel32"
-          rescue DL::DLError
-            dlload "crtdll", "kernel32"
-          end
-          extern "unsigned long _getch()"
-          extern "unsigned long GetConsoleScreenBufferInfo(unsigned long, void*)"
-          extern "unsigned long GetStdHandle(unsigned long)"
-
-          # Ruby 1.8 DL::Importable.import does mname[0,1].downcase so FooBar becomes fooBar
-          if defined?(getConsoleScreenBufferInfo)
-            alias_method :GetConsoleScreenBufferInfo, :getConsoleScreenBufferInfo
-            module_function :GetConsoleScreenBufferInfo
-          end
-          if defined?(getStdHandle)
-            alias_method :GetStdHandle, :getStdHandle
-            module_function :GetStdHandle
-          end
-        end
-      end
-
-      CHARACTER_MODE = "Win32API"    # For Debugging purposes only.
-
-      #
-      # Windows savvy getc().
-      #
-      # *WARNING*:  This method ignores <tt>input</tt> and reads one
-      # character from +STDIN+!
-      #
-      def get_character( input = STDIN )
-        WinAPI._getch
-      end
-
-      # We do not define a raw_no_echo_mode for Windows as _getch turns off echo
-      def raw_no_echo_mode
-      end
-
-      def restore_mode
-      end
-
-      # A Windows savvy method to fetch the console columns, and rows.
-      def terminal_size
-        format        = 'SSSSSssssSS'
-        buf           = ([0] * format.size).pack(format)
-        stdout_handle = WinAPI.GetStdHandle(0xFFFFFFF5)
-
-        WinAPI.GetConsoleScreenBufferInfo(stdout_handle, buf)
-        _, _, _, _, _,
-        left, top, right, bottom, _, _ = buf.unpack(format)
-        return right - left + 1, bottom - top + 1
-      end
-    else                  # If we're not on Windows try...
-      begin
-        require "termios"             # Unix, first choice termios.
-
-        CHARACTER_MODE = "termios"    # For Debugging purposes only.
-
-        def raw_no_echo_mode
-          @state = Termios.getattr(@input)
-          new_settings                     =  @state.dup
-          new_settings.c_lflag             &= ~(Termios::ECHO | Termios::ICANON)
-          new_settings.c_cc[Termios::VMIN] =  1
-          Termios.setattr(@input, Termios::TCSANOW, new_settings)
-        end
-
-        def restore_mode
-          Termios.setattr(@input, Termios::TCSANOW, @state)
-        end
-      rescue LoadError                # If our first choice fails, try using JLine
-        if JRUBY                      # if we are on JRuby. JLine is bundled with JRuby.
-          CHARACTER_MODE = "jline"    # For Debugging purposes only.
-
-          def terminal_size
-            if JRUBY_OVER_17
-              [ @java_terminal.get_width, @java_terminal.get_height ]
-            else
-              [ @java_terminal.getTerminalWidth, @java_terminal.getTerminalHeight ]
-            end
-          end
-
-          def raw_no_echo_mode
-            @state = @java_console.getEchoCharacter
-            @java_console.setEchoCharacter 0
-          end
-
-          def restore_mode
-            @java_console.setEchoCharacter @state
-          end
-        else                          # If we are not on JRuby, try ncurses
-          begin
-            require 'ffi-ncurses'
-            CHARACTER_MODE = "ncurses"    # For Debugging purposes only.
-
-            def raw_no_echo_mode
-              FFI::NCurses.initscr
-              FFI::NCurses.cbreak
-            end
-
-            def restore_mode
-              FFI::NCurses.endwin
-            end
-
-            #
-            # A ncurses savvy method to fetch the console columns, and rows.
-            #
-            def terminal_size
-              size = [80, 40]
-              FFI::NCurses.initscr
-              begin
-                size = FFI::NCurses.getmaxyx(FFI::NCurses.stdscr).reverse
-              ensure
-                FFI::NCurses.endwin
-              end
-              size
-            end
-          rescue LoadError            # Finally, if all else fails, use stty
-                                      # *WARNING*:  This requires the external "stty" program!
-            CHARACTER_MODE = "stty"   # For Debugging purposes only.
-
-            def raw_no_echo_mode
-              @state = `stty -g`
-              system "stty raw -echo -icanon isig"
-            end
-
-            def restore_mode
-              system "stty #{@state}"
-              print "\r"
-            end
-          end
-        end
-      end
-
-      # For termios and stty
-      if not method_defined?(:terminal_size)
-        # A Unix savvy method using stty to fetch the console columns, and rows.
-        # ... stty does not work in JRuby
-        def terminal_size
-          begin
-            require "io/console"
-            winsize = IO.console.winsize.reverse rescue nil
-            return winsize if winsize
-          rescue LoadError
-          end
-
-          if /solaris/ =~ RUBY_PLATFORM and
-            `stty` =~ /\brows = (\d+).*\bcolumns = (\d+)/
-            [$2, $1].map { |x| x.to_i }
-          elsif `stty size` =~ /^(\d+)\s(\d+)$/
-            [$2.to_i, $1.to_i]
-          else
-            [ 80, 24 ]
-          end
-        end
-      end
-    end
-
-    if not method_defined?(:get_character)
-      def get_character( input = STDIN )
-        input.getbyte
-      end
-    end
-  end
-end