rdoc 2.5.9 → 2.5.10

data/History.txt

@@ -1,3 +1,21 @@
+=== 2.5.10 / 2010-08-17
+
+* Minor Enhancements
+  * Support rb_singleton_class().  Reported by Jeremy Evans.
+  * Support rb_define_private_method() on rb_singleton_class().  Reported by
+    Jeremy Evans.
+
+* Bug Fixes
+  * Treat non-ASCII RDoc files as text.  Bug #28391 by Kouhei Sutou.
+  * Fix potential test failures due to ivar collision.  Bug #28390 by Kouhei
+    Sutou.
+  * Added duck-typed #aref for RDoc::Attr to RDoc::AnyMethod.  Bug #28375 by
+    Erik Hollensbe
+  * Fixed method references in HTML output when show_hash is false.
+  * Fixed comments with '.' in call-seq in C sources.  Reported by Jeremy
+    Evans.
+  * RDoc now understands singleton aliases.  Reported by Jeremy Evans.
+
 === 2.5.9 / 2010-07-06
 
 * Bug Fixes

data/lib/rdoc.rb

@@ -383,7 +383,7 @@ module RDoc
   ##
   # RDoc version you are using
 
-  VERSION = '2.5.9'
+  VERSION = '2.5.10'
 
   ##
   # Name of the dotfile that contains the description of files to be processed

data/lib/rdoc/alias.rb

@@ -3,6 +3,8 @@ require 'rdoc/code_object'
 ##
 # Represent an alias, which is an old_name/new_name pair associated with a
 # particular context
+#
+# TODO: RDoc::Alias needs to know if it's a singleton alias or not
 
 class RDoc::Alias < RDoc::CodeObject
 
@@ -21,6 +23,11 @@ class RDoc::Alias < RDoc::CodeObject
 
   attr_accessor :old_name
 
+  ##
+  # Is this a singeton alias?
+
+  attr_accessor :singleton
+
   ##
   # Source file token stream
 
@@ -32,10 +39,13 @@ class RDoc::Alias < RDoc::CodeObject
 
   def initialize(text, old_name, new_name, comment)
     super()
+
     @text = text
     @old_name = old_name
     @new_name = new_name
     self.comment = comment
+
+    @singleton = false
   end
 
   def inspect # :nodoc:

data/lib/rdoc/attr.rb

@@ -53,6 +53,15 @@ class RDoc::Attr < RDoc::CodeObject
       self.rw == other.rw
   end
 
+  ##
+  # HTML fragment reference for this attr
+
+  def aref
+    type = singleton ? 'c' : 'i'
+
+    "attribute-#{type}-#{CGI.escape name}"
+  end
+
   ##
   # Returns nil, for duck typing with RDoc::AnyMethod
 

data/lib/rdoc/context.rb

@@ -220,16 +220,23 @@ class RDoc::Context < RDoc::CodeObject
   end
 
   ##
-  # Adds +an_alias+ that is automatically resolved
+  # Adds +an_alias+ that is automatically resolved to it's corresponding
+  # RDoc::AnyMethod object.
 
-  def add_alias(an_alias)
-    meth = find_instance_method_named(an_alias.old_name)
+  def add_alias an_alias
+    old_name = an_alias.old_name
+
+    meth = if an_alias.singleton then
+             find_class_method_named old_name
+           else
+             find_instance_method_named old_name
+           end
 
     if meth then
       add_alias_impl an_alias, meth
     else
       add_to @aliases, an_alias
-      unmatched_alias_list = @unmatched_alias_lists[an_alias.old_name] ||= []
+      unmatched_alias_list = @unmatched_alias_lists[old_name] ||= []
       unmatched_alias_list.push an_alias
     end
 

data/lib/rdoc/generator/darkfish.rb

@@ -151,7 +151,7 @@ class RDoc::Generator::Darkfish
 
 		Dir[(@template_dir + "{js,images}/**/*").to_s].each do |path|
 			next if File.directory? path
-			next if path =~ /#{File::SEPARATOR}\./
+			next if File.basename(path) =~ /^\./
 
 			dst = Pathname.new(path).relative_path_from @template_dir
 

data/lib/rdoc/markup/to_html_crossref.rb

@@ -70,6 +70,11 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
 
   attr_accessor :context
 
+  ##
+  # Should we show '#' characters on method references?
+
+  attr_accessor :show_hash
+
   ##
   # Creates a new crossref resolver that generates links relative to +context+
   # which lives at +from_path+ in the generated files.  '#' characters on
@@ -98,16 +103,15 @@ class RDoc::Markup::ToHtmlCrossref < RDoc::Markup::ToHtml
   def handle_special_CROSSREF(special)
     name = special.text
 
-    # This ensures that words entirely consisting of lowercase letters will
-    # not have cross-references generated (to suppress lots of erroneous
+    # This ensures that words consisting of only lowercase letters will not
+    # have cross-references generated (to suppress lots of erroneous
     # cross-references to "new" in text, for instance)
     return name if name =~ /\A[a-z]*\z/
 
     return @seen[name] if @seen.include? name
-
     lookup = name
 
-    name = name[0, 1] unless @show_hash if name[0, 1] == '#'
+    name = name[1..-1] unless @show_hash if name[0, 1] == '#'
 
     # Find class, module, or method in class or module.
     #

data/lib/rdoc/parser.rb

@@ -62,12 +62,23 @@ class RDoc::Parser
     true
   end
 
+  def self.set_encoding(string)
+    if defined? Encoding then
+      if /coding[=:]\s*([^\s;]+)/i =~ string[%r"\A(?:#!.*\n)?.*\n"]
+        if enc = ::Encoding.find($1)
+          string.force_encoding(enc)
+        end
+      end
+    end
+  end
+
   ##
   # Determines if the file is a "binary" file which basically means it has
   # content that an RDoc parser shouldn't try to consume.
 
   def self.binary?(file)
     s = File.read(file, 1024) or return false
+    set_encoding(s)
 
     if s[0, 2] == Marshal.dump('')[0, 2] then
       true

data/lib/rdoc/parser/c.rb

@@ -120,18 +120,24 @@ class RDoc::Parser::C < RDoc::Parser
     @known_classes = RDoc::KNOWN_CLASSES.dup
     @content = handle_tab_width handle_ifdefs_in(@content)
     @classes = Hash.new
+    @singleton_classes = Hash.new
     @file_dir = File.dirname(@file_name)
   end
 
   def do_aliases
-    @content.scan(%r{rb_define_alias\s*\(\s*(\w+),\s*"([^"]+)",\s*"([^"]+)"\s*\)}m) do
-      |var_name, new_name, old_name|
+    @content.scan(/rb_define_alias\s*\(
+                   \s*(\w+),
+                   \s*"(.+?)",
+                   \s*"(.+?)"
+                   \s*\)/xm) do |var_name, new_name, old_name|
       class_name = @known_classes[var_name] || var_name
-      class_obj  = find_class(var_name, class_name)
+      class_obj  = find_class var_name, class_name
 
-      as = class_obj.add_alias RDoc::Alias.new("", old_name, new_name, "")
+      al = RDoc::Alias.new '', old_name, new_name, ''
+      al.singleton = @singleton_classes.key?(var_name)
 
-      @stats.add_alias as
+      class_obj.add_alias al
+      @stats.add_alias al
     end
   end
 
@@ -165,13 +171,20 @@ class RDoc::Parser::C < RDoc::Parser
     end
 
     @content.scan(/([\w\.]+)\s* = \s*rb_define_class_under\s*
-              \(
-                 \s*(\w+),
-                 \s*"(\w+)",
-                 \s*([\w\*\s\(\)\.\->]+)\s*  # for SWIG
-              \s*\)/mx) do |var_name, in_module, class_name, parent|
+                  \(
+                     \s*(\w+),
+                     \s*"(\w+)",
+                     \s*([\w\*\s\(\)\.\->]+)\s*  # for SWIG
+                  \s*\)/mx) do |var_name, in_module, class_name, parent|
       handle_class_module(var_name, "class", class_name, parent, in_module)
     end
+
+    @content.scan(/([\w\.]+)\s* = \s*rb_singleton_class\s*
+                  \(
+                    \s*(\w+)
+                  \s*\)/mx) do |sclass_var, class_var|
+      handle_singleton sclass_var, class_var
+    end
   end
 
   def do_constants
@@ -432,11 +445,12 @@ class RDoc::Parser::C < RDoc::Parser
 
   def find_modifiers(comment, meth_obj)
     if comment.sub!(/:nodoc:\s*^\s*\*?\s*$/m, '') or
-       comment.sub!(/\A\/\*\s*:nodoc:\s*\*\/\Z/, '')
+       comment.sub!(/\A\/\*\s*:nodoc:\s*\*\/\Z/, '') then
       meth_obj.document_self = false
     end
+
     if comment.sub!(/call-seq:(.*?)^\s*\*?\s*$/m, '') or
-       comment.sub!(/\A\/\*\s*call-seq:(.*?)\*\/\Z/, '')
+       comment.sub!(/\A\/\*\s*call-seq:(.*?)\*\/\Z/, '') then
       seq = $1
       seq.gsub!(/^\s*\*\s*/, '')
       meth_obj.call_seq = seq
@@ -592,8 +606,14 @@ class RDoc::Parser::C < RDoc::Parser
 
   def handle_method(type, var_name, meth_name, meth_body, param_count,
                     source_file = nil)
+    singleton = false
     class_name = @known_classes[var_name]
 
+    unless class_name then
+      class_name = @singleton_classes[var_name]
+      singleton = true if class_name
+    end
+
     return unless class_name
 
     class_obj = find_class var_name, class_name
@@ -601,11 +621,12 @@ class RDoc::Parser::C < RDoc::Parser
     if class_obj then
       if meth_name == "initialize" then
         meth_name = "new"
-        type = "singleton_method"
+        singleton = true
       end
 
       meth_obj = RDoc::AnyMethod.new '', meth_name
-      meth_obj.singleton = %w[singleton_method module_function].include? type
+      meth_obj.singleton =
+        singleton || %w[singleton_method module_function].include?(type)
 
       p_count = Integer(param_count) rescue -1
 
@@ -637,6 +658,12 @@ class RDoc::Parser::C < RDoc::Parser
     end
   end
 
+  def handle_singleton sclass_var, class_var
+    class_name = @known_classes[class_var]
+
+    @singleton_classes[sclass_var] = class_name
+  end
+
   def handle_tab_width(body)
     if /\t/ =~ body
       tab_width = @options.tab_width

data/lib/rdoc/parser/ruby.rb

@@ -498,8 +498,13 @@ class RDoc::Parser::Ruby < RDoc::Parser
     end
 
     al = RDoc::Alias.new get_tkread, old_name, new_name, comment
+    al.singleton = SINGLE == single
     read_documentation_modifiers al, RDoc::ATTR_MODIFIERS
+
     context.add_alias al if al.document_self
+    @stats.add_alias al
+
+    al
   end
 
   def parse_call_parameters(tk)

data/lib/rdoc/rdoc.rb

@@ -405,15 +405,7 @@ The internal error was:
 
   def read_file_contents(filename)
     content = open filename, "rb" do |f| f.read end
-
-    if defined? Encoding then
-      if /coding[=:]\s*([^\s;]+)/i =~ content[%r"\A(?:#!.*\n)?.*\n"]
-        if enc = ::Encoding.find($1)
-          content.force_encoding(enc)
-        end
-      end
-    end
-
+    RDoc::Parser.set_encoding(content)
     content
   rescue Errno::EISDIR, Errno::ENOENT
     nil

data/test/test.ja.rdoc

@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+
 こんにちは！
 
 初めまして。アーロンと申します。

data/test/test_rdoc_attr.rb

@@ -8,6 +8,12 @@ class TestRDocAttr < MiniTest::Unit::TestCase
     @a = RDoc::Attr.new nil, 'attr', 'RW', ''
   end
 
+  def test_aref
+    m = RDoc::Attr.new nil, 'attr', 'RW', nil
+
+    assert_equal 'attribute-i-attr', m.aref
+  end
+
   def test_arglists
     assert_nil @a.arglists
   end

data/test/test_rdoc_context.rb

@@ -51,6 +51,25 @@ class TestRDocContext < XrefTestCase
     assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name }
   end
 
+  def test_add_alias_method_singleton
+    meth = RDoc::AnyMethod.new nil, 'old_name'
+    meth.singleton = true
+
+    as = RDoc::Alias.new nil, 'old_name', 'new_name', 'comment'
+    as.singleton = true
+
+    as.parent = @context
+
+    @context.add_method meth
+    @context.add_alias as
+
+    assert_empty @context.aliases
+    assert_empty @context.unmatched_alias_lists
+    assert_equal %w[old_name new_name], @context.method_list.map { |m| m.name }
+
+    assert @context.method_list.last.singleton
+  end
+
   def test_add_alias_impl
     meth = RDoc::AnyMethod.new nil, 'old_name'
     meth.comment    = 'old comment'

data/test/test_rdoc_markup_pre_process.rb

@@ -10,7 +10,7 @@ class TestRDocMarkupPreProcess < MiniTest::Unit::TestCase
     RDoc::Markup::PreProcess.registered.clear
 
     @tempfile = Tempfile.new 'test_rdoc_markup_pre_process'
-    @name = File.basename @tempfile.path
+    @file_name = File.basename @tempfile.path
     @dir  = File.dirname @tempfile.path
 
     @pp = RDoc::Markup::PreProcess.new __FILE__, [@dir]
@@ -31,7 +31,7 @@ contents of a string.
     @tempfile.flush
     @tempfile.rewind
 
-    content = @pp.include_file @name, ''
+    content = @pp.include_file @file_name, ''
 
     expected = <<-EXPECTED
 Regular expressions (<i>regexp</i>s) are patterns which describe the

data/test/test_rdoc_markup_to_html_crossref.rb

@@ -153,6 +153,13 @@ class TestRDocMarkupToHtmlCrossref < XrefTestCase
     refute_ref '::C3::H1#n',    '\::C3::H1#n'
   end
 
+  def test_handle_special_CROSSREF_show_hash_false
+    @xref.show_hash = false
+
+    assert_equal "<p>\n<a href=\"C1.html#method-i-m\">m</a>\n</p>\n",
+                 @xref.convert('#m')
+  end
+
   def test_handle_special_CROSSREF_special
     assert_equal "<p>\n<a href=\"C2/C3.html\">C2::C3</a>;method(*)\n</p>\n",
                  @xref.convert('C2::C3;method(*)')

data/test/test_rdoc_parser.rb

@@ -42,6 +42,18 @@ class TestRDocParser < MiniTest::Unit::TestCase
     File.unlink marshal
   end
 
+  def test_class_binary_japanese_text
+    file_name = File.expand_path '../test.ja.txt', __FILE__
+    assert @RP.binary?(file_name)
+  end
+
+  def test_class_binary_japanese_rdoc
+    skip "Encoding not implemented" unless defined? ::Encoding
+
+    file_name = File.expand_path '../test.ja.rdoc', __FILE__
+    assert !@RP.binary?(file_name)
+  end
+
   def test_class_can_parse
     assert_equal @RP.can_parse(__FILE__), @RP::Ruby
 
@@ -72,6 +84,10 @@ class TestRDocParser < MiniTest::Unit::TestCase
   def test_class_for_binary
     rp = @RP.dup
 
+    class << rp
+      alias old_can_parse can_parse
+    end
+
     def rp.can_parse(*args) nil end
 
     assert_nil @RP.for(nil, @binary_dat, nil, nil, nil)

data/test/test_rdoc_parser_c.rb

@@ -1,12 +1,12 @@
 require 'stringio'
 require 'tempfile'
 require 'rubygems'
-require 'minitest/unit'
+require 'minitest/autorun'
 require 'rdoc/options'
 require 'rdoc/parser/c'
 
 class RDoc::Parser::C
-  attr_accessor :classes
+  attr_accessor :classes, :singleton_classes
 
   public :do_classes, :do_constants
 end
@@ -30,6 +30,59 @@ class TestRDocParserC < MiniTest::Unit::TestCase
     @tempfile.close
   end
 
+  def test_do_aliases
+    content = <<-EOF
+/*
+ * This should show up as an alias with documentation
+ */
+VALUE blah(VALUE klass, VALUE year) {
+}
+
+void Init_Blah(void) {
+  cDate = rb_define_class("Date", rb_cObject);
+
+  rb_define_method(cDate, "blah", blah, 1);
+
+  rb_define_alias(cDate, "bleh", "blah");
+}
+    EOF
+
+    klass = util_get_class content, 'cDate'
+
+    methods = klass.method_list
+    assert_equal 2,      methods.length
+    assert_equal 'bleh', methods.last.name
+    assert_equal 'blah', methods.last.is_alias_for.name
+  end
+
+  def test_do_aliases_singleton
+    content = <<-EOF
+/*
+ * This should show up as an alias with documentation
+ */
+VALUE blah(VALUE klass, VALUE year) {
+}
+
+void Init_Blah(void) {
+  cDate = rb_define_class("Date", rb_cObject);
+  sDate = rb_singleton_class(cDate);
+
+  rb_define_method(sDate, "blah", blah, 1);
+
+  rb_define_alias(sDate, "bleh", "blah");
+}
+    EOF
+
+    klass = util_get_class content, 'cDate'
+
+    methods = klass.method_list
+
+    assert_equal 2,      methods.length
+    assert_equal 'bleh', methods.last.name
+    assert               methods.last.singleton
+    assert_equal 'blah', methods.last.is_alias_for.name
+  end
+
   def test_do_classes_boot_class
     content = <<-EOF
 /* Document-class: Foo
@@ -68,6 +121,17 @@ VALUE cFoo = rb_define_class("Foo", rb_cObject);
     assert_equal "this is the Foo class", klass.comment
   end
 
+  def test_do_classes_singleton
+    content = <<-EOF
+VALUE cFoo = rb_define_class("Foo", rb_cObject);
+VALUE cFooS = rb_singleton_class(cFoo);
+    EOF
+
+    util_get_class content, 'cFooS'
+
+    assert_equal 'Foo', @parser.singleton_classes['cFooS']
+  end
+
   def test_do_classes_class_under
     content = <<-EOF
 /* Document-class: Kernel::Foo
@@ -406,6 +470,38 @@ Init_Foo(void) {
     assert_equal "a comment for bar", bar.comment
   end
 
+  def test_find_modifiers
+    comment = <<-COMMENT
+/* call-seq:
+ *   commercial() -> Date <br />
+ *   commercial(cwyear, cweek=41, cwday=5, sg=nil) -> Date [ruby 1.8] <br />
+ *   commercial(cwyear, cweek=1, cwday=1, sg=nil) -> Date [ruby 1.9]
+ *
+ * If no arguments are given:
+ * * ruby 1.8: returns a +Date+ for 1582-10-15 (the Day of Calendar Reform in
+ *   Italy)
+ * * ruby 1.9: returns a +Date+ for julian day 0
+ *
+ * Otherwise, returns a +Date+ for the commercial week year, commercial week,
+ * and commercial week day given. Ignores the 4th argument.
+ */
+
+    COMMENT
+
+    parser = util_parser ''
+    method_obj = RDoc::AnyMethod.new nil, 'blah'
+
+    parser.find_modifiers comment, method_obj
+
+    expected = <<-CALL_SEQ
+commercial() -> Date <br />
+commercial(cwyear, cweek=41, cwday=5, sg=nil) -> Date [ruby 1.8] <br />
+commercial(cwyear, cweek=1, cwday=1, sg=nil) -> Date [ruby 1.9]
+    CALL_SEQ
+
+    assert_equal expected, method_obj.call_seq
+  end
+
   def test_look_for_directives_in
     parser = util_parser ''
 
@@ -442,6 +538,7 @@ Init_IO(void) {
     read_method = klass.method_list.first
     assert_equal "read", read_method.name
     assert_equal "Method Comment!   ", read_method.comment
+    assert read_method.singleton
   end
 
   def test_define_method_private
@@ -472,6 +569,65 @@ Init_IO(void) {
     assert_equal "Method Comment!   ", read_method.comment
   end
 
+  def test_define_method_private_singleton
+    content = <<-EOF
+/*Method Comment! */
+static VALUE
+rb_io_s_read(argc, argv, io)
+    int argc;
+    VALUE *argv;
+    VALUE io;
+{
+}
+
+void
+Init_IO(void) {
+    /*
+     * a comment for class Foo on rb_define_class
+     */
+    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
+    VALUE rb_cIO_s = rb_singleton_class(rb_cIO);
+    rb_define_private_method(rb_cIO_s, "read", rb_io_s_read, -1);
+}
+    EOF
+
+    klass = util_get_class content, 'rb_cIO'
+    read_method = klass.method_list.first
+    assert_equal "read", read_method.name
+    assert_equal "Method Comment!   ", read_method.comment
+    assert_equal :private, read_method.visibility
+    assert read_method.singleton
+  end
+
+  def test_define_method_singleton
+    content = <<-EOF
+/*Method Comment! */
+static VALUE
+rb_io_s_read(argc, argv, io)
+    int argc;
+    VALUE *argv;
+    VALUE io;
+{
+}
+
+void
+Init_IO(void) {
+    /*
+     * a comment for class Foo on rb_define_class
+     */
+    VALUE rb_cIO = rb_define_class("IO", rb_cObject);
+    VALUE rb_cIO_s = rb_singleton_class(rb_cIO);
+    rb_define_method(rb_cIO_s, "read", rb_io_s_read, -1);
+}
+    EOF
+
+    klass = util_get_class content, 'rb_cIO'
+    read_method = klass.method_list.first
+    assert_equal "read", read_method.name
+    assert_equal "Method Comment!   ", read_method.comment
+    assert read_method.singleton
+  end
+
   def util_get_class(content, name)
     @parser = util_parser content
     @parser.scan
@@ -484,4 +640,3 @@ Init_IO(void) {
 
 end
 
-MiniTest::Unit.autorun

data/test/test_rdoc_parser_ruby.rb

@@ -172,6 +172,23 @@ class TestRDocParserRuby < MiniTest::Unit::TestCase
     assert_equal 'comment', alas.comment
   end
 
+  def test_parse_alias_singleton
+    klass = RDoc::NormalClass.new 'Foo'
+    klass.parent = @top_level
+
+    util_parser "alias :next= :bar"
+
+    tk = @parser.get_tk
+
+    alas = @parser.parse_alias klass, RDoc::Parser::Ruby::SINGLE, tk, 'comment'
+
+    assert_equal 'bar',     alas.old_name
+    assert_equal 'next=',   alas.new_name
+    assert_equal klass,     alas.parent
+    assert_equal 'comment', alas.comment
+    assert                  alas.singleton
+  end
+
   def test_parse_alias_meta
     klass = RDoc::NormalClass.new 'Foo'
     klass.parent = @top_level

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rdoc
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 15
   prerelease: false
   segments: 
   - 2
   - 5
-  - 9
-  version: 2.5.9
+  - 10
+  version: 2.5.10
 platform: ruby
 authors: 
 - Eric Hodel
@@ -39,7 +39,7 @@ cert_chain:
   x52qPcexcYZR7w==
   -----END CERTIFICATE-----
 
-date: 2010-07-06 00:00:00 -07:00
+date: 2010-08-17 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,34 +50,18 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 9
+        hash: 7
         segments: 
         - 2
         - 0
-        - 3
-        version: 2.0.3
+        - 4
+        version: 2.0.4
   type: :development
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: gemcutter
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 0
-        - 5
-        - 0
-        version: 0.5.0
-  type: :development
-  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: minitest
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -88,23 +72,23 @@ dependencies:
         - 3
         version: "1.3"
   type: :development
-  version_requirements: *id003
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: hoe
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 27
+        hash: 21
         segments: 
         - 2
-        - 5
-        - 0
-        version: 2.5.0
+        - 6
+        - 1
+        version: 2.6.1
   type: :development
-  version_requirements: *id004
+  version_requirements: *id003
 description: |-
   RDoc is an application that produces documentation for one or more Ruby source
   files.  RDoc includes the +rdoc+ and +ri+ tools for generating and displaying

metadata.gz.sig

@@ -1,2 +1,4 @@
-
-;]	���j$eA
+�L����
+đ(p!�k�Y
+﯅�%�gZ��{r�s�G�цvMa��DF@�\[i���ބ��3�$��(k+�b��I�;�����0|��X�����<�S7�э�
�~�� �1���Z�}8�o�	q����9Mw.+�U!I�6�B�_�v��y�c��tKK~
t�d	I,�2�+���KeM�
+A���J�E�v��9�5ׂ�fj�t���8��I�t�<�0�b8f�e&ÆR�����ki’����}a: