brakeman 5.2.2 → 7.1.1

data/bundle/ruby/2.7.0/gems/highline-2.0.3/README.md

@@ -1,202 +0,0 @@
-HighLine
-========
-
-[![Build Status](https://travis-ci.org/JEG2/highline.svg?branch=master)](https://travis-ci.org/JEG2/highline)
-[![Build status](https://ci.appveyor.com/api/projects/status/4p05fijpah77d28x/branch/master?svg=true)](https://ci.appveyor.com/project/JEG2/highline/branch/master)
-[![Gem Version](https://badge.fury.io/rb/highline.svg)](https://badge.fury.io/rb/highline)
-[![Code Climate](https://codeclimate.com/github/JEG2/highline/badges/gpa.svg)](https://codeclimate.com/github/JEG2/highline)
-[![Test Coverage](https://codeclimate.com/github/JEG2/highline/badges/coverage.svg)](https://codeclimate.com/github/JEG2/highline/coverage)
-[![Inline docs](http://inch-ci.org/github/JEG2/highline.svg?branch=master)](http://inch-ci.org/github/JEG2/highline)
-
-Description
------------
-
-Welcome to HighLine.
-
-HighLine was designed to ease the tedious tasks of doing console input and
-output with low-level methods like ```gets``` and ```puts```. HighLine provides a
-robust system for requesting data from a user, without needing to code all the
-error checking and validation rules and without needing to convert the typed
-Strings into what your program really needs.  Just tell HighLine what you're
-after, and let it do all the work.
-
-Documentation
--------------
-
-See: [Rubydoc.info for HighLine](http://www.rubydoc.info/github/JEG2/highline/master).
-Specially [HighLine](http://www.rubydoc.info/github/JEG2/highline/master/HighLine) and [HighLine::Question](http://www.rubydoc.info/github/JEG2/highline/master/HighLine/Question).
-
-Usage
------
-
-```ruby
-
-require 'highline'
-
-# Basic usage
-
-cli = HighLine.new
-answer = cli.ask "What do you think?"
-puts "You have answered: #{answer}"
-
-
-# Default answer
-
-cli.ask("Company?  ") { |q| q.default = "none" }
-
-
-# Validation
-
-cli.ask("Age?  ", Integer) { |q| q.in = 0..105 }
-cli.ask("Name?  (last, first)  ") { |q| q.validate = /\A\w+, ?\w+\Z/ }
-
-
-# Type conversion for answers:
-
-cli.ask("Birthday?  ", Date)
-cli.ask("Interests?  (comma sep list)  ", lambda { |str| str.split(/,\s*/) })
-
-
-# Reading passwords:
-
-cli.ask("Enter your password:  ") { |q| q.echo = false }
-cli.ask("Enter your password:  ") { |q| q.echo = "x" }
-
-
-# ERb based output (with HighLine's ANSI color tools):
-
-cli.say("This should be <%= color('bold', BOLD) %>!")
-
-
-# Menus:
-
-cli.choose do |menu|
-  menu.prompt = "Please choose your favorite programming language?  "
-  menu.choice(:ruby) { cli.say("Good choice!") }
-  menu.choices(:python, :perl) { cli.say("Not from around here, are you?") }
-  menu.default = :ruby
-end
-
-## Using colored indices on Menus
-
-HighLine::Menu.index_color   = :rgb_77bbff # set default index color
-
-cli.choose do |menu|
-  menu.index_color  = :rgb_999999      # override default color of index
-                                       # you can also use constants like :blue
-  menu.prompt = "Please choose your favorite programming language?  "
-  menu.choice(:ruby) { cli.say("Good choice!") }
-  menu.choices(:python, :perl) { cli.say("Not from around here, are you?") }
-end
-```
-
-If you want to save some characters, you can inject/import HighLine methods on Kernel by doing the following. Just be sure to avoid name collisions in the top-level namespace.
-
-
-```ruby
-require 'highline/import'
-
-say "Now you can use #say directly"
-```
-
-For more examples see the examples/ directory of this project.
-
-Requirements
-------------
-
-HighLine from version >= 1.7.0 requires ruby >= 1.9.3
-
-Installing
-----------
-
-To install HighLine, use the following command:
-
-```sh
-$ gem install highline
-```
-
-(Add `sudo` if you're installing under a POSIX system as root)
-
-If you're using [Bundler](http://bundler.io/), add this to your Gemfile:
-
-```ruby
-source "https://rubygems.org"
-gem 'highline'
-```
-
-And then run:
-
-```sh
-$ bundle
-```
-
-If you want to build the gem locally, use the following command from the root of the sources:
-
-```sh
-$ rake package
-```
-
-You can also build and install directly:
-
-```sh
-$ rake install
-```
-
-Contributing
-------------
-
-1. Open an issue
-  - https://github.com/JEG2/highline/issues
-
-2. Fork the repository
-  - https://github.com/JEG2/highline/fork
-
-3. Clone it locally
-  - ```git clone git@github.com:YOUR-USERNAME/highline.git```
-
-4. Add the main HighLine repository as the __upstream__ remote
-  - ```cd highline``` # to enter the cloned repository directory.
-  - ```git remote add upstream https://github.com/JEG2/highline```
-
-5. Keep your fork in sync with __upstream__
-  - ```git fetch upstream```
-  - ```git checkout master```
-  - ```git merge upstream/master```
-
-6. Create your feature branch
-  - ```git checkout -b your_branch```
-
-7. Hack the source code, run the tests and __pronto__
-  - ```rake test```
-  - ```rake acceptance```
-  - ```pronto run```
-
-8. Commit your changes
-  - ```git commit -am "Your commit message"```
-
-9. Push it
-  - ```git push```
-
-10. Open a pull request
-  - https://github.com/JEG2/highline/pulls
-
-Details on:
-
-* GitHub Guide to Contributing to Open Source - https://guides.github.com/activities/contributing-to-open-source/
-* GitHub issues - https://guides.github.com/features/issues/
-* Forking - https://help.github.com/articles/fork-a-repo/
-* Cloning - https://help.github.com/articles/cloning-a-repository/
-* Adding upstream - https://help.github.com/articles/configuring-a-remote-for-a-fork/
-* Syncing your fork - https://help.github.com/articles/syncing-a-fork/
-* Branching - https://git-scm.com/book/en/v2/Git-Branching-Basic-Branching-and-Merging
-* Commiting - https://git-scm.com/book/en/v2/Git-Basics-Recording-Changes-to-the-Repository
-* Pushing - https://git-scm.com/book/en/v2/Git-Basics-Working-with-Remotes
-
-The Core HighLine Team
-----------------------
-
-* [James Edward Gray II](https://github.com/JEG2) - Author
-* [Gregory Brown](https://github.com/practicingruby) - Core contributor
-* [Abinoam P. Marques Jr.](https://github.com/abinoam) - Core contributor
-
-_For a list of people who have contributed to the codebase, see [GitHub's list of contributors](https://github.com/JEG2/highline/contributors)._

data/bundle/ruby/2.7.0/gems/highline-2.0.3/appveyor.yml

@@ -1,37 +0,0 @@
-version: 2.0.{build}-{branch}
-
-cache:
-  - vendor/bundle
-
-environment:
-  matrix:
-    - RUBY_VERSION: "193"
-    - RUBY_VERSION: "200"
-    - RUBY_VERSION: "200-x64"
-    - RUBY_VERSION: "21"
-    - RUBY_VERSION: "21-x64"
-    - RUBY_VERSION: "22"
-    - RUBY_VERSION: "22-x64"
-    - RUBY_VERSION: "23"
-    - RUBY_VERSION: "23-x64"
-    - RUBY_VERSION: "24"
-    - RUBY_VERSION: "24-x64"
-
-matrix:
-  allow_failures:
-    - RUBY_VERSION: "193"
-
-install:
-  - set PATH=C:\Ruby%RUBY_VERSION%\bin;%PATH%
-  - bundle config --local path vendor/bundle
-  - bundle install --retry=3 --without code_quality
-
-build: off
-
-before_test:
-  - ruby -v
-  - gem -v
-  - bundle -v
-
-test_script:
-  - bundle exec rake

data/bundle/ruby/2.7.0/gems/highline-2.0.3/highline.gemspec

@@ -1,35 +0,0 @@
-# coding: utf-8
-
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "highline/version"
-
-Gem::Specification.new do |spec|
-  spec.name        = "highline"
-  spec.version     = HighLine::VERSION
-  spec.author      = "James Edward Gray II"
-  spec.email       = "james@graysoftinc.com"
-
-  spec.summary     = "HighLine is a high-level command-line IO library."
-  spec.description = <<DESCRIPTION
-A high-level IO library that provides validation, type conversion, and more for
-command-line interfaces. HighLine also includes a complete menu system that can
-crank out anything from simple list selection to complete shells with just
-minutes of work.
-DESCRIPTION
-  spec.homepage    = "https://github.com/JEG2/highline"
-  spec.license     = "Ruby"
-
-  spec.files       = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
-  spec.require_paths = ["lib"]
-
-  spec.extra_rdoc_files = %w[README.md TODO Changelog.md LICENSE]
-
-  spec.required_ruby_version = ">= 1.9.3"
-
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest"
-end

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

@@ -1,37 +0,0 @@
-# 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

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

@@ -1,261 +0,0 @@
-# coding: utf-8
-
-require "highline/template_renderer"
-require "highline/wrapper"
-require "highline/list"
-
-class HighLine
-  #
-  # This class is a utility for quickly and easily laying out lists
-  # to be used by HighLine.
-  #
-  class ListRenderer
-    # Items list
-    # @return [Array]
-    attr_reader :items
-
-    # @return [Symbol] the current mode the List is being rendered
-    # @see #initialize for more details see mode parameter of #initialize
-    attr_reader :mode
-
-    # Changes the behaviour of some modes. Example, in :inline mode
-    # the option is treated as the 'end separator' (defaults to " or ")
-    # @return option parameter that changes the behaviour of some modes.
-    attr_reader :option
-
-    # @return [HighLine] context
-    attr_reader :highline
-
-    # The only required parameters are _items_ and _highline_.
-    # @param items [Array] the Array of items to list
-    # @param mode [Symbol] controls how that list is formed
-    # @param option has different effects, depending on the _mode_.
-    # @param highline [HighLine] a HighLine instance to direct the output to.
-    #
-    # Recognized modes are:
-    #
-    # <tt>:columns_across</tt>::         _items_ will be placed in columns,
-    #                                    flowing from left to right.  If given,
-    #                                    _option_ is the number of columns to be
-    #                                    used.  When absent, columns will be
-    #                                    determined based on _wrap_at_ or a
-    #                                    default of 80 characters.
-    # <tt>:columns_down</tt>::           Identical to <tt>:columns_across</tt>,
-    #                                    save flow goes down.
-    # <tt>:uneven_columns_across</tt>::  Like <tt>:columns_across</tt> but each
-    #                                    column is sized independently.
-    # <tt>:uneven_columns_down</tt>::    Like <tt>:columns_down</tt> but each
-    #                                    column is sized independently.
-    # <tt>:inline</tt>::                 All _items_ are placed on a single
-    #                                    line. The last two _items_ are
-    #                                    separated by _option_ or a default of
-    #                                    " or ".  All other _items_ are
-    #                                    separated by ", ".
-    # <tt>:rows</tt>::                   The default mode.  Each of the _items_
-    #                                    is placed on its own line. The _option_
-    #                                    parameter is ignored in this mode.
-    #
-    # Each member of the _items_ Array is passed through ERb and thus can
-    # contain their own expansions. Color escape expansions do not contribute to
-    # the final field width.
-
-    def initialize(items, mode = :rows, option = nil, highline)
-      @highline = highline
-      @mode     = mode
-      @option   = option
-      @items    = render_list_items(items)
-    end
-
-    # Render the list using the appropriate mode and options.
-    # @return [String] rendered list as String
-    def render
-      return "" if items.empty?
-
-      case mode
-      when :inline
-        list_inline_mode
-      when :columns_across
-        list_columns_across_mode
-      when :columns_down
-        list_columns_down_mode
-      when :uneven_columns_across
-        list_uneven_columns_mode
-      when :uneven_columns_down
-        list_uneven_columns_down_mode
-      else
-        list_default_mode
-      end
-    end
-
-    private
-
-    def render_list_items(items)
-      items.to_ary.map do |item|
-        item = String(item)
-        template = if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
-          ERB.new(item, trim_mode: "%")
-        else
-          ERB.new(item, nil, "%")
-        end
-        template_renderer =
-          HighLine::TemplateRenderer.new(template, self, highline)
-        template_renderer.render
-      end
-    end
-
-    def list_default_mode
-      items.map { |i| "#{i}\n" }.join
-    end
-
-    def list_inline_mode
-      end_separator = option || " or "
-
-      if items.size == 1
-        items.first
-      else
-        items[0..-2].join(", ") + "#{end_separator}#{items.last}"
-      end
-    end
-
-    def list_columns_across_mode
-      HighLine::List.new(right_padded_items, cols: col_count).to_s
-    end
-
-    def list_columns_down_mode
-      HighLine::List.new(
-        right_padded_items,
-        cols: col_count,
-        col_down: true
-      ).to_s
-    end
-
-    def list_uneven_columns_mode(list = nil)
-      list ||= HighLine::List.new(items)
-
-      col_max = option || items.size
-      col_max.downto(1) do |column_count|
-        list.cols = column_count
-        widths = get_col_widths(list)
-
-        if column_count == 1 || # last guess
-           inside_line_size_limit?(widths) || # good guess
-           option # defined by user
-          return pad_uneven_rows(list, widths)
-        end
-      end
-    end
-
-    def list_uneven_columns_down_mode
-      list = HighLine::List.new(items, col_down: true)
-      list_uneven_columns_mode(list)
-    end
-
-    def pad_uneven_rows(list, widths)
-      right_padded_list = Array(list).map do |row|
-        right_pad_row(row.compact, widths)
-      end
-      stringfy_list(right_padded_list)
-    end
-
-    def stringfy_list(list)
-      list.map { |row| row_to_s(row) }.join
-    end
-
-    def row_to_s(row)
-      row.compact.join(row_join_string) + "\n"
-    end
-
-    def right_pad_row(row, widths)
-      row.zip(widths).map do |field, width|
-        right_pad_field(field, width)
-      end
-    end
-
-    def right_pad_field(field, width)
-      field = String(field) # nil protection
-      pad_size = width - actual_length(field)
-      field + (pad_char * pad_size)
-    end
-
-    def get_col_widths(lines)
-      lines = transpose(lines)
-      get_segment_widths(lines)
-    end
-
-    def get_row_widths(lines)
-      get_segment_widths(lines)
-    end
-
-    def get_segment_widths(lines)
-      lines.map do |col|
-        actual_lengths_for(col).max
-      end
-    end
-
-    def actual_lengths_for(line)
-      line.map do |item|
-        actual_length(item)
-      end
-    end
-
-    def transpose(lines)
-      lines = Array(lines)
-      first_line = lines.shift
-      first_line.zip(*lines)
-    end
-
-    def inside_line_size_limit?(widths)
-      line_size = widths.reduce(0) { |sum, n| sum + n + row_join_str_size }
-      line_size <= line_size_limit + row_join_str_size
-    end
-
-    def actual_length(text)
-      HighLine::Wrapper.actual_length text
-    end
-
-    def items_max_length
-      @items_max_length ||= max_length(items)
-    end
-
-    def max_length(items)
-      items.map { |item| actual_length(item) }.max
-    end
-
-    def line_size_limit
-      @line_size_limit ||= (highline.wrap_at || 80)
-    end
-
-    def row_join_string
-      @row_join_string ||= "  "
-    end
-
-    attr_writer :row_join_string
-
-    def row_join_str_size
-      row_join_string.size
-    end
-
-    def col_count_calculate
-      (line_size_limit + row_join_str_size) /
-        (items_max_length + row_join_str_size)
-    end
-
-    def col_count
-      option || col_count_calculate
-    end
-
-    def right_padded_items
-      items.map do |item|
-        right_pad_field(item, items_max_length)
-      end
-    end
-
-    def pad_char
-      " "
-    end
-
-    def row_count
-      (items.count / col_count.to_f).ceil
-    end
-  end
-end