yard 0.9.23 → 0.9.27

data/spec/registry_store_spec.rb

@@ -1,327 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe YARD::RegistryStore do
-  before do
-    FileUtils.rm_rf("foo")
-    @store = RegistryStore.new
-    @serializer = Serializers::YardocSerializer.new('foo')
-    @foo = CodeObjects::MethodObject.new(nil, :foo)
-    @bar = CodeObjects::ClassObject.new(nil, :Bar)
-    allow(Serializers::YardocSerializer).to receive(:new).and_return(@serializer)
-  end
-
-  describe "#load" do
-    it "loads root.dat as full object list if it is a Hash" do
-      expect(File).to receive(:directory?).with('foo').and_return(true)
-      expect(File).to receive(:file?).with('foo/checksums').and_return(false)
-      expect(File).to receive(:file?).with('foo/proxy_types').and_return(false)
-      expect(File).to receive(:file?).with('foo/object_types').and_return(false)
-      expect(@serializer).to receive(:deserialize).with('root').and_return(:root => @foo, :A => @bar)
-      expect(@store.load('foo')).to be true
-      expect(@store.root).to eq @foo
-      expect(@store.get('A')).to eq @bar
-    end
-
-    it "loads old yardoc format if .yardoc is a file" do
-      expect(File).to receive(:directory?).with('foo').and_return(false)
-      expect(File).to receive(:file?).with('foo').and_return(true)
-      expect(File).to receive(:read_binary).with('foo').and_return('FOO')
-      expect(Marshal).to receive(:load).with('FOO')
-
-      @store.load('foo')
-    end
-
-    it "loads new yardoc format if .yardoc is a directory" do
-      expect(File).to receive(:directory?).with('foo').and_return(true)
-      expect(File).to receive(:file?).with('foo/checksums').and_return(false)
-      expect(File).to receive(:file?).with('foo/proxy_types').and_return(false)
-      expect(File).to receive(:file?).with('foo/object_types').and_return(false)
-      expect(File).to receive(:file?).with('foo/objects/root.dat').and_return(false)
-
-      expect(@store.load('foo')).to be true
-    end
-
-    it "returns true if .yardoc is loaded (file)" do
-      expect(File).to receive(:directory?).with('myyardoc').and_return(false)
-      expect(File).to receive(:file?).with('myyardoc').and_return(true)
-      expect(File).to receive(:read_binary).with('myyardoc').and_return(Marshal.dump(''))
-      expect(@store.load('myyardoc')).to be true
-    end
-
-    it "returns true if .yardoc is loaded (directory)" do
-      expect(File).to receive(:directory?).with('foo').and_return(true)
-      expect(File).to receive(:file?).with('foo/checksums').and_return(false)
-      expect(File).to receive(:file?).with('foo/proxy_types').and_return(false)
-      expect(File).to receive(:file?).with('foo/object_types').and_return(false)
-      expect(File).to receive(:file?).with('foo/objects/root.dat').and_return(false)
-      expect(@store.load('foo')).to be true
-    end
-
-    it "returns false if .yardoc does not exist" do
-      expect(@store.load('NONEXIST')).to be false
-    end
-
-    it "returns false if there is no file to load" do
-      expect(@store.load(nil)).to be false
-    end
-
-    it "loads checksums if they exist" do
-      expect(File).to receive(:directory?).with('foo').and_return(true)
-      expect(File).to receive(:file?).with('foo/checksums').and_return(true)
-      expect(File).to receive(:file?).with('foo/proxy_types').and_return(false)
-      expect(File).to receive(:file?).with('foo/objects/root.dat').and_return(false)
-      expect(File).to receive(:file?).with('foo/object_types').and_return(false)
-      expect(File).to receive(:readlines).with('foo/checksums').and_return([
-        'file1 CHECKSUM1', '  file2 CHECKSUM2 '
-      ])
-      expect(@store.load('foo')).to be true
-      expect(@store.checksums).to eq('file1' => 'CHECKSUM1', 'file2' => 'CHECKSUM2')
-    end
-
-    it "loads proxy_types if they exist" do
-      expect(File).to receive(:directory?).with('foo').and_return(true)
-      expect(File).to receive(:file?).with('foo/checksums').and_return(false)
-      expect(File).to receive(:file?).with('foo/proxy_types').and_return(true)
-      expect(File).to receive(:file?).with('foo/object_types').and_return(false)
-      expect(File).to receive(:file?).with('foo/objects/root.dat').and_return(false)
-      expect(File).to receive(:read_binary).with('foo/proxy_types').and_return(Marshal.dump('a' => 'b'))
-      expect(@store.load('foo')).to be true
-      expect(@store.proxy_types).to eq('a' => 'b')
-    end
-
-    it "loads root object if it exists" do
-      expect(File).to receive(:directory?).with('foo').and_return(true)
-      expect(File).to receive(:file?).with('foo/checksums').and_return(false)
-      expect(File).to receive(:file?).with('foo/proxy_types').and_return(false)
-      expect(File).to receive(:file?).with('foo/object_types').and_return(false)
-      expect(File).to receive(:file?).with('foo/objects/root.dat').and_return(true)
-      expect(File).to receive(:read_binary).with('foo/objects/root.dat').and_return(Marshal.dump(@foo))
-      expect(@store.load('foo')).to be true
-      expect(@store.root).to eq @foo
-    end
-  end
-
-  describe "#save" do
-    before do
-      allow(@store).to receive(:write_proxy_types)
-      allow(@store).to receive(:write_checksums)
-      allow(@store).to receive(:destroy)
-    end
-
-    after do
-      Registry.single_object_db = nil
-    end
-
-    def saves_to_singledb
-      expect(@serializer).to receive(:serialize).once.with(instance_of(Hash))
-      @store.save(true, 'foo')
-    end
-
-    def add_items(n)
-      n.times {|i| @store[i.to_s] = @foo }
-    end
-
-    def saves_to_multidb
-      times = @store.keys.size
-      expect(@serializer).to receive(:serialize).exactly(times).times
-      @store.save(true, 'foo')
-      @last = times
-    end
-
-    it "saves as single object db if single_object_db is nil and there are less than 3000 objects" do
-      Registry.single_object_db = nil
-      add_items(100)
-      saves_to_singledb
-      expect(@serializer.complete?).to eq true
-    end
-
-    it "saves as single object db if single_object_db is nil and there are more than 3000 objects" do
-      Registry.single_object_db = nil
-      add_items(5000)
-      saves_to_singledb
-    end
-
-    it "saves as single object db if single_object_db is true (and any amount of objects)" do
-      Registry.single_object_db = true
-      add_items(100)
-      saves_to_singledb
-      add_items(5000)
-      saves_to_singledb
-    end
-
-    it "never saves as single object db if single_object_db is false" do
-      Registry.single_object_db = false
-      add_items(100)
-      saves_to_multidb
-      add_items(5000)
-      saves_to_multidb
-    end
-  end
-
-  describe "#put" do
-    it "assigns values" do
-      @store.put(:YARD, @foo)
-      expect(@store.get(:YARD)).to eq @foo
-    end
-
-    it "treats '' as root" do
-      @store.put('', @foo)
-      expect(@store.get(:root)).to eq @foo
-    end
-  end
-
-  describe "#get" do
-    it "hits cache if object exists" do
-      @store.put(:YARD, @foo)
-      expect(@store.get(:YARD)).to eq @foo
-    end
-
-    it "hits backstore on cache miss and cache is not fully loaded" do
-      serializer = double(:serializer)
-      expect(serializer).to receive(:deserialize).once.with(:YARD).and_return(@foo)
-      @store.load('foo')
-      @store.instance_variable_set("@loaded_objects", 0)
-      @store.instance_variable_set("@available_objects", 100)
-      @store.instance_variable_set("@serializer", serializer)
-      expect(@store.get(:YARD)).to eq @foo
-      expect(@store.get(:YARD)).to eq @foo
-      expect(@store.instance_variable_get("@loaded_objects")).to eq 1
-    end
-  end
-
-  [:keys, :values].each do |item|
-    describe "##{item}" do
-      it "loads entire database if reload=true" do
-        expect(File).to receive(:directory?).with('foo').and_return(true)
-        @store.load('foo')
-        expect(@store).to receive(:load_all)
-        @store.send(item, true)
-      end
-
-      it "does not load entire database if reload=false" do
-        expect(File).to receive(:directory?).with('foo').and_return(true)
-        @store.load('foo')
-        expect(@store).not_to receive(:load_all)
-        @store.send(item, false)
-      end
-    end
-  end
-
-  describe "#paths_for_type" do
-    after { Registry.clear }
-
-    it "sets all object types if not set by object_types" do
-      expect(File).to receive(:directory?).with('foo').and_return(true)
-      expect(File).to receive(:file?).with('foo/checksums').and_return(false)
-      expect(File).to receive(:file?).with('foo/proxy_types').and_return(false)
-      expect(File).to receive(:file?).with('foo/object_types').and_return(false)
-      expect(@serializer).to receive(:deserialize).with('root').and_return(:'A#foo' => @foo, :A => @bar)
-      @store.load('foo')
-      expect(@store.paths_for_type(:method)).to eq ['#foo']
-      expect(@store.paths_for_type(:class)).to eq ['Bar']
-    end
-
-    it "keeps track of types when assigning values" do
-      @store.put(:abc, @foo)
-      expect(@store.paths_for_type(@foo.type)).to eq ['abc']
-    end
-
-    it "reassigns path if type changes" do
-      foo = CodeObjects::ClassObject.new(:root, :Foo)
-      @store.put('Foo', foo)
-      expect(@store.get('Foo').type).to eq :class
-      expect(@store.paths_for_type(:class)).to eq ["Foo"]
-      foo = CodeObjects::ModuleObject.new(:root, :Foo)
-      @store.put('Foo', foo)
-      expect(@store.get('Foo').type).to eq :module
-      expect(@store.paths_for_type(:class)).to eq []
-      expect(@store.paths_for_type(:module)).to eq ["Foo"]
-    end
-  end
-
-  describe "#values_for_type" do
-    it "returns all objects with type" do
-      @store.put(:abc, @foo)
-      expect(@store.values_for_type(@foo.type)).to eq [@foo]
-    end
-  end
-
-  describe "#load_all" do
-    it "loads the entire database" do
-      foomock = double(:Foo)
-      barmock = double(:Bar)
-      allow(foomock).to receive(:type).and_return(:class)
-      allow(barmock).to receive(:type).and_return(:class)
-      expect(foomock).to receive(:path).and_return('Foo')
-      expect(barmock).to receive(:path).and_return('Bar')
-      expect(File).to receive(:directory?).with('foo').and_return(true)
-      expect(File).to receive(:file?).with('foo/proxy_types').and_return(false)
-      expect(File).to receive(:file?).with('foo/object_types').and_return(false)
-      expect(File).to receive(:file?).with('foo/checksums').and_return(false)
-      expect(File).to receive(:file?).with('foo/objects/root.dat').and_return(false)
-      expect(@store).to receive(:all_disk_objects).at_least(1).times.and_return(['foo/objects/foo', 'foo/objects/bar'])
-      @store.load('foo')
-      serializer = @store.instance_variable_get("@serializer")
-      expect(serializer).to receive(:deserialize).with('foo/objects/foo', true).and_return(foomock)
-      expect(serializer).to receive(:deserialize).with('foo/objects/bar', true).and_return(barmock)
-      @store.send(:load_all)
-      expect(@store.instance_variable_get("@available_objects")).to eq 2
-      expect(@store.instance_variable_get("@loaded_objects")).to eq 2
-      expect(@store[:Foo]).to eq foomock
-      expect(@store[:Bar]).to eq barmock
-    end
-  end
-
-  describe "#destroy" do
-    it "destroys file ending in .yardoc when force=false" do
-      expect(File).to receive(:file?).with('foo.yardoc').and_return(true)
-      expect(File).to receive(:unlink).with('foo.yardoc')
-      @store.instance_variable_set("@file", 'foo.yardoc')
-      expect(@store.destroy).to be true
-    end
-
-    it "destroys dir ending in .yardoc when force=false" do
-      expect(File).to receive(:directory?).with('foo.yardoc').and_return(true)
-      expect(FileUtils).to receive(:rm_rf).with('foo.yardoc')
-      @store.instance_variable_set("@file", 'foo.yardoc')
-      expect(@store.destroy).to be true
-    end
-
-    it "does not destroy file/dir not ending in .yardoc when force=false" do
-      expect(File).not_to receive(:file?).with('foo')
-      expect(File).not_to receive(:directory?).with('foo')
-      expect(File).not_to receive(:unlink).with('foo')
-      expect(FileUtils).not_to receive(:rm_rf).with('foo')
-      @store.instance_variable_set("@file", 'foo')
-      expect(@store.destroy).to be false
-    end
-
-    it "destroys any file/dir when force=true" do
-      expect(File).to receive(:file?).with('foo').and_return(true)
-      expect(File).to receive(:unlink).with('foo')
-      @store.instance_variable_set("@file", 'foo')
-      expect(@store.destroy(true)).to be true
-    end
-  end
-
-  describe "#delete" do
-    it "deletes the given object from store" do
-      @store.put(:YARD, @foo)
-      expect(@store.get(:YARD)).to be @foo
-      expect(@store.paths_for_type(:method)).to eq ["YARD"]
-      @store.delete(:YARD)
-      expect(@store.get(:YARD)).to be nil
-      expect(@store.paths_for_type(:method)).to eq []
-    end
-  end
-
-  describe "#locale" do
-    it "loads ./po/LOCALE_NAME.po" do
-      fr_locale = I18n::Locale.new("fr")
-      expect(I18n::Locale).to receive(:new).with("fr").and_return(fr_locale)
-      expect(Registry).to receive(:po_dir).and_return("po")
-      expect(fr_locale).to receive(:load).with("po")
-      expect(@store.locale("fr")).to eq fr_locale
-    end
-  end
-end

data/spec/rubygems/doc_manager_spec.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-require File.join(YARD::ROOT, 'rubygems_plugin')
-require 'fileutils'
-
-RSpec.describe Gem::DocManager do
-  before do
-    # Ensure filesystem integrity
-    allow(FileUtils).to receive(:mkdir_p)
-    allow(FileUtils).to receive(:rm_rf)
-    allow(Dir).to receive(:chdir)
-
-    allow(YARD::CLI::Yardoc).to receive(:run)
-
-    @spec_file = File.join(YARD::ROOT, '..', 'yard.gemspec')
-    @spec = Gem::SourceIndex.load_specification(@spec_file)
-    @spec.has_yardoc = false # no yardoc docs for now
-    @yardopts = File.join(@spec.full_gem_path, '.yardopts')
-    @doc = Gem::DocManager.new(@spec)
-    allow(@doc).to receive(:install_ri_yard_orig)
-    allow(@doc).to receive(:install_rdoc_yard_orig)
-  end
-
-  def runs; expect(YARD::CLI::Yardoc).to receive(:run) end
-
-  describe ".load_yardoc" do
-    it "properly loads YARD" do
-      expect(Gem::DocManager).to receive(:require) do |path|
-        expect(File.expand_path(path)).to eq YARD::ROOT + '/yard'
-      end
-      Gem::DocManager.load_yardoc
-    end
-  end
-
-  describe "#install_ri_yard" do
-    def install
-      msg = "Building YARD (yri) index for #{@spec.full_name}..."
-      expect(@doc).to receive(:say).with(msg)
-      @doc.install_ri_yard
-    end
-
-    it "passes --quiet to all documentation" do
-      runs.with('-c', '-n', '--quiet', 'lib')
-      install
-    end
-
-    it "passes extra_rdoc_files to documentation" do
-      @spec.extra_rdoc_files = %w(README LICENSE)
-      runs.with('-c', '-n', '--quiet', 'lib', '-', 'README', 'LICENSE')
-      install
-    end
-
-    it "adds --backtrace if Gem.configuration.backtrace" do
-      Gem.configuration.backtrace = true
-      runs.with('-c', '-n', '--quiet', '--backtrace', 'lib')
-      install
-      Gem.configuration.backtrace = false
-    end
-
-    it "adds require_paths if there is no .yardopts" do
-      expect(File).to receive(:file?).with(@yardopts).and_return(true)
-      runs.with('-c', '-n', '--quiet')
-      install
-    end
-
-    it "adds extra_rdoc_files if there is no .yardopts" do
-      @spec.extra_rdoc_files = %w(README LICENSE)
-      expect(File).to receive(:file?).with(@yardopts).and_return(true)
-      runs.with('-c', '-n', '--quiet')
-      install
-    end
-
-    it "switches to directory before running command" do
-      old = Dir.pwd
-      expect(Dir).to receive(:chdir).with(@spec.full_gem_path)
-      expect(Dir).to receive(:chdir).with(old)
-      install
-    end
-
-    it "ensures that directory is switched back at end of command in failure" do
-      old = Dir.pwd
-      expect(Dir).to receive(:chdir).with(@spec.full_gem_path)
-      expect(Dir).to receive(:chdir).with(old)
-      expect(@doc.ui.errs).to receive(:puts).with(/ERROR:\s*While generating documentation/)
-      expect(@doc.ui.errs).to receive(:puts).with(/MESSAGE:\s*foo/)
-      expect(@doc.ui.errs).to receive(:puts).with(/YARDOC args:\s*-c -n --quiet lib/)
-      expect(@doc.ui.errs).to receive(:puts).with("(continuing with the rest of the installation)")
-      expect(YARD::CLI::Yardoc).to receive(:run).and_raise(RuntimeError.new("foo"))
-      install
-    end
-
-    it "handles permission errors" do
-      expect(YARD::CLI::Yardoc).to receive(:run).and_raise(Errno::EACCES.new("- dir"))
-      expect { install }.to raise_error(Gem::FilePermissionError)
-    end
-  end
-
-  describe "#install_rdoc_yard" do
-    def install
-      msg = "Installing YARD documentation for #{@spec.full_name}..."
-      expect(@doc).to receive(:say).with(msg)
-      @doc.install_rdoc_yard
-    end
-
-    it "adds -o outdir when generating docs" do
-      expect(File).to receive(:file?).with(@yardopts).and_return(true)
-      @spec.has_yardoc = true
-      doc_dir = File.join(@doc.instance_variable_get("@doc_dir"), 'rdoc')
-      runs.with('-o', doc_dir, '--quiet')
-      install
-    end
-  end
-end if Gem::VERSION < '2.0.0'

data/spec/serializers/data/serialized_yardoc/checksums

@@ -1 +0,0 @@
-test.rb 80e5834ff1e98223761615c0917ff9b77b7ae057

data/spec/serializers/data/serialized_yardoc/proxy_types

@@ -1,2 +0,0 @@
-{I"Object:EF:
-class

data/spec/serializers/file_system_serializer_spec.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-require 'stringio'
-
-RSpec.describe YARD::Serializers::FileSystemSerializer do
-  before do
-    allow(FileUtils).to receive(:mkdir_p)
-    allow(File).to receive(:open)
-  end
-
-  describe "#basepath" do
-    it "defaults the base path to the 'doc/'" do
-      obj = Serializers::FileSystemSerializer.new
-      expect(obj.basepath).to eq 'doc'
-    end
-  end
-
-  describe "#extension" do
-    it "defaults the file extension to .html" do
-      obj = Serializers::FileSystemSerializer.new
-      expect(obj.extension).to eq "html"
-    end
-  end
-
-  describe "#serialized_path" do
-    it "allows no extension to be used" do
-      obj = Serializers::FileSystemSerializer.new :extension => nil
-      yard = CodeObjects::ClassObject.new(nil, :FooBar)
-      expect(obj.serialized_path(yard)).to eq 'FooBar'
-    end
-
-    it "serializes to top-level-namespace for root" do
-      obj = Serializers::FileSystemSerializer.new :extension => nil
-      expect(obj.serialized_path(Registry.root)).to eq "top-level-namespace"
-    end
-
-    it "returns serialized_path for a String" do
-      s = Serializers::FileSystemSerializer.new(:basepath => 'foo', :extension => 'txt')
-      expect(s.serialized_path('test.txt')).to eq 'test.txt'
-    end
-
-    it "removes special chars from path" do
-      m = CodeObjects::MethodObject.new(nil, 'a')
-      s = Serializers::FileSystemSerializer.new
-
-      {:gsub! => 'gsub_21_i.html',
-        :ask? => 'ask_3F_i.html',
-        :=== => '_3D_3D_3D_i.html',
-        :+ => '_2B_i.html',
-        :- => '-_i.html',
-        :[]= => '_5B_5D_3D_i.html',
-        :<< => '_3C_3C_i.html',
-        :>= => '_3E_3D_i.html',
-        :` => '_60_i.html',
-        :& => '_26_i.html',
-        :* => '_2A_i.html',
-        :| => '_7C_i.html',
-        :/ => '_2F_i.html',
-        :=~ => '_3D_7E_i.html'}.each do |meth, value|
-        allow(m).to receive(:name).and_return(meth)
-        expect(s.serialized_path(m)).to eq value
-      end
-    end
-
-    it "handles ExtraFileObject's" do
-      s = Serializers::FileSystemSerializer.new
-      e = CodeObjects::ExtraFileObject.new('filename.txt', '')
-      expect(s.serialized_path(e)).to eq 'file.filename.html'
-    end
-
-    it "differentiates instance and class methods from serialized path" do
-      s = Serializers::FileSystemSerializer.new
-      m1 = CodeObjects::MethodObject.new(nil, 'meth')
-      m2 = CodeObjects::MethodObject.new(nil, 'meth', :class)
-      expect(s.serialized_path(m1)).not_to eq s.serialized_path(m2)
-    end
-
-    it "serializes path from overload tag" do
-      YARD.parse_string <<-'eof'
-        class Foo
-          # @overload bar
-          def bar; end
-        end
-      eof
-
-      serializer = Serializers::FileSystemSerializer.new
-      object = Registry.at('Foo#bar').tag(:overload)
-      expect(serializer.serialized_path(object)).to eq "Foo/bar_i.html"
-    end
-
-    it "maps matching case sensitive object names to different files on disk" do
-      Registry.clear
-      o1 = CodeObjects::ClassObject.new(:root, "AB")
-      o2 = CodeObjects::ClassObject.new(:root, "Ab")
-      s = Serializers::FileSystemSerializer.new
-      expect([["AB_.html", "Ab.html"], ["AB.html", "Ab_.html"]]).to include(
-        [s.serialized_path(o1), s.serialized_path(o2)]
-      )
-    end
-
-    it "handles case sensitivity of nested paths for objects with matching names" do
-      Registry.clear
-      YARD.parse_string <<-eof
-        class Abc; class D; end end
-        class ABC; class D; end end
-      eof
-
-      s = Serializers::FileSystemSerializer.new
-      expect(s.serialized_path(Registry.at('ABC::D'))).to eq "ABC/D.html"
-      expect(s.serialized_path(Registry.at('Abc::D'))).to eq "Abc/D.html"
-    end
-  end
-
-  describe "#serialize" do
-    it "serializes to the correct path" do
-      yard = CodeObjects::ClassObject.new(nil, :FooBar)
-      meth = CodeObjects::MethodObject.new(yard, :baz, :class)
-      meth2 = CodeObjects::MethodObject.new(yard, :baz)
-
-      {'foo/FooBar/baz_c.txt' => meth,
-        'foo/FooBar/baz_i.txt' => meth2,
-        'foo/FooBar.txt' => yard}.each do |path, obj|
-        io = StringIO.new
-        expect(File).to receive(:open).with(path, 'wb').and_yield(io)
-        expect(io).to receive(:write).with("data")
-
-        s = Serializers::FileSystemSerializer.new(:basepath => 'foo', :extension => 'txt')
-        s.serialize(obj, "data")
-      end
-    end
-
-    it "guarantees the directory exists" do
-      o1 = CodeObjects::ClassObject.new(nil, :Really)
-      o2 = CodeObjects::ClassObject.new(o1, :Long)
-      o3 = CodeObjects::ClassObject.new(o2, :PathName)
-      obj = CodeObjects::MethodObject.new(o3, :foo)
-
-      expect(FileUtils).to receive(:mkdir_p).once.with('doc/Really/Long/PathName')
-
-      s = Serializers::FileSystemSerializer.new
-      s.serialize(obj, "data")
-    end
-  end
-end

data/spec/serializers/spec_helper.rb

@@ -1,2 +0,0 @@
-# frozen_string_literal: true
-include YARD

data/spec/serializers/yardoc_serializer_spec.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-instance_eval do
-  class YARD::Serializers::YardocSerializer
-    public :dump
-    public :internal_dump
-  end
-end
-
-RSpec.describe YARD::Serializers::YardocSerializer do
-  before do
-    @serializer = YARD::Serializers::YardocSerializer.new('.yardoc')
-
-    Registry.clear
-    @foo = CodeObjects::ClassObject.new(:root, :Foo)
-    @bar = CodeObjects::MethodObject.new(@foo, :bar)
-  end
-
-  describe "#dump" do
-    it "maintains object equality when loading a dumped object" do
-      newfoo = @serializer.internal_dump(@foo)
-      expect(newfoo).to equal(@foo)
-      expect(newfoo).to eq @foo
-      expect(@foo).to equal(newfoo)
-      expect(@foo).to eq newfoo
-      expect(newfoo.hash).to eq @foo.hash
-    end
-
-    it "maintains hash key equality when loading a dumped object" do
-      newfoo = @serializer.internal_dump(@foo)
-      expect(@foo => 1).to have_key(newfoo)
-      expect(newfoo => 1).to have_key(@foo)
-    end
-  end
-
-  describe "#serialize" do
-    it "accepts a hash of codeobjects (and write to root)" do
-      data = {:root => Registry.root}
-      marshaldata = Marshal.dump(data)
-      filemock = double(:file)
-      expect(filemock).to receive(:write).with(marshaldata)
-      expect(File).to receive(:open!).with('.yardoc/objects/root.dat', 'wb').and_yield(filemock)
-      @serializer.serialize(data)
-    end
-  end
-
-  describe "#lock_for_writing" do
-    it "creates a lock file during writing and cleans up" do
-      expect(File).to receive(:open!).with(@serializer.processing_path, 'w')
-      expect(File).to receive(:exist?).with(@serializer.processing_path).exactly(2).times.and_return(true)
-      expect(File).to receive(:unlink).with(@serializer.processing_path)
-      @serializer.lock_for_writing do
-        expect(@serializer.locked_for_writing?).to eq true
-      end
-    end
-  end
-
-  describe "#complete?" do
-    it "returns false if complete file does not exist" do
-      allow(File).to receive(:exist?).with(@serializer.complete_lock_path).and_return(false)
-      allow(File).to receive(:exist?).with(@serializer.processing_path).and_return(false)
-      expect(@serializer.complete?).to eq false
-    end
-
-    it "returns false if processing file exists" do
-      allow(File).to receive(:exist?).with(@serializer.complete_lock_path).and_return(true)
-      allow(File).to receive(:exist?).with(@serializer.processing_path).and_return(true)
-      expect(@serializer.complete?).to eq false
-    end
-
-    it "returns true if complete file exists with no processing file" do
-      allow(File).to receive(:exist?).with(@serializer.complete_lock_path).and_return(true)
-      allow(File).to receive(:exist?).with(@serializer.processing_path).and_return(false)
-      expect(@serializer.complete?).to eq true
-    end
-  end
-end