teems 0.3.2 → 0.8.0

data/lib/teems/formatters/html_text.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Tag groups used by HtmlText
+    module HtmlTags
+      # Removed with their contents before conversion
+      DROPPED = %r{<(head|style|script|title|xml)\b[^>]*>.*?</\1\s*>}im
+      COMMENTS = /<!--.*?-->/m
+      TOKENS = /<[^>]*>|<|[^<]+/m
+      BLOCKS = %w[address article blockquote center dd div dl dt footer form h1 h2 h3 h4 h5 h6 header
+                  li ol section table tbody thead tfoot tr ul].freeze
+
+      module_function
+
+      # [name, closing?] for a tag token, or nil for anything that is not a tag
+      def parse(token)
+        match = token.match(%r{\A<\s*(/?)\s*([a-zA-Z][a-zA-Z0-9:-]*)})
+        match && [match[2].downcase, !match[1].empty?]
+      end
+
+      def attribute(token, name)
+        match = token.match(/\s#{name}\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i)
+        match && HtmlEntities.decode(match.captures.compact.first)
+      end
+    end
+
+    # Accumulates converted text, tracking line starts so block boundaries never stack up
+    # more newlines than asked for and indentation from source HTML never leaks in
+    class TextBuffer
+      ZERO_WIDTH = /[\u200b\u200c\u200d\u2060\ufeff\u034f\u00ad]/
+
+      def initialize
+        @out = +''
+      end
+
+      def <<(text)
+        @out << text
+        self
+      end
+
+      # Inline text with source whitespace collapsed; << keeps it as-is
+      def add_text(text)
+        collapsed = text.gsub(/[ \t\r\n\f]+/, ' ')
+        self << (line_start? ? collapsed.lstrip : collapsed)
+      end
+
+      def line_break
+        trim_line_end
+        self << "\n"
+      end
+
+      # At least count newlines at the end, without adding to ones already there
+      def ensure_newlines(count)
+        return self if @out.empty?
+
+        trim_line_end
+        missing = count - trailing_newlines(count)
+        missing.positive? ? self << ("\n" * missing) : self
+      end
+
+      def space
+        @out.end_with?(' ', "\n") || @out.empty? ? self : self << ' '
+      end
+
+      def line_start? = @out.empty? || @out.end_with?("\n")
+
+      def to_s
+        text = @out.tr("\u00a0", ' ').gsub(ZERO_WIDTH, '').gsub(/[ \t]+$/, '')
+        text.gsub(/\n{3,}/, "\n\n").sub(/\A\n+/, '').rstrip
+      end
+
+      private
+
+      # Both helpers look only at the end of the buffer. An end-anchored regex such as
+      # /[ \t]+\z/ is scanned from the start, which made long messages quadratic.
+      def trim_line_end
+        @out.chop! while @out.end_with?(' ', "\t")
+      end
+
+      # Newlines already at the end, counting no further than limit
+      def trailing_newlines(limit) = (1..limit).count { |run| @out.end_with?("\n" * run) }
+    end
+
+    # Converts an HTML mail body to plain text. Each anchor's text stays inline followed by
+    # a [N] marker, and the URLs are listed once each in a numbered "Links:" footer
+    # (SafeLinks unwrapped, click tracking dropped, mailto:/tel:/cid: skipped).
+    class HtmlText
+      # Converted text and its "Links:" footer ('' when there are no links)
+      Result = Data.define(:text, :footer) do
+        # Text with the footer appended after a blank line, or the text alone when there are no links
+        def to_s = footer.empty? ? text : "#{text}\n\n#{footer}"
+      end
+
+      OPEN_TAGS = {
+        'a' => :open_anchor, 'br' => :line_break, 'p' => :open_paragraph, 'li' => :open_list_item,
+        'img' => :image, 'hr' => :rule, 'pre' => :open_pre, 'td' => :cell, 'th' => :cell
+      }.freeze
+      CLOSE_TAGS = { 'a' => :close_anchor, 'br' => :line_break, 'p' => :close_paragraph, 'pre' => :close_pre }.freeze
+
+      def self.convert(html) = new.convert(html.to_s)
+
+      def initialize
+        @buffer = TextBuffer.new
+        @links = LinkCollector.new
+        # Preformatted text, and whether the open <p> is one of Outlook's one-line paragraphs
+        @state = { pre: false, outlook_paragraph: false }
+      end
+
+      def convert(html)
+        tokens(html).each { |token| token.start_with?('<') ? tag(token) : text(token) }
+        close_anchor
+        Result.new(text: @buffer.to_s, footer: @links.footer)
+      end
+
+      private
+
+      def tokens(html)
+        Support::ControlChars.strip(html.scrub('')).gsub(HtmlTags::COMMENTS, '').gsub(HtmlTags::DROPPED, '').scan(HtmlTags::TOKENS)
+      end
+
+      def tag(token)
+        name, closing = HtmlTags.parse(token)
+        return text(token) unless name
+
+        handler = (closing ? CLOSE_TAGS : OPEN_TAGS)[name]
+        return send(handler, token) if handler
+
+        @buffer.ensure_newlines(1) if HtmlTags::BLOCKS.include?(name)
+      end
+
+      def text(token)
+        chunk = HtmlEntities.decode(token)
+        @state[:pre] ? @buffer << chunk : @buffer.add_text(chunk)
+        @links.add_text(chunk)
+      end
+
+      def open_anchor(token)
+        href = HtmlTags.attribute(token, 'href')
+        href ? @links.start(href) : close_anchor
+      end
+
+      def close_anchor(_token = nil)
+        number = @links.finish
+        @buffer.space << "[#{number}]" if number
+      end
+
+      def line_break(_token) = @buffer.line_break
+
+      # Outlook writes every line as its own <p class=MsoNormal>, with &nbsp; paragraphs for
+      # blank lines, so those end with one newline; other paragraphs get a blank line.
+      def open_paragraph(token)
+        @state[:outlook_paragraph] = HtmlTags.attribute(token, 'class').to_s.match?(/\bMso/i)
+        @buffer.ensure_newlines(1)
+      end
+
+      def close_paragraph(_token) = @buffer.ensure_newlines(@state[:outlook_paragraph] ? 1 : 2)
+
+      def open_list_item(_token) = @buffer.ensure_newlines(1) << '- '
+
+      def image(token)
+        @links.add_alt(HtmlTags.attribute(token, 'alt').to_s) if @links.capturing?
+      end
+
+      def rule(_token) = @buffer.ensure_newlines(1) << "#{'_' * 32}\n"
+
+      def open_pre(_token) = pre(true)
+
+      def close_pre(_token) = pre(false)
+
+      def pre(enabled)
+        @buffer.ensure_newlines(1)
+        @state[:pre] = enabled
+      end
+
+      def cell(_token)
+        @buffer.space unless @buffer.line_start?
+      end
+    end
+  end
+end

data/lib/teems/formatters/ics_format.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Renders Models::IcsEvent objects as an RFC 5545 calendar for subscribing from
+    # Calendar.app and friends. The VEVENT layout follows the feed outlook-cli served,
+    # so a subscription keeps showing invitees, responses and Teams join buttons.
+    module IcsFormat
+      PRODID = '-//ericboehs//teems//EN'
+      PARTSTAT = { 'accepted' => 'ACCEPTED', 'organizer' => 'ACCEPTED', 'declined' => 'DECLINED',
+                   'tentativelyAccepted' => 'TENTATIVE' }.freeze
+      ROLE = { 'optional' => 'OPT-PARTICIPANT', 'resource' => 'NON-PARTICIPANT' }.freeze
+
+      module_function
+
+      def calendar(events, name:, stamp: Time.now)
+        dtstamp = utc(stamp)
+        vevents = events.select(&:dated?).flat_map { |event| vevent(event, dtstamp) }
+        lines = ['BEGIN:VCALENDAR', 'VERSION:2.0', "PRODID:#{PRODID}", 'CALSCALE:GREGORIAN', 'METHOD:PUBLISH',
+                 "X-WR-CALNAME:#{escape(name)}", *vevents, 'END:VCALENDAR']
+        "#{lines.map { |line| fold(line) }.join("\r\n")}\r\n"
+      end
+
+      def vevent(event, dtstamp)
+        ['BEGIN:VEVENT', "UID:#{uri(event.uid)}", "DTSTAMP:#{dtstamp}", *times(event),
+         "SUMMARY:#{escape(event.subject)}", *optional_text('LOCATION', event.location),
+         *people(event), *optional_text('DESCRIPTION', event.description), *join_lines(event.join_url),
+         *status_lines(event), 'END:VEVENT']
+      end
+
+      def times(event) = ["DTSTART#{time_value(event.starts)}", "DTEND#{time_value(event.ends)}"]
+
+      # All-day events have Dates, others UTC Times
+      def time_value(value) = value.is_a?(Date) ? ";VALUE=DATE:#{value.strftime('%Y%m%d')}" : ":#{utc(value)}"
+
+      def people(event)
+        organizer = Hash(event.organizer)
+        email = mail_address(organizer)
+        lines = email ? ["ORGANIZER;CN=#{common_name(organizer, email)}:mailto:#{email}"] : []
+        lines + event.attendees.filter_map { |attendee| attendee_line(attendee) }
+      end
+
+      def attendee_line(attendee)
+        email = mail_address(attendee)
+        return unless email
+
+        role = ROLE.fetch(attendee[:type].to_s, 'REQ-PARTICIPANT')
+        partstat = PARTSTAT.fetch(attendee[:response].to_s, 'NEEDS-ACTION')
+        "ATTENDEE;CN=#{common_name(attendee, email)};ROLE=#{role};PARTSTAT=#{partstat};RSVP=TRUE:mailto:#{email}"
+      end
+
+      # An address that makes a valid mailto: URI, or nil. Exchange-internal X.500 addresses
+      # (/O=EXCHANGELABS/...) have no @ and are left out with the people who have them.
+      def mail_address(person)
+        email = uri(person[:email]).strip
+        email.include?('@') ? email : nil
+      end
+
+      def common_name(person, email)
+        name = person[:name].to_s.strip
+        param(name.empty? ? email : name)
+      end
+
+      # URI values are not text-escaped. URL is what most clients show; CONFERENCE and the
+      # Microsoft property are what Calendar.app and Outlook look for to offer a Join button.
+      def join_lines(join_url)
+        url = uri(join_url)
+        return [] if url.empty?
+
+        ["URL;VALUE=URI:#{url}", %(CONFERENCE;VALUE=URI;FEATURE=AUDIO,VIDEO;LABEL="Microsoft Teams":#{url}),
+         "X-MICROSOFT-SKYPETEAMSMEETINGURL:#{url}"]
+      end
+
+      def status_lines(event)
+        [*('STATUS:CANCELLED' if event.cancelled?), *('TRANSP:TRANSPARENT' if event.free?)]
+      end
+
+      def optional_text(name, text) = text.to_s.strip.empty? ? [] : ["#{name}:#{escape(text)}"]
+
+      # Control characters RFC 5545 allows in no value: all but HTAB, once line breaks are handled
+      CONTROLS = /[\x00-\x08\x0A-\x1F\x7F]/
+
+      # RFC 5545 TEXT escaping
+      def escape(text)
+        text.to_s.gsub(/[\\;,]/) { |char| "\\#{char}" }.gsub(/\r\n|\r|\n/, '\\n').gsub(CONTROLS, '')
+      end
+
+      # UIDs, URIs and addresses are not escaped, so a line break in one would start a new
+      # property: control characters are dropped
+      def uri(value) = value.to_s.gsub(CONTROLS, '')
+
+      # Parameter values are quoted when they hold a separator; quotes themselves cannot appear
+      def param(value)
+        text = value.to_s.delete('"').gsub(/[\r\n]+/, ' ').gsub(CONTROLS, '')
+        text.match?(/[;:,]/) ? %("#{text}") : text
+      end
+
+      def utc(time) = time.utc.strftime('%Y%m%dT%H%M%SZ')
+
+      # Lines longer than 75 octets continue on lines starting with a space, never splitting a character
+      def fold(line)
+        parts = []
+        line.each_char do |char|
+          current = parts.last
+          fits = current && current.bytesize + char.bytesize <= (parts.one? ? 75 : 74)
+          fits ? current << char : parts << char
+        end
+        parts.join("\r\n ")
+      end
+    end
+  end
+end

data/lib/teems/formatters/link_cleaner.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Cleans the hrefs listed in a mail links footer. SafeLinks wrappers are unwrapped and
+    # click tracking is dropped (utm_* everywhere, plus SharePoint and Teams noise on
+    # SharePoint hosts). Every other query parameter is kept with its original encoding.
+    module LinkCleaner
+      SAFELINKS_HOSTS = %w[.safelinks.protection.outlook.com .safelinks.protection.office365.us].freeze
+      SHAREPOINT_HOSTS = %w[.sharepoint.com .sharepoint.us].freeze
+      # ASP.NET reads query keys case-insensitively, so these are matched that way too
+      SHAREPOINT_NOISE = %w[xsdata sdata ovuser clickparams teamscid ct linkopentime or].freeze
+      # Not web pages: mail and phone links, inline images, scripts
+      SKIP_SCHEMES = %w[mailto: tel: cid: javascript: data: sms: callto: about:].freeze
+      URL_PARTS = %r{\A(?<head>[a-z][a-z0-9+.-]*://(?<host>[^/?#]*)[^?#]*)(?:\?(?<query>[^#]*))?(?<frag>#.*)?\z}im
+
+      module_function
+
+      def skip?(href)
+        href.empty? || href.start_with?('#') || href.downcase.start_with?(*SKIP_SCHEMES)
+      end
+
+      def clean(href)
+        url = unwrap_safelinks(href.gsub(/[\t\r\n]/, '').strip)
+        drop_tracking(url).gsub(' ', '%20')
+      end
+
+      # SafeLinks wraps the real URL in its url param, sometimes more than once when a
+      # message has been forwarded around
+      def unwrap_safelinks(url)
+        5.times do
+          inner = safelinks_target(url)
+          break unless inner
+
+          url = inner
+        end
+        url
+      end
+
+      def safelinks_target(url)
+        parts = URL_PARTS.match(url)
+        return unless parts && host_of(parts).end_with?(*SAFELINKS_HOSTS)
+
+        URI.decode_www_form(parts[:query].to_s).assoc('url')&.last&.strip
+      rescue ArgumentError
+        nil
+      end
+
+      def drop_tracking(url)
+        parts = URL_PARTS.match(url)
+        query = parts&.[](:query)
+        return url if query.to_s.empty?
+
+        pairs = query.split('&', -1)
+        noise = host_of(parts).end_with?(*SHAREPOINT_HOSTS) ? SHAREPOINT_NOISE : []
+        kept = pairs.reject { |pair| tracking_param?(pair, noise) }
+        kept.length == pairs.length ? url : rebuild(parts, kept)
+      end
+
+      def tracking_param?(pair, noise)
+        name = unescape(pair.split('=', 2).first.to_s).downcase
+        pair.empty? || name.start_with?('utm_') || noise.include?(name)
+      end
+
+      def rebuild(parts, kept)
+        query = kept.empty? ? '' : "?#{kept.join('&')}"
+        "#{parts[:head]}#{query}#{parts[:frag]}"
+      end
+
+      # Link text that is a URL, or just repeats the start of this one, adds nothing.
+      # Compared without scheme, leading www. and trailing slashes.
+      def label(text, url, max:)
+        text = text.delete("\u200b\ufeff").gsub(/[[:space:]]+/, ' ').strip
+        return '' if text.empty? || text.match?(%r{\A(https?://|www\.)}i) || prefix_of_url?(text, url)
+
+        text.length > max ? "#{text[0, max - 3].rstrip}..." : text
+      end
+
+      def prefix_of_url?(text, url)
+        bare_text = bare(text)
+        bare_text.match?(%r{[./]}) && bare(url).start_with?(bare_text)
+      end
+
+      def bare(text) = text.downcase.sub(%r{\A([a-z][a-z0-9+.-]*://)?(www\.)?}, '').sub(%r{/+\z}, '')
+
+      def host_of(parts) = parts[:host].sub(/\A.*@/, '').sub(/:\d*\z/, '').downcase
+
+      def unescape(text) = text.gsub(/%(\h\h)/) { Regexp.last_match(1).hex.chr }
+    end
+  end
+end

data/lib/teems/formatters/link_collector.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Collects the anchors of an HTML body, one entry per cleaned URL, numbered by first
+    # appearance. A later anchor for the same URL supplies the label when the first had none.
+    class LinkCollector
+      LABEL_MAX = 80
+
+      def initialize
+        @links = {}
+        # Each URL's footer number, kept when it is first added
+        @numbers = {}
+        @current = nil
+      end
+
+      def links = @links.to_a
+
+      def empty? = @links.empty?
+
+      def capturing? = @current.is_a?(Hash)
+
+      def start(href)
+        finish
+        @current = { href: href, text: +'', alt: [] }
+      end
+
+      def add_text(text)
+        @current[:text] << text if @current
+      end
+
+      def add_alt(alt)
+        @current[:alt] << alt if @current && !alt.empty?
+      end
+
+      # Ends the current anchor; returns its footer number, or nil when it is not listed
+      def finish
+        current = @current
+        return unless current
+
+        @current = nil
+        register(current[:href].strip, anchor_text(current))
+      end
+
+      def footer
+        return '' if empty?
+
+        lines = links.each.with_index(1).map do |(url, label), number|
+          label.empty? ? "[#{number}] #{url}" : "[#{number}] #{label} <#{url}>"
+        end
+        ['Links:', *lines].join("\n")
+      end
+
+      private
+
+      def anchor_text(current)
+        text = current[:text]
+        text.strip.empty? ? current[:alt].join(' ') : text
+      end
+
+      def register(href, text)
+        return if LinkCleaner.skip?(href)
+
+        url = LinkCleaner.clean(href)
+        @links[url] = LinkCleaner.label(text, url, max: LABEL_MAX) if @links.fetch(url, '').empty?
+        @numbers[url] ||= @numbers.size + 1
+      end
+    end
+  end
+end

data/lib/teems/formatters/mail_formatter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Date styles shared by mail output
+    module MailDates
+      module_function
+
+      # The style Outlook for Mac printed, kept for `read` headers and synced Markdown
+      def long(time) = time ? time.getlocal.strftime('%A, %B %-d, %Y at %-I:%M:%S %p') : ''
+
+      def short(time) = time ? time.getlocal.strftime('%Y-%m-%d %H:%M') : ''
+
+      def iso(time) = time ? time.getlocal.iso8601 : ''
+    end
+
+    # Terminal output for `teems mail` (TSV rows come from the models)
+    class MailFormatter
+      FROM_WIDTH = 24
+      SUBJECT_WIDTH = 70
+
+      def initialize(output:)
+        @output = output
+      end
+
+      # id, received (local), from, subject, read flag
+      def message_rows(messages) = messages.map { |message| message_row(message) }
+
+      # message_rows plus each message's folder, which lines up after the read/unread column
+      def thread_rows(conversation)
+        conversation.messages.map do |message|
+          padding = message.read? ? '    ' : '  '
+          "#{message_row(message)}#{padding}#{@output.gray(conversation.folder(message).to_s)}"
+        end
+      end
+
+      def folder_rows(folders)
+        width = folders.map { |folder| folder.path.length }.push(6).max
+        header = @output.bold("#{'FOLDER'.ljust(width)}  #{'UNREAD'.rjust(6)}  #{'TOTAL'.rjust(7)}")
+        [header, *folders.collect { |folder| folder_row(folder, width) }]
+      end
+
+      private
+
+      def message_row(message)
+        short_id, received, from, subject = message.list_columns
+        from = FormatUtils.truncate(from, FROM_WIDTH - 3).ljust(FROM_WIDTH)
+        row = "#{@output.cyan(short_id)}  #{received}  #{from}  #{FormatUtils.truncate(subject, SUBJECT_WIDTH)}"
+        row = message.read? ? "#{row}  #{@output.gray('read')}" : @output.bold("#{row}  unread")
+        message.flagged ? "#{row}  #{@output.yellow('flagged')}" : row
+      end
+
+      def folder_row(folder, width)
+        "#{folder.path.ljust(width)}  #{folder.unread_count.to_s.rjust(6)}  #{folder.total_count.to_s.rjust(7)}"
+      end
+    end
+  end
+end

data/lib/teems/formatters/mail_markdown.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Renders a synced mail message as Markdown with YAML frontmatter. The fields and layout
+    # follow the files outlook-cli wrote to ~/Mail, so md2maildir and search indexes keep working.
+    class MailMarkdown
+      SLUG_MAX = 80
+
+      def self.filename(message)
+        date = message.received_at&.getlocal&.strftime('%Y-%m-%d') || 'unknown-date'
+        slug = message.subject.unicode_normalize(:nfkc).gsub(/[^[:alnum:]]+/, '-')[0, SLUG_MAX].gsub(/\A-+|-+\z/, '')
+        "#{date}-#{slug.empty? ? 'no-subject' : slug}-#{message.short_id}.md"
+      end
+
+      def self.render(message, folder:, attachments: []) = new(message, folder, attachments).render
+
+      def initialize(message, folder, attachments)
+        @message = message
+        @folder = folder
+        @attachments = attachments
+      end
+
+      def render
+        [frontmatter, '', "# #{@message.subject}", '', "**From:** #{@message.from_display}",
+         "**To:** #{addresses(@message.to)}", "**Date:** #{MailDates.long(@message.received_at)}",
+         '', '---', '', *protection_lines, "#{@message.text_body}\n"].join("\n")
+      end
+
+      private
+
+      def frontmatter
+        fields = { 'id' => @message.id, **quoted_fields, 'status' => @message.status.downcase,
+                   'attachments' => quote(@attachments.join(', ')),
+                   'internet_message_id' => quote(@message.internet_message_id), **protection_field }
+        ['---', *fields.map { |key, value| "#{key}: #{value}" }, '---'].join("\n")
+      end
+
+      def quoted_fields
+        received = @message.received_at
+        fields = { 'subject' => @message.subject, 'from' => @message.from_display, 'to' => addresses(@message.to),
+                   'cc' => addresses(@message.cc), 'date' => MailDates.long(received),
+                   'received' => MailDates.iso(received), 'folder' => @folder,
+                   'categories' => @message.categories.join(', ') }
+        fields.transform_values { |value| quote(value) }
+      end
+
+      # Protected mail only, so files of plain mail stay as outlook-cli wrote them
+      def protection_field
+        kind = @message.protection
+        kind ? { 'protection' => quote(kind) } : {}
+      end
+
+      # A note above the body of protected mail, whose body is empty or Microsoft's placeholder;
+      # Purview mail's links to Outlook on the web, which opens it
+      def protection_lines
+        note = @message.protection_note
+        return [] unless note
+
+        link = @message.protection == 'purview' && @message.web_link
+        [link ? "> #{note}: <#{link}>" : "> #{note}", '']
+      end
+
+      def addresses(list) = list.map { |entry| entry[:address] }.reject(&:empty?).join(', ')
+
+      # JSON strings are valid YAML double-quoted scalars
+      def quote(value) = JSON.generate(value.to_s)
+    end
+  end
+end

data/lib/teems/formatters/mail_rule_formatter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # `teems mail rules` output: a table, TSV, or JSON, each with MailRuleText's description
+    class MailRuleFormatter
+      NAME_WIDTH = 30
+
+      # folder_names: Graph folder ID => path, to name where a rule moves mail
+      def initialize(output:, folder_names: {})
+        @output = output
+        @text = MailRuleText.new(folder_names)
+      end
+
+      def describe(rule) = @text.describe(rule)
+
+      def rows(rules)
+        width = name_width(rules)
+        rules.map { |rule| row(rule, width) }
+      end
+
+      def tsv_rows(rules) = rules.map { |rule| rule.tsv_row(describe(rule)) }
+
+      def json(rules) = rules.map { |rule| rule.to_json_hash(describe(rule)) }
+
+      private
+
+      def name_width(rules) = rules.map { |rule| rule.name.length }.max.to_i.clamp(..NAME_WIDTH)
+
+      def row(rule, width)
+        number, state, name = rule.columns
+        "#{number.to_s.rjust(3)}  #{state_text(state)}  #{name[0, width].ljust(width)}  #{describe(rule)}"
+      end
+
+      def state_text(state)
+        padded = state.ljust(5)
+        case state
+        when 'on' then @output.green(padded)
+        when 'off' then @output.gray(padded)
+        else @output.red(padded)
+        end
+      end
+    end
+  end
+end