tty-box 0.2.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b0c9524c939271bcc5168d3cc467b790657109218f53284a6328db8173225b8
-  data.tar.gz: cfe75b8c4b2f3567e03bd511ecd5a914fcda3180ab4339fb82412255cfd24206
+  metadata.gz: 66cd38e818e47ac372868586d8a76cdeb41a98aa9efc59430ec89acb84629410
+  data.tar.gz: d96e96b93e46a9ed8b7432632618af9c54e4da5f9575df820c6f77987104baf2
 SHA512:
-  metadata.gz: 0c5988a4893aa1c2411429c40d88445ad51a3a3306ecde927125868aa2741686835eabbebe538ea8338639981cf0985318d48e27f586057eb73b492b7797996d
-  data.tar.gz: ce051a4e7751ecd3a8caaa50ff626fb4d7929bdb348025c41ed2324c74cd5b055225112d85bb2ffdb90420d05c36b8308131e4756f652eefb4755781e7bd94bc
+  metadata.gz: 6bc7bddb63b580b8430d3dcdf596801db37e2f5813c12b8512a89dc9aff4140ebf6478e91d828020ffb182c84ca81b990d3d346c27718491c420a5a0099deca7
+  data.tar.gz: 43756dd006eec4de539d4a802c69afa04ca1b56fdd29505725d7001418a9e37f94005fc4606daa6be2564a8a12d2b876cbfb4d2ff1f0b43254c7580a99961b48

data/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Change log
 
+## [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
+* Add border parameters :top_left, :top_right, :bottom_left & :bottom_right to allow specifying values for box corners
+* Add :ascii border type for drawing ASCII boxes
+
+### Fixed
+* 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
 
 ### Fixed
@@ -15,6 +62,11 @@
 
 * Initial implementation and release
 
+[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
 [v0.1.0]: https://github.com/piotrmurach/tty-box/compare/v0.1.0

data/README.md

@@ -1,5 +1,5 @@
 <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://piotrmurach.github.io/tty" target="_blank"><img width="130" src="https://github.com/piotrmurach/tty/blob/master/images/tty.png" alt="tty logo" /></a>
 </div>
 
 # TTY::Box [![Gitter](https://badges.gitter.im/Join%20Chat.svg)][gitter]
@@ -19,18 +19,18 @@
 [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:
@@ -194,10 +233,10 @@ print box
 
 ### 2.5 border
 
-There are two types of border `:light` and `:thick`. By default the `:light` border is used. This can be changed using the `:border` keyword:
+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:
@@ -217,10 +256,66 @@ print box
 # ╚════════════════════════════╝
 ```
 
-You can also selectively switch off border sides by passing options hash. For example to remove bottom border do:
+You can also selectively specify and turn off border parts by passing a hash with a `:border` key. The border parts are:
+
+```
+                 :top
+    :top_left ┌────────┐ :top_right
+              │        │
+        :left │        │ :right
+              │        │
+ :bottom_left └────────┘ :bottom_right
+               :bottom
+```
+
+The following are available border parts values:
+
+| Border values        | ASCII | Unicode Light | Unicode Thick |
+| -------------------- |:-----:|:-------------:|:-------------:|
+| :line                | `-`   | `─`           | `═`           |
+| :pipe                | `\|`  | `\│`          | `\║`          |
+| :cross               | `+`   | `┼`           | `╬`           |
+| :divider_up          | `+`   | `┴`           | `╩`           |
+| :divider_down        | `+`   | `┬`           | `╦`           |
+| :divider_left        | `+`   | `┤`           | `╣`           |
+| :divider_right       | `+`   | `├`           | `╠`           |
+| :corner_top_left     | `+`   | `┌`           | `╔`           |
+| :corner_top_right    | `+`   | `┐`           | `╗`           |
+| :corner_bottom_left  | `+`   | `└`           | `╚`           |
+| :corner_bottom_right | `+`   | `┘`           | `╝`           |
+
+For example, to change all box corners to be a `:cross` do:
+
+```ruby
+box = TTY::Box.frame(
+  width: 10, height: 4,
+  border: {
+    top_left: :cross,
+    top_right: :cross,
+    bottom_left: :cross,
+    bottom_right: :cross
+  }
+)
+```
 
 ```ruby
-TTY::Box.new(width: 30, height: 10, border: {type: :thick, bottom: false})
+print box
+# =>
+# ┼────────┼
+# │        │
+# │        │
+# ┼────────┼
+```
+
+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(
+  width: 30, height: 10,
+  border: {
+    type: :thick,
+    bottom: false
+  })
 ```
 
 ### 2.6 styling
@@ -301,6 +396,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

@@ -11,53 +11,58 @@ module TTY
   module Box
     module_function
 
+    NEWLINE = "\n"
+
+    LINE_BREAK = %r{\r\n|\r|\n}.freeze
+
     BOX_CHARS = {
+      ascii: %w[+ + + + + + + + - | +],
       light: %w[┘ ┐ ┌ └ ┤ ┴ ┬ ├ ─ │ ┼],
       thick: %w[╝ ╗ ╔ ╚ ╣ ╩ ╦ ╠ ═ ║ ╬]
     }.freeze
 
-    def line_char(border = :light)
-      BOX_CHARS[border][8]
+    def corner_bottom_right_char(border = :light)
+      BOX_CHARS[border][0]
     end
 
-    def pipe_char(border = :light)
-      BOX_CHARS[border][9]
+    def corner_top_right_char(border = :light)
+      BOX_CHARS[border][1]
     end
 
-    def cross_char(border = :light)
-      BOX_CHARS[border][10]
+    def corner_top_left_char(border = :light)
+      BOX_CHARS[border][2]
     end
 
-    def left_divider_char(border = :light)
-      BOX_CHARS[border][7]
+    def corner_bottom_left_char(border = :light)
+      BOX_CHARS[border][3]
     end
 
-    def right_divider_char(border = :light)
+    def divider_left_char(border = :light)
       BOX_CHARS[border][4]
     end
 
-    def top_left_char(border = :light)
-      BOX_CHARS[border][2]
+    def divider_up_char(border = :light)
+      BOX_CHARS[border][5]
     end
 
-    def top_divider_char(border = :light)
+    def divider_down_char(border = :light)
       BOX_CHARS[border][6]
     end
 
-    def top_right_char(border = :light)
-      BOX_CHARS[border][1]
+    def divider_right_char(border = :light)
+      BOX_CHARS[border][7]
     end
 
-    def bottom_left_char(border = :light)
-      BOX_CHARS[border][3]
+    def line_char(border = :light)
+      BOX_CHARS[border][8]
     end
 
-    def bottom_divider_char(border = :light)
-      BOX_CHARS[border][5]
+    def pipe_char(border = :light)
+      BOX_CHARS[border][9]
     end
 
-    def bottom_right_char(border = :light)
-      BOX_CHARS[border][0]
+    def cross_char(border = :light)
+      BOX_CHARS[border][10]
     end
 
     def cursor
@@ -68,70 +73,228 @@ module TTY
       @color ||= Pastel.new
     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: {})
       output = []
-      content = []
+      sep = NEWLINE
       position = top && left
 
       border = Border.parse(border)
+      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)
+        str = yield
+      else
+        str = case content.size
+        when 0 then ""
+        when 1 then content[0]
+        else content.join(NEWLINE)
+        end
       end
 
+      sep = str[LINE_BREAK] || NEWLINE # infer line break
+      lines = str.split(sep)
+      # infer dimensions
+      dimensions = infer_dimensions(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
+      content = format(str, width, padding, align) # adjust content
+      # 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.type, style)
-        output << "\n" unless position
+        output << top_border(title, width, border, style)
+        output << sep unless position
       end
-      (height - 2).times do |i|
+
+      (height - top_size - bottom_size).times do |i|
+        output << cursor.move_to(left, top + i + top_size) if position
         if border.left?
-          output << cursor.move_to(left, top + i + 1) if position
           output << border_bg.(border_fg.(pipe_char(border.type)))
         end
-        if content[i].nil? && (style[:fg] || style[:bg] || !position)
-          output << bg.(fg.(' ' * (width - 2)))
-        else
+
+        content_size = width - left_size - right_size
+        unless content[i].nil?
           output << bg.(fg.(content[i]))
-          if style[:fg] || style[:bg]
-            output << bg.(fg.(' ' * (width - 2 - content[i].size)))
-          end
+          size = Strings::ANSI.sanitize(content[i]).scan(/[[:print:]]/).join.size
+          content_size -= size
+        end
+        if style[:fg] || style[:bg] || !position # something to color
+          output << bg.(fg.(" " * content_size))
         end
+
         if border.right?
-          output << cursor.move_to(left + width - 1, top + i + 1) if position
+          if position
+            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 - 1) if position
-        output << bottom_border(title, width, border.type, style)
-        output << "\n" unless position
+        output << cursor.move_to(left, top + height - bottom_size) if position
+        output << bottom_border(title, width, border, style)
+        output << sep unless position
       end
 
       output.join
     end
 
+    # 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)
+      content_height = lines.size
+      content_width = lines.empty? ? 1 : lines.max_by(&:length).length
+      width = pad.left + content_width + pad.right
+      height = pad.top + content_height + pad.bottom
+      [width, height]
+    end
+
     # Format content
     #
     # @return [Array[String]]
     #
     # @api private
     def format(content, width, padding, align)
+      return "" if content.to_s.empty?
+
       pad = Strings::Padder.parse(padding)
       total_width = width - 2 - (pad.left + pad.right)
+      sep = content[LINE_BREAK] || NEWLINE # infer line break
 
       wrapped = Strings.wrap(content, total_width)
       aligned = Strings.align(wrapped, total_width, direction: align)
       padded  = Strings.pad(aligned, padding)
-      padded.split("\n")
+      padded.split(sep)
     end
 
     # Convert style keywords into styling
@@ -145,32 +308,99 @@ module TTY
       [fg, bg]
     end
 
+    # 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
+
+    # Top left corner
+    #
+    # @return [String]
+    #
+    # @api private
+    def top_left_corner(border)
+      border.top_left? && border.left? ? send(:"#{border.top_left}_char", border.type) : ""
+    end
+
+    # Top right corner
+    #
+    # @return [String]
+    #
+    # @api private
+    def top_right_corner(border)
+      border.top_right? && border.right? ? send(:"#{border.top_right}_char", border.type) : ""
+    end
+
+    # Top titles size
+    #
+    # @return [Integer]
+    #
+    # @api private
+    def top_titles_size(title)
+      title[:top_left].to_s.size + title[:top_center].to_s.size + title[:top_right].to_s.size
+    end
+
     # Top border
     #
     # @return [String]
     #
     # @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_space_left = width - top_titles_size -
-                       top_left_char.size - top_right_char.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
+      top_space_after  = top_space_left / 2 + top_space_left % 2
 
       [
-        bg.(fg.(top_left_char(border))),
-        bg.(title[:top_left].to_s),
-        bg.(fg.(line_char(border) * top_space_before)),
-        bg.(title[:top_center].to_s),
-        bg.(fg.(line_char(border) * top_space_after)),
-        bg.(title[:top_right].to_s),
-        bg.(fg.(top_right_char(border)))
+        bg.(fg.(top_left_corner(border))),
+        bg.(fg.(title[:top_left].to_s)),
+        bg.(fg.(line_char(border.type) * top_space_before)),
+        bg.(fg.(title[:top_center].to_s)),
+        bg.(fg.(line_char(border.type) * top_space_after)),
+        bg.(fg.(title[:top_right].to_s)),
+        bg.(fg.(top_right_corner(border)))
       ].join('')
     end
+    # 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
+
+    # Bottom left corner
+    #
+    # @return [String]
+    #
+    # @api private
+    def bottom_left_corner(border)
+      border.bottom_left? && border.left? ? send(:"#{border.bottom_left}_char", border.type) : ""
+    end
+
+    # Bottom right corner
+    #
+    # @return [String]
+    #
+    # @api private
+    def bottom_right_corner(border)
+      border.bottom_right? && border.right? ? send(:"#{border.bottom_right}_char", border.type) : ""
+    end
+
+    # Bottom titles size
+    #
+    # @return [Integer]
+    #
+    # @api private
+    def bottom_titles_size(title)
+      title[:bottom_left].to_s.size + title[:bottom_center].to_s.size + title[:bottom_right].to_s.size
+    end
 
     # Bottom border
     #
@@ -178,24 +408,20 @@ 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_space_left = width - bottom_titles_size -
-                          bottom_left_char.size - bottom_right_char.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_char(border))),
-        bg.(title[:bottom_left].to_s),
-        bg.(fg.(line_char(border) * bottom_space_before)),
-        bg.(title[:bottom_center].to_s),
-        bg.(fg.(line_char(border) * bottom_space_after)),
-        bg.(title[:bottom_right].to_s),
-        bg.(fg.(bottom_right_char(border)))
+        bg.(fg.(bottom_left_corner(border))),
+        bg.(fg.(title[:bottom_left].to_s)),
+        bg.(fg.(line_char(border.type) * bottom_space_before)),
+        bg.(fg.(title[:bottom_center].to_s)),
+        bg.(fg.(line_char(border.type) * bottom_space_after)),
+        bg.(fg.(title[:bottom_right].to_s)),
+        bg.(fg.(bottom_right_corner(border)))
       ].join('')
     end
   end # TTY