strings 0.0.0 → 0.1.0

data/appveyor.yml

@@ -0,0 +1,21 @@
+---
+install:
+  - SET PATH=C:\Ruby%ruby_version%\bin;%PATH%
+  - ruby --version
+  - gem --version
+  - bundle install
+build: off
+test_script:
+  - bundle exec rake ci
+environment:
+  matrix:
+    - ruby_version: "200"
+    - ruby_version: "200-x64"
+    - ruby_version: "21"
+    - ruby_version: "21-x64"
+    - ruby_version: "22"
+    - ruby_version: "22-x64"
+    - ruby_version: "23"
+    - ruby_version: "23-x64"
+    - ruby_version: "24"
+    - ruby_version: "24-x64"

data/benchmarks/speed_profile.rb

@@ -0,0 +1,30 @@
+require 'benchmark/ips'
+require 'strings'
+
+text = "Ignorance is the parent of fear."
+
+Benchmark.ips do |x|
+  x.report('wrap') do
+    Strings::Wrap.wrap(text, 10)
+  end
+
+  x.report('truncate') do
+    Strings::Truncate.truncate(text, 10)
+  end
+
+  x.compare!
+end
+
+# (2017-12-09)
+#
+# Calculating -------------------------------------
+#                 wrap       186 i/100ms
+#             truncate       295 i/100ms
+# -------------------------------------------------
+#                 wrap     1917.2 (±2.2%) i/s -       9672 in   5.047297s
+#             truncate     3020.6 (±3.0%) i/s -      15340 in   5.083516s
+#
+# Comparison:
+#             truncate:     3020.6 i/s
+#                 wrap:     1917.2 i/s - 1.58x slower
+#

data/lib/strings.rb

@@ -1,5 +1,111 @@
-require "strings/version"
+# frozen_string_literal: true
+
+require_relative 'strings/align'
+require_relative 'strings/ansi'
+require_relative 'strings/fold'
+require_relative 'strings/pad'
+require_relative 'strings/truncate'
+require_relative 'strings/wrap'
+require_relative 'strings/version'
 
 module Strings
-  # Your code goes here...
-end
+  # Align text within the width.
+  #
+  # @see Strings::Align#align
+  #
+  # @api public
+  def align(*args)
+    Align.align(*args)
+  end
+  module_function :align
+
+  # Align text left within the width.
+  #
+  # @see Strings::Align#align_left
+  #
+  # @api public
+  def align_left(*args)
+    Align.align_left(*args)
+  end
+  module_function :align_left
+
+  # Align text with the width.
+  #
+  # @see Strings::Align#align
+  #
+  # @api public
+  def align_center(*args)
+    Align.align_center(*args)
+  end
+  module_function :align_center
+
+  # Align text with the width.
+  #
+  # @see Strings::Align#align
+  #
+  # @api public
+  def align_right(*args)
+    Align.align_right(*args)
+  end
+  module_function :align_right
+
+  # Check if string contains ANSI codes
+  #
+  # @see Strings::ANSI#ansi?
+  #
+  # @api public
+  def ansi?(string)
+    ANSI.ansi?(string)
+  end
+  module_function :ansi?
+
+  # Remove any line break characters from the text
+  #
+  # @see Strings::Fold#fold
+  #
+  # @api public
+  def fold(*args)
+    Fold.fold(*args)
+  end
+  module_function :fold
+
+  # Apply padding to multiline text with ANSI codes
+  #
+  # @see Strings::Pad#pad
+  #
+  # @api public
+  def pad(*args)
+    Pad.pad(*args)
+  end
+  module_function :pad
+
+  # Remove ANSI codes from the string
+  #
+  # @see Strings::ANSI#sanitize
+  #
+  # @api public
+  def sanitize(text)
+    ANSI.sanitize(text)
+  end
+  module_function :sanitize
+
+  # Truncate a text at a given length
+  #
+  # @see Strings::Truncate#truncate
+  #
+  # @api public
+  def truncate(text, truncate_at, options = {})
+    Truncate.truncate(text, truncate_at, options)
+  end
+  module_function :truncate
+
+  # Wrap a text into lines at wrap length
+  #
+  # @see Strings::Wrap#wrap
+  #
+  # @api public
+  def wrap(text, wrap_at)
+    Wrap.wrap(text, wrap_at)
+  end
+  module_function :wrap
+end # Strings

data/lib/strings/align.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'unicode/display_width'
+
+require_relative 'ansi'
+
+module Strings
+  # Responsible for text alignment
+  module Align
+    NEWLINE = "\n".freeze
+
+    SPACE = ' '.freeze
+
+    # Aligns text within the width.
+    #
+    # If the text is greater than the width then unmodified
+    # string is returned.
+    #
+    # @param [String] text
+    #   the text to align lines of
+    # @param [Integer] width
+    #   the maximum width to align to
+    #
+    # @example
+    #   text = "the madness of men"
+    #
+    #   Strings::Align.align(22, :left)
+    #   # => "the madness of men      "
+    #
+    #   Strings::Align.align(22, :center)
+    #   # => "   the madness of men   "
+    #
+    #   Strings::Align(22, :right)
+    #   # => "      the madness of men"
+    #
+    #   Strings::Align.align(22, :center, fill: '*)
+    #   # => "***the madness of men***"
+    #
+    # @api public
+    def align(text, width, direction: :left, **options)
+      return text if width.nil?
+      method = to_alignment(direction)
+      send(method, text, width, options)
+    end
+    module_function :align
+
+    # Convert direction to method name
+    #
+    # @api private
+    def to_alignment(direction)
+      case direction.to_sym
+      when :left   then :align_left
+      when :right  then :align_right
+      when :center then :align_center
+      else
+        raise ArgumentError, "Unknown alignment `#{direction}`."
+      end
+    end
+    module_function :to_alignment
+
+    # Aligns text to the left at given length
+    #
+    # @return [String]
+    #
+    # @api public
+    def align_left(text, width, fill: SPACE, separator: NEWLINE)
+      return if width.nil?
+      each_line(text, separator) do |line|
+        width_diff = width - display_width(line)
+        if width_diff > 0
+          line + fill * width_diff
+        else
+          line
+        end
+      end
+    end
+    module_function :align_left
+
+    # Centers text within the width
+    #
+    # @return [String]
+    #
+    # @api public
+    def align_center(text, width, fill: SPACE, separator: NEWLINE)
+      return text if width.nil?
+      each_line(text, separator) do |line|
+        width_diff = width - display_width(line)
+        if width_diff > 0
+          right_count = (width_diff.to_f / 2).ceil
+          left_count  =  width_diff - right_count
+          [fill * left_count, line, fill * right_count].join
+        else
+          text
+        end
+      end
+    end
+    module_function :align_center
+
+    # Aligns text to the right at given length
+    #
+    # @return [String]
+    #
+    # @api public
+    def align_right(text, width, fill: SPACE, separator: NEWLINE)
+      return text if width.nil?
+      each_line(text, separator) do |line|
+        width_diff = width - display_width(line)
+        if width_diff > 0
+          fill * width_diff + line
+        else
+          line
+        end
+      end
+    end
+    module_function :align_right
+
+    # Enumerate text line by line
+    #
+    # @param [String] text
+    #
+    # @return [String]
+    #
+    # @api private
+    def each_line(text, separator)
+      lines = text.split(separator)
+      return yield(text) if text.empty?
+      lines.reduce([]) do |aligned, line|
+        aligned << yield(line)
+      end.join(separator)
+    end
+    module_function :each_line
+
+    # Visible width of a string
+    #
+    # @api private
+    def display_width(string)
+      Unicode::DisplayWidth.of(Strings::ANSI.sanitize(string))
+    end
+    module_function :display_width
+  end # Align
+end # Strings

data/lib/strings/ansi.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Strings
+  # Helper functions for handling ANSI escape sequences
+  module ANSI
+    # The control sequence indicator
+    CSI = "\033".freeze
+
+    # The code for reseting styling
+    RESET = "\e[0m".freeze
+
+    # The regex to match ANSI codes
+    ANSI_MATCHER = '(\[)?\033(\[)?[;?\d]*[\dA-Za-z]([\];])?'.freeze
+
+    # Remove ANSI characters from the text
+    #
+    # @param [String] text
+    #
+    # @example
+    #   Strings::ANSI.sanitize("\e[33mfoo\[e0m")
+    #   # => "foo"
+    #
+    # @return [String]
+    #
+    # @api public
+    def sanitize(text)
+      text.gsub(/#{ANSI_MATCHER}/, '')
+    end
+    module_function :sanitize
+
+    # Check if string contains ANSI codes
+    #
+    # @param [String] string
+    #   the string to check
+    #
+    # @example
+    #   Strings::ANSI.ansi?("\e[33mfoo\[e0m")
+    #   # => true
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def ansi?(string)
+      !!(string =~ /#{ANSI_MATCHER}/)
+    end
+    module_function :ansi?
+
+    # Check if string contains only ANSI codes
+    #
+    # @param [String] string
+    #   the string to check
+    #
+    # @example
+    #   Strings::ANSI.only_ansi?("\e[33mfoo\[e0m")
+    #   # => false
+    #
+    #   Strings::ANSI.only_ansi?("\e[33m")
+    #   # => false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def only_ansi?(string)
+      !!(string =~ /^#{ANSI_MATCHER}$/)
+    end
+    module_function :only_ansi?
+  end # Sanitizer
+end # Strings

data/lib/strings/fold.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Strings
+  module Fold
+    LINE_BREAK = "(\r\n+|\r+|\n+|\t+)".freeze
+
+    # Fold a multiline text into a single line string
+    #
+    # @example
+    #   fold("\tfoo \r\n\n bar") # => "foo  bar"
+    #
+    # @param [String] text
+    #
+    # @param [String] separator
+    #   the separators to be removed from the text, default: (\r\n+|\r+|\n+|\t+)
+    #
+    # @return [String]
+    #
+    # @api public
+    def fold(text, separator = LINE_BREAK)
+      text.gsub(/([ ]+)#{separator}/, "\\1")
+          .gsub(/#{separator}(?<space>[ ]+)/, "\\k<space>")
+          .gsub(/#{separator}/, ' ')
+    end
+    module_function :fold
+  end # Fold
+end # Strings

data/lib/strings/pad.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'unicode/display_width'
+
+require_relative 'ansi'
+require_relative 'padder'
+
+module Strings
+  # Responsible for text padding
+  module Pad
+    NEWLINE = "\n".freeze
+
+    SPACE = ' '.freeze
+
+    # Apply padding to multiline text with ANSI codes
+    #
+    # @param [String] text
+    #   the text to pad out
+    # @param [Integer, Array[Integer]] padding
+    #   the padding to apply to text
+    #
+    # @example
+    #  text = "Ignorance is the parent of fear."
+    #
+    #  Strings::Pad.pad(text, [1, 2], fill: "*")
+    #  # =>
+    #  # "************************************\n"
+    #  # "**Ignorance is the parent of fear.**\n"
+    #  # "************************************\n"
+    #
+    # @return [String]
+    #
+    # @api private
+    def pad(text, padding, fill: SPACE, separator: NEWLINE)
+      padding   = Strings::Padder.parse(padding)
+      text_copy = text.dup
+      line_width = max_line_length(text, separator)
+      output = []
+
+      filler_line = fill * line_width
+
+      padding.top.times do
+        output << pad_around(filler_line, padding, fill: fill)
+      end
+
+      text_copy.split(separator).each do |line|
+        output << pad_around(line, padding, fill: fill)
+      end
+
+      padding.bottom.times do
+        output << pad_around(filler_line, padding, fill: fill)
+      end
+
+      output.join(separator)
+    end
+    module_function :pad
+
+    # Apply padding to left and right side of string
+    #
+    # @param [String] text
+    #
+    # @return [String]
+    #
+    # @api private
+    def pad_around(text, padding, fill: SPACE)
+      fill * padding.left + text + fill * padding.right
+    end
+    module_function :pad_around
+
+    # Determine maximum length for all multiline content
+    #
+    # @param [String] text
+    # @param [String] separator
+    #
+    # @return [Integer]
+    #
+    # @api private
+    def max_line_length(text, separator)
+      lines = text.split(separator, -1)
+      display_width(lines.max_by { |line| display_width(line) } || '')
+    end
+    module_function :max_line_length
+
+    # Calculate visible string width
+    #
+    # @return [Integer]
+    #
+    # @api private
+    def display_width(string)
+      Unicode::DisplayWidth.of(Strings::ANSI.sanitize(string))
+    end
+    module_function :display_width
+  end # Padding
+end # Strings