tty-box 0.3.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de83dc517a44cecc9c6936beafcc7a9e92bbef44b9f835ce8c5f537a34fcfb99
-  data.tar.gz: 4e5a152bf222a4a1a267fa97699b8f20cbe33be48c9d7847b83172dc26708c2a
+  metadata.gz: b9509817a402d4b790c91be69e5d9c11947ba1374a32ba0df8a06a18c333d371
+  data.tar.gz: ea1322ac1cedabf28d34c52fb666386b97013feffc6319cd9c24356039831597
 SHA512:
-  metadata.gz: 8979a9ad2c06c9ff1762005feabfbdf28456e75a496c3a39a4276b7fe73a31fc9bb69c8941d4470efb8c2a7277bdbdce62de7c788f95622a24c299cd015a2e72
-  data.tar.gz: 99f56b7376c5d96b933e1deb3f7282d37e7b7ce10130240516dc3408387feb38edb567de17ee72a96e9c1e5de49b3cde2c3f2d35fd0ff6cfc22767e1a010fb9b
+  metadata.gz: 78d7164d16610ae4fc585977880845b3bd83c2be04e5c417ec08ce1aa00d0a56d6ff90efa5a3229742e97ea4836faadd140d59aca936ed545dd3606d85bf27d4
+  data.tar.gz: 8c7af2b0bf020d0208065a6afdd2ad8a28edfe3ed731582fbf20f4f8b301b574ebd54b5f0c7d9f05db853a7f9e35a507e5092f8a18ab62feefcc0a84851472bb

data/CHANGELOG.md

@@ -1,5 +1,55 @@
 # Change log
 
+## [v0.7.0] - 2020-12-20
+
+### Added
+* Add :enable_color configuration to allow control over colouring
+
+### Changed
+* Change to ensure non-negative space filler size
+* Change to enforce private visibility for the private module methods
+
+### Fixed
+* Fix box width calculation to ignore colored text by @LainLayer
+* Fix drawing frame around multiline colored content
+
+## [v0.6.0] - 2020-08-11
+
+### Changed
+* Change to preserve newline characters when wrapping content
+* Change gemspec to include metadata and remove test files
+* Change to update pastel & strings dependencies
+
+### Fixed
+* Fix Ruby 2.7 warnings
+
+## [v0.5.0] - 2019-10-08
+
+### Added
+* Add ability to create frames without specifying width or height
+* Add #info, #warn, #success, #error ready frames for status messages inspired by conversation with Konstantin Gredeskoul(@kigster)
+
+### Changed
+* Change #frame to accept content as an argument in addition to a block
+* Change to match titles with border styling
+
+## [v0.4.1] - 2019-08-28
+
+### Added
+* Add example to demonstrate different line endings
+
+### Fixed
+* Fix to handle different line endings
+
+## [v0.4.0] - 2019-06-05
+
+### Changed
+* Change gemspec to require Ruby >= 2.0.0
+* Change to update tty-cursor dependency
+
+### Fixed
+* Fix issue with displaying box with colored content
+
 ## [v0.3.0] - 2018-10-08
 
 ### Added
@@ -7,7 +57,7 @@
 * Add :ascii border type for drawing ASCII boxes
 
 ### Fixed
-* Fix box color fill to corretly recognise missing borders and match the height and width
+* Fix box color fill to correctly recognise missing borders and match the height and width
 * Fix absolute content positioning when borders are missing
 
 ## [v0.2.1] - 2018-09-10
@@ -25,6 +75,11 @@
 
 * Initial implementation and release
 
+[v0.7.0]: https://github.com/piotrmurach/tty-box/compare/v0.6.0...v0.7.0
+[v0.6.0]: https://github.com/piotrmurach/tty-box/compare/v0.5.0...v0.6.0
+[v0.5.0]: https://github.com/piotrmurach/tty-box/compare/v0.4.1...v0.5.0
+[v0.4.1]: https://github.com/piotrmurach/tty-box/compare/v0.4.0...v0.4.1
+[v0.4.0]: https://github.com/piotrmurach/tty-box/compare/v0.3.0...v0.4.0
 [v0.3.0]: https://github.com/piotrmurach/tty-box/compare/v0.2.1...v0.3.0
 [v0.2.1]: https://github.com/piotrmurach/tty-box/compare/v0.2.0...v0.2.1
 [v0.2.0]: https://github.com/piotrmurach/tty-box/compare/v0.1.0...v0.2.0

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Piotr Murach
+Copyright (c) 2018 Piotr Murach (https://piotrmurach.com)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,11 +1,11 @@
 <div align="center">
-  <a href="https://piotrmurach.github.io/tty" target="_blank"><img width="130" src="https://cdn.rawgit.com/piotrmurach/tty/master/images/tty.png" alt="tty logo" /></a>
+  <a href="https://ttytoolkit.org"><img width="130" src="https://github.com/piotrmurach/tty/blob/master/images/tty.png" alt="TTY Toolkit logo" /></a>
 </div>
 
 # TTY::Box [![Gitter](https://badges.gitter.im/Join%20Chat.svg)][gitter]
 
 [![Gem Version](https://badge.fury.io/rb/tty-box.svg)][gem]
-[![Build Status](https://secure.travis-ci.org/piotrmurach/tty-box.svg?branch=master)][travis]
+[![Actions CI](https://github.com/piotrmurach/tty-box/workflows/CI/badge.svg?branch=master)][gh_actions_ci]
 [![Build status](https://ci.appveyor.com/api/projects/status/h9b88fk5xpya3fh1?svg=true)][appveyor]
 [![Maintainability](https://api.codeclimate.com/v1/badges/dfac05073e1549e9dbb6/maintainability)][codeclimate]
 [![Coverage Status](https://coveralls.io/repos/github/piotrmurach/tty-box/badge.svg)][coverage]
@@ -13,24 +13,24 @@
 
 [gitter]: https://gitter.im/piotrmurach/tty
 [gem]: http://badge.fury.io/rb/tty-box
-[travis]: http://travis-ci.org/piotrmurach/tty-box
+[gh_actions_ci]: https://github.com/piotrmurach/tty-box/actions?query=workflow%3ACI
 [appveyor]: https://ci.appveyor.com/project/piotrmurach/tty-box
 [codeclimate]: https://codeclimate.com/github/piotrmurach/tty-box/maintainability
 [coverage]: https://coveralls.io/github/piotrmurach/tty-box
 [inchpages]: http://inch-ci.org/github/piotrmurach/tty-box
 
-> Draw various frames and boxes in your terminal interface.
+> Draw various frames and boxes in the terminal window.
 
 **TTY::Box** provides box drawing component for [TTY](https://github.com/piotrmurach/tty) toolkit.
 
-![Box drawing](https://cdn.rawgit.com/piotrmurach/tty-box/master/assets/tty-box-drawing.png)
+![Box drawing](https://github.com/piotrmurach/tty-box/blob/master/assets/tty-box-drawing.png)
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'tty-box'
+gem "tty-box"
 ```
 
 And then execute:
@@ -52,49 +52,90 @@ Or install it yourself as:
   * [2.5 border](#25-border)
   * [2.6 styling](#26-styling)
   * [2.7 formatting](#27-formatting)
+  * [2.8 messages](#28-messages)
+    * [2.8.1 info](#281-info)
+    * [2.8.2 warn](#282-warn)
+    * [2.8.3 success](#283-success)
+    * [2.8.4 error](#284-error)
 
 ## 1. Usage
 
 Using the `frame` method, you can draw a box in a terminal emulator:
 
 ```ruby
-box = TTY::Box.frame(
-  width: 30,
-  height: 10,
-  align: :center,
-  padding: 3
-) do
-  "Drawing a box in terminal emulator"
-end
-
+box = TTY::Box.frame "Drawing a box in", "terminal emulator", padding: 3, align: :center
 ```
 
+And then print:
+
 ```ruby
 print box
 # =>
-# ┌────────────────────────────┐
-# │                            │
-# │                            │
-# │                            │
-# │     Drawing a box in       │
-# │     terminal emulator      │
-# │                            │
-# │                            │
-# │                            │
-# └────────────────────────────┘
+# ┌───────────────────────┐
+# │                       │
+# │                       │
+# │                       │
+# │   Drawing a box in    │
+# │   terminal emulator   │
+# │                       │
+# │                       │
+# │                       │
+# └───────────────────────┘
 ```
 
 ## 2. Interface
 
 ### 2.1 frame
 
-You can draw a box in the top left corner of your terminal window by using the `frame` method and providing at the very minimum the height and the width:
+You can draw a box in your terminal window by using the `frame` method and passing a content to display. By default the box will be drawn around the content.
+
+```ruby
+print TTY::Box.frame "Hello world!"
+# =>
+# ┌────────────┐
+# │Hello world!│
+# └────────────┘
+```
+
+You can also provide multi line content as separate arguments.
+
+```ruby
+print TTY::Box.frame "Hello", "world!"
+# =>
+# ┌──────┐
+# │Hello │
+# │world!│
+# └──────┘
+```
+
+Alternatively, provide a multi line content using newline chars in a single argument:
+
+```ruby
+print TTY::Box.frame "Hello\nworld!"
+# =>
+# ┌──────┐
+# │Hello │
+# │world!│
+# └──────┘
+```
+
+Finally, you can use a block to specify content:
+
+```ruby
+print TTY::Box.frame { "Hello world!" }
+# =>
+# ┌────────────┐
+# │Hello world!│
+# └────────────┘
+```
+
+You can also enforce a given box size without any content and use [tty-cursor](https://github.com/piotrmurach/tty-cursor) to position content whatever you like.
 
 ```ruby
 box = TTY::Box.frame(width: 30, height: 10)
 ```
 
-which when printed will prodcue the following output in your terminal:
+When printed will produce the following output in your terminal:
 
 ```ruby
 print box
@@ -111,8 +152,6 @@ print box
 # └────────────────────────────┘
 ```
 
-Then you can use [tty-cursor](https://github.com/piotrmurach/tty-cursor) to directly manipulate content to be displayed inside the box.
-
 Alternatively, you can also pass a block to provide a content for the box:
 
 ```ruby
@@ -121,7 +160,7 @@ box = TTY::Box.frame(width: 30, height: 10) do
 end
 ```
 
-which when printed will produce the following output in your terminal:
+When printed will produce the following output in your terminal:
 
 ```ruby
 print box
@@ -172,7 +211,7 @@ You can specify titles using the `:title` keyword and a hash value that contains
 
 
 ```ruby
-box = TTY::Box.frame(width: 30, height: 10, title: {top_left: 'TITLE', bottom_right: 'v1.0'})
+box = TTY::Box.frame(width: 30, height: 10, title: {top_left: "TITLE", bottom_right: "v1.0"})
 ```
 
 which when printed in console will render the following:
@@ -197,7 +236,7 @@ print box
 There are three types of border `:ascii`, `:light`, `:thick`. By default the `:light` border is used. This can be changed using the `:border` keyword:
 
 ```ruby
-box = TTY::Box.new(width 30, height: 10, border: :thick)
+box = TTY::Box.frame(width: 30, height: 10, border: :thick)
 ```
 
 and printing the box out to console will produce:
@@ -268,10 +307,10 @@ print box
 # ┼────────┼
 ```
 
-If you want to remoe a given border element as a value use `false`. For example to remove bottom border do:
+If you want to remove a given border element as a value use `false`. For example to remove bottom border do:
 
 ```ruby
-TTY::Box.new(
+TTY::Box.frame(
   width: 30, height: 10,
   border: {
     type: :thick,
@@ -296,6 +335,20 @@ style: {
 
 The above style configuration will produce the result similar to the top demo, a MS-DOS look & feel window.
 
+You can disable or force output styling regardless of the terminal using the `enable_color` keyword. By default, the color support is automatically detected.
+
+```ruby
+TTY::Box.frame({
+  enable_color: true, # force to always color output
+  style: {
+    border: {
+      fg: :bright_yellow,
+      bg: :blue
+    }
+  }
+})
+```
+
 ### 2.7 formatting
 
 You can use `:align` keyword to format content either to be `:left`, `:center` or `:right` aligned:
@@ -357,6 +410,90 @@ print box
 #
 ```
 
+### 2.8 messages
+
+![Box messages](https://github.com/piotrmurach/tty-box/blob/master/assets/tty-box-messages.png)
+
+#### 2.8.1 info
+
+To draw an information type box around your content use `info`:
+
+```ruby
+box = TTY::Box.info("Deploying application")
+```
+
+And then print:
+
+```ruby
+print box
+# =>
+# ╔ ℹ INFO ═══════════════╗
+# ║                       ║
+# ║ Deploying application ║
+# ║                       ║
+# ╚═══════════════════════╝
+```
+
+#### 2.8.2 warn
+
+To draw a warning type box around your content use `warn`:
+
+```ruby
+box = TTY::Box.warn("Deploying application")
+```
+
+And then print:
+
+```ruby
+print box
+# =>
+# ╔ ⚠ WARNING ════════════╗
+# ║                       ║
+# ║ Deploying application ║
+# ║                       ║
+# ╚═══════════════════════╝
+```
+
+#### 2.8.3 success
+
+To draw a success type box around your content use `success`:
+
+```ruby
+box = TTY::Box.success("Deploying application")
+```
+
+And then print:
+
+```ruby
+print box
+# =>
+# ╔ ✔ OK ═════════════════╗
+# ║                       ║
+# ║ Deploying application ║
+# ║                       ║
+# ╚═══════════════════════╝
+```
+
+#### 2.8.4 error
+
+To draw an error type box around your content use `error`:
+
+```ruby
+box = TTY::Box.error("Deploying application")
+```
+
+And then print:
+
+```ruby
+print box
+# =>
+# ╔ ⨯ ERROR ══════════════╗
+# ║                       ║
+# ║ Deploying application ║
+# ║                       ║
+# ╚═══════════════════════╝
+```
+
 ## 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.

data/lib/tty-box.rb

@@ -1 +1 @@
-require_relative 'tty/box'
+require_relative "tty/box"

data/lib/tty/box.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
 
-require 'strings'
-require 'pastel'
-require 'tty-cursor'
+require "strings"
+require "pastel"
+require "tty-cursor"
 
-require_relative 'box/border'
-require_relative 'box/version'
+require_relative "box/border"
+require_relative "box/version"
 
 module TTY
   module Box
     module_function
 
+    NEWLINE = "\n"
+    SPACE = " "
+
+    LINE_BREAK = %r{\r\n|\r|\n}.freeze
+
     BOX_CHARS = {
       ascii: %w[+ + + + + + + + - | +],
       light: %w[┘ ┐ ┌ └ ┤ ┴ ┬ ├ ─ │ ┼],
@@ -65,36 +70,162 @@ module TTY
       TTY::Cursor
     end
 
-    def color
-      @color ||= Pastel.new
+    def color(enabled: nil)
+      @color ||= Pastel.new(enabled: enabled)
+    end
+
+    # A frame for info type message
+    #
+    # @param [String] message
+    #   the message to display
+    #
+    # @api public
+    def info(message, **opts)
+      new_opts = {
+        title: { top_left: " ℹ INFO " },
+        border: { type: :thick },
+        padding: 1,
+        style: {
+          fg: :black,
+          bg: :bright_blue,
+          border: {
+            fg: :black,
+            bg: :bright_blue
+          }
+        }
+      }.merge(opts)
+      frame(**new_opts) { message }
+    end
+
+    # A frame for warning type message
+    #
+    # @param [String] message
+    #   the message to display
+    #
+    # @api public
+    def warn(message, **opts)
+      new_opts = {
+        title: { top_left: " ⚠ WARNING " },
+        border: { type: :thick },
+        padding: 1,
+        style: {
+          fg: :black,
+          bg: :bright_yellow,
+          border: {
+            fg: :black,
+            bg: :bright_yellow
+          }
+        }
+      }.merge(opts)
+      frame(**new_opts) { message }
+    end
+
+    # A frame for for success type message
+    #
+    # @param [String] message
+    #   the message to display
+    #
+    # @api public
+    def success(message, **opts)
+      new_opts = {
+        title: { top_left: " ✔ OK " },
+        border: { type: :thick },
+        padding: 1,
+        style: {
+          fg: :black,
+          bg: :bright_green,
+          border: {
+            fg: :black,
+            bg: :bright_green
+          }
+        }
+      }.merge(opts)
+      frame(**new_opts) { message }
+    end
+
+    # A frame for error type message
+    #
+    # @param [String] message
+    #   the message to display
+    #
+    # @api public
+    def error(message, **opts)
+      new_opts = {
+        title: { top_left: " ⨯ ERROR " },
+        border: { type: :thick },
+        padding: 1,
+        style: {
+          fg: :bright_white,
+          bg: :red,
+          border: {
+            fg: :bright_white,
+            bg: :red
+          }
+        }
+      }.merge(opts)
+      frame(**new_opts) { message }
     end
 
     # Create a frame
     #
+    # @param [Integer] top
+    #   the offset from the terminal top
+    # @param [Integer] left
+    #   the offset from the terminal left
+    # @param [Integer] width
+    #   the width of the box
+    # @param [Integer] height
+    #   the height of the box
+    # @param [Symbol] align
+    #   the content alignment
+    # @param [Integer,Array[Integer]] padding
+    #   the padding around content
+    # @param [Hash] title
+    #   the title for top or bottom border
+    # @param [Hash, Symbol] border
+    #   the border type
+    # @param [Hash] style
+    #   the styling for the front and background
+    #
     # @api public
-    def frame(top: nil, left: nil, width: 35, height: 3, align: :left, padding: 0,
-              title: {}, border: :light, style: {})
+    def frame(*content, top: nil, left: nil, width: nil, height: nil,
+              align: :left, padding: 0, title: {}, border: :light, style: {},
+              enable_color: nil)
+      @color = nil
+      color(enabled: enable_color)
       output = []
-      content = []
+      sep = NEWLINE
       position = top && left
 
       border = Border.parse(border)
-      top_size    = border.top? ? 1: 0
-      bottom_size = border.bottom? ? 1: 0
+      top_size    = border.top? ? 1 : 0
+      bottom_size = border.bottom? ? 1 : 0
       left_size   = border.left? ? 1 : 0
       right_size  = border.right ? 1 : 0
 
-      if block_given?
-        content = format(yield, width, padding, align)
-      end
+      str = block_given? ? yield : content_to_str(content)
+      sep = str[LINE_BREAK] || NEWLINE # infer line break
+      content_lines = str.split(sep)
 
+      # infer dimensions
+      dimensions = infer_dimensions(content_lines, padding)
+      width ||= left_size + dimensions[0] + right_size
+      width = [width,
+               top_space_taken(title, border),
+               bottom_space_taken(title, border)].max
+      height ||= top_size + dimensions[1] + bottom_size
+
+      # apply formatting to content
+      formatted_lines = format(content_lines, width, padding, align, sep)
+
+      # infer styling
       fg, bg = *extract_style(style)
       border_fg, border_bg = *extract_style(style[:border] || {})
 
       if border.top?
         output << cursor.move_to(left, top) if position
         output << top_border(title, width, border, style)
-        output << "\n" unless position
+        output << sep unless position
       end
 
       (height - top_size - bottom_size).times do |i|
@@ -103,47 +234,116 @@ module TTY
           output << border_bg.(border_fg.(pipe_char(border.type)))
         end
 
-        content_size = width - left_size - right_size
-        unless content[i].nil?
-          output << bg.(fg.(content[i]))
-          content_size -= content[i].size
+        filler_size = width - left_size - right_size
+        if formatted_line = formatted_lines[i]
+          output << bg.(fg.(formatted_line))
+          line_content_size = Strings::ANSI.sanitize(formatted_line)
+                                           .scan(/[[:print:]]/).join.size
+          filler_size = [filler_size - line_content_size, 0].max
         end
+
         if style[:fg] || style[:bg] || !position # something to color
-          output << bg.(fg.(' ' * content_size))
+          output << bg.(fg.(SPACE * filler_size))
         end
 
         if border.right?
           if position
-            output << cursor.move_to(left + width - right_size, top + i + top_size)
+            output << cursor.move_to(left + width - right_size,
+                                     top + i + top_size)
           end
           output << border_bg.(border_fg.(pipe_char(border.type)))
         end
-        output << "\n" unless position
+        output << sep unless position
       end
 
       if border.bottom?
         output << cursor.move_to(left, top + height - bottom_size) if position
         output << bottom_border(title, width, border, style)
-        output << "\n" unless position
+        output << sep unless position
       end
 
       output.join
     end
 
-    # Format content
+    # Convert content array to string
+    #
+    # @param [Array<String>] content
+    #
+    # @return [String]
+    #
+    # @api private
+    def content_to_str(content)
+      case content.size
+      when 0 then ""
+      when 1 then content[0]
+      else content.join(NEWLINE)
+      end
+    end
+    private_class_method :content_to_str
+
+    # Infer box dimensions based on content lines and padding
+    #
+    # @param [Array[String]] lines
+    # @param [Array[Integer]|Integer] padding
+    #
+    # @return [Array[Integer]]
+    #
+    # @api private
+    def infer_dimensions(lines, padding)
+      pad = Strings::Padder.parse(padding)
+      width = pad.left + content_width(lines) + pad.right
+      height = pad.top + lines.size + pad.bottom
+      [width, height]
+    end
+    private_class_method :infer_dimensions
+
+    # The maximum content width for all the lines
+    #
+    # @param [Array<String>] lines
+    #
+    # @return [Integer]
+    #
+    # @api private
+    def content_width(lines)
+      return 1 if lines.empty?
+
+      lines.map(&Strings::ANSI.method(:sanitize)).max_by(&:length).length
+    end
+    private_class_method :content_width
+
+    # Format content by wrapping, aligning and padding out
+    #
+    # @param [Array<String>] lines
+    #   the lines to format
+    # @param [Integer] width
+    #   the maximum width
+    # @param [Integer, Array<Integer>] padding
+    #   the amount of padding
+    # @param [Symbol] align
+    #   the type of alignment
+    # @param [String] separator
+    #   the newline separator
     #
     # @return [Array[String]]
     #
     # @api private
-    def format(content, width, padding, align)
+    def format(lines, width, padding, align, separator)
+      return [] if lines.empty?
+
       pad = Strings::Padder.parse(padding)
       total_width = width - 2 - (pad.left + pad.right)
 
-      wrapped = Strings.wrap(content, total_width)
-      aligned = Strings.align(wrapped, total_width, direction: align)
-      padded  = Strings.pad(aligned, padding)
-      padded.split("\n")
+      formatted = lines.each_with_object([]) do |line, acc|
+        wrapped = Strings::Wrap.wrap(line, total_width, separator: separator)
+        acc << Strings::Align.align(wrapped, total_width,
+                                    direction: align,
+                                    separator: separator)
+      end.join(separator)
+
+      Strings::Pad.pad(formatted, padding, separator: separator)
+                  .split(separator)
     end
+    private_class_method :format
 
     # Convert style keywords into styling
     #
@@ -151,10 +351,63 @@ module TTY
     #
     # @api private
     def extract_style(style)
-      fg = style[:fg] ? color.send(style[:fg]).detach : -> (c) { c }
-      bg = style[:bg] ? color.send(:"on_#{style[:bg]}").detach : -> (c) { c }
+      fg = style[:fg] ? color.send(style[:fg]).detach : ->(c) { c }
+      bg = style[:bg] ? color.send(:"on_#{style[:bg]}").detach : ->(c) { c }
       [fg, bg]
     end
+    private_class_method :extract_style
+
+    # Top space taken by titles and corners
+    #
+    # @return [Integer]
+    #
+    # @api private
+    def top_space_taken(title, border)
+      top_titles_size(title) +
+        top_left_corner(border).size +
+        top_right_corner(border).size
+    end
+    private_class_method :top_space_taken
+
+    # Top left corner
+    #
+    # @param [Border] border
+    #
+    # @return [String]
+    #
+    # @api private
+    def top_left_corner(border)
+      return "" unless border.top_left? && border.left?
+
+      send(:"#{border.top_left}_char", border.type)
+    end
+    private_class_method :top_left_corner
+
+    # Top right corner
+    #
+    # @param [Border] border
+    #
+    # @return [String]
+    #
+    # @api private
+    def top_right_corner(border)
+      return "" unless border.top_right? && border.right?
+
+      send(:"#{border.top_right}_char", border.type)
+    end
+    private_class_method :top_right_corner
+
+    # Top titles size
+    #
+    # @return [Integer]
+    #
+    # @api private
+    def top_titles_size(title)
+      color.strip(title[:top_left].to_s).size +
+        color.strip(title[:top_center].to_s).size +
+        color.strip(title[:top_right].to_s).size
+    end
+    private_class_method :top_titles_size
 
     # Top border
     #
@@ -162,28 +415,75 @@ module TTY
     #
     # @api private
     def top_border(title, width, border, style)
-      top_titles_size = title[:top_left].to_s.size +
-                        title[:top_center].to_s.size +
-                        title[:top_right].to_s.size
       fg, bg = *extract_style(style[:border] || {})
 
-      top_left = border.top_left? && border.left? ? send(:"#{border.top_left}_char", border.type) : ""
-      top_right = border.top_right? && border.right? ? send(:"#{border.top_right}_char", border.type) : ""
-
-      top_space_left   = width - top_titles_size - top_left.size - top_right.size
+      top_space_left = width - top_space_taken(title, border)
       top_space_before = top_space_left / 2
       top_space_after  = top_space_left / 2 + top_space_left % 2
 
       [
-        bg.(fg.(top_left)),
-        bg.(title[:top_left].to_s),
+        bg.(fg.(top_left_corner(border))),
+        bg.(fg.(title[:top_left].to_s)),
         bg.(fg.(line_char(border.type) * top_space_before)),
-        bg.(title[:top_center].to_s),
+        bg.(fg.(title[:top_center].to_s)),
         bg.(fg.(line_char(border.type) * top_space_after)),
-        bg.(title[:top_right].to_s),
-        bg.(fg.(top_right))
-      ].join('')
+        bg.(fg.(title[:top_right].to_s)),
+        bg.(fg.(top_right_corner(border)))
+      ].join
     end
+    private_class_method :top_border
+
+    # Bottom space taken by titles and corners
+    #
+    # @return [Integer]
+    #
+    # @api private
+    def bottom_space_taken(title, border)
+      bottom_titles_size(title) +
+        bottom_left_corner(border).size +
+        bottom_right_corner(border).size
+    end
+    private_class_method :bottom_space_taken
+
+    # Bottom left corner
+    #
+    # @param [Border] border
+    #
+    # @return [String]
+    #
+    # @api private
+    def bottom_left_corner(border)
+      return "" unless border.bottom_left? && border.left?
+
+      send(:"#{border.bottom_left}_char", border.type)
+    end
+    private_class_method :bottom_left_corner
+
+    # Bottom right corner
+    #
+    # @param [Border] border
+    #
+    # @return [String]
+    #
+    # @api private
+    def bottom_right_corner(border)
+      return "" unless border.bottom_right? && border.right?
+
+      send(:"#{border.bottom_right}_char", border.type)
+    end
+    private_class_method :bottom_right_corner
+
+    # Bottom titles size
+    #
+    # @return [Integer]
+    #
+    # @api private
+    def bottom_titles_size(title)
+      color.strip(title[:bottom_left].to_s).size +
+        color.strip(title[:bottom_center].to_s).size +
+        color.strip(title[:bottom_right].to_s).size
+    end
+    private_class_method :bottom_titles_size
 
     # Bottom border
     #
@@ -191,28 +491,22 @@ module TTY
     #
     # @api private
     def bottom_border(title, width, border, style)
-      bottom_titles_size = title[:bottom_left].to_s.size +
-                           title[:bottom_center].to_s.size +
-                           title[:bottom_right].to_s.size
       fg, bg = *extract_style(style[:border] || {})
 
-      bottom_left  = border.bottom_left? && border.left? ? send(:"#{border.bottom_left}_char", border.type) : ""
-      bottom_right = border.bottom_right? && border.right? ? send(:"#{border.bottom_right}_char", border.type) : ""
-
-      bottom_space_left = width - bottom_titles_size -
-                          bottom_left.size - bottom_right.size
+      bottom_space_left = width - bottom_space_taken(title, border)
       bottom_space_before = bottom_space_left / 2
       bottom_space_after = bottom_space_left / 2 + bottom_space_left % 2
 
       [
-        bg.(fg.(bottom_left)),
-        bg.(title[:bottom_left].to_s),
+        bg.(fg.(bottom_left_corner(border))),
+        bg.(fg.(title[:bottom_left].to_s)),
         bg.(fg.(line_char(border.type) * bottom_space_before)),
-        bg.(title[:bottom_center].to_s),
+        bg.(fg.(title[:bottom_center].to_s)),
         bg.(fg.(line_char(border.type) * bottom_space_after)),
-        bg.(title[:bottom_right].to_s),
-        bg.(fg.(bottom_right))
-      ].join('')
+        bg.(fg.(title[:bottom_right].to_s)),
+        bg.(fg.(bottom_right_corner(border)))
+      ].join
     end
+    private_class_method :bottom_border
   end # TTY
 end # Box