rdoc 8.0.0 → 8.1.0

data/lib/rdoc/markup/list.rb

@@ -1,101 +1,93 @@
 # frozen_string_literal: true
-##
-# A List is a homogeneous set of ListItems.
-#
-# The supported list types include:
-#
-# :BULLET::
-#   An unordered list
-# :LABEL::
-#   An unordered definition list, but using an alternate RDoc::Markup syntax
-# :LALPHA::
-#   An ordered list using increasing lowercase English letters
-# :NOTE::
-#   An unordered definition list
-# :NUMBER::
-#   An ordered list using increasing Arabic numerals
-# :UALPHA::
-#   An ordered list using increasing uppercase English letters
-#
-# Definition lists behave like HTML definition lists.  Each list item can
-# describe multiple terms.  See RDoc::Markup::ListItem for how labels and
-# definition are stored as list items.
 
-class RDoc::Markup::List
-
-  ##
-  # The list's type
-
-  attr_accessor :type
-
-  ##
-  # Items in the list
-
-  attr_reader :items
-
-  ##
-  # Creates a new list of +type+ with +items+.  Valid list types are:
-  # +:BULLET+, +:LABEL+, +:LALPHA+, +:NOTE+, +:NUMBER+, +:UALPHA+
-
-  def initialize(type = nil, *items)
-    @type = type
-    @items = []
-    @items.concat items
-  end
-
-  ##
-  # Appends +item+ to the list
-
-  def <<(item)
-    @items << item
-  end
-
-  def ==(other) # :nodoc:
-    self.class == other.class and
-      @type == other.type and
-      @items == other.items
-  end
-
-  ##
-  # Runs this list and all its #items through +visitor+
-
-  def accept(visitor)
-    visitor.accept_list_start self
+module RDoc
+  class Markup
+    # A List is a homogeneous set of ListItems.
+    #
+    # The supported list types include:
+    #
+    # :BULLET::
+    #   An unordered list
+    # :LABEL::
+    #   An unordered definition list, but using an alternate RDoc::Markup syntax
+    # :LALPHA::
+    #   An ordered list using increasing lowercase English letters
+    # :NOTE::
+    #   An unordered definition list
+    # :NUMBER::
+    #   An ordered list using increasing Arabic numerals
+    # :UALPHA::
+    #   An ordered list using increasing uppercase English letters
+    #
+    # Definition lists behave like HTML definition lists. Each list item can
+    # describe multiple terms. See RDoc::Markup::ListItem for how labels and
+    # definitions are stored as list items.
+    class List < Element
+      # The list's type
+      #: Symbol?
+      attr_accessor :type
+
+      # Items in the list
+      #: Array[ListItem]
+      attr_reader :items
+
+      # Creates a new list of +type+ with +items+. Valid list types are:
+      # +:BULLET+, +:LABEL+, +:LALPHA+, +:NOTE+, +:NUMBER+, +:UALPHA+
+      #: (Symbol?, *ListItem) -> void
+      def initialize(type = nil, *items)
+        @type = type
+        @items = items
+      end
 
-    @items.each do |item|
-      item.accept visitor
-    end
+      # Appends +item+ to the list
+      #: (ListItem) -> void
+      def <<(item)
+        @items << item
+      end
 
-    visitor.accept_list_end self
-  end
+      #: (top) -> bool
+      def ==(other) # :nodoc:
+        self.class == other.class &&
+          @type == other.type &&
+          @items == other.items
+      end
 
-  ##
-  # Is the list empty?
+      # Runs this list and all its #items through +visitor+
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_list_start(self)
+        @items.each { |item| item.accept(visitor) }
+        visitor.accept_list_end(self)
+      end
 
-  def empty?
-    @items.empty?
-  end
+      # Is the list empty?
+      #: () -> bool
+      def empty?
+        @items.empty?
+      end
 
-  ##
-  # Returns the last item in the list
+      # Returns the last item in the list
+      #: () -> ListItem?
+      def last
+        @items.last
+      end
 
-  def last
-    @items.last
-  end
+      # @override
+      #: (PP) -> void
+      def pretty_print(q) # :nodoc:
+        q.group(2, "[list: #{@type} ", ']') do
+          q.seplist(@items) do |item|
+            q.pp(item)
+          end
+        end
+      end
 
-  def pretty_print(q) # :nodoc:
-    q.group 2, "[list: #{@type} ", ']' do
-      q.seplist @items do |item|
-        q.pp item
+      # Appends +items+ to the list
+      #: (*ListItem) -> void
+      def push(*items)
+        @items.concat(items)
       end
     end
   end
-
-  ##
-  # Appends +items+ to the list
-
-  def push(*items)
-    @items.concat items
-  end
-
 end

data/lib/rdoc/markup/list_item.rb

@@ -1,99 +1,87 @@
 # frozen_string_literal: true
-##
-# An item within a List that contains paragraphs, headings, etc.
-#
-# For BULLET, NUMBER, LALPHA and UALPHA lists, the label will always be nil.
-# For NOTE and LABEL lists, the list label may contain:
-#
-# * a single String for a single label
-# * an Array of Strings for a list item with multiple terms
-# * nil for an extra description attached to a previously labeled list item
 
-class RDoc::Markup::ListItem
-
-  ##
-  # The label for the ListItem
-
-  attr_accessor :label
-
-  ##
-  # Parts of the ListItem
-
-  attr_reader :parts
-
-  ##
-  # Creates a new ListItem with an optional +label+ containing +parts+
-
-  def initialize(label = nil, *parts)
-    @label = label
-    @parts = []
-    @parts.concat parts
-  end
-
-  ##
-  # Appends +part+ to the ListItem
-
-  def <<(part)
-    @parts << part
-  end
-
-  def ==(other) # :nodoc:
-    self.class == other.class and
-      @label == other.label and
-      @parts == other.parts
-  end
-
-  ##
-  # Runs this list item and all its #parts through +visitor+
-
-  def accept(visitor)
-    visitor.accept_list_item_start self
-
-    @parts.each do |part|
-      part.accept visitor
-    end
+module RDoc
+  class Markup
+    # An item within a List that contains paragraphs, headings, etc.
+    #
+    # For BULLET, NUMBER, LALPHA and UALPHA lists, the label will always be nil.
+    # For NOTE and LABEL lists, the list label may contain:
+    #
+    # * a single String for a single label
+    # * an Array of Strings for a list item with multiple terms
+    # * nil for an extra description attached to a previously labeled list item
+    class ListItem < Element
+      # The label for the ListItem
+      #: (Array[String] | String)?
+      attr_accessor :label
+
+      # Parts of the ListItem
+      #: Array[untyped]
+      attr_reader :parts
+
+      # Creates a new ListItem with an optional +label+ containing +parts+
+      #: ((Array[String] | String)?, *untyped) -> void
+      def initialize(label = nil, *parts)
+        @label = label
+        @parts = parts
+      end
 
-    visitor.accept_list_item_end self
-  end
+      # Appends +part+ to the ListItem
+      #: (untyped) -> void
+      def <<(part)
+        @parts << part
+      end
 
-  ##
-  # Is the ListItem empty?
+      #: (top) -> bool
+      def ==(other) # :nodoc:
+        self.class == other.class &&
+          @label == other.label &&
+          @parts == other.parts
+      end
 
-  def empty?
-    @parts.empty?
-  end
+      # Runs this list item and all its #parts through +visitor+
+      # @override
+      #: (untyped) -> void
+      def accept(visitor)
+        visitor.accept_list_item_start(self)
+        @parts.each { |part| part.accept(visitor) }
+        visitor.accept_list_item_end(self)
+      end
 
-  ##
-  # Length of parts in the ListItem
+      # Is the ListItem empty?
+      #: () -> bool
+      def empty?
+        @parts.empty?
+      end
 
-  def length
-    @parts.length
-  end
+      # Length of parts in the ListItem
+      #: () -> Integer
+      def length
+        @parts.length
+      end
 
-  def pretty_print(q) # :nodoc:
-    q.group 2, '[item: ', ']' do
-      case @label
-      when Array then
-        q.pp @label
-        q.text ';'
-        q.breakable
-      when String then
-        q.pp @label
-        q.text ';'
-        q.breakable
+      # @override
+      #: (PP) -> void
+      def pretty_print(q) # :nodoc:
+        q.group(2, '[item: ', ']') do
+          case @label
+          when Array, String
+            q.pp(@label)
+            q.text(';')
+            q.breakable
+          end
+
+          q.seplist(@parts) do |part|
+            q.pp(part)
+          end
+        end
       end
 
-      q.seplist @parts do |part|
-        q.pp part
+      # Adds +parts+ to the ListItem
+      #: (*untyped) -> void
+      def push(*parts)
+        @parts.concat(parts)
       end
     end
   end
-
-  ##
-  # Adds +parts+ to the ListItem
-
-  def push(*parts)
-    @parts.concat parts
-  end
-
 end

data/lib/rdoc/markup/paragraph.rb

@@ -1,28 +1,32 @@
 # frozen_string_literal: true
-##
-# A Paragraph of text
+module RDoc
+  class Markup
+    ##
+    # A Paragraph of text
 
-class RDoc::Markup::Paragraph < RDoc::Markup::Raw
+    class Paragraph < Markup::Raw
 
-  ##
-  # Calls #accept_paragraph on +visitor+
+      ##
+      # Calls #accept_paragraph on +visitor+
 
-  def accept(visitor)
-    visitor.accept_paragraph self
-  end
+      def accept(visitor)
+        visitor.accept_paragraph self
+      end
 
-  ##
-  # Joins the raw paragraph text and converts inline HardBreaks to the
-  # +hard_break+ text.
+      ##
+      # Joins the raw paragraph text and converts inline HardBreaks to the
+      # +hard_break+ text.
 
-  def text(hard_break = '')
-    @parts.map do |part|
-      if RDoc::Markup::HardBreak === part then
-        hard_break
-      else
-        part
+      def text(hard_break = '')
+        @parts.map do |part|
+          if Markup::HardBreak === part
+            hard_break
+          else
+            part
+          end
+        end.join
       end
-    end.join
-  end
 
+    end
+  end
 end