strings-truncation 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3837ca8b06eb6173b46ec33382369c9cb6f1f1a78515cf318658dfdf2f3dbce1
+  data.tar.gz: 49be33a7cc3f22afbf77c2f168704f46234b5312ada53a4aefcdb4d315143e14
+SHA512:
+  metadata.gz: 6308a3c890c3fd4f603399eb27cbe7faba13dbbc318497a3974d2db31ea3ed2827056162fb96eec522fc4dcbf2cd7b3e1eb84293500a041a8bcdbf349a554a9e
+  data.tar.gz: abf85e81c7fff5e9d0036c9e039a5880de95fcf9fdceef2d24abbeb908be8d6e07fdd09010d2e1a37e95e2b28395ccea7791d6c456c1772302e0fd62d5ebd9e0

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Change log
+
+## [v0.1.0] - 2020-02-23
+
+* Initial implementation and release
+
+[v0.1.0]: https://github.com/piotrmurach/strings-truncation/compare/efb1d50...v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Piotr Murach
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,247 @@
+<div align="center">
+  <img width="225" src="https://github.com/piotrmurach/strings/blob/master/assets/strings_logo.png" alt="strings logo" />
+</div>
+
+# Strings::Truncation
+
+[![Gem Version](https://badge.fury.io/rb/strings-truncation.svg)][gem]
+[![Actions CI](https://github.com/piotrmurach/strings-truncation/workflows/CI/badge.svg?branch=master)][gh_actions_ci]
+[![Build status](https://ci.appveyor.com/api/projects/status/s8y94c4tvi8mgrh2?svg=true)][appveyor]
+[![Maintainability](https://api.codeclimate.com/v1/badges/f7ecb5bf87696e522ccb/maintainability)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/github/piotrmurach/strings-truncation/badge.svg?branch=master)][coverage]
+[![Inline docs](http://inch-ci.org/github/piotrmurach/strings-truncation.svg?branch=master)][inchpages]
+
+[gem]: http://badge.fury.io/rb/strings-truncation
+[gh_actions_ci]: https://github.com/piotrmurach/strings-truncation/actions?query=workflow%3ACI
+[appveyor]: https://ci.appveyor.com/project/piotrmurach/strings-truncation
+[codeclimate]: https://codeclimate.com/github/piotrmurach/strings-truncation/maintainability
+[coverage]: https://coveralls.io/github/piotrmurach/strings-truncation?branch=master
+[inchpages]: http://inch-ci.org/github/piotrmurach/strings-truncation
+
+> Truncate strings with fullwidth characters and ANSI codes.
+
+## Features
+
+* No monkey-patching String class
+* Omit text from the start, middle, end or both ends
+* Account for fullwidth characters in encodings such as UTF-8, EUC-JP
+* Shorten text without whitespaces between words (Chinese, Japanese, Korean etc)
+* Preserve ANSI escape codes
+
+## Contents
+
+* [1. Usage](#1-usage)
+* [2. API](#2-api)
+  * [2.1 configure](#21-configure)
+  * [2.2 truncate](#22-truncate)
+* [3. Extending String class](#3-extending-string-class)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "strings-truncation"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install strings-truncation
+
+## 1. Usage
+
+Use `truncate` to shorten string to 30 characters by default:
+
+```ruby
+strings = Strings::Truncation.new
+strings.truncate("I try all things, I achieve what I can.")
+# => "I try all things, I achieve w…"
+```
+
+As a convenience, you can call `truncate` method directly on a class:
+
+```ruby
+Strings::Truncation.truncate("I try all things, I achieve what I can.")
+# => "I try all things, I achieve w…"
+```
+
+To change the default truncation length, pass an integer as a second argument:
+
+```ruby
+strings.truncate("I try all things, I achieve what I can.", 15)
+# => "I try all thin…"
+```
+
+Or if you want to be more explicit and flexible use `:length` keyword:
+
+```ruby
+strings.truncate("I try all things, I achieve what I can.", length: 15)
+# => "I try all thin…"
+```
+
+You can specify custom omission string in place of default `…`:
+
+```ruby
+strings.truncate("I try all things, I achieve what I can.", omission: "...")
+# => "I try all things, I achieve..."
+```
+
+If you wish to truncate preserving words use a string or regexp as a separator:
+
+```ruby
+strings.truncate("I try all things, I achieve what I can.", separator: /\s/)
+# => "I try all things, I achieve…"
+```
+
+You can omit text from the `start`, `middle`, `end` or both `ends`:
+
+```ruby
+strings.truncate("I try all things, I achieve what I can", position: :middle)
+# => "I try all thing…ve what I can."
+```
+
+You can truncate text with fullwidth characters (Chinese, Japanese, Korean etc):
+
+```ruby
+strings.truncate("おはようございます", 8)
+# => "おはよ…"
+```
+
+As well as truncate text that contains ANSI escape codes:
+
+```ruby
+strings.truncate("\e[34mI try all things, I achieve what I can\e[0m", 18)
+# => "\e[34mI try all things,\e[0m…"
+```
+
+## 2. API
+
+### 2.1 configure
+
+To change default configuration settings at initialization use keyword arguments.
+
+For example, to omit text from the start and separate on a whitespace character do:
+
+```ruby
+strings = Strings::Truncation.new(position: :start, separator: /\s/)
+```
+
+After initialization, you can use `configure` to change settings inside a block:
+
+```ruby
+strings.configure do |config|
+  config.length 25
+  config.omission "[...]"
+  config.position :start
+  config.separator /\s/
+end
+```
+
+Alternatively, you can also use `configure` with keyword arguments:
+
+```ruby
+strings.configure(position: :start, separator: /\s/)
+```
+
+### 2.2 truncate
+
+By default a string is truncated from the end to maximum length of `30` display columns.
+
+```ruby
+strings.truncate("I try all things, I achieve what I can.")
+# => "I try all things, I achieve w…"
+```
+
+To change the default truncation length, pass an integer as a second argument:
+
+```ruby
+strings.truncate("I try all things, I achieve what I can.", 15)
+# => "I try all thin…"
+```
+
+Or use `:length` keyword to be more explicit:
+
+```ruby
+strings.truncate("I try all things, I achieve what I can.", length: 15)
+# => "I try all thin…"
+```
+
+The default `…` omission character can be replaced using `:omission`:
+
+```ruby
+strings.truncate("I try all things, I achieve what I can.", omission: "...")
+# => "I try all things, I achieve..."
+```
+
+You can omit text from the `start`, `middle`, `end` or both `ends` by specifying `:position`:
+
+```ruby
+strings.truncate("I try all things, I achieve what I can", position: :start)
+# => "…things, I achieve what I can."
+
+strings.truncate("I try all things, I achieve what I can", position: :middle)
+# => "I try all thing…ve what I can."
+
+strings.truncate("I try all things, I achieve what I can", position: :ends)
+# => "… all things, I achieve what …"
+```
+
+To truncate based on custom character(s) use `:separator` that accepts a string or regular expression:
+
+```ruby
+strings.truncate("I try all things, I achieve what I can.", separator: /\s/)
+=> "I try all things, I achieve…"
+```
+
+You can combine all settings to achieve desired result:
+
+```ruby
+strings.truncate("I try all things, I achieve what I can.", length: 20,
+                 omission: "...", position: :ends, separator: /\s/)
+# => "...I achieve what..."
+```
+
+## 3. Extending String class
+
+Though it is highly discouraged to pollute core Ruby classes, you can add the required methods to String class by using refinements.
+
+To include all the **Strings::Truncation** methods, you can load extensions like so:
+
+```ruby
+require "strings/truncation/extensions"
+
+using Strings::Truncation::Extensions
+```
+
+And then call `truncate` directly on any string:
+
+```ruby
+"I try all things, I achieve what I can.".truncate(20, separator: " ")
+# => "I try all things, I…"
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/piotrmurach/strings-truncation. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Strings::Truncation project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/piotrmurach/strings-truncation/blob/master/CODE_OF_CONDUCT.md).
+
+## Copyright
+
+Copyright (c) 2019 Piotr Murach. See LICENSE for further details.

data/lib/strings-truncation.rb

@@ -0,0 +1 @@
+require "strings/truncation"

data/lib/strings/truncation.rb

@@ -0,0 +1,368 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "strscan"
+require "strings-ansi"
+require "unicode/display_width"
+
+require_relative "truncation/configuration"
+require_relative "truncation/version"
+
+module Strings
+  class Truncation
+    class Error < StandardError; end
+
+    ANSI_REGEXP  = /#{Strings::ANSI::ANSI_MATCHER}/.freeze
+    RESET_REGEXP = /#{Regexp.escape(Strings::ANSI::RESET)}/.freeze
+    END_REGEXP   = /\A(#{Strings::ANSI::ANSI_MATCHER})*\z/.freeze
+
+    # Global instance
+    #
+    # @api private
+    def self.__instance__
+      @__instance__ ||= Truncation.new
+    end
+
+    class << self
+      extend Forwardable
+
+      delegate %i[truncate] => :__instance__
+    end
+
+    # Create a Strings::Truncation instance
+    #
+    # @example
+    #   strings = Strings::Truncation.new(separator: /[,- ]/)
+    #
+    # @param [Integer] length
+    #   the maximum length to truncate to
+    # @param [String] omission
+    #   the string to denote omitted content
+    # @param [String|Integer] position
+    #   the position of the omission within the string
+    # @param [String|Regexp] separator
+    #   the separator to break words on
+    #
+    # @api public
+    def initialize(**options)
+      configuration.update(**options)
+    end
+
+    # Access configuration
+    #
+    # @api public
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Configure truncation
+    #
+    # @example
+    #   strings = Strings::Truncation.new
+    #   strings.configure do |config|
+    #     config.length 20
+    #     config.omission "[...]"
+    #     config.position :middle
+    #     config.separator /[,- ]/
+    #   end
+    #
+    # @example
+    #   strings = Strings::Truncation.new
+    #   strings.configure length: 20, omission: "[...]"
+    #
+    # @yield [Configuration]
+    #
+    # @api public
+    def configure(**options)
+      if block_given?
+        yield configuration
+      else
+        configuration.update(**options)
+      end
+    end
+
+    # Truncate a text at a given length (defualts to 30)
+    #
+    # @param [String] text
+    #   the text to be truncated
+    #
+    # @param [Integer] truncate_at
+    #   the width at which to truncate the text
+    #
+    # @param [String|Regexp] separator
+    #   the character for splitting words
+    #
+    # @param [String] omission
+    #   the string to use for displaying omitted content
+    #
+    # @param [String|Integer] position
+    #   the position in text from which to omit content
+    #
+    # @example
+    #   truncate("It is not down on any map; true places never are.")
+    #   # => "It is not down on any map; tr…""
+    #
+    #   truncate("It is not down on any map; true places never are.", 15)
+    #   # => "It is not down…""
+    #
+    #   truncate("It is not down on any map; true places never are.",
+    #            separator: " ")
+    #   # => "It is not down on any map;…"
+    #
+    #   truncate("It is not down on any map; true places never are.", 40,
+    #            omission: "[...]")
+    #   # => "It is not down on any map; true pla[...]"
+    #
+    # @api public
+    def truncate(text, truncate_at = configuration.length, length: nil,
+                 position: configuration.position,
+                 separator: configuration.separator,
+                 omission: configuration.omission)
+      truncate_at = length if length
+
+      return text if truncate_at.nil? || text.bytesize <= truncate_at.to_i
+
+      return "" if truncate_at.zero?
+
+      separator = Regexp.new(separator) if separator
+
+      case position
+      when :start
+        truncate_start(text, truncate_at, omission, separator)
+      when :middle
+        truncate_middle(text, truncate_at, omission, separator)
+      when :ends
+        truncate_ends(text, truncate_at, omission, separator)
+      when :end
+        truncate_from(0, text, truncate_at, omission, separator)
+      when Numeric
+        truncate_from(position, text, truncate_at, omission, separator)
+      else
+        raise Error, "unsupported position: #{position.inspect}"
+      end
+    end
+
+    private
+
+    # Truncate text at the start
+    #
+    # @param [String] text
+    #   the text to truncate
+    # @param [Integer] length
+    #   the maximum length to truncate at
+    # @param [String] omission
+    #   the string to denote omitted content
+    # @param [String|Regexp] separator
+    #   the pattern or string to separate on
+    #
+    # @return [String]
+    #   the truncated text
+    #
+    # @api private
+    def truncate_start(text, length, omission, separator)
+      text_width = display_width(Strings::ANSI.sanitize(text))
+      omission_width = display_width(omission)
+      return text if text_width == length
+      return omission if omission_width == length
+
+      from = [text_width - length, 0].max
+      from += omission_width if from > 0
+      words, = *slice(text, from, length - omission_width,
+                      omission_width: omission_width,
+                      separator: separator)
+
+      "#{omission if from > 0}#{words}"
+    end
+
+    # Truncate text before the from position and after the length
+    #
+    # @param [Integer] from
+    #   the position to start extracting from
+    # @param [String] text
+    #   the text to truncate
+    # @param [Integer] length
+    #   the maximum length to truncate at
+    # @param [String] omission
+    #   the string to denote omitted content
+    # @param [String|Regexp] separator
+    #   the pattern or string to separate on
+    #
+    # @return [String]
+    #   the truncated text
+    #
+    # @api private
+    def truncate_from(from, text, length, omission, separator)
+      omission_width = display_width(omission)
+      length_without_omission = length - omission_width
+      length_without_omission -= omission_width if from > 0
+      words, stop = *slice(text, from, length_without_omission,
+                           omission_width: omission_width,
+                           separator: separator)
+
+      "#{omission if from > 0}#{words}#{omission if stop}"
+    end
+
+    # Truncate text in the middle
+    #
+    # @param [String] text
+    #   the text to truncate
+    # @param [Integer] length
+    #   the maximum length to truncate at
+    # @param [String] omission
+    #   the string to denote omitted content
+    # @param [String|Regexp] separator
+    #   the pattern or string to separate on
+    #
+    # @return [String]
+    #   the truncated text
+    #
+    # @api private
+    def truncate_middle(text, length, omission, separator)
+      text_width = display_width(Strings::ANSI.sanitize(text))
+      omission_width = display_width(omission)
+      return text if text_width == length
+      return omission if omission_width == length
+
+      half_length = length / 2
+      rem_length = half_length + length % 2
+      half_omission = omission_width / 2
+      rem_omission = half_omission + omission_width % 2
+
+      before_words, = *slice(text, 0, half_length - half_omission,
+                             omission_width: half_omission,
+                             separator: separator)
+
+      after_words, = *slice(text, text_width - rem_length + rem_omission,
+                            rem_length - rem_omission,
+                            omission_width: rem_omission,
+                            separator: separator)
+
+      "#{before_words}#{omission}#{after_words}"
+    end
+
+    # Truncate text at both ends
+    #
+    # @param [String] text
+    #   the text to truncate
+    # @param [Integer] length
+    #   the maximum length to truncate at
+    # @param [String] omission
+    #   the string to denote omitted content
+    # @param [String|Regexp] separator
+    #   the pattern or string to separate on
+    #
+    # @return [String]
+    #   the truncated text
+    #
+    # @api private
+    def truncate_ends(text, length, omission, separator)
+      text_width = display_width(Strings::ANSI.sanitize(text))
+      omission_width = display_width(omission)
+      return text if text_width <= length
+      return omission if length <= 2 * omission_width
+
+      from = (text_width - length) / 2 + omission_width
+      words, stop = *slice(text, from, length - 2 * omission_width,
+                           omission_width: omission_width,
+                           separator: separator)
+      return omission if words.empty?
+
+      "#{omission if from > 0}#{words}#{omission if stop}"
+    end
+
+    # Extract number of characters from a text starting at the from position
+    #
+    # @param [Integer] from
+    #   the position to start from
+    # @param [Integer] length
+    #   the number of characters to extract
+    # @param [Integer] omission_width
+    #   the width of the omission
+    # @param [String|Regexp] separator
+    #   the string or pattern to use for splitting words
+    #
+    # @return [Array<String, Boolean>]
+    #   return a substring and a stop flag
+    #
+    # @api private
+    def slice(text, from, length, omission_width: 0, separator: nil)
+      scanner = StringScanner.new(text)
+      length_with_omission = length + omission_width
+      current_length = 0
+      start_position = 0
+      ansi_reset = false
+      visible_char = false
+      word_break = false
+      stop = false
+      words = []
+      word = []
+      char = nil
+
+      while !(scanner.eos? || stop)
+        if scanner.scan(RESET_REGEXP)
+          unless scanner.eos?
+            words << scanner.matched
+            ansi_reset = false
+          end
+        elsif scanner.scan(ANSI_REGEXP)
+          words << scanner.matched
+          ansi_reset = true
+        else
+          if (char =~ separator && start_position <= from) ||
+             separator && start_position.zero?
+            word_break = start_position != from
+          end
+
+          char = scanner.getch
+          char_width = display_width(char)
+          start_position += char_width
+          next if (start_position - char_width) < from
+
+          current_length += char_width
+
+          if char =~ separator
+            if word_break
+              word_break = false
+              current_length = 0
+              next
+            end
+            visible_char = true
+            words << word.join
+            word.clear
+          end
+
+          if current_length <= length || scanner.check(END_REGEXP) &&
+                                         current_length <= length_with_omission
+            if separator
+              word << char unless word_break
+            else
+              words << char
+              visible_char = true
+            end
+          else
+            stop = true
+          end
+        end
+      end
+
+      visible_char = true if !word.empty? && scanner.eos?
+
+      return ["", stop] unless visible_char
+
+      words << word.join if !word.empty? && scanner.eos?
+
+      words << Strings::ANSI::RESET if ansi_reset
+
+      [words.join, stop]
+    end
+
+    # Visible width of a string
+    #
+    # @return [Integer]
+    #
+    # @api private
+    def display_width(string)
+      Unicode::DisplayWidth.of(string)
+    end
+  end # Truncation
+end # Strings

data/lib/strings/truncation/configuration.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Strings
+  class Truncation
+    # A configuration object used by a Strings::Truncation instance
+    #
+    # @api private
+    class Configuration
+      DEFAULT_LENGTH = 30
+
+      DEFAULT_OMISSION = "…"
+
+      DEFAULT_POSITION = 0
+
+      # Create a configuration
+      #
+      # @api public
+      def initialize(length: DEFAULT_LENGTH, omission: DEFAULT_OMISSION,
+                     position: DEFAULT_POSITION, separator: nil)
+        @length = length
+        @omission = omission
+        @position = position
+        @separator = separator
+      end
+
+      # Update current configuration
+      #
+      # @api public
+      def update(length: nil, omission: nil, position: nil, separator: nil)
+        @length = length if length
+        @omission = omission if omission
+        @position = position if position
+        @separator = separator if separator
+      end
+
+      # The maximum length to truncate to
+      #
+      # @example
+      #   strings = Strings::Truncation.new
+      #
+      #   strings.configure do |config|
+      #     config.length 40
+      #   end
+      #
+      # @param [Integer] number
+      #
+      # @api public
+      def length(number = (not_set = true))
+        if not_set
+          @length
+        else
+          @length = number
+        end
+      end
+
+      # The string to denote omitted content
+      #
+      # @example
+      #   strings = Strings::Truncation.new
+      #
+      #   strings.configure do |config|
+      #     config.omission "..."
+      #   end
+      #
+      # @param [String] string
+      #
+      # @api public
+      def omission(string = (not_set = true))
+        if not_set
+          @omission
+        else
+          @omission = string
+        end
+      end
+
+      # The position of the omission within the string
+      #
+      # @example
+      #   strings = Strings::Truncation.new
+      #
+      #   strings.configure do |config|
+      #     config.position :start
+      #   end
+      #
+      #
+      # @param [Symbol] position
+      #   the position out of :start, :middle or :end
+      #
+      # @api public
+      def position(position = (not_set = true))
+        if not_set
+          @position
+        else
+          @position = position
+        end
+      end
+
+      # The separator to break the characters into words
+      #
+      # @example
+      #   strings = Strings::Truncation.new
+      #
+      #   strings.configure do |config|
+      #     config.separator /[, ]/
+      #   end
+      #
+      # @param [String|Regexp] separator
+      #
+      # @api public
+      def separator(separator = (not_set = true))
+        if not_set
+          @separator
+        else
+          @separator = separator
+        end
+      end
+    end # Configruation
+  end # Truncation
+end # Strings

data/lib/strings/truncation/extensions.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../truncation"
+
+module Strings
+  class Truncation
+    module Extensions
+      refine String do
+        def truncate(*args, **options)
+          Strings::Truncation.truncate(self, *args, **options)
+        end
+      end
+    end # Extensions
+  end # Truncation
+end # Strings

data/lib/strings/truncation/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Strings
+  class Truncation
+    VERSION = "0.1.0"
+  end # Truncation
+end # Strings

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: strings-truncation
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Piotr Murach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: strings-ansi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: unicode-display_width
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Truncate strings with fullwidth characters and ANSI codes. Characters
+  can be omitted from the start, middle, end or both ends.
+email:
+- piotr@piotrmurach.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- CHANGELOG.md
+- LICENSE.txt
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/strings-truncation.rb
+- lib/strings/truncation.rb
+- lib/strings/truncation/configuration.rb
+- lib/strings/truncation/extensions.rb
+- lib/strings/truncation/version.rb
+homepage: https://github.com/piotrmurach/strings-truncation
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  bug_tracker_uri: https://github.com/piotrmurach/strings-truncation/issues
+  changelog_uri: https://github.com/piotrmurach/strings-truncation/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/strings-truncation
+  homepage_uri: https://github.com/piotrmurach/strings-truncation
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Truncate strings with fullwidth characters and ANSI codes.
+test_files: []