Add rule widget

Adds a new rule widget.
Also fixes some bugs I encountered while testing
some unrelated things in an extremely small console.

src/Spectre.Console/Extensions/RuleExtensions.cs

@@ -0,0 +1,75 @@
+using System;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// Contains extension methods for <see cref="RuleExtensions"/>.
+    /// </summary>
+    public static class RuleExtensions
+    {
+        /// <summary>
+        /// Sets the rule title.
+        /// </summary>
+        /// <param name="rule">The rule.</param>
+        /// <param name="title">The title.</param>
+        /// <returns>The same instance so that multiple calls can be chained.</returns>
+        public static Rule SetTitle(this Rule rule, string title)
+        {
+            if (rule is null)
+            {
+                throw new ArgumentNullException(nameof(rule));
+            }
+
+            if (title is null)
+            {
+                throw new ArgumentNullException(nameof(title));
+            }
+
+            rule.Title = title;
+            return rule;
+        }
+
+        /// <summary>
+        /// Sets the rule style.
+        /// </summary>
+        /// <param name="rule">The rule.</param>
+        /// <param name="style">The rule style string.</param>
+        /// <returns>The same instance so that multiple calls can be chained.</returns>
+        public static Rule SetStyle(this Rule rule, string style)
+        {
+            if (rule is null)
+            {
+                throw new ArgumentNullException(nameof(rule));
+            }
+
+            if (style is null)
+            {
+                throw new ArgumentNullException(nameof(style));
+            }
+
+            return SetStyle(rule, Style.Parse(style));
+        }
+
+        /// <summary>
+        /// Sets the rule style.
+        /// </summary>
+        /// <param name="rule">The rule.</param>
+        /// <param name="style">The rule style.</param>
+        /// <returns>The same instance so that multiple calls can be chained.</returns>
+        public static Rule SetStyle(this Rule rule, Style style)
+        {
+            if (rule is null)
+            {
+                throw new ArgumentNullException(nameof(rule));
+            }
+
+            if (style is null)
+            {
+                throw new ArgumentNullException(nameof(style));
+            }
+
+            rule.Style = style;
+            return rule;
+        }
+    }
+}

src/Spectre.Console/Rendering/RenderContext.cs

@@ -27,6 +27,12 @@ namespace Spectre.Console.Rendering
         /// </summary>
         public Justify? Justification { get; }
 
+        /// <summary>
+        /// Gets a value indicating whether the context want items to render without
+        /// line breaks and return a single line where applicable.
+        /// </summary>
+        internal bool SingleLine { get; }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="RenderContext"/> class.
         /// </summary>
@@ -34,21 +40,42 @@ namespace Spectre.Console.Rendering
         /// <param name="legacyConsole">A value indicating whether or not this a legacy console (i.e. cmd.exe).</param>
         /// <param name="justification">The justification to use when rendering.</param>
         public RenderContext(Encoding encoding, bool legacyConsole, Justify? justification = null)
+            : this(encoding, legacyConsole, justification, false)
+        {
+        }
+
+        private RenderContext(Encoding encoding, bool legacyConsole, Justify? justification = null, bool singleLine = false)
         {
             Encoding = encoding ?? throw new System.ArgumentNullException(nameof(encoding));
             LegacyConsole = legacyConsole;
             Justification = justification;
             Unicode = Encoding == Encoding.UTF8 || Encoding == Encoding.Unicode;
+            SingleLine = singleLine;
         }
 
         /// <summary>
         /// Creates a new context with the specified justification.
         /// </summary>
         /// <param name="justification">The justification.</param>
-        /// <returns>A new <see cref="RenderContext"/> instance with the specified justification.</returns>
+        /// <returns>A new <see cref="RenderContext"/> instance.</returns>
         public RenderContext WithJustification(Justify? justification)
         {
             return new RenderContext(Encoding, LegacyConsole, justification);
         }
+
+        /// <summary>
+        /// Creates a new context that tell <see cref="IRenderable"/> instances
+        /// to not care about splitting things in new lines. Whether or not to
+        /// comply to the request is up to the item being rendered.
+        /// </summary>
+        /// <remarks>
+        /// Use with care since this has the potential to mess things up.
+        /// Only use this kind of context with items that you know about.
+        /// </remarks>
+        /// <returns>A new <see cref="RenderContext"/> instance.</returns>
+        internal RenderContext WithSingleLine()
+        {
+            return new RenderContext(Encoding, LegacyConsole, Justification, true);
+        }
     }
 }

src/Spectre.Console/Rendering/Segment.cs

@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Linq;
+using System.Text;
 using Spectre.Console.Internal;
 
 namespace Spectre.Console.Rendering
@@ -125,48 +127,11 @@ namespace Spectre.Console.Rendering
         /// <param name="context">The render context.</param>
         /// <param name="segments">The segments to measure.</param>
         /// <returns>The number of cells that the segments occupies in the console.</returns>
-        public static int CellLength(RenderContext context, List<Segment> segments)
+        public static int CellLength(RenderContext context, IEnumerable<Segment> segments)
         {
             return segments.Sum(segment => segment.CellLength(context));
         }
 
-        /// <summary>
-        /// Truncates the segments to the specified width.
-        /// </summary>
-        /// <param name="context">The render context.</param>
-        /// <param name="segments">The segments to truncate.</param>
-        /// <param name="maxWidth">The maximum width that the segments may occupy.</param>
-        /// <returns>A list of segments that has been truncated.</returns>
-        public static List<Segment> Truncate(RenderContext context, IEnumerable<Segment> segments, int maxWidth)
-        {
-            if (context is null)
-            {
-                throw new ArgumentNullException(nameof(context));
-            }
-
-            if (segments is null)
-            {
-                throw new ArgumentNullException(nameof(segments));
-            }
-
-            var result = new List<Segment>();
-
-            var totalWidth = 0;
-            foreach (var segment in segments)
-            {
-                var segmentWidth = segment.CellLength(context);
-                if (totalWidth + segmentWidth > maxWidth)
-                {
-                    break;
-                }
-
-                result.Add(segment);
-                totalWidth += segmentWidth;
-            }
-
-            return result;
-        }
-
         /// <summary>
         /// Splits the provided segments into lines.
         /// </summary>
@@ -387,6 +352,90 @@ namespace Spectre.Console.Rendering
             return result;
         }
 
+        /// <summary>
+        /// Truncates the segments to the specified width.
+        /// </summary>
+        /// <param name="context">The render context.</param>
+        /// <param name="segments">The segments to truncate.</param>
+        /// <param name="maxWidth">The maximum width that the segments may occupy.</param>
+        /// <returns>A list of segments that has been truncated.</returns>
+        public static List<Segment> Truncate(RenderContext context, IEnumerable<Segment> segments, int maxWidth)
+        {
+            if (context is null)
+            {
+                throw new ArgumentNullException(nameof(context));
+            }
+
+            if (segments is null)
+            {
+                throw new ArgumentNullException(nameof(segments));
+            }
+
+            var result = new List<Segment>();
+
+            var totalWidth = 0;
+            foreach (var segment in segments)
+            {
+                var segmentWidth = segment.CellLength(context);
+                if (totalWidth + segmentWidth > maxWidth)
+                {
+                    break;
+                }
+
+                result.Add(segment);
+                totalWidth += segmentWidth;
+            }
+
+            if (result.Count == 0 && segments.Any())
+            {
+                var segment = Truncate(context, segments.First(), maxWidth);
+                if (segment != null)
+                {
+                    result.Add(segment);
+                }
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Truncates the segment to the specified width.
+        /// </summary>
+        /// <param name="context">The render context.</param>
+        /// <param name="segment">The segment to truncate.</param>
+        /// <param name="maxWidth">The maximum width that the segment may occupy.</param>
+        /// <returns>A new truncated segment, or <c>null</c>.</returns>
+        public static Segment? Truncate(RenderContext context, Segment segment, int maxWidth)
+        {
+            if (segment is null)
+            {
+                return null;
+            }
+
+            if (segment.CellLength(context) <= maxWidth)
+            {
+                return segment;
+            }
+
+            var builder = new StringBuilder();
+            foreach (var character in segment.Text)
+            {
+                if (Cell.GetCellLength(context, builder.ToString()) >= maxWidth)
+                {
+                    break;
+                }
+
+                builder.Append(character);
+            }
+
+            if (builder.Length == 0)
+            {
+                return null;
+            }
+
+            return new Segment(builder.ToString(), segment.Style);
+        }
+
         internal static Segment TruncateWithEllipsis(string text, Style style, RenderContext context, int maxWidth)
         {
             return SplitOverflow(
@@ -396,6 +445,46 @@ namespace Spectre.Console.Rendering
                 maxWidth)[0];
         }
 
+        internal static List<Segment> TruncateWithEllipsis(IEnumerable<Segment> segments, RenderContext context, int maxWidth)
+        {
+            if (CellLength(context, segments) <= maxWidth)
+            {
+                return new List<Segment>(segments);
+            }
+
+            segments = TrimEnd(Truncate(context, segments, maxWidth - 1));
+            if (!segments.Any())
+            {
+                return new List<Segment>(1);
+            }
+
+            var result = new List<Segment>(segments);
+            result.Add(new Segment("…", result.Last().Style));
+            return result;
+        }
+
+        internal static List<Segment> TrimEnd(IEnumerable<Segment> segments)
+        {
+            var stack = new Stack<Segment>();
+            var checkForWhitespace = true;
+            foreach (var segment in segments.Reverse())
+            {
+                if (checkForWhitespace)
+                {
+                    if (segment.IsWhiteSpace)
+                    {
+                        continue;
+                    }
+
+                    checkForWhitespace = false;
+                }
+
+                stack.Push(segment);
+            }
+
+            return stack.ToList();
+        }
+
         internal static List<List<SegmentLine>> MakeSameHeight(int cellHeight, List<List<SegmentLine>> cells)
         {
             foreach (var cell in cells)

src/Spectre.Console/Widgets/Columns.cs

@@ -66,10 +66,15 @@ namespace Spectre.Console
 
             var itemWidths = _items.Select(item => item.Measure(context, maxWidth).Max).ToArray();
             var columnCount = CalculateColumnCount(maxWidth, itemWidths, _items.Count, maxPadding);
+            if (columnCount == 0)
+            {
+                // Temporary work around for extremely small consoles
+                return new Measurement(maxWidth, maxWidth);
+            }
 
-            var rows = _items.Count / columnCount;
+            var rows = _items.Count / Math.Max(columnCount, 1);
             var greatestWidth = 0;
-            for (var row = 0; row < rows; row += columnCount)
+            for (var row = 0; row < rows; row += Math.Max(1, columnCount))
             {
                 var widths = itemWidths.Skip(row * columnCount).Take(columnCount).ToList();
                 var totalWidth = widths.Sum() + (maxPadding * (widths.Count - 1));
@@ -89,6 +94,11 @@ namespace Spectre.Console
 
             var itemWidths = _items.Select(item => item.Measure(context, maxWidth).Max).ToArray();
             var columnCount = CalculateColumnCount(maxWidth, itemWidths, _items.Count, maxPadding);
+            if (columnCount == 0)
+            {
+                // Temporary work around for extremely small consoles
+                columnCount = 1;
+            }
 
             var table = new Table();
             table.NoBorder();

src/Spectre.Console/Widgets/Paragraph.cs

@@ -138,7 +138,9 @@ namespace Spectre.Console
                 return Array.Empty<Segment>();
             }
 
-            var lines = SplitLines(context, maxWidth);
+            var lines = context.SingleLine
+                ? new List<SegmentLine>(_lines)
+                : SplitLines(context, maxWidth);
 
             // Justify lines
             var justification = context.Justification ?? Alignment ?? Justify.Left;
@@ -170,6 +172,11 @@ namespace Spectre.Console
                 }
             }
 
+            if (context.SingleLine)
+            {
+                return lines.First().Where(segment => !segment.IsLineBreak);
+            }
+
             return new SegmentLineEnumerator(lines);
         }
 

src/Spectre.Console/Widgets/Rule.cs

@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Spectre.Console.Internal;
+using Spectre.Console.Rendering;
+
+namespace Spectre.Console
+{
+    /// <summary>
+    /// A renderable horizontal rule.
+    /// </summary>
+    public sealed class Rule : Renderable, IAlignable
+    {
+        /// <summary>
+        /// Gets or sets the rule title markup text.
+        /// </summary>
+        public string? Title { get; set; }
+
+        /// <summary>
+        /// Gets or sets the rule style.
+        /// </summary>
+        public Style? Style { get; set; }
+
+        /// <summary>
+        /// Gets or sets the rule's title alignment.
+        /// </summary>
+        public Justify? Alignment { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Rule"/> class.
+        /// </summary>
+        public Rule()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Rule"/> class.
+        /// </summary>
+        /// <param name="title">The rule title markup text.</param>
+        public Rule(string title)
+        {
+            Title = title ?? throw new ArgumentNullException(nameof(title));
+        }
+
+        /// <inheritdoc/>
+        protected override IEnumerable<Segment> Render(RenderContext context, int maxWidth)
+        {
+            if (Title == null || maxWidth <= 6)
+            {
+                return GetLineWithoutTitle(maxWidth);
+            }
+
+            // Get the title and make sure it fits.
+            var title = GetTitleSegments(context, Title, maxWidth - 6);
+            if (Segment.CellLength(context, title) > maxWidth - 6)
+            {
+                // Truncate the title
+                title = Segment.TruncateWithEllipsis(title, context, maxWidth - 6);
+                if (!title.Any())
+                {
+                    // We couldn't fit the title at all.
+                    return GetLineWithoutTitle(maxWidth);
+                }
+            }
+
+            var (left, right) = GetLineSegments(context, maxWidth, title);
+
+            var segments = new List<Segment>();
+            segments.Add(left);
+            segments.AddRange(title);
+            segments.Add(right);
+            segments.Add(Segment.LineBreak);
+
+            return segments;
+        }
+
+        private IEnumerable<Segment> GetLineWithoutTitle(int maxWidth)
+        {
+            var text = new string('─', maxWidth);
+            return new[]
+            {
+                new Segment(text, Style ?? Style.Plain),
+                Segment.LineBreak,
+            };
+        }
+
+        private (Segment Left, Segment Right) GetLineSegments(RenderContext context, int maxWidth, IEnumerable<Segment> title)
+        {
+            var alignment = Alignment ?? Justify.Center;
+
+            var titleLength = Segment.CellLength(context, title);
+
+            if (alignment == Justify.Left)
+            {
+                var left = new Segment(new string('─', 2) + " ", Style ?? Style.Plain);
+
+                var rightLength = maxWidth - titleLength - left.CellLength(context) - 1;
+                var right = new Segment(" " + new string('─', rightLength), Style ?? Style.Plain);
+
+                return (left, right);
+            }
+            else if (alignment == Justify.Center)
+            {
+                var leftLength = ((maxWidth - titleLength) / 2) - 1;
+                var left = new Segment(new string('─', leftLength) + " ", Style ?? Style.Plain);
+
+                var rightLength = maxWidth - titleLength - left.CellLength(context) - 1;
+                var right = new Segment(" " + new string('─', rightLength), Style ?? Style.Plain);
+
+                return (left, right);
+            }
+            else if (alignment == Justify.Right)
+            {
+                var right = new Segment(" " + new string('─', 2), Style ?? Style.Plain);
+
+                var leftLength = maxWidth - titleLength - right.CellLength(context) - 1;
+                var left = new Segment(new string('─', leftLength) + " ", Style ?? Style.Plain);
+
+                return (left, right);
+            }
+
+            throw new NotSupportedException("Unsupported alignment.");
+        }
+
+        private IEnumerable<Segment> GetTitleSegments(RenderContext context, string title, int width)
+        {
+            title = title.NormalizeLineEndings().Replace("\n", " ").Trim();
+            var markup = new Markup(title, Style);
+            return ((IRenderable)markup).Render(context.WithSingleLine(), width - 6);
+        }
+    }
+}