brakeman 5.2.2 → 7.1.1

data/bundle/ruby/3.1.0/gems/highline-3.1.2/README.md

@@ -0,0 +1,240 @@
+HighLine
+========
+
+[![Tests](https://github.com/JEG2/highline/actions/workflows/ci.yml/badge.svg)](https://github.com/JEG2/highline/actions/workflows/ci.yml)
+[![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" }
+
+## Disable default value hint showing
+
+my_special_default_object = Object.new
+
+cli.ask("Question?  ") do |q|
+  q.default = my_special_default_object
+  q.default_hint_show = false
+end
+
+
+# Validation
+
+cli.ask("Age?  ", Integer) { |q| q.in = 0..105 }
+cli.ask("Name?  (last, first)  ") { |q| q.validate = /\A\w+, ?\w+\Z/ }
+
+## Validation with custom class
+class ZeroToTwentyFourValidator
+  def self.valid?(answer)
+    (0..24).include? answer.to_i
+  end
+
+  def self.inspect
+    "(0..24) rule"
+  end
+end
+
+cli.ask("What hour of the day is it?:  ", Integer) do |q|
+  q.validate = ZeroToTwentyFourValidator
+end
+
+## Validation with Dry::Types
+## `Dry::Types` provides a `valid?` method so it can be used effortlessly
+
+require 'dry-type'
+
+module Types
+  include Dry.Types
+end
+
+cli.ask("Type an integer:", Integer) do |q|
+  q.validate = Types::Coercible::Integer
+end
+
+# 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 >= 3.0.0 requires ruby >= 3.0.0
+
+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```
+
+  Alternatively, if you're in a [Docker](https://www.docker.com)ised environment,
+  don't care about installing anything locally -- just run `bin/test` instead.
+
+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/3.1.0/gems/highline-3.1.2/highline.gemspec

@@ -0,0 +1,40 @@
+# 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 = ">= 3.0"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "dry-types"
+
+  spec.add_runtime_dependency "reline"
+
+  spec.metadata["changelog_uri"] = spec.homepage + "/blob/master/Changelog.md"
+end

data/bundle/ruby/3.1.0/gems/highline-3.1.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(min:nil, time:nil, intr: nil)
+    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/3.1.0/gems/highline-3.1.2/lib/highline/list_renderer.rb

@@ -0,0 +1,261 @@
+# 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
+      result = (line_size_limit + row_join_str_size) / (items_max_length + row_join_str_size)
+      result == 0 ? 1 : result
+    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