rdoc 6.17.0 → 7.2.0

data/lib/rdoc/markup/table.rb

@@ -1,52 +1,60 @@
 # frozen_string_literal: true
-##
-# A section of table
 
-class RDoc::Markup::Table
-  # headers of each column
-  attr_accessor :header
+module RDoc
+  class Markup
+    # A section of table
+    class Table < Element
+      # Headers of each column
+      #: Array[String]
+      attr_accessor :header
 
-  # alignments of each column
-  attr_accessor :align
+      # Alignments of each column
+      #: Array[Symbol?]
+      attr_accessor :align
 
-  # body texts of each column
-  attr_accessor :body
+      # Body texts of each column
+      #: Array[String]
+      attr_accessor :body
 
-  # Creates new instance
-  def initialize(header, align, body)
-    @header, @align, @body = header, align, body
-  end
-
-  # :stopdoc:
-  def ==(other)
-    self.class == other.class and
-      @header == other.header and
-      @align == other.align and
-      @body == other.body
-  end
+      #: (Array[String], Array[Symbol?], Array[String]) -> void
+      def initialize(header, align, body)
+        @header, @align, @body = header, align, body
+      end
 
-  def accept(visitor)
-    visitor.accept_table @header, @body, @align
-  end
+      #: (Object) -> bool
+      def ==(other)
+        self.class == other.class && @header == other.header &&
+          @align == other.align && @body == other.body
+      end
 
-  def pretty_print(q)
-    q.group 2, '[Table: ', ']' do
-      q.group 2, '[Head: ', ']' do
-        q.seplist @header.zip(@align) do |text, align|
-          q.pp text
-          if align
-            q.text ":"
-            q.breakable
-            q.text align.to_s
-          end
-        end
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_table(@header, @body, @align)
       end
-      q.breakable
-      q.group 2, '[Body: ', ']' do
-        q.seplist @body do |body|
-          q.group 2, '[', ']' do
-            q.seplist body do |text|
+
+      # @override
+      #: (untyped) -> String
+      def pretty_print(q)
+        q.group 2, '[Table: ', ']' do
+          q.group 2, '[Head: ', ']' do
+            q.seplist @header.zip(@align) do |text, align|
               q.pp text
+              if align
+                q.text ":"
+                q.breakable
+                q.text align.to_s
+              end
+            end
+          end
+          q.breakable
+          q.group 2, '[Body: ', ']' do
+            q.seplist @body do |body|
+              q.group 2, '[', ']' do
+                q.seplist body do |text|
+                  q.pp text
+                end
+              end
             end
           end
         end

data/lib/rdoc/markup/to_ansi.rb

@@ -19,10 +19,57 @@ class RDoc::Markup::ToAnsi < RDoc::Markup::ToRdoc
   ##
   # Maps attributes to ANSI sequences
 
-  def init_tags
-    add_tag :BOLD, "\e[1m", "\e[m"
-    add_tag :TT,   "\e[7m", "\e[m"
-    add_tag :EM,   "\e[4m", "\e[m"
+  ANSI_STYLE_CODES_ON = {
+    BOLD: 1,
+    TT: 7,
+    EM: 4,
+    STRIKE: 9
+  }
+
+  ANSI_STYLE_CODES_OFF = {
+    BOLD: 22,
+    TT: 27,
+    EM: 24,
+    STRIKE: 29
+  }
+
+  # Apply the given attributes by emitting ANSI sequences.
+  # Emitting attribute changes are deferred until new text is added and applied in batch.
+  # This method computes the necessary ANSI codes to transition from the
+  # current set of applied attributes to the new set of +attributes+.
+
+  def apply_attributes(attributes)
+    before = @applied_attributes
+    after = attributes.sort
+    return if before == after
+
+    if after.empty?
+      emit_inline("\e[m")
+    elsif !before.empty? && before.size > (before & after).size + 1
+      codes = after.map {|attr| ANSI_STYLE_CODES_ON[attr] }.compact
+      emit_inline("\e[#{[0, *codes].join(';')}m")
+    else
+      off_codes = (before - after).map {|attr| ANSI_STYLE_CODES_OFF[attr] }.compact
+      on_codes = (after - before).map {|attr| ANSI_STYLE_CODES_ON[attr] }.compact
+      emit_inline("\e[#{(off_codes + on_codes).join(';')}m")
+    end
+    @applied_attributes = attributes
+  end
+
+  def add_text(text)
+    attrs = @attributes.keys
+    if @applied_attributes != attrs
+      apply_attributes(attrs)
+    end
+    emit_inline(text)
+  end
+
+  def handle_inline(text)
+    @applied_attributes = []
+    res = super
+    res << "\e[m" unless @applied_attributes.empty?
+    @applied_attributes = []
+    res
   end
 
   ##

data/lib/rdoc/markup/to_bs.rb

@@ -17,14 +17,29 @@ class RDoc::Markup::ToBs < RDoc::Markup::ToRdoc
     @in_em = false
   end
 
-  ##
-  # Sets a flag that is picked up by #annotate to do the right thing in
-  # #convert_string
+  def handle_inline(text)
+    initial_style = []
+    initial_style << :BOLD if @in_b
+    initial_style << :EM   if @in_em
+    super(text, initial_style)
+  end
 
-  def init_tags
-    add_tag :BOLD, '+b', '-b'
-    add_tag :EM,   '+_', '-_'
-    add_tag :TT,   '', ''   # we need in_tt information maintained
+  def add_text(text)
+    attrs = @attributes.keys
+    if attrs.include? :BOLD
+      styled = +''
+      text.chars.each do |c|
+        styled << "#{c}\b#{c}"
+      end
+      text = styled
+    elsif attrs.include? :EM
+      styled = +''
+      text.chars.each do |c|
+        styled << "_\b#{c}"
+      end
+      text = styled
+    end
+    emit_inline(text)
   end
 
   ##
@@ -68,39 +83,4 @@ class RDoc::Markup::ToBs < RDoc::Markup::ToRdoc
   def calculate_text_width(text)
     text.gsub(/_\x08/, '').gsub(/\x08./, '').size
   end
-
-  ##
-  # Turns on or off regexp handling for +convert_string+
-
-  def annotate(tag)
-    case tag
-    when '+b' then @in_b = true
-    when '-b' then @in_b = false
-    when '+_' then @in_em = true
-    when '-_' then @in_em = false
-    end
-    ''
-  end
-
-  ##
-  # Calls convert_string on the result of convert_regexp_handling
-
-  def convert_regexp_handling(target)
-    convert_string super
-  end
-
-  ##
-  # Adds bold or underline mixed with backspaces
-
-  def convert_string(string)
-    return string unless @in_b or @in_em
-    chars = if @in_b then
-              string.chars.map do |char| "#{char}\b#{char}" end
-            elsif @in_em then
-              string.chars.map do |char| "_\b#{char}" end
-            end
-
-    chars.join
-  end
-
 end