rdoc 6.17.0 → 8.1.0

data/lib/rdoc/markup/raw.rb

@@ -1,69 +1,66 @@
 # frozen_string_literal: true
-##
-# A section of text that is added to the output document as-is
 
-class RDoc::Markup::Raw
-
-  ##
-  # The component parts of the list
-
-  attr_reader :parts
-
-  ##
-  # Creates a new Raw containing +parts+
-
-  def initialize *parts
-    @parts = []
-    @parts.concat parts
-  end
-
-  ##
-  # Appends +text+
+module RDoc
+  class Markup
+    # A section of text that is added to the output document as-is
+    class Raw < Element
+      # The component parts of the raw text
+      #: Array[String]
+      attr_reader :parts
+
+      # Creates a new Raw containing +parts+
+      #: (*String) -> void
+      def initialize(*parts)
+        @parts = parts
+      end
 
-  def <<(text)
-    @parts << text
-  end
+      # Appends +text+
+      #: (String) -> void
+      def <<(text)
+        @parts << text
+      end
 
-  def ==(other) # :nodoc:
-    self.class == other.class and @parts == other.parts
-  end
+      #: (top) -> bool
+      def ==(other) # :nodoc:
+        self.class == other.class && @parts == other.parts
+      end
 
-  ##
-  # Calls #accept_raw+ on +visitor+
+      # Calls #accept_raw+ on +visitor+
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_raw(self)
+      end
 
-  def accept(visitor)
-    visitor.accept_raw self
-  end
+      # Appends +other+'s parts
+      #: (Raw) -> void
+      def merge(other)
+        @parts.concat(other.parts)
+      end
 
-  ##
-  # Appends +other+'s parts
+      # @override
+      #: (PP) -> void
+      def pretty_print(q) # :nodoc:
+        self.class.name =~ /.*::(\w{1,4})/i
 
-  def merge(other)
-    @parts.concat other.parts
-  end
+        q.group(2, "[#{$1.downcase}: ", ']') do
+          q.seplist(@parts) do |part|
+            q.pp(part)
+          end
+        end
+      end
 
-  def pretty_print(q) # :nodoc:
-    self.class.name =~ /.*::(\w{1,4})/i
+      # Appends +texts+ onto this Paragraph
+      #: (*String) -> void
+      def push(*texts)
+        self.parts.concat(texts)
+      end
 
-    q.group 2, "[#{$1.downcase}: ", ']' do
-      q.seplist @parts do |part|
-        q.pp part
+      # The raw text
+      #: () -> String
+      def text
+        @parts.join(" ")
       end
     end
   end
-
-  ##
-  # Appends +texts+ onto this Paragraph
-
-  def push *texts
-    self.parts.concat texts
-  end
-
-  ##
-  # The raw text
-
-  def text
-    @parts.join ' '
-  end
-
 end

data/lib/rdoc/markup/rule.rb

@@ -1,20 +1,24 @@
 # frozen_string_literal: true
-##
-# A horizontal rule with a weight
+module RDoc
+  class Markup
+    ##
+    # A horizontal rule with a weight
 
-class RDoc::Markup::Rule < Struct.new :weight
+    class Rule < Struct.new :weight
 
-  ##
-  # Calls #accept_rule on +visitor+
+      ##
+      # Calls #accept_rule on +visitor+
 
-  def accept(visitor)
-    visitor.accept_rule self
-  end
+      def accept(visitor)
+        visitor.accept_rule self
+      end
+
+      def pretty_print(q) # :nodoc:
+        q.group 2, '[rule:', ']' do
+          q.pp weight
+        end
+      end
 
-  def pretty_print(q) # :nodoc:
-    q.group 2, '[rule:', ']' do
-      q.pp weight
     end
   end
-
 end

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

@@ -1,97 +1,148 @@
 # frozen_string_literal: true
-##
-# Outputs RDoc markup with vibrant ANSI color!
+module RDoc
+  class Markup
+    ##
+    # Outputs RDoc markup with vibrant ANSI color!
+
+    class ToAnsi < Markup::ToRdoc
+
+      ##
+      # Creates a new ToAnsi visitor that is ready to output vibrant ANSI color!
+
+      def initialize
+        super
+
+        @headings.clear
+        @headings[1] = ["\e[1;32m", "\e[m"] # bold
+        @headings[2] = ["\e[4;32m", "\e[m"] # underline
+        @headings[3] = ["\e[32m",   "\e[m"] # just green
+      end
+
+      ##
+      # Maps attributes to ANSI sequences
+
+      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
+
+      ##
+      # Overrides indent width to ensure output lines up correctly.
+
+      def accept_list_item_end(list_item)
+        width = case @list_type.last
+                when :BULLET
+                  2
+                when :NOTE, :LABEL
+                  if @prefix
+                    @res << @prefix.strip
+                    @prefix = nil
+                  end
+
+                  @res << "\n" unless res.length == 1
+                  2
+                else
+                  bullet = @list_index.last.to_s
+                  @list_index[-1] = @list_index.last.succ
+                  bullet.length + 2
+                end
+
+        @indent -= width
+      end
+
+      ##
+      # Adds coloring to note and label list items
+
+      def accept_list_item_start(list_item)
+        bullet = case @list_type.last
+                 when :BULLET
+                   '*'
+                 when :NOTE, :LABEL
+                   labels = Array(list_item.label).map do |label|
+                     attributes(label).strip
+                   end.join "\n"
+
+                   labels << ":\n" unless labels.empty?
+
+                   labels
+                 else
+                   @list_index.last.to_s + '.'
+                 end
+
+        case @list_type.last
+        when :NOTE, :LABEL
+          @indent += 2
+          @prefix = bullet + (' ' * @indent)
+        else
+          @prefix = (' ' * @indent) + bullet.ljust(bullet.length + 1)
+
+          width = bullet.gsub(/\e\[[\d;]*m/, '').length + 1
+
+          @indent += width
+        end
+      end
+
+      def calculate_text_width(text)
+        text.gsub(/\e\[[\d;]*m/, '').size
+      end
+
+      ##
+      # Starts accepting with a reset screen
+
+      def start_accepting
+        super
+
+        @res = ["\e[0m"]
+      end
 
-class RDoc::Markup::ToAnsi < RDoc::Markup::ToRdoc
-
-  ##
-  # Creates a new ToAnsi visitor that is ready to output vibrant ANSI color!
-
-  def initialize(markup = nil)
-    super
-
-    @headings.clear
-    @headings[1] = ["\e[1;32m", "\e[m"] # bold
-    @headings[2] = ["\e[4;32m", "\e[m"] # underline
-    @headings[3] = ["\e[32m",   "\e[m"] # just green
-  end
-
-  ##
-  # 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"
-  end
-
-  ##
-  # Overrides indent width to ensure output lines up correctly.
-
-  def accept_list_item_end(list_item)
-    width = case @list_type.last
-            when :BULLET then
-              2
-            when :NOTE, :LABEL then
-              if @prefix then
-                @res << @prefix.strip
-                @prefix = nil
-              end
-
-              @res << "\n" unless res.length == 1
-              2
-            else
-              bullet = @list_index.last.to_s
-              @list_index[-1] = @list_index.last.succ
-              bullet.length + 2
-            end
-
-    @indent -= width
-  end
-
-  ##
-  # Adds coloring to note and label list items
-
-  def accept_list_item_start(list_item)
-    bullet = case @list_type.last
-             when :BULLET then
-               '*'
-             when :NOTE, :LABEL then
-               labels = Array(list_item.label).map do |label|
-                 attributes(label).strip
-               end.join "\n"
-
-               labels << ":\n" unless labels.empty?
-
-               labels
-             else
-               @list_index.last.to_s + '.'
-             end
-
-    case @list_type.last
-    when :NOTE, :LABEL then
-      @indent += 2
-      @prefix = bullet + (' ' * @indent)
-    else
-      @prefix = (' ' * @indent) + bullet.ljust(bullet.length + 1)
-
-      width = bullet.gsub(/\e\[[\d;]*m/, '').length + 1
-
-      @indent += width
     end
   end
-
-  def calculate_text_width(text)
-    text.gsub(/\e\[[\d;]*m/, '').size
-  end
-
-  ##
-  # Starts accepting with a reset screen
-
-  def start_accepting
-    super
-
-    @res = ["\e[0m"]
-  end
-
 end

data/lib/rdoc/markup/to_bs.rb

@@ -1,106 +1,90 @@
 # frozen_string_literal: true
-##
-# Outputs RDoc markup with hot backspace action!  You will probably need a
-# pager to use this output format.
-#
-# This formatter won't work on 1.8.6 because it lacks String#chars.
-
-class RDoc::Markup::ToBs < RDoc::Markup::ToRdoc
-
-  ##
-  # Returns a new ToBs that is ready for hot backspace action!
-
-  def initialize(markup = nil)
-    super
-
-    @in_b  = false
-    @in_em = false
-  end
-
-  ##
-  # Sets a flag that is picked up by #annotate to do the right thing in
-  # #convert_string
-
-  def init_tags
-    add_tag :BOLD, '+b', '-b'
-    add_tag :EM,   '+_', '-_'
-    add_tag :TT,   '', ''   # we need in_tt information maintained
-  end
-
-  ##
-  # Makes heading text bold.
-
-  def accept_heading(heading)
-    use_prefix or @res << ' ' * @indent
-    @res << @headings[heading.level][0]
-    @in_b = true
-    @res << attributes(heading.text)
-    @in_b = false
-    @res << @headings[heading.level][1]
-    @res << "\n"
-  end
-
-  ##
-  # Prepares the visitor for consuming +list_item+
-
-  def accept_list_item_start(list_item)
-    type = @list_type.last
-
-    case type
-    when :NOTE, :LABEL then
-      bullets = Array(list_item.label).map do |label|
-        attributes(label).strip
-      end.join "\n"
-
-      bullets << ":\n" unless bullets.empty?
-
-      @prefix = ' ' * @indent
-      @indent += 2
-      @prefix << bullets + (' ' * @indent)
-    else
-      bullet = type == :BULLET ? '*' :  @list_index.last.to_s + '.'
-      @prefix = (' ' * @indent) + bullet.ljust(bullet.length + 1)
-      width = bullet.length + 1
-      @indent += width
-    end
-  end
-
-  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
+module RDoc
+  class Markup
+    ##
+    # Outputs RDoc markup with hot backspace action!  You will probably need a
+    # pager to use this output format.
+    #
+    # This formatter won't work on 1.8.6 because it lacks String#chars.
+
+    class ToBs < Markup::ToRdoc
+
+      ##
+      # Returns a new ToBs that is ready for hot backspace action!
+
+      def initialize
+        super
+
+        @in_b  = false
+        @in_em = false
+      end
+
+      def handle_inline(text)
+        initial_style = []
+        initial_style << :BOLD if @in_b
+        initial_style << :EM   if @in_em
+        super(text, initial_style)
+      end
+
+      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
+
+      ##
+      # Makes heading text bold.
+
+      def accept_heading(heading)
+        use_prefix or @res << ' ' * @indent
+        @res << @headings[heading.level][0]
+        @in_b = true
+        @res << attributes(heading.text)
+        @in_b = false
+        @res << @headings[heading.level][1]
+        @res << "\n"
+      end
+
+      ##
+      # Prepares the visitor for consuming +list_item+
+
+      def accept_list_item_start(list_item)
+        type = @list_type.last
+
+        case type
+        when :NOTE, :LABEL
+          bullets = Array(list_item.label).map do |label|
+            attributes(label).strip
+          end.join "\n"
+
+          bullets << ":\n" unless bullets.empty?
+
+          @prefix = ' ' * @indent
+          @indent += 2
+          @prefix << bullets + (' ' * @indent)
+        else
+          bullet = type == :BULLET ? '*' :  @list_index.last.to_s + '.'
+          @prefix = (' ' * @indent) + bullet.ljust(bullet.length + 1)
+          width = bullet.length + 1
+          @indent += width
+        end
+      end
+
+      def calculate_text_width(text)
+        text.gsub(/_\x08/, '').gsub(/\x08./, '').size
+      end
     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