yard 0.9.23 → 0.9.27

data/spec/i18n/pot_generator_spec.rb

@@ -1,295 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::I18n::PotGenerator do
-  def create_messages(messages)
-    yard_messages = YARD::I18n::Messages.new
-    add_messages(yard_messages, messages)
-    yard_messages
-  end
-
-  def add_messages(yard_messages, messages)
-    messages.each do |id, properties|
-      yard_message = yard_messages.register(id)
-      (properties[:locations] || []).each do |path, line|
-        yard_message.add_location(path, line)
-      end
-      (properties[:comments] || []).each do |comment|
-        yard_message.add_comment(comment)
-      end
-    end
-  end
-
-  before do
-    @generator = YARD::I18n::PotGenerator.new("..")
-  end
-
-  describe "Generate" do
-    it "generates the default header" do
-      current_time = Time.parse("2011-11-20 22:17+0900")
-      allow(@generator).to receive(:current_time).and_return(current_time)
-      pot_creation_date = current_time.strftime("%Y-%m-%d %H:%M%z")
-      expect(@generator.generate).to eq <<-eoh
-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSION\\n"
-"Report-Msgid-Bugs-To: \\n"
-"POT-Creation-Date: #{pot_creation_date}\\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
-"Language-Team: LANGUAGE <LL@li.org>\\n"
-"Language: \\n"
-"MIME-Version: 1.0\\n"
-"Content-Type: text/plain; charset=UTF-8\\n"
-"Content-Transfer-Encoding: 8bit\\n"
-
-eoh
-    end
-
-    it "generates messages in location order" do
-      allow(@generator).to receive(:header).and_return("HEADER\n\n")
-      messages = {
-        "tag|see|Parser::SourceParser.parse" => {
-          :locations => [["yard.rb", 14]],
-          :comments => ["@see"]
-        },
-        "Parses a path or set of paths" => {
-          :locations => [["yard.rb", 12], ["yard/parser/source_parser.rb", 83]],
-          :comments => ["YARD.parse", "YARD::Parser::SourceParser.parse"]
-        }
-      }
-      add_messages(@generator.messages, messages)
-      expect(@generator.generate).to eq <<-'eoh'
-HEADER
-
-# YARD.parse
-# YARD::Parser::SourceParser.parse
-#: ../yard.rb:12
-#: ../yard/parser/source_parser.rb:83
-msgid "Parses a path or set of paths"
-msgstr ""
-
-# @see
-#: ../yard.rb:14
-msgid "tag|see|Parser::SourceParser.parse"
-msgstr ""
-
-eoh
-    end
-  end
-
-  describe "Escape" do
-    def generate_message_pot(message_id)
-      pot = String.new("")
-      message = YARD::I18n::Message.new(message_id)
-      @generator.send(:generate_message, pot, message)
-      pot
-    end
-
-    it "escapes <\\>" do
-      expect(generate_message_pot("hello \\ world")).to eq <<-'eop'
-msgid "hello \\ world"
-msgstr ""
-
-eop
-    end
-
-    it "escapes <\">" do
-      expect(generate_message_pot("hello \" world")).to eq <<-'eop'
-msgid "hello \" world"
-msgstr ""
-
-eop
-    end
-
-    it "escapes <\\n>" do
-      expect(generate_message_pot("hello \n world")).to eq <<-'eop'
-msgid "hello \n"
-" world"
-msgstr ""
-
-eop
-    end
-  end
-
-  describe "Object" do
-    before do
-      Registry.clear
-      @yard = YARD::CodeObjects::ModuleObject.new(:root, :YARD)
-    end
-
-    it "extracts at docstring" do
-      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
-        o.docstring = "An alias to {Parser::SourceParser}'s parsing method"
-      end
-      @generator.parse_objects([object])
-      expect(@generator.messages).to eq create_messages(
-        "An alias to {Parser::SourceParser}'s parsing method" => {
-          :locations => [],
-          :comments => ["YARD.parse"]
-        }
-      )
-    end
-
-    it "extracts at location" do
-      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
-        o.docstring = "An alias to {Parser::SourceParser}'s parsing method"
-        o.files = [["yard.rb", 12]]
-      end
-      @generator.parse_objects([object])
-      expect(@generator.messages).to eq create_messages(
-        "An alias to {Parser::SourceParser}'s parsing method" => {
-          :locations => [["yard.rb", 13]],
-          :comments => ["YARD.parse"]
-        }
-      )
-    end
-
-    it "extracts at tag name" do
-      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
-        o.docstring = "@see Parser::SourceParser.parse"
-        o.files = [["yard.rb", 12]]
-      end
-      @generator.parse_objects([object])
-      expect(@generator.messages).to eq create_messages(
-        "tag|see|Parser::SourceParser.parse" => {
-          :locations => [["yard.rb", 12]],
-          :comments => ["@see"]
-        }
-      )
-    end
-
-    it "extracts at tag text" do
-      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
-        o.docstring = <<-eod
-@example Parse a glob of files
-  YARD.parse('lib/**/*.rb')
-eod
-        o.files = [["yard.rb", 12]]
-      end
-      @generator.parse_objects([object])
-      expect(@generator.messages).to eq create_messages(
-        "tag|example|Parse a glob of files" => {
-          :locations => [["yard.rb", 12]],
-          :comments => ["@example"]
-        },
-        "YARD.parse('lib/**/*.rb')" => {
-          :locations => [["yard.rb", 12]],
-          :comments => ["@example Parse a glob of files"]
-        }
-      )
-    end
-
-    it "extracts at tag types" do
-      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
-        o.docstring = <<-eod
-@param [String, Array<String>] paths a path, glob, or list of paths to
-  parse
-eod
-        o.files = [["yard.rb", 12]]
-      end
-      @generator.parse_objects([object])
-      expect(@generator.messages).to eq create_messages(
-        "tag|param|paths" => {
-          :locations => [["yard.rb", 12]],
-          :comments => ["@param [String, Array<String>]"]
-        },
-        "a path, glob, or list of paths to\nparse" => {
-          :locations => [["yard.rb", 12]],
-          :comments => ["@param [String, Array<String>] paths"]
-        }
-      )
-    end
-
-    it "extracts at overload tag recursively" do
-      object = YARD::CodeObjects::MethodObject.new(@yard, :parse, :module) do |o|
-        o.docstring = <<-eod
-@overload foo(i)
-  docstring foo(i)
-  @param [Integer] i integer parameter
-eod
-      end
-
-      @generator.parse_objects([object])
-      expect(@generator.messages).to eq create_messages(
-        "tag|overload|foo" => {
-          :locations => [],
-          :comments => ["@overload"]
-        },
-        "docstring foo(i)" => {
-          :locations => [],
-          :comments => ["YARD.parse"]
-        },
-        "tag|param|i" => {
-          :locations => [],
-          :comments => ["@param [Integer]"]
-        },
-        "integer parameter" => {
-          :locations => [],
-          :comments => ["@param [Integer] i"]
-        }
-      )
-    end
-  end
-
-  describe "File" do
-    it "extracts at attribute" do
-      path = "GettingStarted.md"
-      text = <<-eor
-# @title Getting Started Guide
-
-# Getting Started with YARD
-eor
-      allow(File).to receive(:open).with(path).and_yield(StringIO.new(text))
-      allow(File).to receive(:read).with(path).and_return(text)
-      file = YARD::CodeObjects::ExtraFileObject.new(path)
-      @generator.parse_files([file])
-      expect(@generator.messages).to eq create_messages(
-        "Getting Started Guide" => {
-          :locations => [[path, 1]],
-          :comments => ["title"]
-        },
-        "# Getting Started with YARD" => {
-          :locations => [[path, 3]],
-          :comments => []
-        }
-      )
-    end
-
-    it "extracts at paragraphs" do
-      path = "README.md"
-      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
-      allow(File).to receive(:open).with(path).and_yield(StringIO.new(text))
-      allow(File).to receive(:read).with(path).and_return(text)
-      file = YARD::CodeObjects::ExtraFileObject.new(path)
-      @generator.parse_files([file])
-      expect(@generator.messages).to eq create_messages(
-        paragraph1 => {
-          :locations => [[path, 1]],
-          :comments => []
-        },
-        paragraph2 => {
-          :locations => [[path, 4]],
-          :comments => []
-        }
-      )
-    end
-  end
-end

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