ric 0.11.19 → 0.14.0

data/vendor/bundle/ruby/2.7.0/gems/paint-2.2.1/lib/paint/constants.rb

@@ -0,0 +1,102 @@
+module Paint
+  # Clears all colors
+  NOTHING = "\033[0m".freeze
+
+  # Number of possible colors in TRUE COLOR mode
+  TRUE_COLOR = 0xFFFFFF
+
+  # Basic colors (often, the color differs when using the bright effect)
+  # Final color will be 30 + value for foreground and 40 + value for background
+  ANSI_COLORS = {
+    :black   => 0,
+    :red     => 1,
+    :green   => 2,
+    :yellow  => 3,
+    :blue    => 4,
+    :magenta => 5,
+    :cyan    => 6,
+    :white   => 7, :gray => 7,
+    :default => 9,
+  }.freeze
+
+  ANSI_COLORS_FOREGROUND = {
+    :black   => 30,
+    :red     => 31,
+    :green   => 32,
+    :yellow  => 33,
+    :blue    => 34,
+    :magenta => 35,
+    :cyan    => 36,
+    :white   => 37, :gray => 37,
+    :default => 39,
+  }.freeze
+
+  ANSI_COLORS_BACKGROUND = {
+    :black   => 40,
+    :red     => 41,
+    :green   => 42,
+    :yellow  => 43,
+    :blue    => 44,
+    :magenta => 45,
+    :cyan    => 46,
+    :white   => 47, :gray => 47,
+    :default => 49,
+  }.freeze
+
+  # Terminal effects - most of them are not supported ;)
+  # See https://en.wikipedia.org/wiki/ANSI_escape_code
+  ANSI_EFFECTS = {
+    :reset         => 0,  :nothing         => 0,  # usually supported
+    :bright        => 1,  :bold            => 1,  # usually supported
+    :faint         => 2,
+    :italic        => 3,
+    :underline     => 4,                          # usually supported
+    :blink         => 5,  :slow_blink      => 5,
+    :rapid_blink   => 6,
+    :inverse       => 7,  :swap            => 7,  # usually supported
+    :conceal       => 8,  :hide            => 9,
+    :default_font  => 10,
+    :font0 => 10, :font1 => 11, :font2 => 12, :font3 => 13, :font4 => 14,
+    :font5 => 15, :font6 => 16, :font7 => 17, :font8 => 18, :font9 => 19,
+    :fraktur       => 20,
+    :bright_off    => 21, :bold_off        => 21, :double_underline => 21,
+    :clean         => 22,
+    :italic_off    => 23, :fraktur_off     => 23,
+    :underline_off => 24,
+    :blink_off     => 25,
+    :inverse_off   => 26, :positive        => 26,
+    :conceal_off   => 27, :show            => 27, :reveal           => 27,
+    :crossed_off   => 29, :crossed_out_off => 29,
+    :frame         => 51,
+    :encircle      => 52,
+    :overline      => 53,
+    :frame_off     => 54, :encircle_off    => 54,
+    :overline_off  => 55,
+  }.freeze
+
+  # A list of color names for standard ansi colors, needed for 16/8 color fallback mode
+  # See https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
+  RGB_COLORS_ANSI = {
+    :black   => [  0,   0,   0],
+    :red     => [205,   0,   0],
+    :green   => [  0, 205,   0],
+    :yellow  => [205, 205,   0],
+    :blue    => [  0,   0, 238],
+    :magenta => [205,   0, 205],
+    :cyan    => [  0, 205, 205],
+    :white   => [229, 229, 229], :gray => [229, 229, 229],
+  }.each { |k, v| v.freeze }.freeze
+
+  # A list of color names for standard bright ansi colors, needed for 16 color fallback mode
+  # See https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
+  RGB_COLORS_ANSI_BRIGHT = {
+    :black   => [127, 127, 127],
+    :red     => [255,   0,   0],
+    :green   => [  0, 255,   0],
+    :yellow  => [255, 255,   0],
+    :blue    => [ 92,  92, 255],
+    :magenta => [255,   0, 255],
+    :cyan    => [  0, 255, 255],
+    :white   => [255, 255, 255], :gray => [255, 255, 255],
+  }.each { |k, v| v.freeze }.freeze
+end

data/vendor/bundle/ruby/2.7.0/gems/paint-2.2.1/lib/paint/pa.rb

@@ -0,0 +1,11 @@
+require 'paint'
+
+module Kernel
+  private
+
+  # A helper method similar to puts for printing a String on STDOUT
+  # Passes all arguments to Paint.[]
+  def pa(*args)
+    puts Paint[*args]
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/paint-2.2.1/lib/paint/rgb_colors.rb

@@ -0,0 +1,12 @@
+require "zlib"
+
+module Paint
+  RGB_COLORS_INDEX_FILENAME = File.dirname(__FILE__) + "/../../data/rgb_colors.marshal.gz"
+  # A list of color names, based on X11's rgb.txt
+
+  File.open(RGB_COLORS_INDEX_FILENAME, "rb") do |file|
+    serialized_data = Zlib::GzipReader.new(file).read
+    serialized_data.force_encoding Encoding::BINARY
+    RGB_COLORS = Marshal.load(serialized_data)
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/paint-2.2.1/lib/paint/util.rb

@@ -0,0 +1,14 @@
+module Paint
+  # Standalone helpers which add functionality you sometimes need when working with terminal colors
+  class << self
+    # Removes any color and effect strings
+    def unpaint(string)
+      string.gsub(/\e\[(?:[0-9];?)+m/, '')
+    end
+
+    # Creates a random ANSI color
+    def random(background = false)
+      (background ? 40 : 30) + rand(8)
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/paint-2.2.1/lib/paint/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Paint
+  VERSION = "2.2.1"
+end

data/vendor/bundle/ruby/2.7.0/gems/paint-2.2.1/lib/paint.rb

@@ -0,0 +1,257 @@
+require_relative 'paint/version'
+require_relative 'paint/constants'
+require_relative 'paint/util'
+
+module Paint
+  autoload :RGB_COLORS, 'paint/rgb_colors'
+
+  class << self
+    # Takes a string and color options and colorizes the string, fast version without nesting
+    def [](string, *options)
+      return string.to_s if @mode.zero? || options.empty?
+      options = options[0] if options.size == 1 && !options[0].respond_to?(:to_ary)
+      @cache[options] + string.to_s + NOTHING
+    end
+
+    # Takes an array with string and color options and colorizes the string,
+    # extended version with nesting and substitution support
+    def %(paint_arguments, clear_color = NOTHING)
+      string, *options = paint_arguments
+      return string.to_s if options.empty?
+      substitutions = options.pop if options[-1].is_a?(Hash)
+      options = options[0] if options.size == 1 && !options[0].respond_to?(:to_ary)
+      current_color = @cache[options]
+
+      # Substitutions & Nesting
+      if substitutions
+        substitutions.each{ |key, value|
+          string.gsub!(
+            "%{#{key}}",
+            (value.is_a?(Array) ? self.%(value, current_color) : value.to_s)
+          )
+        }
+      end
+
+      # Wrap string (if Paint.mode > 0)
+      if @mode.zero?
+        string.to_s
+      else
+        current_color + string.to_s + clear_color
+      end
+    end
+
+    # Transforms options into the desired color. Used by @cache
+    def color(*options)
+      return '' if @mode.zero? || options.empty?
+      mix = []
+      color_seen = false
+      colors = ANSI_COLORS_FOREGROUND
+
+      options.each{ |option|
+        case option
+        when Symbol
+          if color = colors[option]
+            mix << color
+            color_seen = :set
+          elsif ANSI_EFFECTS.key?(option)
+            mix << effect(option)
+          else
+            raise ArgumentError, "Unknown color or effect: #{ option }"
+          end
+
+        when Array
+          if option.size == 3 && option.all?{ |n| n.is_a? Numeric }
+            mix << rgb(*[*option, color_seen])
+            color_seen = :set
+          else
+            raise ArgumentError, "Array argument must contain 3 numerals"
+          end
+
+        when ::String
+          if option =~ /\A#?(?<hex_color>[[:xdigit:]]{3}{1,2})\z/ # 3 or 6 hex chars
+            mix << rgb_hex($~[:hex_color], color_seen)
+            color_seen = :set
+          else
+            mix << rgb_name(option, color_seen)
+            color_seen = :set
+          end
+
+        when Numeric
+          integer = option.to_i
+          color_seen = :set if (30..49).include?(integer)
+          mix << integer
+
+        when nil
+          color_seen = :set
+
+        else
+          raise ArgumentError, "Invalid argument: #{ option.inspect }"
+
+        end
+
+        if color_seen == :set
+          colors = ANSI_COLORS_BACKGROUND
+          color_seen = true
+        end
+      }
+
+      wrap(*mix)
+    end
+
+    # This variable influences the color code generation
+    # Currently supported values:
+    # * 0xFFFFFF  - 24-bit (~16 million) colors, aka truecolor
+    # * 256       - 256 colors
+    # * 16        - only ansi colors and bright effect
+    # * 8         - only ansi colors
+    # * 0         - no colorization!
+    attr_reader :mode
+    def mode=(val)
+      @cache.clear
+
+      case val
+      when 0, 8, 16, 256, TRUE_COLOR
+        @mode = val
+      when TrueClass
+        @mode = TRUE_COLOR
+      when nil
+        @mode = 0
+      else
+        raise ArgumentError, "Cannot set paint mode to value <#{val}>, possible values are: 0xFFFFFF (true), 256, 16, 8, 0 (nil)"
+      end
+    end
+
+    # Adds ANSI sequence
+    def wrap(*ansi_codes)
+      "\033[" + ansi_codes*";" + "m"
+    end
+
+    # Creates simple ansi color by looking it up on Paint::ANSI_COLORS
+    def simple(color_name, background = false)
+      (background ? 40 : 30) + ANSI_COLORS[color_name]
+    end
+
+    # If not true_color, creates a 256-compatible color from rgb values,
+    # otherwise, an exact 24-bit color
+    def rgb(red, green, blue, background = false)
+      case @mode
+      when 8
+        "#{background ? 4 : 3}#{rgb_to_ansi(red, green, blue, false)}"
+      when 16
+        "#{background ? 4 : 3}#{rgb_to_ansi(red, green, blue, true)}"
+      when 256
+        "#{background ? 48 : 38}#{rgb_to_256(red, green, blue)}"
+      when TRUE_COLOR
+        "#{background ? 48 : 38}#{rgb_true(red, green, blue)}"
+      end
+    end
+
+    # Creates RGB color from a HTML-like color definition string
+    def rgb_hex(string, background = false)
+      case string.size
+      when 6
+        color_code = string.each_char.each_slice(2).map{ |hex_color| hex_color.join.to_i(16) }
+      when 3
+        color_code = string.each_char.map{ |hex_color_half| (hex_color_half*2).to_i(16) }
+      end
+      rgb(*[*color_code, background])
+    end
+
+    # Creates a RGB from a name found in Paint::RGB_COLORS (based on rgb.txt)
+    def rgb_name(color_name, background = false)
+      if color_code = RGB_COLORS[color_name]
+        rgb(*[*color_code, background])
+      end
+    end
+
+    # Creates the specified effect by looking it up in Paint::ANSI_EFFECTS
+    def effect(effect_name)
+      ANSI_EFFECTS[effect_name]
+    end
+
+    # Determine supported colors
+    # Note: there's no reliable test for 24-bit color support
+    def detect_mode
+      if ENV['NO_COLOR'] # see https://no-color.org/
+        0
+      elsif RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ # windows
+        if ENV['ANSICON']
+          16
+        elsif ENV['ConEmuANSI'] == 'ON'
+          TRUE_COLOR
+        else
+          0
+        end
+      elsif ENV['TERM_PROGRAM'] == 'Apple_Terminal'
+        256
+      else
+        case ENV['TERM']
+        when /^rxvt-(?:.*)-256color$/
+          256
+        when /-color$/, /^rxvt/
+          16
+        else # optimistic default
+          TRUE_COLOR
+        end
+      end
+    end
+
+    private
+
+    # Returns 24-bit color value (see https://gist.github.com/XVilka/8346728)
+    # in ANSI escape sequnce format, without fore-/background information
+    def rgb_true(red, green, blue)
+      ";2;#{red};#{green};#{blue}"
+    end
+
+    # Returns closest supported 256-color an RGB value, without fore-/background information
+    # Inspired by the rainbow gem
+    def rgb_to_256(red, green, blue, approx = true)
+      return ";2;#{red};#{green};#{blue}" unless approx
+
+      gray_possible = true
+      sep = 42.5
+
+      while gray_possible
+        if red < sep || green < sep || blue < sep
+          gray = red < sep && green < sep && blue < sep
+          gray_possible = false
+        end
+        sep += 42.5
+      end
+
+      if gray
+        ";5;#{ 232 + ((red.to_f + green.to_f + blue.to_f)/33).round }"
+      else # rgb
+        ";5;#{ [16, *[red, green, blue].zip([36, 6, 1]).map{ |color, mod|
+          (6 * (color.to_f / 256)).to_i * mod
+        }].inject(:+) }"
+      end
+    end
+
+    # Returns best ANSI color matching an RGB value, without fore-/background information
+    # See https://mail.python.org/pipermail/python-list/2008-December/1150496.html
+    def rgb_to_ansi(red, green, blue, use_bright = false)
+      color_pool =  RGB_COLORS_ANSI.values
+      color_pool += RGB_COLORS_ANSI_BRIGHT.values if use_bright
+
+      ansi_color_rgb = color_pool.min_by{ |col| rgb_color_distance([red, green, blue],col) }
+      if ansi_color = RGB_COLORS_ANSI.key(ansi_color_rgb)
+        ANSI_COLORS[ansi_color]
+      else
+        ansi_color = RGB_COLORS_ANSI_BRIGHT.key(ansi_color_rgb)
+        "#{ANSI_COLORS[ansi_color]};1"
+      end
+    end
+
+    def rgb_color_distance(rgb1, rgb2)
+      rgb1.zip(rgb2).inject(0){ |acc, (cur1, cur2)|
+        acc + (cur1 - cur2)**2
+      }
+    end
+  end
+
+  # init instance vars
+  @mode  = detect_mode
+  @cache = Hash.new{ |h, k| h[k] = color(*k) }
+end

data/vendor/bundle/ruby/2.7.0/gems/paint-2.2.1/paint.gemspec

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+require File.dirname(__FILE__) + "/lib/paint/version"
+
+Gem::Specification.new do |s|
+  s.name        = "paint"
+  s.version     = Paint::VERSION
+  s.authors     = ["Jan Lelis"]
+  s.email       = ["hi@ruby.consulting"]
+  s.homepage    = "https://github.com/janlelis/paint"
+  s.summary     = "Terminal painter!"
+  s.description = "Terminal painter with RGB and 256 (fallback) color and terminal effects support. No string extensions! Usage: Paint['string', :red, :bright]"
+  s.license = 'MIT'
+
+  s.files = %w[
+    paint.gemspec
+    Rakefile
+    .rspec
+    .travis.yml
+    lib/paint.rb
+    lib/paint/pa.rb
+    lib/paint/rgb_colors.rb
+    lib/paint/constants.rb
+    lib/paint/util.rb
+    lib/paint/version.rb
+    data/rgb_colors.marshal.gz
+  ]
+  s.extra_rdoc_files = %w[
+    README.md
+    CHANGELOG.md
+    MIT-LICENSE.txt
+  ]
+
+  s.required_ruby_version = '>= 1.9.3'
+  s.add_development_dependency 'rspec', '~> 3.2'
+  s.add_development_dependency 'rake', '~> 12.3'
+  s.add_development_dependency 'benchmark-ips', '~> 2.7'
+  s.add_development_dependency 'rainbow', '~> 3.0'
+  s.add_development_dependency 'term-ansicolor', '~> 1.7'
+  s.add_development_dependency 'ansi', '~> 1.5'
+  s.add_development_dependency 'hansi', '~> 0.2'
+  s.add_development_dependency 'pastel', '~> 0.7'
+end

data/vendor/bundle/ruby/2.7.0/gems/power_assert-2.0.1/BSDL

@@ -0,0 +1,22 @@
+Copyright (C) 2014 Kazuki Tsujimoto
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/vendor/bundle/ruby/2.7.0/gems/power_assert-2.0.1/COPYING

@@ -0,0 +1,57 @@
+Copyright (C) 2014 Kazuki Tsujimoto
+
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them,
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/vendor/bundle/ruby/2.7.0/gems/power_assert-2.0.1/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gemspec
+
+# https://github.com/redmine/redmine/blob/3.0.4/Gemfile#L101
+local_gemfile = File.join(File.dirname(__FILE__), "Gemfile.local")
+if File.exist?(local_gemfile)
+  eval_gemfile local_gemfile
+end

data/vendor/bundle/ruby/2.7.0/gems/power_assert-2.0.1/LEGAL

@@ -0,0 +1,4 @@
+LEGAL NOTICE INFORMATION
+------------------------
+
+All the files in this distribution are written by the author.

data/vendor/bundle/ruby/2.7.0/gems/power_assert-2.0.1/README.md

@@ -0,0 +1,98 @@
+# power_assert
+## About
+Power Assert shows each value of variables and method calls in the expression.
+It is useful for testing, providing which value wasn't correct when the condition is not satisfied.
+
+    Failure:
+       assert { 3.times.to_a.include?(3) }
+                  |     |    |
+                  |     |    false
+                  |     [0, 1, 2]
+                  #<Enumerator: 3:times>
+
+## Related Projects
+In general, you don't need to use this library directly.
+Use following test frameworks or extensions instead.
+
+* [test-unit](https://github.com/test-unit/test-unit)(>= 3.0.0)
+  * [Document](http://test-unit.github.io/test-unit/en/Test/Unit/Assertions.html#assert-instance_method)
+* [minitest-power_assert](https://github.com/hsbt/minitest-power_assert)
+* [rspec-power_assert](https://github.com/joker1007/rspec-power_assert)
+* [rspec-matchers-power_assert_matchers](https://github.com/kachick/rspec-matchers-power_assert_matchers)
+* [pry-power_assert](https://github.com/yui-knk/pry-power_assert)
+* [pry-byebug-power_assert](https://github.com/k-tsj/pry-byebug-power_assert)
+* [irb-power_assert](https://github.com/kachick/irb-power_assert)
+* [power_p](https://github.com/k-tsj/power_p)
+
+## Requirement
+* CRuby 2.5+
+
+## Configuration
+To colorize output messages, add <code>require "power_assert/colorize"</code> to your code.
+(It requires CRuby 3.0.1+ or irb 1.3.1+)
+
+## Known Limitations
+* Expressions must be put in one line. Expressions with folded long lines produce nothing report, e.g.:
+
+```ruby
+assert do
+  # reported
+  func(foo: 0123456789, bar: "abcdefg")
+end
+
+assert do
+  # won't be reported
+  func(foo: 0123456789,
+       bar: "abcdefg")
+end
+```
+
+* Expressions must have one or more method call. Expressions with no method call produce nothing report, e.g.:
+
+```ruby
+val = false
+assert do
+  # reported
+  val == true
+end
+
+assert do
+  # won't be reported
+  val
+end
+```
+
+* Returned values from accessor methods, method missing, or "super" produce nothing report, e.g:
+
+```ruby
+class Foo
+  attr_accessor :val
+end
+foo = Foo.new
+foo.val = false
+
+assert do
+  # reported (only the value of "foo" and the literal "true")
+  foo.val == true
+end
+
+assert do
+  # won't be reported
+  foo.val
+end
+```
+
+* Expressions should not have conditional branches. Expressions with such conditional codes may produce nothing report, e.g.:
+
+```ruby
+condition = true
+expected = false
+actual = true
+assert do
+  # this will fail but nothing reported
+  condition ? expected == actual : expected == actual
+end
+```
+
+## Reference
+* [Power Assert in Ruby (at RubyKaigi 2014) // Speaker Deck](https://speakerdeck.com/k_tsj/power-assert-in-ruby)