teems 0.3.3 → 0.8.0

data/lib/teems/commands/meet.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Teems
+  module Commands
+    MEET_HELP = <<~HELP
+      teems meet - Start a Teams meeting and print its join link
+
+      USAGE:
+        teems meet [minutes] [options]
+
+      Puts a Teams meeting on your calendar, starting now for 30 minutes unless told
+      otherwise, prints its join link (alone on stdout, so it pipes) and opens it here
+      to join. With nobody invited, nothing is sent.
+
+      Joining here matters: people from organizations yours does not trust wait in the
+      lobby until a member of yours joins, even with "Everyone" set to bypass the lobby
+      in Meeting options, and even when invited. Once you are in you can admit them;
+      the meeting usually carries on after you leave.
+
+      OPTIONS:
+        --at TIME            Start: now (default), HH:MM, "today HH:MM",
+                             "tomorrow HH:MM", or "YYYY-MM-DD HH:MM"
+        --title TEXT         Event title (default: Meet now)
+        --with EMAILS        Comma-separated people to invite. Exchange emails
+                             each an invitation, so this asks first
+        -y, --yes            Invite without asking (needed without a terminal)
+        --copy               Also copy the link to the clipboard
+        --no-open            Do not open the link here (just print it)
+        -q, --quiet          Just the link
+        --json               Event ID, title, start, end and link as JSON
+
+      EXAMPLES:
+        teems meet                         # Now, 30 minutes, and join here
+        teems meet 60 --title "Pairing"    # Now, an hour
+        teems meet --copy                  # Also copy the link
+        teems meet --no-open | pbcopy      # Just the link, for someone else
+        teems meet --at 14:30 --with alice@example.com
+    HELP
+
+    # `teems meet`: a calendar event with a Teams meeting, starting now by default, and
+    # its join link. Calendars.ReadWrite is enough for that, where creating a bare online
+    # meeting would need OnlineMeetings.ReadWrite.
+    class Meet < Base
+      include Support::Timezone
+      include Support::TimeParsing
+      include Confirmation
+
+      DEFAULT_MINUTES = 30
+      MAX_MINUTES = 24 * 60
+      VALUE_OPTIONS = { '--at' => :at, '--title' => :title, '--with' => :with }.freeze
+      # --open is the default; it is still accepted, so scripts that pass it keep working
+      FLAGS = { '--copy' => :copy, '--open' => :open, '--no-open' => :no_open, '--yes' => :yes, '-y' => :yes }.freeze
+
+      def initialize(args, runner:)
+        @options = {}
+        super
+      end
+
+      def execute
+        validation = validate_options
+        return validation if validation
+
+        auth = require_auth
+        return auth if auth
+
+        with_token_refresh { create_meeting }
+      rescue ApiError => e
+        api_error_result('Could not create the meeting', e)
+      rescue Teems::Error => e
+        error(e.message)
+      end
+
+      protected
+
+      def handle_option(arg, pending)
+        return @options[FLAGS[arg]] = true if FLAGS.key?(arg)
+        return super unless VALUE_OPTIONS.key?(arg)
+
+        @options[VALUE_OPTIONS[arg]] = pending.shift
+      end
+
+      def help_text = MEET_HELP
+
+      private
+
+      def create_meeting
+        start = start_time
+        finish = start + (minutes * 60)
+        return error('Cancelled; no meeting created') unless invite_confirmed?
+
+        event = runner.calendar_api.create_event(event_body(start, finish))
+        link = event.online_meeting_url or raise Error, 'Graph created the event but gave no Teams link'
+        report(event, link, start..finish)
+      end
+
+      def minutes
+        given = positional_args.first
+        return DEFAULT_MINUTES unless given
+
+        count = Integer(given, 10, exception: false)
+        raise Error, "Minutes must be a whole number from 1 to #{MAX_MINUTES}" unless count&.between?(1, MAX_MINUTES)
+
+        count
+      end
+
+      def start_time
+        given = @options[:at] || 'now'
+        parse_time_input(given) or raise Error, "Unknown time: #{given} (use now, HH:MM, \"tomorrow HH:MM\", ...)"
+      end
+
+      def invitees = @options[:with].to_s.split(',').map(&:strip).reject(&:empty?)
+
+      # Inviting people sends them mail, so it needs a yes (at the prompt, or --yes)
+      def invite_confirmed?
+        people = invitees
+        return true if people.empty? || @options[:yes]
+
+        confirm?("Invite #{people.join(', ')} (Exchange emails each an invitation)",
+                 refusal: 'Inviting people sends them email; pass --yes to go ahead')
+      end
+
+      def event_body(start, finish)
+        zone = detect_timezone
+        { subject: @options[:title] || 'Meet now', isOnlineMeeting: true, onlineMeetingProvider: 'teamsForBusiness',
+          start: { dateTime: graph_time(start), timeZone: zone }, end: { dateTime: graph_time(finish), timeZone: zone },
+          attendees: invitees.map { |address| { emailAddress: { address: address }, type: 'required' } },
+          transactionId: SecureRandom.uuid }
+      end
+
+      # On stderr, beside the link on stdout; -q leaves just the link
+      def note(message) = @options[:quiet] || output.note(message)
+
+      def graph_time(time) = time.strftime('%Y-%m-%dT%H:%M:%S')
+
+      def report(event, link, times)
+        return json_report(event, link, times) if @options[:json]
+
+        output.puts(link)
+        note("#{event.subject}, #{times.begin.strftime('%-I:%M')}-#{times.end.strftime('%-I:%M %p')}")
+        hand_off(link)
+        0
+      end
+
+      def json_report(event, link, times)
+        hand_off(link)
+        output_json(id: event.id, title: event.subject, start: times.begin.iso8601, end: times.end.iso8601,
+                    join_url: link)
+        0
+      end
+
+      def hand_off(link)
+        runner.clipboard.copy(link) && note('Copied the link') if @options[:copy]
+        runner.browser.open(link) && note('Opened it to join') unless @options[:no_open]
+      end
+    end
+  end
+end

data/lib/teems/commands/sync.rb

@@ -13,7 +13,9 @@ module Teems
         --chat CHAT_ID   Sync only this chat
         --images         Also download inline (pasted) images into each chat's images/ dir
         --auth           Authenticate via Safari before syncing
-        --dry-run        Show what would be synced without writing files
+        --dry-run        Show what would be synced and every folder change, without writing anything
+        --migrate-dirs   Also rename existing chat folders to "<name> (<chat ID>)" and write
+                         a map of old to new paths (sync/dir-maps/)
         -v, --verbose    Show debug output
         -q, --quiet      Suppress output
 
@@ -23,11 +25,13 @@ module Teems
         teems sync --chat 19:abc@thread.v2 # Sync a single chat
         teems sync --images                # Include pasted screenshots
         teems sync --dry-run               # Preview what would be synced
+        teems sync --dry-run --migrate-dirs # Preview renaming every folder
 
       OUTPUT:
         Files are stored in ~/.local/share/teems/sync/chats/
         Each chat gets: messages.md, messages.json, chat_metadata.json
         (plus images/ with --images; messages.md links saved images, otherwise [image: ...])
+        New chats get a "<name> (<chat ID>)" folder; existing folders keep their names.
     HELP
 
     # Handles syncing individual chats: fetch, merge, retry on 404
@@ -62,10 +66,7 @@ module Teems
       end
 
       def sync_single_chat(chat)
-        @sync_store.ensure_dir_name(
-          @state, chat_info: { chat_id: chat.id, display_name: chat.display_name,
-                               chat_type: chat.chat_type }
-        )
+        report_dir_move(@sync_store.ensure_chat_dir(@state, chat_info: dir_info(chat)))
         new_messages = fetch_new_messages(chat)
         debug("  Fetched #{new_messages.length} new message(s)")
         process_fetched_messages(chat, new_messages)
@@ -82,7 +83,7 @@ module Teems
 
       def fetch_new_messages(chat)
         chat_id = chat.id
-        start_time = @sync_store.last_synced_time(@state, chat_id) || since_time
+        start_time = @sync_store.last_synced_time(@state, chat_id) || resync_start(@state, chat_id)
         with_token_refresh { sync_engine.fetch_all_messages(chat_id, start_time) }
       end
 
@@ -198,12 +199,13 @@ module Teems
       def show_dry_run(chats)
         syncable = chats.reject { |chat| skip_reason(chat['id']) }
         display_dry_run_list(chats.length - syncable.length, syncable)
+        show_dir_plan(syncable)
+        0
       end
 
       def display_dry_run_list(skipped_count, syncable)
         display_dry_run_header(skipped_count, syncable.length)
         syncable.each { |chat| format_dry_run_chat(chat) }
-        0
       end
 
       def display_dry_run_header(skipped, syncable_count)
@@ -228,6 +230,7 @@ module Teems
         success('Sync complete!')
         show_summary_stats
         info("  Output: #{@sync_store.sync_dir}")
+        show_folder_summary
       end
 
       def show_summary_stats
@@ -315,6 +318,7 @@ module Teems
       include SyncImageHandler
       include SyncDisplay
       include SyncAuth
+      include SyncFolders
 
       DEFAULT_SINCE_DAYS = 180
       SKIP_PREFIXES = %w[48:].freeze
@@ -345,6 +349,7 @@ module Teems
         '--chat' => ->(opts, args) { opts[:chat_id] = args.shift },
         '--dry-run' => ->(opts, _args) { opts[:dry_run] = true },
         '--images' => ->(opts, _args) { opts[:images] = true },
+        '--migrate-dirs' => ->(opts, _args) { opts[:migrate_dirs] = true },
         '--auth' => ->(opts, _args) { opts[:auth] = true }
       }.freeze
 
@@ -369,6 +374,7 @@ module Teems
       end
 
       def sync_all_chats(chats)
+        detach_shared_dirs
         chats.each_with_index { |chat_data, index| sync_or_skip_chat(chat_data, "[#{index + 1}/#{chats.length}]") }
         save_state_safely
         show_summary
@@ -404,7 +410,8 @@ module Teems
         error("Warning: Failed to save sync state: #{e.message}")
       end
 
-      def since_time = Time.now - ((@options[:since_days] || DEFAULT_SINCE_DAYS) * 86_400)
+      def since_days = @options[:since_days] || DEFAULT_SINCE_DAYS
+      def since_time = Time.now - (since_days * 86_400)
 
       def setup_api_logging
         out = output

data/lib/teems/commands/sync_folders.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    # Chat folder changes made by sync: detaching shared folders, moving folders, listing old
+    # shared folders still on disk, and previewing all of it for --dry-run
+    module SyncFolders
+      # How each kind of folder change is described; :split is described by split_note, and :new
+      # and :kept aren't reported
+      MOVE_NOTES = {
+        move: '',
+        retarget: ' (the old folder is already gone)',
+        repoint: ' (the new folder already exists: switching to it, the old folder is left in place)',
+        release: " (the old folder also holds another chat's messages and is left in place)"
+      }.freeze
+
+      private
+
+      def dir_info(chat) = { **chat.sync_identity, migrate: @options[:migrate_dirs] }
+
+      # sync --chat X only detaches X, so the other chats keep their cursors until they sync
+      def detach_shared_dirs
+        detached = @sync_store.detach_shared_dirs(@state, only: @options[:chat_id])
+        @detached_dirs = detached.keys
+        warn_shared_dirs(detached)
+      end
+
+      def warn_shared_dirs(shared)
+        return if shared.empty?
+
+        warn([shared_dirs_intro(shared), *dir_lines(shared), shared_dirs_plan].join("\n"))
+      end
+
+      def shared_dirs_intro(shared)
+        "#{shared.length} folder(s) in #{File.join(@sync_store.sync_dir, 'chats')} mix messages from " \
+          'several chats (an older teems gave those chats the same folder name):'
+      end
+
+      def shared_dirs_plan
+        'These folders are left as they are. Each affected chat now syncs to its own folder, re-fetching ' \
+          'history back to the oldest message in the old folder. Older history may still exist only in the ' \
+          "old folders, so keep them until you've checked the new ones."
+      end
+
+      def dir_lines(dirs) = dirs.map { |path, ids| "  #{path} (#{ids.length} chat#{'s' unless ids.one?})" }
+
+      def report_dir_move(move)
+        line = dir_move_line(move, @state)
+        return unless line
+
+        (@dir_moves ||= []) << move
+        move.kind == :repoint ? warn("  Folder: #{line}") : info("  Folder: #{line}")
+      end
+
+      def dir_move_line(move, state)
+        note = move_note(move.to_h, state)
+        "#{move}#{note}" if note
+      end
+
+      def move_note(move_attrs, state)
+        kind, chat_id = move_attrs.values_at(:kind, :chat_id)
+        return MOVE_NOTES[kind] unless kind == :split
+
+        start = resync_start(state, chat_id).strftime('%Y-%m-%d')
+        " (split from a shared folder, which is left in place; re-fetching from #{start})"
+      end
+
+      # A detached chat re-syncs from the oldest message in its old folder, or --since if earlier
+      def resync_start(state, chat_id) = [@sync_store.resync_from(state, chat_id), since_time].compact.min
+
+      def show_folder_summary
+        write_dir_map
+        show_legacy_dirs(@detached_dirs)
+      end
+
+      def write_dir_map
+        moves = @dir_moves
+        return unless @options[:migrate_dirs] && moves
+
+        info("  Folder map: #{@sync_store.write_dir_map(moves)}")
+      end
+
+      def show_legacy_dirs(exclude)
+        legacy = @sync_store.legacy_shared_dirs(@state).except(*exclude)
+        return if legacy.empty?
+
+        info("Old shared folders still on disk (they may hold history the new folders don't):\n" \
+             "#{dir_lines(legacy).join("\n")}")
+      end
+
+      # Plans on a copy of the state, so nothing changes on disk or in sync_state.json
+      def show_dir_plan(syncable)
+        plan = JSON.parse(JSON.generate(@state))
+        detached = @sync_store.detach_shared_dirs(plan, only: @options[:chat_id])
+        lines = syncable.filter_map do |chat_data|
+          dir_move_line(@sync_store.plan_chat_dir(plan, dir_info(Models::Chat.from_api(chat_data))), plan)
+        end
+        show_planned_moves(lines)
+        show_planned_detaches(detached)
+        show_legacy_dirs([])
+      end
+
+      def show_planned_moves(lines)
+        puts
+        return info('Folder changes: none') if lines.empty?
+
+        info("Folder changes (#{lines.length}):\n#{lines.map { |line| "  #{line}" }.join("\n")}")
+      end
+
+      def show_planned_detaches(detached)
+        return if detached.empty?
+
+        info("Shared folders that would be detached (#{detached.length}):\n" \
+             "#{dir_lines(detached).join("\n")}\n#{shared_dirs_plan}")
+      end
+    end
+  end
+end

data/lib/teems/formatters/format_utils.rb

@@ -4,6 +4,13 @@ module Teems
   module Formatters
     # Shared stateless formatting utilities used across commands and formatters
     module FormatUtils
+      # Longest file name most filesystems allow, in bytes
+      NAME_MAX = 255
+      # Names File.basename can return that are not a file in the directory
+      UNSAFE_NAMES = ['', '.', '..', '/'].freeze
+      # Longer "extensions" are just dots in a long name, and are cut with the rest of it
+      MAX_EXTENSION = 16
+
       module_function
 
       def truncate(text, max = 120)
@@ -17,9 +24,23 @@ module Teems
         end
       end
 
+      # A name safe to join onto a directory: no path or control characters, not "." or "..",
+      # and short enough for the filesystem (keeping the extension when it has to be cut)
       def safe_filename(name)
-        base = File.basename(name)
-        base.empty? ? 'file' : base
+        base = File.basename(name.to_s.scrub('').gsub(/[[:cntrl:]]/, ''))
+        UNSAFE_NAMES.include?(base) ? 'file' : fit_filename(base)
+      end
+
+      def fit_filename(base)
+        return base if base.bytesize <= NAME_MAX
+
+        ext = kept_extension(base)
+        "#{base.delete_suffix(ext).byteslice(0, NAME_MAX - ext.bytesize).scrub('')}#{ext}"
+      end
+
+      def kept_extension(base)
+        ext = File.extname(base)
+        ext.bytesize > MAX_EXTENSION ? '' : ext
       end
 
       def attachment_name(att)

data/lib/teems/formatters/html_entities.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Decodes the HTML character references found in mail bodies
+    module HtmlEntities
+      ENTITY = /&(?:#(\d{1,7})|#[xX](\h{1,6})|([a-zA-Z][a-zA-Z0-9]{1,31}));?/
+      NAMED = {
+        'amp' => '&', 'lt' => '<', 'gt' => '>', 'quot' => '"', 'apos' => "'", 'nbsp' => "\u00a0",
+        'ensp' => "\u2002", 'emsp' => "\u2003", 'thinsp' => "\u2009", 'zwnj' => "\u200c", 'zwj' => "\u200d",
+        'shy' => "\u00ad", 'ndash' => "\u2013", 'mdash' => "\u2014", 'lsquo' => "\u2018", 'rsquo' => "\u2019",
+        'sbquo' => "\u201a", 'ldquo' => "\u201c", 'rdquo' => "\u201d", 'bdquo' => "\u201e",
+        'hellip' => "\u2026", 'bull' => "\u2022", 'middot' => "\u00b7", 'copy' => "\u00a9", 'reg' => "\u00ae",
+        'trade' => "\u2122", 'deg' => "\u00b0", 'times' => "\u00d7", 'divide' => "\u00f7",
+        'laquo' => "\u00ab", 'raquo' => "\u00bb", 'euro' => "\u20ac", 'pound' => "\u00a3", 'cent' => "\u00a2",
+        'yen' => "\u00a5", 'sect' => "\u00a7", 'para' => "\u00b6", 'plusmn' => "\u00b1", 'micro' => "\u00b5",
+        'frac12' => "\u00bd", 'frac14' => "\u00bc", 'frac34' => "\u00be", 'rarr' => "\u2192",
+        'larr' => "\u2190", 'uarr' => "\u2191", 'darr' => "\u2193", 'iexcl' => "\u00a1", 'iquest' => "\u00bf"
+      }.freeze
+
+      module_function
+
+      def decode(text)
+        return text unless text.include?('&')
+
+        text.gsub(ENTITY) do
+          dec, hex, name = Regexp.last_match.captures
+          name ? NAMED.fetch(name, Regexp.last_match(0)) : codepoint((dec || hex.to_i(16)).to_i)
+        end
+      end
+
+      # Like browsers, 0x80-0x9F mean their Windows-1252 characters (&#146; is a right quote).
+      # Other control characters decode to nothing (see Support::ControlChars).
+      def codepoint(number)
+        return windows_char(number) if number.between?(0x80, 0x9F)
+        return '' if number.between?(0xD800, 0xDFFF) || number > 0x10FFFF
+
+        Support::ControlChars.strip([number].pack('U'))
+      end
+
+      # '' for the five bytes Windows-1252 leaves undefined
+      def windows_char(number)
+        number.chr.force_encoding(Encoding::Windows_1252).encode(Encoding::UTF_8)
+      rescue EncodingError
+        ''
+      end
+    end
+  end
+end

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