brakeman 7.0.0 → 7.0.1

data/bundle/ruby/3.1.0/gems/{tilt-2.5.0 → tilt-2.6.0}/lib/tilt/template.rb

@@ -57,7 +57,28 @@ module Tilt
     # it should read template data and return as a String. When file is nil,
     # a block is required.
     #
-    # All arguments are optional.
+    # All arguments are optional. The following options are respected and
+    # are used by Tilt::Template itself and not the underlying template
+    # libraries:
+    #
+    # :default_encoding :: Force the encoding of the template to the given
+    #                      encoding.
+    # :skip_compiled_encoding_detection :: Do not scan template code for
+    #                                      an encoding magic comment.
+    # :fixed_locals :: Force a specific method parameter signature, and call
+    #                  the method with a splat of locals, instead of passing
+    #                  the locals hash as a positional argument, and
+    #                  extracting locals from that. Should be a string
+    #                  containing the parameters for the compiled method,
+    #                  surrounded by parentheses.  Can be set to false to
+    #                  disable the scan for embedded fixed locals.
+    # :extract_fixed_locals :: Whether embedded fixed locals should be scanned for
+    #                          and extracted from the template code.
+    # :default_fixed_locals :: Similar to fixed_locals, but lowest priority,
+    #                          only used if :fixed_locals is not provided
+    #                          and no embedded locals are found (or scanned for).
+    # :scope_class :: Force the scope class used for the method.  By default,
+    #                 uses the class of the scope provided to render.
     def initialize(file=nil, line=nil, options=nil)
       @file, @line, @options = nil, 1, nil
 
@@ -69,7 +90,9 @@ module Tilt
 
       @options ||= {}
 
-      set_compiled_method_cache
+      # Force a specific scope class, instead of using the class of the provided
+      # scope as the scope class.
+      @scope_class = @options.delete :scope_class
 
       # Force the encoding of the input data
       @default_encoding = @options.delete :default_encoding
@@ -78,6 +101,13 @@ module Tilt
       # for compiled templates
       @skip_compiled_encoding_detection = @options.delete :skip_compiled_encoding_detection
 
+      # Compiled path to use.  This must be specified as an option if
+      # providing the :scope_class option and using fixed locals,
+      # since template compilation occurs during initialization in that case.
+      if compiled_path = @options.delete(:compiled_path)
+        self.compiled_path = compiled_path
+      end
+
       # load template data and prepare (uses binread to avoid encoding issues)
       @data = block_given? ? yield(self) : read_template_file
 
@@ -92,7 +122,9 @@ module Tilt
         end
       end
 
+      set_fixed_locals
       prepare
+      set_compiled_method_cache
     end
 
     # Render the template in the given scope with the locals specified. If a
@@ -119,6 +151,11 @@ module Tilt
       @file || '(__TEMPLATE__)'
     end
 
+    # Whether the template uses fixed locals.
+    def fixed_locals?
+      @fixed_locals ? true : false
+    end
+
     # An empty Hash that the template engine can populate with various
     # metadata.
     def metadata
@@ -129,7 +166,14 @@ module Tilt
       end
     end
 
-    # Set the prefix to use for compiled paths.
+    # Set the prefix to use for compiled paths, similar to using the
+    # :compiled_path template option. Note that this only
+    # has affect for future template compilations.  When using the
+    # :scope_class template option, and using fixed_locals, calling
+    # this after the template is created has no effect, since the
+    # template is compiled during initialization in that case. It
+    # is recommended to use the :compiled_path template option
+    # instead of this method in new code.
     def compiled_path=(path)
       if path
         # Use expanded paths when loading, since that is helpful
@@ -145,7 +189,18 @@ module Tilt
     # directly on the scope class, which are much faster to call than
     # Tilt's normal rendering.
     def compiled_method(locals_keys, scope_class=nil)
-      key = [scope_class, locals_keys].freeze
+      if @fixed_locals
+        if @scope_class
+          return @compiled_method
+        else
+          key = scope_class
+        end
+      elsif @scope_class
+        key = locals_keys.dup.freeze
+      else
+        key = [scope_class, locals_keys].freeze
+      end
+
       LOCK.synchronize do
         if meth = @compiled_method[key]
           return meth
@@ -181,7 +236,7 @@ module Tilt
     end
 
     CLASS_METHOD = Kernel.instance_method(:class)
-    USE_BIND_CALL = RUBY_VERSION >= '2.7'
+    USE_BIND_CALL = RUBY_VERSION >= '3'
 
     # Execute the compiled template and return the result string. Template
     # evaluation is guaranteed to be performed in the scope object with the
@@ -190,26 +245,25 @@ module Tilt
     # This method is only used by source generating templates. Subclasses that
     # override render() may not support all features.
     def evaluate(scope, locals, &block)
-      locals_keys = locals.keys
-      locals_keys.sort!{|x, y| x.to_s <=> y.to_s}
-
-      case scope
-      when Object
-        scope_class = Module === scope ? scope : scope.class
+      if @fixed_locals
+        locals_keys = EMPTY_ARRAY
       else
-        # :nocov:
-        scope_class = USE_BIND_CALL ? CLASS_METHOD.bind_call(scope) : CLASS_METHOD.bind(scope).call
-        # :nocov:
+        locals_keys = locals.keys
+        locals_keys.sort!{|x, y| x.to_s <=> y.to_s}
       end
-      method = compiled_method(locals_keys, scope_class)
 
-      if USE_BIND_CALL
-        method.bind_call(scope, locals, &block)
-      # :nocov:
-      else
-        method.bind(scope).call(locals, &block)
-      # :nocov:
+      unless scope_class = @scope_class
+        scope_class = case scope
+        when Object
+          Module === scope ? scope : scope.class
+        else
+          # :nocov:
+          USE_BIND_CALL ? CLASS_METHOD.bind_call(scope) : CLASS_METHOD.bind(scope).call
+          # :nocov:
+        end
       end
+
+      evaluate_method(compiled_method(locals_keys, scope_class), scope, locals, &block)
     end
 
     # Generates all template source by combining the preamble, template, and
@@ -303,7 +357,12 @@ module Tilt
     end
 
     def set_compiled_method_cache
-      @compiled_method = {}
+      @compiled_method = if @fixed_locals && @scope_class
+        # No hash needed, only a single compiled method per template.
+        compile_template_method(EMPTY_ARRAY, @scope_class)
+      else
+        {}
+      end
     end
 
     def local_extraction(local_keys)
@@ -327,9 +386,39 @@ module Tilt
       assignments.join("\n")
     end
 
+    if USE_BIND_CALL
+      def evaluate_method(method, scope, locals, &block)
+        if @fixed_locals
+          method.bind_call(scope, **locals, &block)
+        else
+          method.bind_call(scope, locals, &block)
+        end
+      end
+    # :nocov:
+    else
+      def evaluate_method(method, scope, locals, &block)
+        if @fixed_locals
+          if locals.empty?
+            # Empty keyword splat on Ruby 2.0-2.6 passes empty hash
+            method.bind(scope).call(&block)
+          else
+            method.bind(scope).call(**locals, &block)
+          end
+        else
+          method.bind(scope).call(locals, &block)
+        end
+      end
+    end
+    # :nocov:
+
     def compile_template_method(local_keys, scope_class=nil)
       source, offset = precompiled(local_keys)
-      local_code = local_extraction(local_keys)
+      if @fixed_locals
+        method_args = @fixed_locals
+      else
+        method_args = "(locals)"
+        local_code = local_extraction(local_keys)
+      end
 
       method_name = "__tilt_#{Thread.current.object_id.abs}"
       method_source = String.new
@@ -340,7 +429,7 @@ module Tilt
       end
 
       # Don't indent method source, to avoid indentation warnings when using compiled paths
-      method_source << "::Tilt::TOPOBJECT.class_eval do\ndef #{method_name}(locals)\n#{local_code}\n"
+      method_source << "::Tilt::TOPOBJECT.class_eval do\ndef #{method_name}#{method_args}\n#{local_code}\n"
 
       offset += method_source.count("\n")
       method_source << source
@@ -397,6 +486,40 @@ module Tilt
       method
     end
 
+    # Set the fixed locals for the template, which may be nil if no fixed locals can
+    # be determined.
+    def set_fixed_locals
+      fixed_locals = @options.delete(:fixed_locals)
+      extract_fixed_locals = @options.delete(:extract_fixed_locals)
+      default_fixed_locals = @options.delete(:default_fixed_locals)
+
+      if fixed_locals.nil?
+        if extract_fixed_locals.nil?
+          extract_fixed_locals = Tilt.extract_fixed_locals
+        end
+
+        if extract_fixed_locals
+          fixed_locals = extract_fixed_locals()
+        end
+
+        if fixed_locals.nil?
+          fixed_locals = default_fixed_locals
+        end
+      end
+
+      @fixed_locals = fixed_locals
+    end
+
+    # Extract fixed locals from the template code string. Should return nil
+    # if there are no fixed locals specified, or a method argument string
+    # surrounded by parentheses if there are fixed locals.  The method
+    # argument string will be used when defining the template method if given.
+    def extract_fixed_locals
+      if @data.is_a?(String) && (match = /\#\s*locals:\s*(\(.*\))/.match(@data))
+        match[1]
+      end
+    end
+
     def extract_encoding(script, &block)
       extract_magic_comment(script, &block) || script.encoding
     end
@@ -475,5 +598,9 @@ module Tilt
     # Do nothing, since compiled method cache is not used.
     def set_compiled_method_cache
     end
+
+    # Do nothing, since fixed locals are not used.
+    def set_fixed_locals
+    end
   end
 end

data/bundle/ruby/3.1.0/gems/{tilt-2.5.0 → tilt-2.6.0}/lib/tilt.rb

@@ -5,12 +5,16 @@ require_relative 'tilt/template'
 # Namespace for Tilt. This module is not intended to be included anywhere.
 module Tilt
   # Current version.
-  VERSION = '2.5.0'
+  VERSION = '2.6.0'
+
+  EMPTY_ARRAY = [].freeze
+  private_constant :EMPTY_ARRAY
 
   EMPTY_HASH = {}.freeze
   private_constant :EMPTY_HASH
 
   @default_mapping = Mapping.new
+  @extract_fixed_locals = false
 
   # Replace the default mapping with a finalized version of the default
   # mapping. This can be done to improve performance after the template
@@ -86,6 +90,10 @@ module Tilt
     # @return [Tilt::Mapping] the main mapping object
     attr_reader :default_mapping
 
+    # Whether to extract fixed locals from templates by scanning the
+    # template content.
+    attr_accessor :extract_fixed_locals
+
     # Alias register as prefer for Tilt 1.x compatibility.
     alias prefer register
   end

data/bundle/ruby/3.1.0/gems/{unicode-display_width-2.6.0 → unicode-display_width-3.1.4}/CHANGELOG.md

@@ -1,5 +1,78 @@
 # CHANGELOG
 
+## 3.1.4
+
+- Fix that skin tone modifiers were ignored when used in a non-ZWJ sequence
+  context (= single emoji char + modifier) #29
+- Add more docs and specs about modifier handling
+
+## 3.1.3
+
+Better handling of non-UTF-8 strings, patch by @Earlopain:
+
+- Data with *BINARY* encoding is interpreted as UTF-8, if possible
+- Use `invalid: :replace` and `undef: :replace` options when converting to UTF-8
+
+## 3.1.2
+
+- Performance improvements
+
+## 3.1.1
+
+- Performance improvements
+
+## 3.1.0
+
+**Improve Emoji support:**
+
+- Emoji modes: Differentiate between well-formed Emoji (`:possible`) and any
+  ZWJ/modifier sequence (`:all`). The latter is more common and more efficient
+  to implement.
+- Unify `:rgi_{fqe,mqe,uqe}` options to just `:rgi` to keep things simpler (corresponds to
+  the former `:rgi_uqe` option). Most terminals that want to support the RGI set
+  will probably want to catch Emoji sequences with missing VS16s.
+- Add new `:all_no_vs16` and `:rgi_at` modes to be able to support some terminals
+  that needs these quirks
+- Add alias `emoji: :auto` for `emoji: true` and `emoji: :none` for `emoji: false`
+- `:auto` mode: Only consider terminal cells when recommending Emoji support level
+  (Emoji themselves might display differently)
+- `:auto` mode: Set default Emoji mode for unknown/unsupported terminals to `:none`
+- Rename `:basic` mode to `:vs16`
+
+## 3.0.1
+
+
+- Add WezTerm and foot as good Emoji terminals
+
+## 3.0.0
+
+**Rework Emoji support:**
+
+- Emoji widths are now enabled by default
+- Only reduce Emoji width to 2 when RGI Emoji detected (configurable)
+- VS16 turns Emoji characters of width 1 into full-width
+- Please note that Emoji parsing has a notable impact on performance.
+  You can use the `emoji: false` option to disable Emoji adjustments
+- Tries to detect terminal's Emoji support level automatically (from ENV vars)
+
+**Index fixes and updates:**
+
+- Private-use characters are considered ambiguous (were given width 1 before)
+- Fix that a few zero-width ignorable codepoints from recent Unicode were missing
+- Consider the following separators to be zero-width:
+  - U+2028 - LINE SEPARATOR - Zl
+  - U+2029 - PARAGRAPH SEPARATOR - Zp
+
+**Other:**
+
+- Add keyword arguments to `Unicode::DisplayWidth.of`. If you are using a hash
+  with overwrite values as third parameter, be sure to put it in curly braces.
+- Using third parameter or explicit hash as fourth parameter is deprecated,
+  please migrate to the keyword arguments API
+- Gem raises `ArgumentError` for ambiguous values other than 1 or 2
+- Performance optimizations
+- Require Ruby 2.5
+
 ## 2.6.0
 
 - Unicode 16
@@ -40,8 +113,26 @@ More performance improvements:
 
 ## 2.0.0
 
-- Release 2.0.0
-- Supports Ruby 3.0
+Add Support for Ruby 3.0
+
+### Breaking Changes
+
+Some features of this library were marked deprecated for a long time and have been removed with Version 2.0:
+
+- Aliases of display\_width (…\_size, …\_length) have been removed
+- Auto-loading of string core extension has been removed:
+
+If you are relying on the `String#display_width` string extension to be automatically loaded (old behavior), please load it explicitly now:
+
+```ruby
+require "unicode/display_width/string_ext"
+```
+
+You could also change your `Gemfile` line to achieve this:
+
+```ruby
+gem "unicode-display_width", require: "unicode/display_width/string_ext"
+```
 
 ## 2.0.0.pre2
 

data/bundle/ruby/3.1.0/gems/unicode-display_width-3.1.4/README.md

@@ -0,0 +1,194 @@
+# Unicode::DisplayWidth [![[version]](https://badge.fury.io/rb/unicode-display_width.svg)](https://badge.fury.io/rb/unicode-display_width) [<img src="https://github.com/janlelis/unicode-display_width/workflows/Test/badge.svg" />](https://github.com/janlelis/unicode-display_width/actions?query=workflow%3ATest)
+
+Determines the monospace display width of a string in Ruby, which is useful for all kinds of terminal-based applications. The implementation is based on [EastAsianWidth.txt](https://www.unicode.org/Public/UNIDATA/EastAsianWidth.txt), the [Emoji specfication](https://www.unicode.org/reports/tr51/) and other data, 100% in Ruby. It does not rely on the OS vendor ([wcwidth()](https://github.com/janlelis/wcswidth-ruby)) to provide an up-to-date method for measuring string width in terminals.
+
+Unicode version: **16.0.0** (September 2024)
+
+## Gem Version 3 — Improved Emoji Support
+
+**Emoji support is now enabled by default.** See below for description and configuration possibilities.
+
+**Unicode::DisplayWidth.of now takes keyword arguments:** { ambiguous:, emoji:, overwrite: }
+
+See [CHANGELOG](/CHANGELOG.md) for details.
+
+## Gem Version 2.4.2 — Performance Updates
+
+**If you use this gem, you should really upgrade to 2.4.2 or newer. It's often 100x faster, sometimes even 1000x and more!**
+
+This is possible because the gem now detects if you use very basic (and common) characters, like ASCII characters. Furthermore, the character width lookup code has been optimized, so even when the string involves full-width or ambiguous characters, the gem is much faster now.
+
+## Introduction to Character Widths
+
+Guessing the correct space a character will consume on terminals is not easy. There is no single standard. Most implementations combine data from [East Asian Width](https://www.unicode.org/reports/tr11/), some [General Categories](https://en.wikipedia.org/wiki/Unicode_character_property#General_Category), and hand-picked adjustments.
+
+### How this Library Handles Widths
+
+Further at the top means higher precedence. Please expect changes to this algorithm with every MINOR version update (the X in 1.X.0)!
+
+Width  | Characters                   | Comment
+-------|------------------------------|--------------------------------------------------
+?      | (user defined)               | Overwrites any other values
+?      | Emoji                        | See "How this Library Handles Emoji Width" below
+-1     | `"\b"`                       | Backspace (total width never below 0)
+0      | `"\0"`, `"\x05"`, `"\a"`, `"\n"`, `"\v"`, `"\f"`, `"\r"`, `"\x0E"`, `"\x0F"` | [C0 control codes](https://en.wikipedia.org/wiki/C0_and_C1_control_codes#C0_.28ASCII_and_derivatives.29) which do not change horizontal width
+1      | `"\u{00AD}"`                 | SOFT HYPHEN
+2      | `"\u{2E3A}"`                 | TWO-EM DASH
+3      | `"\u{2E3B}"`                 | THREE-EM DASH
+0      | General Categories: Mn, Me, Zl, Zp, Cf (non-arabic)| Excludes ARABIC format characters
+0      | Derived Property: Default_Ignorable_Code_Point     | Ignorable ranges
+0      | `"\u{1160}".."\u{11FF}"`, `"\u{D7B0}".."\u{D7FF}"` | HANGUL JUNGSEONG
+2      | East Asian Width: F, W       | Full-width characters
+2      | `"\u{3400}".."\u{4DBF}"`, `"\u{4E00}".."\u{9FFF}"`, `"\u{F900}".."\u{FAFF}"`, `"\u{20000}".."\u{2FFFD}"`, `"\u{30000}".."\u{3FFFD}"` | Full-width ranges
+1 or 2 | East Asian Width: A          | Ambiguous characters, user defined, default: 1
+1      | All other codepoints         | -
+
+## Install
+
+Install the gem with:
+
+    $ gem install unicode-display_width
+
+Or add to your Gemfile:
+
+    gem 'unicode-display_width'
+
+## Usage
+
+```ruby
+require 'unicode/display_width'
+
+Unicode::DisplayWidth.of("⚀") # => 1
+Unicode::DisplayWidth.of("一") # => 2
+```
+
+### Ambiguous Characters
+
+The second parameter defines the value returned by characters defined as ambiguous:
+
+```ruby
+Unicode::DisplayWidth.of("·", 1) # => 1
+Unicode::DisplayWidth.of("·", 2) # => 2
+```
+
+### Encoding Notes
+
+- Data with *BINARY* encoding is interpreted as UTF-8, if possible
+- Non-UTF-8 strings are converted to UTF-8 before measuring, using the [`{invalid: :replace, undef: :replace}`) options](https://ruby-doc.org/3.3.5/encodings_rdoc.html#label-Encoding+Options)
+
+### Custom Overwrites
+
+You can overwrite how to handle specific code points by passing a hash (or even a proc) as `overwrite:` parameter:
+
+```ruby
+Unicode::DisplayWidth.of("a\tb", 1, overwrite: { "\t".ord => 10 })) # => TAB counted as 10, result is 12
+```
+
+Please note that using overwrites disables some perfomance optimizations of this gem.
+
+### Emoji
+
+If your terminal supports it, the gem detects Emoji and Emoji sequences and adjusts the width of the measured string. This can be disabled by passing `emoji: false` as an argument:
+
+```ruby
+Unicode::DisplayWidth.of "🤾🏽‍♀️", emoji: :all # => 2
+Unicode::DisplayWidth.of "🤾🏽‍♀️", emoji: false # => 5
+```
+
+#### How this Library Handles Emoji Width
+
+There are many Emoji which get constructed by combining other Emoji in a sequence. This makes measuring the width complicated, since terminals might either display the combined Emoji or the separate parts of the Emoji individually.
+
+Another aspect where terminals disagree is whether Emoji characters which have a text presentation by default (width 1) should be turned into full-width (width 2) when combined with Variation Selector 16 (*U+FEOF*).
+
+Finally, it varies if Skin Tone Modifiers can be applied to all characters or just to those with the "Emoji Base" property.
+
+Emoji Type  | Width / Comment
+------------|----------------
+Basic/Single Emoji character without Variation Selector   | No special handling
+Basic/Single Emoji character with VS15 (Text)             | No special handling
+Basic/Single Emoji character with VS16 (Emoji)            | 2 or East Asian Width (see table below)
+Single Emoji character with Skin Tone Modifier            | 2
+Skin Tone Modifier used in isolation or with invalid base | 2 if Emoji mode is configured to `:rgi` / `:rgi_at`
+Emoji Sequence                                            | 2 if Emoji belongs to configured Emoji set (see table below)
+
+#### Emoji Modes
+
+The `emoji:` option can be used to configure which type of Emoji should be considered to have a width of 2 and if VS16-Emoji should be widened. Other sequences are treated as non-combined Emoji, so the widths of all partial Emoji add up (e.g. width of one basic Emoji + one skin tone modifier + another basic Emoji). The following Emoji settings can be used:
+
+`emoji:` Option | VS16-Emoji Width | Emoji Sequences Width / Comment | Example Terminals
+----------------|------------------|---------------------------------|------------------
+`true` or `:auto`  | - | Automatically use recommended Emoji setting for your terminal | -
+`:all`     | 2                | 2 for all ZWJ/modifier/keycap sequences, even if they are not well-formed Emoji sequences | iTerm, foot
+`:all_no_vs16` | EAW (1 or 2) | 2 for all ZWJ/modifier/keycap sequences, even if they are not well-formed Emoji sequences | WezTerm
+`:possible`| 2                | 2 for all possible/well-formed Emoji sequences | ?
+`:rgi`     | 2                | 2 for all [RGI Emoji](https://www.unicode.org/reports/tr51/#def_rgi_set) sequences | ?
+`:rgi_at`  | EAW (1 or 2)     | 1 or 2: Like `:rgi`, but Emoji sequences starting with a default-text Emoji have EAW | Apple Terminal
+`:vs16`    | 2                | 2 * number of partial Emoji (sequences never considered to represent a combined Emoji) | kitty?
+`false` or  `:none` | EAW (1 or 2) | No Emoji adjustments | gnome-terminal, many older terminals
+
+- *EAW:* East Asian Width
+- *RGI Emoji:* Emoji Recommended for General Interchange
+- *ZWJ:* Zero-width Joiner: Codepoint `U+200D`,used in many Emoji sequences
+
+#### Emoji Support in Terminals
+
+Unfortunately, the level of Emoji support varies a lot between terminals. While some of them are able to display (almost) all Emoji sequences correctly, others fall back to displaying sequences of basic Emoji. When `emoji: true` or `emoji: :auto` is used, the gem will attempt to set the best fitting Emoji setting for you (e.g. `:rgi_at` on "Apple_Terminal" or `false` on Gnome's terminal widget).
+
+Please note that Emoji display and number of terminal columns used might differs a lot. For example, it might be the case that a terminal does not understand which Emoji to display, but still manages to calculate the proper amount of terminal cells. The automatic Emoji support level per terminal only considers the latter (cursor position), not the actual Emoji image(s) displayed. Please [open an issue](https://github.com/janlelis/unicode-display_width/issues/new) if you notice your terminal application could use a better default value. Also see the [ucs-detect project](https://ucs-detect.readthedocs.io/results.html), which is a great resource that compares various terminal's Unicode/Emoji capabilities. You can visually check how your terminals renders different kind of Emoji types with the [terminal-emoji-width.rb script](https://github.com/janlelis/unicode-display_width/blob/main/misc/terminal-emoji-width.rb).
+
+**To terminal implementors reading this:** Although the practice of giving all Emoji/ZWJ sequences a width of 2 (`:all` mode described above) has some advantages, it does not lead to a particularly good developer experience. Since there is always the possibility of well-formed Emoji that are currently not supported (non-RGI / future Unicode) appearing, those sequences will take more cells. Instead of overflowing, cutting off sequences or displaying placeholder-Emoji, could it be worthwile to implement the `:rgi` option (only known Emoji get width 2) and give those unknown Emoji the space they need? This would support the idea that the meaning of an unknown Emoji sequence can still be conveyed (without messing up the terminal at the same time). Just a thought…
+
+### Usage with String Extension
+
+```ruby
+require 'unicode/display_width/string_ext'
+
+"⚀".display_width # => 1
+'一'.display_width # => 2
+```
+
+### Usage with Config Object
+
+You can use a config object that allows you to save your configuration for later-reuse. This requires an extra line of code, but has the advantage that you'll need to define your string-width options only once:
+
+```ruby
+require 'unicode/display_width'
+
+display_width = Unicode::DisplayWidth.new(
+  # ambiguous: 1,
+  overwrite: { "A".ord => 100 },
+  emoji: :all,
+)
+
+display_width.of "⚀" # => 1
+display_width.of "🤠‍🤢" # => 2
+display_width.of "A" # => 100
+```
+
+### Usage from the Command-Line
+
+Use this one-liner to print out display widths for strings from the command-line:
+
+```
+$ gem install unicode-display_width
+$ ruby -r unicode/display_width -e 'puts Unicode::DisplayWidth.of $*[0]' -- "一"
+```
+Replace "一" with the actual string to measure
+
+## Other Implementations & Discussion
+
+- Python: https://github.com/jquast/wcwidth
+- JavaScript: https://github.com/mycoboco/wcwidth.js
+- C: https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+- C for Julia: https://github.com/JuliaLang/utf8proc/issues/2
+- Golang: https://github.com/rivo/uniseg
+
+See [unicode-x](https://github.com/janlelis/unicode-x) for more Unicode related micro libraries.
+
+## Copyright & Info
+
+- Copyright (c) 2011, 2015-2024 Jan Lelis, https://janlelis.com, released under the MIT
+license
+- Early versions based on runpaint's unicode-data interface: Copyright (c) 2009 Run Paint Run Run
+- Unicode data: https://www.unicode.org/copyright.html#Exhibit1

data/bundle/ruby/3.1.0/gems/{unicode-display_width-2.6.0 → unicode-display_width-3.1.4}/lib/unicode/display_width/constants.rb

@@ -2,7 +2,7 @@
 
 module Unicode
   class DisplayWidth
-    VERSION = "2.6.0"
+    VERSION = "3.1.4"
     UNICODE_VERSION = "16.0.0"
     DATA_DIRECTORY = File.expand_path(File.dirname(__FILE__) + "/../../../data/")
     INDEX_FILENAME = DATA_DIRECTORY + "/display_width.marshal.gz"

data/bundle/ruby/3.1.0/gems/unicode-display_width-3.1.4/lib/unicode/display_width/emoji_support.rb

@@ -0,0 +1,52 @@
+# require "rbconfig"
+# RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ # windows
+
+module Unicode
+  class DisplayWidth
+    module EmojiSupport
+      # Tries to find out which terminal emulator is used to
+      # set emoji: config to best suiting value
+      #
+      # Please also see section in README.md and
+      # misc/terminal-emoji-width.rb
+      #
+      # Please note: Many terminals do not set any ENV vars,
+      # maybe CSI queries can help?
+      def self.recommended
+        if ENV["CI"]
+          return :rqi
+        end
+
+        case ENV["TERM_PROGRAM"]
+        when "iTerm.app"
+          return :all
+        when "Apple_Terminal"
+          return :rgi_at
+        when "WezTerm"
+          return :all_no_vs16
+        end
+
+        case ENV["TERM"]
+        when "contour","foot"
+          # konsole: all, how to detect?
+          return :all
+        when /kitty/
+          return :vs16
+        end
+
+        if ENV["WT_SESSION"] # Windows Terminal
+          return :vs16
+        end
+
+        # As of last time checked: gnome-terminal, vscode, alacritty
+        :none
+      end
+
+      # Maybe: Implement something like https://github.com/jquast/ucs-detect
+      #        which uses the terminal cursor to check for best support level
+      #        at runtime
+      # def self.detect!
+      # end
+    end
+  end
+end

data/bundle/ruby/3.1.0/gems/unicode-display_width-3.1.4/lib/unicode/display_width/reline_ext.rb

@@ -0,0 +1,14 @@
+# Experimental
+# Patches Reline's get_mbchar_width to use Unicode::DisplayWidth
+
+require "reline"
+require "reline/unicode"
+
+require_relative "../display_width"
+
+class Reline::Unicode
+  def self.get_mbchar_width(mbchar)
+    Unicode::DisplayWidth.of(mbchar, Reline.ambiguous_width)
+  end
+end
+