yard 0.9.21 → 0.9.26

data/spec/cli/command_parser_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::CLI::CommandParser do
-  describe "#run" do
-    before do
-      @cmd = CLI::CommandParser.new
-    end
-
-    it "shows help if --help is provided" do
-      command = double(:command)
-      expect(command).to receive(:run).with('--help')
-      CLI::CommandParser.commands[:foo] = command
-      @cmd.class.default_command = :foo
-      @cmd.run(*%w(foo --help))
-    end
-
-    it "uses default command if first argument is a switch" do
-      command = double(:command)
-      expect(command).to receive(:run).with('--a', 'b', 'c')
-      CLI::CommandParser.commands[:foo] = command
-      @cmd.class.default_command = :foo
-      @cmd.run(*%w(--a b c))
-    end
-
-    it "uses default command if no arguments are provided" do
-      command = double(:command)
-      expect(command).to receive(:run)
-      CLI::CommandParser.commands[:foo] = command
-      @cmd.class.default_command = :foo
-      @cmd.run
-    end
-
-    it "lists commands if command is not found" do
-      expect(@cmd).to receive(:list_commands)
-      @cmd.run(*%w(unknown_command --args))
-    end
-
-    it "lists commands if --help is provided as sole argument" do
-      expect(@cmd).to receive(:list_commands)
-      @cmd.run(*%w(--help))
-    end
-  end
-end

data/spec/cli/command_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-require 'optparse'
-
-RSpec.describe YARD::CLI::Command do
-  describe "#parse_options" do
-    before do
-      @options = OptionParser.new
-      @saw_foo = false
-      @options.on('--foo') { @saw_foo = true }
-    end
-
-    def parse(*args)
-      CLI::Command.new.send(:parse_options, @options, args)
-      args
-    end
-
-    it "skips unrecognized options but continue to next option" do
-      expect(log).to receive(:warn).with(/Unrecognized.*--list/)
-      expect(log).to receive(:warn).with(/Unrecognized.*--list2/)
-      parse('--list', '--list2', '--foo')
-      expect(@saw_foo).to be true
-    end
-
-    it "skips unrecognized options and any extra non-option arg that follows" do
-      expect(log).to receive(:warn).with(/Unrecognized.*--list/)
-      parse('--list', 'foo', '--foo')
-      expect(@saw_foo).to be true
-    end
-
-    it "stops retrying to parse at non-switch argument" do
-      expect(log).to receive(:warn).with(/Unrecognized.*--list/)
-      args = parse('--list', 'foo', 'foo', 'foo')
-      expect(args).to eq %w(foo foo)
-    end
-  end
-end

data/spec/cli/config_spec.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-require 'yaml'
-
-RSpec.describe YARD::CLI::Config do
-  before do
-    @config = YARD::CLI::Config.new
-    YARD::Config.options = YARD::Config::DEFAULT_CONFIG_OPTIONS.dup
-    allow(YARD::Config).to receive(:save)
-  end
-
-  def run(*args)
-    @config.run(*args)
-  end
-
-  describe "Listing configuration" do
-    it "accepts --list" do
-      opts = YARD::Config.options
-      expect(YAML).to receive(:dump).twice.and_return("--- foo\nbar\nbaz")
-      expect(log).to receive(:puts).twice.with("bar\nbaz")
-      run
-      run('--list')
-      expect(YARD::Config.options).to eq opts
-    end
-  end
-
-  describe "Viewing an item" do
-    it "views item if no value is given" do
-      YARD::Config.options[:foo] = 'bar'
-      expect(log).to receive(:puts).with('"bar"')
-      run 'foo'
-      expect(YARD::Config.options[:foo]).to eq 'bar'
-    end
-  end
-
-  describe "Modifying an item" do
-    it "accepts --reset to set value" do
-      YARD::Config.options[:load_plugins] = 'foo'
-      run('--reset', 'load_plugins')
-      expect(YARD::Config.options[:load_plugins]).to be false
-    end
-
-    it "accepts --as-list to force single item as list" do
-      run('--as-list', 'foo', 'bar')
-      expect(YARD::Config.options[:foo]).to eq ['bar']
-    end
-
-    it "accepts --append to append values to existing key" do
-      YARD::Config.options[:foo] = ['bar']
-      run('--append', 'foo', 'baz', 'quux')
-      expect(YARD::Config.options[:foo]).to eq ['bar', 'baz', 'quux']
-      run('-a', 'foo', 'last')
-      expect(YARD::Config.options[:foo]).to eq ['bar', 'baz', 'quux', 'last']
-    end
-
-    it "turns key into list if --append is used on single item" do
-      YARD::Config.options[:foo] = 'bar'
-      run('-a', 'foo', 'baz')
-      expect(YARD::Config.options[:foo]).to eq ['bar', 'baz']
-    end
-
-    it "modifies item if value is given" do
-      run('foo', 'xxx')
-      expect(YARD::Config.options[:foo]).to eq 'xxx'
-    end
-
-    it "turns list of values into array of values" do
-      run('foo', 'a', 'b', '1', 'true', 'false')
-      expect(YARD::Config.options[:foo]).to eq ['a', 'b', 1, true, false]
-    end
-
-    it "turns number into numeric Ruby type" do
-      run('foo', '1')
-      expect(YARD::Config.options[:foo]).to eq 1
-    end
-
-    it "turns true into TrueClass" do
-      run('foo', 'true')
-      expect(YARD::Config.options[:foo]).to be true
-    end
-
-    it "turns false into FalseClass" do
-      run('foo', 'false')
-      expect(YARD::Config.options[:foo]).to be false
-    end
-
-    it "saves on modification" do
-      expect(YARD::Config).to receive(:save)
-      run('foo', 'true')
-    end
-  end
-
-  describe "RubyGems hooks" do
-    require 'rubygems'
-
-    class FakeGemConfig < Hash
-      attr_accessor :written
-      def write; @written = true end
-      def path; nil end
-    end
-
-    before do
-      allow(Gem).to receive(:configuration).and_return(FakeGemConfig.new)
-    end
-
-    it "accepts --gem-install-yri" do
-      @config.send(:optparse, '--gem-install-yri')
-      expect(@config.gem_install_cmd).to eq 'yri'
-    end
-
-    it "accepts --gem-install-yard" do
-      @config.send(:optparse, '--gem-install-yard')
-      expect(@config.gem_install_cmd).to eq 'yard'
-    end
-
-    it "does not change back to yri if yard was specified" do
-      @config.send(:optparse, '--gem-install-yard', '--gem-install-yri')
-      expect(@config.gem_install_cmd).to eq 'yard'
-    end
-
-    it "ignores actual config options" do
-      run('--gem-install-yri', 'foo', 'true')
-      expect(YARD::Config).not_to receive(:save)
-    end
-
-    it "updates configuration as :gem if no configuration exists" do
-      run('--gem-install-yri')
-      expect(Gem.configuration[:gem]).to eq "--document=yri"
-      expect(Gem.configuration.written).to eq true
-    end
-
-    [:install, "install", :gem, "gem"].each do |type|
-      it "finds existing config in #{type.inspect} and updates that line without changing anything else" do
-        Gem.configuration[type] = "--opts x"
-        run('--gem-install-yri')
-        expect(Gem.configuration[type]).to eq "--opts x --document=yri"
-        ([:install, "install", :gem, "gem"] - [type]).each do |other|
-          expect(Gem.configuration[other]).to eq nil
-        end
-      end
-    end
-
-    it "scrubs --document values from existing config" do
-      Gem.configuration["gem"] = "--document=yri,ri --no-document --opts x"
-      run('--gem-install-yri')
-      expect(Gem.configuration["gem"]).to eq "--opts x --document=yri"
-    end
-  end
-end

data/spec/cli/diff_spec.rb

@@ -1,254 +0,0 @@
-# frozen_string_literal: true
-require 'stringio'
-require 'open-uri'
-
-RSpec.describe YARD::CLI::Diff do
-  before do
-    allow(CLI::Yardoc).to receive(:run)
-    allow(CLI::Gems).to receive(:run)
-    @diff = CLI::Diff.new
-  end
-
-  describe "Argument handling" do
-    it "exits if there is only one gem name" do
-      expect(@diff).to receive(:exit)
-      expect(log).to receive(:puts).with(/Usage/)
-      @diff.run
-    end
-  end
-
-  describe "Diffing" do
-    before do
-      @objects1 = nil
-      @objects2 = nil
-    end
-
-    def run(*args)
-      @all_call = -1
-      @data = StringIO.new
-      @objects1 ||= %w(C#fooey C#baz D.bar)
-      @objects2 ||= %w(A A::B A::B::C A.foo A#foo B C.foo C.bar C#baz)
-      @objects = [@objects1, @objects2]
-      expect(@diff).to receive(:load_gem_data).ordered.with('gem1') do
-        Registry.clear
-        YARD.parse_string <<-eof
-          class C
-            def fooey; end
-            def baz; FOO end
-          end
-          class D
-            def self.bar; end
-          end
-        eof
-      end
-      expect(@diff).to receive(:load_gem_data).ordered.with('gem2') do
-        Registry.clear
-        YARD.parse_string <<-eof
-          module A
-            module B
-              class C; end
-            end
-            def self.foo; end
-            def foo; end
-          end
-          class C
-            def self.foo; end
-            def self.bar; end
-            def baz; BAR end
-          end
-        eof
-      end
-      allow(log).to receive(:print) {|data| @data << data }
-      allow(log).to receive(:puts) {|*pargs| @data << pargs.join("\n"); @data << "\n" }
-      @diff.run(*(args + ['gem1', 'gem2']))
-    end
-
-    it "shows differences between objects" do
-      run
-      expect(@data.string).to eq <<-eof
-Added objects:
-
-  A ((stdin):1) (...)
-  A::B::C ((stdin):3)
-  C.bar ((stdin):10)
-  C.foo ((stdin):9)
-
-Modified objects:
-
-  C#baz ((stdin):3)
-
-Removed objects:
-
-  C#fooey ((stdin):2)
-  D ((stdin):5) (...)
-
-eof
-    end
-
-    it "accepts --compact" do
-      run('--compact')
-      expect(@data.string).to eq <<-eof
-A A ((stdin):1) (...)
-A A::B::C ((stdin):3)
-A C.bar ((stdin):10)
-A C.foo ((stdin):9)
-M C#baz ((stdin):3)
-D C#fooey ((stdin):2)
-D D ((stdin):5) (...)
-eof
-    end
-
-    it "accepts -a/--all" do
-      ['-a', '--all'].each do |opt|
-        run(opt)
-        expect(@data.string).to eq <<-eof
-Added objects:
-
-  A ((stdin):1)
-  A#foo ((stdin):6)
-  A.foo ((stdin):5)
-  A::B ((stdin):2)
-  A::B::C ((stdin):3)
-  C.bar ((stdin):10)
-  C.foo ((stdin):9)
-
-Modified objects:
-
-  C#baz ((stdin):3)
-
-Removed objects:
-
-  C#fooey ((stdin):2)
-  D ((stdin):5)
-  D.bar ((stdin):6)
-
-eof
-      end
-    end
-
-    it "accepts --compact and --all" do
-      run('--compact', '--all')
-      expect(@data.string).to eq <<-eof
-A A ((stdin):1)
-A A#foo ((stdin):6)
-A A.foo ((stdin):5)
-A A::B ((stdin):2)
-A A::B::C ((stdin):3)
-A C.bar ((stdin):10)
-A C.foo ((stdin):9)
-M C#baz ((stdin):3)
-D C#fooey ((stdin):2)
-D D ((stdin):5)
-D D.bar ((stdin):6)
-eof
-    end
-
-    it "accepts --no-modified" do
-      run('--compact', '--no-modified')
-      expect(@data.string).to eq <<-eof
-A A ((stdin):1) (...)
-A A::B::C ((stdin):3)
-A C.bar ((stdin):10)
-A C.foo ((stdin):9)
-D C#fooey ((stdin):2)
-D D ((stdin):5) (...)
-eof
-    end
-
-    it "accepts --query" do
-      run('--compact', '--query', 'o.type == :method')
-      expect(@data.string).to eq <<-eof
-A A#foo ((stdin):6)
-A A.foo ((stdin):5)
-A C.bar ((stdin):10)
-A C.foo ((stdin):9)
-M C#baz ((stdin):3)
-D C#fooey ((stdin):2)
-D D.bar ((stdin):6)
-eof
-    end
-  end
-
-  describe "File searching" do
-    before do
-      allow(@diff).to receive(:generate_yardoc)
-    end
-
-    it "searches for gem/.yardoc" do
-      expect(File).to receive(:directory?).with('gem1/.yardoc').and_return(true)
-      expect(File).to receive(:directory?).with('gem2/.yardoc').and_return(true)
-      expect(Registry).to receive(:load_yardoc).with('gem1/.yardoc')
-      expect(Registry).to receive(:load_yardoc).with('gem2/.yardoc')
-      @diff.run('gem1', 'gem2')
-    end
-
-    it "searches for argument as yardoc" do
-      expect(File).to receive(:directory?).with('gem1/.yardoc').and_return(false)
-      expect(File).to receive(:directory?).with('gem2/.yardoc').and_return(false)
-      expect(File).to receive(:directory?).with('gem1').and_return(true)
-      expect(File).to receive(:directory?).with('gem2').and_return(true)
-      expect(Registry).to receive(:load_yardoc).with('gem1')
-      expect(Registry).to receive(:load_yardoc).with('gem2')
-      @diff.run('gem1', 'gem2')
-    end
-
-    it "searches for installed gem" do
-      expect(File).to receive(:directory?).with('gem1-1.0.0.gem/.yardoc').and_return(false)
-      expect(File).to receive(:directory?).with('gem2-1.0.0/.yardoc').and_return(false)
-      expect(File).to receive(:directory?).with('gem1-1.0.0.gem').and_return(false)
-      expect(File).to receive(:directory?).with('gem2-1.0.0').and_return(false)
-      spec1   = double(:spec)
-      spec2   = double(:spec)
-      allow(YARD::GemIndex).to receive(:each) {|&b| [spec1, spec2].each(&b) }
-      allow(spec1).to receive(:full_name).and_return('gem1-1.0.0')
-      allow(spec1).to receive(:name).and_return('gem1')
-      allow(spec1).to receive(:version).and_return('1.0.0')
-      allow(spec2).to receive(:full_name).and_return('gem2-1.0.0')
-      allow(spec2).to receive(:name).and_return('gem2')
-      allow(spec2).to receive(:version).and_return('1.0.0')
-      expect(Registry).to receive(:yardoc_file_for_gem).with('gem1', '= 1.0.0').and_return('/path/to/file')
-      expect(Registry).to receive(:yardoc_file_for_gem).with('gem2', '= 1.0.0').and_return(nil)
-      expect(Registry).to receive(:load_yardoc).with('/path/to/file')
-      expect(CLI::Gems).to receive(:run).with('gem2', '1.0.0').and_return(nil)
-      allow(Dir).to receive(:chdir)
-      @diff.run('gem1-1.0.0.gem', 'gem2-1.0.0')
-    end
-
-    it "searches for .gem file" do
-      expect(File).to receive(:directory?).with('gem1/.yardoc').and_return(false)
-      expect(File).to receive(:directory?).with('gem2.gem/.yardoc').and_return(false)
-      expect(File).to receive(:directory?).with('gem1').and_return(false)
-      expect(File).to receive(:directory?).with('gem2.gem').and_return(false)
-      expect(File).to receive(:exist?).with('gem1.gem').and_return(true)
-      expect(File).to receive(:exist?).with('gem2.gem').and_return(true)
-      expect(File).to receive(:open).with('gem1.gem', 'rb')
-      expect(File).to receive(:open).with('gem2.gem', 'rb')
-      allow(FileUtils).to receive(:mkdir_p)
-      allow(Gem::Package).to receive(:open)
-      allow(FileUtils).to receive(:rm_rf)
-      @diff.run('gem1', 'gem2.gem')
-    end
-
-    it "searches for .gem file on rubygems.org" do
-      expect(File).to receive(:directory?).with('gem1/.yardoc').and_return(false)
-      expect(File).to receive(:directory?).with('gem2.gem/.yardoc').and_return(false)
-      expect(File).to receive(:directory?).with('gem1').and_return(false)
-      expect(File).to receive(:directory?).with('gem2.gem').and_return(false)
-      expect(File).to receive(:exist?).with('gem1.gem').and_return(false)
-      expect(File).to receive(:exist?).with('gem2.gem').and_return(false)
-      expect(@diff).to receive(:open).with('http://rubygems.org/downloads/gem1.gem')
-      expect(@diff).to receive(:open).with('http://rubygems.org/downloads/gem2.gem')
-      allow(FileUtils).to receive(:mkdir_p)
-      allow(Gem::Package).to receive(:open)
-      allow(FileUtils).to receive(:rm_rf)
-      @diff.run('gem1', 'gem2.gem')
-    end
-
-    it "raises an error if gem is not found" do
-      expect(log).to receive(:error).with("Cannot find gem gem1")
-      expect(log).to receive(:error).with("Cannot find gem gem2.gem")
-      allow(@diff).to receive(:load_gem_data).and_return(false)
-      @diff.run('gem1', 'gem2.gem')
-    end
-  end
-end