yard 0.9.24 → 0.9.25

data/spec/i18n/text_spec.rb

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::I18n::Text do
-  describe "#extract_messages" do
-    def extract_messages(input, options = {})
-      text = YARD::I18n::Text.new(StringIO.new(input), options)
-      messages = []
-      text.extract_messages do |*message|
-        messages << message
-      end
-      messages
-    end
-
-    describe "Header" do
-      it "extracts at attribute" do
-        text = <<-eot
-# @title Getting Started Guide
-
-# Getting Started with YARD
-eot
-        expect(extract_messages(text, :have_header => true)).to eq(
-          [[:attribute, "title", "Getting Started Guide", 1],
-           [:paragraph, "# Getting Started with YARD", 3]]
-        )
-      end
-
-      it "ignores markup line" do
-        text = <<-eot
-#!markdown
-# @title Getting Started Guide
-
-# Getting Started with YARD
-eot
-        expect(extract_messages(text, :have_header => true)).to eq(
-          [[:attribute, "title", "Getting Started Guide", 2],
-           [:paragraph, "# Getting Started with YARD", 4]]
-        )
-      end
-
-      it "terminates header block by markup line not at the first line" do
-        text = <<-eot
-# @title Getting Started Guide
-#!markdown
-
-# Getting Started with YARD
-eot
-        expect(extract_messages(text, :have_header => true)).to eq(
-          [[:attribute, "title", "Getting Started Guide", 1],
-           [:paragraph, "#!markdown", 2],
-           [:paragraph, "# Getting Started with YARD", 4]]
-        )
-      end
-    end
-
-    describe "Body" do
-      it "splits to paragraphs" do
-        paragraph1 = <<-eop.strip
-Note that class methods must not be referred to with the "::" namespace
-separator. Only modules, classes and constants should use "::".
-eop
-        paragraph2 = <<-eop.strip
-You can also do lookups on any installed gems. Just make sure to build the
-.yardoc databases for installed gems with:
-eop
-        text = <<-eot
-#{paragraph1}
-
-#{paragraph2}
-eot
-        expect(extract_messages(text)).to eq(
-          [[:paragraph, paragraph1, 1],
-           [:paragraph, paragraph2, 4]]
-        )
-      end
-    end
-  end
-
-  describe "#translate" do
-    def locale
-      locale = YARD::I18n::Locale.new("fr")
-      messages = locale.instance_variable_get(:@messages)
-      messages["markdown"] = "markdown (markdown in fr)"
-      messages["Hello"] = "Bonjour (Hello in fr)"
-      messages["Paragraph 1."] = "Paragraphe 1."
-      messages["Paragraph 2."] = "Paragraphe 2."
-      locale
-    end
-
-    def translate(input, options = {})
-      text = YARD::I18n::Text.new(StringIO.new(input), options)
-      text.translate(locale)
-    end
-
-    describe "Header" do
-      it "extracts at attribute" do
-        text = <<-eot
-# @title Hello
-
-# Getting Started with YARD
-
-Paragraph.
-eot
-        expect(translate(text, :have_header => true)).to eq <<-eot
-# @title Bonjour (Hello in fr)
-
-# Getting Started with YARD
-
-Paragraph.
-eot
-      end
-
-      it "ignores markup line" do
-        text = <<-eot
-#!markdown
-# @title Hello
-
-# Getting Started with YARD
-
-Paragraph.
-eot
-        expect(translate(text, :have_header => true)).to eq <<-eot
-#!markdown
-# @title Bonjour (Hello in fr)
-
-# Getting Started with YARD
-
-Paragraph.
-eot
-      end
-    end
-
-    describe "Body" do
-      it "splits to paragraphs" do
-        paragraph1 = <<-eop.strip
-Paragraph 1.
-eop
-        paragraph2 = <<-eop.strip
-Paragraph 2.
-eop
-        text = <<-eot
-#{paragraph1}
-
-#{paragraph2}
-eot
-        expect(translate(text)).to eq <<-eot
-Paragraphe 1.
-
-Paragraphe 2.
-eot
-      end
-
-      it "does not modify non-translated message" do
-        nonexistent_paragraph = <<-eop.strip
-Nonexsitent paragraph.
-eop
-        text = <<-eot
-#{nonexistent_paragraph}
-eot
-        expect(translate(text)).to eq <<-eot
-#{nonexistent_paragraph}
-eot
-      end
-
-      it "keeps empty lines" do
-        text = <<-eot
-Paragraph 1.
-
-
-
-
-Paragraph 2.
-eot
-        expect(translate(text)).to eq <<-eot
-Paragraphe 1.
-
-
-
-
-Paragraphe 2.
-eot
-      end
-    end
-  end
-end

data/spec/logging_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Logger do
-  describe "#show_backtraces" do
-    it "is true if debug level is on" do
-      log.show_backtraces = true
-      log.enter_level(Logger::DEBUG) do
-        log.show_backtraces = false
-        expect(log.show_backtraces).to be true
-      end
-      expect(log.show_backtraces).to be false
-    end
-  end
-
-  describe "#backtrace" do
-    before { log.show_backtraces = true }
-    after  { log.show_backtraces = false }
-
-    it "logs backtrace in error by default" do
-      expect(log).to receive(:error).with("RuntimeError: foo")
-      expect(log).to receive(:error).with("Stack trace:\n\tline1\n\tline2\n")
-      exc = RuntimeError.new("foo")
-      exc.set_backtrace(['line1', 'line2'])
-      log.enter_level(Logger::INFO) { log.backtrace(exc) }
-    end
-
-    it "allows backtrace to be entered in other modes" do
-      expect(log).to receive(:warn).with("RuntimeError: foo")
-      expect(log).to receive(:warn).with("Stack trace:\n\tline1\n\tline2\n")
-      exc = RuntimeError.new("foo")
-      exc.set_backtrace(['line1', 'line2'])
-      log.enter_level(Logger::INFO) { log.backtrace(exc, :warn) }
-    end
-  end
-
-  describe '#warn' do
-    before  { log.warned = false }
-    after   { log.warned = false }
-
-    it 'changes #warned from false to true' do
-      expect { log.warn('message') }.to change(log, :warned).from(false).to(true)
-    end
-  end
-end

data/spec/options_spec.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Options do
-  class FooOptions < YARD::Options
-    attr_accessor :foo
-    def initialize; self.foo = "abc" end
-  end
-
-  describe ".default_attr" do
-    it "allows default attributes to be defined with symbols" do
-      class DefaultOptions1 < YARD::Options
-        default_attr :foo, 'HELLO'
-      end
-      o = DefaultOptions1.new
-      o.reset_defaults
-      expect(o.foo).to eq 'HELLO'
-    end
-
-    it "calls lambda if value is a Proc" do
-      class DefaultOptions2 < YARD::Options
-        default_attr :foo, lambda { 100 }
-      end
-      o = DefaultOptions2.new
-      o.reset_defaults
-      expect(o.foo).to eq 100
-    end
-  end
-
-  describe "#reset_defaults" do
-    it "does not define defaults until reset is called" do
-      class ResetDefaultOptions1 < YARD::Options
-        default_attr :foo, 'FOO'
-      end
-      expect(ResetDefaultOptions1.new.foo).to be nil
-      o = ResetDefaultOptions1.new
-      o.reset_defaults
-      expect(o.foo).to eq 'FOO'
-    end
-
-    it "uses defaults from superclass as well" do
-      class ResetDefaultOptions2 < YARD::Options
-        default_attr :foo, 'FOO'
-      end
-      class ResetDefaultOptions3 < ResetDefaultOptions2
-      end
-      o = ResetDefaultOptions3.new
-      o.reset_defaults
-      expect(o.foo).to eq 'FOO'
-    end
-  end
-
-  describe "#delete" do
-    it "deletes an option" do
-      o = FooOptions.new
-      o.delete(:foo)
-      expect(o.to_hash).to eq({})
-    end
-
-    it "does not error if an option is deleted that does not exist" do
-      o = FooOptions.new
-      o.delete(:foo)
-      o.delete(:foo)
-      expect(o.to_hash).to eq({})
-    end
-  end
-
-  describe "#[]" do
-    it "handles getting option values using hash syntax" do
-      expect(FooOptions.new[:foo]).to eq "abc"
-    end
-  end
-
-  describe "#[]=" do
-    it "handles setting options using hash syntax" do
-      o = FooOptions.new
-      o[:foo] = "xyz"
-      expect(o[:foo]).to eq "xyz"
-    end
-
-    it "allows setting of unregistered keys" do
-      o = FooOptions.new
-      o[:bar] = "foo"
-      expect(o[:bar]).to eq "foo"
-    end
-  end
-
-  describe "#method_missing" do
-    it "allows setting of unregistered keys" do
-      o = FooOptions.new
-      o.bar = 'foo'
-      expect(o.bar).to eq 'foo'
-    end
-
-    it "allows getting values of unregistered keys (return nil)" do
-      expect(FooOptions.new.bar).to be nil
-    end
-
-    it "prints debugging messages about unregistered keys" do
-      expect(log).to receive(:debug).with("Attempting to access unregistered key bar on FooOptions")
-      FooOptions.new.bar
-      expect(log).to receive(:debug).with("Attempting to set unregistered key bar on FooOptions")
-      FooOptions.new.bar = 1
-    end
-  end
-
-  describe "#update" do
-    it "allows updating of options" do
-      expect(FooOptions.new.update(:foo => "xyz").foo).to eq "xyz"
-    end
-
-    it "does not ignore keys with no setter (OpenStruct behaviour)" do
-      o = FooOptions.new
-      o.update(:bar => "xyz")
-      expect(o.to_hash).to eq(:foo => "abc", :bar => "xyz")
-    end
-  end
-
-  describe "#merge" do
-    it "updates a new object" do
-      o = FooOptions.new
-      expect(o.merge(:foo => "xyz").object_id).not_to eq o.object_id
-      expect(o.merge(:foo => "xyz").to_hash).to eq(:foo => "xyz")
-    end
-
-    it "adds in values from original object" do
-      o = FooOptions.new
-      o.update(:bar => "foo")
-      expect(o.merge(:baz => 1).to_hash).to eq(:foo => "abc", :bar => "foo", :baz => 1)
-    end
-  end
-
-  describe "#to_hash" do
-    it "converts all instance variables and symbolized keys" do
-      class ToHashOptions1 < YARD::Options
-        attr_accessor :foo, :bar, :baz
-        def initialize; @foo = 1; @bar = 2; @baz = "hello" end
-      end
-      o = ToHashOptions1.new
-      hash = o.to_hash
-      expect(hash.keys).to include(:foo, :bar, :baz)
-      expect(hash[:foo]).to eq 1
-      expect(hash[:bar]).to eq 2
-      expect(hash[:baz]).to eq "hello"
-    end
-
-    it "uses accessor when converting values to hash" do
-      class ToHashOptions2 < YARD::Options
-        def initialize; @foo = 1 end
-        def foo; "HELLO#{@foo}" end
-      end
-      o = ToHashOptions2.new
-      expect(o.to_hash).to eq(:foo => "HELLO1")
-    end
-
-    it "ignores ivars with no accessor" do
-      class ToHashOptions3 < YARD::Options
-        attr_accessor :foo
-        def initialize; @foo = 1; @bar = "NOIGNORE" end
-      end
-      o = ToHashOptions3.new
-      expect(o.to_hash).to eq(:foo => 1, :bar => "NOIGNORE")
-    end
-  end
-
-  describe "#tap" do
-    it "supports #tap(&block) (even in 1.8.6)" do
-      o = FooOptions.new.tap {|obj| obj.foo = :BAR }
-      expect(o.to_hash).to eq(:foo => :BAR)
-    end
-  end
-end

data/spec/parser/base_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Parser::Base do
-  describe "#initialize" do
-    class MyParser < Parser::Base; def initialize(a, b) end end
-
-    it "takes 2 arguments" do
-      expect { YARD::Parser::Base.new }.to raise_error(ArgumentError,
-        /wrong (number|#) of arguments|given 0, expected 2/)
-    end
-
-    it "raises NotImplementedError on #initialize" do
-      expect { YARD::Parser::Base.new('a', 'b') }.to raise_error(NotImplementedError)
-    end
-
-    it "raises NotImplementedError on #parse" do
-      expect { MyParser.new('a', 'b').parse }.to raise_error(NotImplementedError)
-    end
-
-    it "raises NotImplementedError on #tokenize" do
-      expect { MyParser.new('a', 'b').tokenize }.to raise_error(NotImplementedError)
-    end
-  end
-end

data/spec/parser/c_parser_spec.rb

@@ -1,236 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::Parser::C::CParser do
-  describe "#parse" do
-    def parse(contents)
-      Registry.clear
-      YARD.parse_string(contents, :c)
-    end
-
-    describe "Array class" do
-      before(:all) do
-        file = File.join(File.dirname(__FILE__), 'examples', 'array.c.txt')
-        parse(File.read(file))
-      end
-
-      it "parses Array class" do
-        obj = YARD::Registry.at('Array')
-        expect(obj).not_to be nil
-        expect(obj.docstring).not_to be_blank
-      end
-
-      it "parses method" do
-        obj = YARD::Registry.at('Array#initialize')
-        expect(obj.docstring).not_to be_blank
-        expect(obj.tags(:overload).size).to be > 1
-      end
-
-      it "parses new_ary return type" do
-        obj = YARD::Registry.at('Array#map')
-        expect(obj.tags(:overload).count do |overload|
-          overload.tag(:return) && overload.tag(:return).types == ['Enumerator']
-        end).to eq 2
-        expect(obj.tags(:overload).count do |overload|
-          overload.tag(:return) && overload.tag(:return).types == ['Array']
-        end).to eq 2
-      end
-    end
-
-    describe "C++ namespace" do
-      before(:all) do
-        file = File.join(File.dirname(__FILE__), 'examples', 'namespace.cpp.txt')
-        parse(File.read(file))
-      end
-
-      it "parses Rect class" do
-        obj = YARD::Registry.at('Rect')
-        expect(obj).not_to be nil
-        expect(obj.docstring).not_to be_blank
-      end
-
-      it "parses method inside of namespace" do
-        obj = YARD::Registry.at('Rect#inspect')
-        expect(obj.docstring).not_to be_blank
-      end
-
-      it "parses method after namespace" do
-        obj = YARD::Registry.at('Rect#hello_world')
-        expect(obj.docstring).not_to be_blank
-      end
-    end
-
-    describe "Source located in extra files" do
-      before(:all) do
-        @multifile = File.join(File.dirname(__FILE__), 'examples', 'multifile.c.txt')
-        @extrafile = File.join(File.dirname(__FILE__), 'examples', 'extrafile.c.txt')
-        @contents = File.read(@multifile)
-      end
-
-      it "looks for methods in extra files (if 'in' comment is found)" do
-        extra_contents = File.read(@extrafile)
-        expect(File).to receive(:read).with('extra.c').and_return(extra_contents)
-        parse(@contents)
-        expect(Registry.at('Multifile#extra').docstring).to eq 'foo'
-      end
-
-      it "stops searching for extra source file gracefully if file is not found" do
-        expect(File).to receive(:read).with('extra.c').and_raise(Errno::ENOENT)
-        expect(log).to receive(:warn).with("Missing source file `extra.c' when parsing Multifile#extra")
-        parse(@contents)
-        expect(Registry.at('Multifile#extra').docstring).to eq ''
-      end
-
-      it "differentiates between a struct and a pointer to a struct retval" do
-        parse(@contents)
-        expect(Registry.at('Multifile#hello_mars').docstring).to eq 'Hello Mars'
-      end
-    end
-
-    describe "Foo class" do
-      it "does not include comments in docstring source" do
-        parse <<-eof
-          /*
-           * Hello world
-           */
-          VALUE foo(VALUE x) {
-            int value = x;
-          }
-
-          void Init_Foo() {
-            rb_define_method(rb_cFoo, "foo", foo, 1);
-          }
-        eof
-        expect(Registry.at('Foo#foo').source.gsub(/\s\s+/, ' ')).to eq(
-          "VALUE foo(VALUE x) { int value = x;\n}"
-        )
-      end
-    end
-
-    describe "Constant" do
-      it "does not truncate docstring" do
-        parse <<-eof
-          #define MSK_DEADBEEF 0xdeadbeef
-          void
-          Init_Mask(void)
-          {
-              rb_cMask  = rb_define_class("Mask", rb_cObject);
-              /* 0xdeadbeef: This constant is frequently used to indicate a
-               * software crash or deadlock in embedded systems. */
-              rb_define_const(rb_cMask, "DEADBEEF", INT2FIX(MSK_DEADBEEF));
-          }
-        eof
-        constant = Registry.at('Mask::DEADBEEF')
-        expect(constant.value).to eq '0xdeadbeef'
-        expect(constant.docstring).to eq "This constant is frequently used to indicate a\nsoftware crash or deadlock in embedded systems."
-      end
-    end
-
-    describe "Macros" do
-      it "handles param## inside of macros" do
-        thr = Thread.new do
-          parse <<-eof
-          void
-          Init_gobject_gparamspecs(void)
-          {
-              VALUE cParamSpec = GTYPE2CLASS(G_TYPE_PARAM);
-              VALUE c;
-
-          #define DEF_NUMERIC_PSPEC_METHODS(c, typename) \
-            G_STMT_START {\
-              rbg_define_method(c, "initialize", typename##_initialize, 7); \
-              rbg_define_method(c, "minimum", typename##_minimum, 0); \
-              rbg_define_method(c, "maximum", typename##_maximum, 0); \
-              rbg_define_method(c, "range", typename##_range, 0); \
-            } G_STMT_END
-
-          #if 0
-              rbg_define_method(c, "default_value", typename##_default_value, 0); \
-              rb_define_alias(c, "default", "default_value"); \
-
-          #endif
-
-              c = G_DEF_CLASS(G_TYPE_PARAM_CHAR, "Char", cParamSpec);
-              DEF_NUMERIC_PSPEC_METHODS(c, char);
-          eof
-        end
-        thr.join(5)
-        if thr.alive?
-          thr.kill
-          raise "Did not parse in time"
-        end
-      end
-    end
-
-    describe "C macros in declaration" do
-      it "handles C macros in method declaration" do
-        Registry.clear
-        parse <<-eof
-        // docstring
-        FOOBAR VALUE func() { }
-
-        void
-        Init_mod(void)
-        {
-          rb_define_method(rb_cFoo, "func", func, 0); \
-        }
-        eof
-
-        expect(Registry.at('Foo#func').docstring).to eq "docstring"
-      end
-    end
-
-    describe "File singleton methods" do
-      before(:all) do
-        file = File.join(File.dirname(__FILE__), 'examples', 'file.c.txt')
-        parse(File.read(file))
-      end
-
-      it "parses methods from define_filetest_function" do
-        obj = YARD::Registry.at('File.exist?')
-        expect(obj).not_to be nil
-        expect(obj.docstring).not_to be_blank
-      end
-    end
-  end
-
-  describe "Override comments" do
-    before(:all) do
-      Registry.clear
-      override_file = File.join(File.dirname(__FILE__), 'examples', 'override.c.txt')
-      @override_parser = YARD.parse_string(File.read(override_file), :c)
-    end
-
-    it "parses GMP::Z class" do
-      z = YARD::Registry.at('GMP::Z')
-      expect(z).not_to be nil
-      expect(z.docstring).not_to be_blank
-    end
-
-    it "parses GMP::Z methods w/ bodies" do
-      add = YARD::Registry.at('GMP::Z#+')
-      expect(add.docstring).not_to be_blank
-      expect(add.source).not_to be nil
-      expect(add.source).not_to be_empty
-
-      add_self = YARD::Registry.at('GMP::Z#+')
-      expect(add_self.docstring).not_to be_blank
-      expect(add_self.source).not_to be nil
-      expect(add_self.source).not_to be_empty
-
-      sqrtrem = YARD::Registry.at('GMP::Z#+')
-      expect(sqrtrem.docstring).not_to be_blank
-      expect(sqrtrem.source).not_to be nil
-      expect(sqrtrem.source).not_to be_empty
-    end
-
-    it "parses GMP::Z methods w/o bodies" do
-      neg = YARD::Registry.at('GMP::Z#neg')
-      expect(neg.docstring).not_to be_blank
-      expect(neg.source).to be nil
-
-      neg_self = YARD::Registry.at('GMP::Z#neg')
-      expect(neg_self.docstring).not_to be_blank
-      expect(neg_self.source).to be nil
-    end
-  end
-end