yard 0.9.23 → 0.9.27

data/spec/handlers/class_handler_spec.rb

@@ -1,247 +0,0 @@
-# frozen_string_literal: true
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassHandler" do
-  before(:all) { parse_file :class_handler_001, __FILE__ }
-
-  it "parses a class block with docstring" do
-    expect(P("A").docstring).to eq "Docstring"
-  end
-
-  it "handles complex class names" do
-    expect(P("A::B::C")).not_to eq nil
-  end
-
-  it "handles the subclassing syntax" do
-    expect(P("A::B::C").superclass).to eq P(:String)
-    expect(P("A::X").superclass).to eq Registry.at("A::B::C")
-  end
-
-  it "interprets class << self as a class level block" do
-    expect(P("A.classmethod1")).not_to eq nil
-  end
-
-  it "interprets class << ClassName as a class level block in ClassName's namespace" do
-    expect(P("A::B::C.Hello")).to be_instance_of(CodeObjects::MethodObject)
-  end
-
-  it "makes visibility public when parsing a block" do
-    expect(P("A::B::C#method1").visibility).to eq :public
-  end
-
-  it "sets superclass type to :class if it is a Proxy" do
-    expect(P("A::B::C").superclass.type).to eq :class
-  end
-
-  it "looks for a superclass before creating the class if it shares the same name" do
-    expect(P('B::A').superclass).to eq P('A')
-  end
-
-  it "handles class definitions in the form ::ClassName" do
-    expect(Registry.at("MyRootClass")).not_to be nil
-  end
-
-  it "handles superclass as a constant-style method (camping style < R /path/)" do
-    expect(P('Test1').superclass).to eq P(:R)
-    expect(P('Test2').superclass).to eq P(:R)
-    expect(P('Test6').superclass).to eq P(:NotDelegateClass)
-  end
-
-  it "handles superclass with OStruct.new or Struct.new syntax (superclass should be OStruct/Struct)" do
-    expect(P('Test3').superclass).to eq P(:Struct)
-    expect(P('Test4').superclass).to eq P(:OStruct)
-  end
-
-  it "handles DelegateClass(CLASSNAME) superclass syntax" do
-    expect(P('Test5').superclass).to eq P(:Array)
-  end
-
-  it "handles a superclass of the same name in the form ::ClassName" do
-    expect(P('Q::Logger').superclass).to eq P(:Logger)
-    expect(P('Q::Foo').superclass).not_to eq P('Q::Logger')
-  end
-
-  ["CallMethod('test')", "VSD^#}}", 'not.aclass', 'self'].each do |klass|
-    it "raises an UndocumentableError for invalid class '#{klass}'" do
-      with_parser(:ruby18) { undoc_error "class #{klass}; end" }
-    end
-  end
-
-  ['@@INVALID', 'hi', '$MYCLASS', 'AnotherClass.new'].each do |klass|
-    it "raises an UndocumentableError for invalid superclass '#{klass}' but it should create the class." do
-      expect(YARD::CodeObjects::ClassObject).to receive(:new).with(Registry.root, 'A')
-      with_parser(:ruby18) { undoc_error "class A < #{klass}; end" }
-      expect(Registry.at('A').superclass).to eq P(:Object)
-    end
-  end
-
-  ['not.aclass', 'self', 'AnotherClass.new'].each do |klass|
-    it "raises an UndocumentableError if the constant class reference 'class << SomeConstant' does not point to a valid class name" do
-      with_parser(:ruby18) do
-        undoc_error <<-eof
-          CONST = #{klass}
-          class << CONST; end
-        eof
-      end
-      expect(Registry.at(klass)).to be nil
-    end
-  end
-
-  it "documents 'class << SomeConstant' by using SomeConstant's value as a reference to the real class name" do
-    expect(Registry.at('String.classmethod')).not_to be nil
-  end
-
-  it "allows class << SomeRubyClass to create the class if it does not exist" do
-    expect(Registry.at('Symbol.toString')).not_to be nil
-  end
-
-  it "documents 'class Exception' without running into superclass issues" do
-    Parser::SourceParser.parse_string <<-eof
-      class Exception
-      end
-    eof
-    expect(Registry.at(:Exception)).not_to be nil
-  end
-
-  it "documents 'class RT < XX::RT' with proper superclass even if XX::RT is a proxy" do
-    expect(Registry.at(:RT)).not_to be nil
-    expect(Registry.at(:RT).superclass).to eq P('XX::RT')
-  end
-
-  it "does not overwrite docstring with an empty one" do
-    expect(Registry.at(:Zebra).docstring).to eq "Docstring 2"
-  end
-
-  it "turns 'class Const < Struct.new(:sym)' into class Const with attr :sym" do
-    obj = Registry.at("Point")
-    expect(obj).to be_kind_of(CodeObjects::ClassObject)
-    attrs = obj.attributes[:instance]
-    [:x, :y, :z].each do |key|
-      expect(attrs).to have_key(key)
-      expect(attrs[key][:read]).not_to be nil
-      expect(attrs[key][:write]).not_to be nil
-    end
-  end
-
-  it "turns 'class Const < Struct.new('Name', :sym)' into class Const with attr :sym" do
-    obj = Registry.at("AnotherPoint")
-    expect(obj).to be_kind_of(CodeObjects::ClassObject)
-    attrs = obj.attributes[:instance]
-    [:a, :b, :c].each do |key|
-      expect(attrs).to have_key(key)
-      expect(attrs[key][:read]).not_to be nil
-      expect(attrs[key][:write]).not_to be nil
-    end
-
-    expect(Registry.at("XPoint")).to be nil
-  end
-
-  it "creates a Struct::Name class when class Const < Struct.new('Name', :sym) is found" do
-    obj = Registry.at("Struct::XPoint")
-    expect(obj).not_to be nil
-  end
-
-  it "attaches attribtues to the generated Struct::Name class when Struct.new('Name') is used" do
-    obj = Registry.at("Struct::XPoint")
-    attrs = obj.attributes[:instance]
-    [:a, :b, :c].each do |key|
-      expect(attrs).to have_key(key)
-      expect(attrs[key][:read]).not_to be nil
-      expect(attrs[key][:write]).not_to be nil
-    end
-  end
-
-  it "uses @attr to set attribute descriptions on Struct subclasses" do
-    obj = Registry.at("DoccedStruct#input")
-    expect(obj.docstring).to eq "the input stream"
-  end
-
-  it "uses @attr to set attribute types on Struct subclasses" do
-    obj = Registry.at("DoccedStruct#someproc")
-    expect(obj).not_to be nil
-    expect(obj.tag(:return)).not_to be nil
-    expect(obj.tag(:return).types).to eq ["Proc", "#call"]
-  end
-
-  it "defaults types unspecified by @attr to Object on Struct subclasses" do
-    obj = Registry.at("DoccedStruct#mode")
-    expect(obj).not_to be nil
-    expect(obj.tag(:return)).not_to be nil
-    expect(obj.tag(:return).types).to eq ["Object"]
-  end
-
-  it "creates parameters for writers of Struct subclass's attributes" do
-    obj = Registry.at("DoccedStruct#input=")
-    expect(obj.tags(:param).size).to eq 1
-    expect(obj.tag(:param).types).to eq ["IO"]
-  end
-
-  ["SemiDoccedStruct", "NotAStruct"].each do |struct|
-    describe("Attributes on a " + (struct == "NotAStruct" ? "class" : "struct")) do
-      it "defines both readers and writers when @attr is used on Structs" do
-        obj = Registry.at(struct)
-        attrs = obj.attributes[:instance]
-        expect(attrs[:first][:read]).not_to be nil
-        expect(attrs[:first][:write]).not_to be nil
-      end
-
-      it "defines only a reader when only @attr_reader is used on Structs" do
-        obj = Registry.at(struct)
-        attrs = obj.attributes[:instance]
-        expect(attrs[:second][:read]).not_to be nil
-        expect(attrs[:second][:write]).to be nil
-      end
-
-      it "defines only a writer when only @attr_writer is used on Structs" do
-        obj = Registry.at(struct)
-        attrs = obj.attributes[:instance]
-        expect(attrs[:third][:read]).to be nil
-        expect(attrs[:third][:write]).not_to be nil
-      end
-
-      it "defines a reader with correct return types when @attr_reader is used on Structs" do
-        obj = Registry.at("#{struct}#second")
-        expect(obj.tag(:return).types).to eq ["Fixnum"]
-      end
-
-      it "defines a writer with correct parameter types when @attr_writer is used on Structs" do
-        obj = Registry.at("#{struct}#third=")
-        expect(obj.tag(:param).types).to eq ["Array"]
-      end
-
-      it "defines a reader and a writer when both @attr_reader and @attr_writer are used" do
-        obj = Registry.at(struct)
-        attrs = obj.attributes[:instance]
-        expect(attrs[:fourth][:read]).not_to be nil
-        expect(attrs[:fourth][:write]).not_to be nil
-      end
-
-      it "uses @attr_reader for the getter when both @attr_reader and @attr_writer are given" do
-        obj = Registry.at("#{struct}#fourth")
-        expect(obj.tag(:return).types).to eq ["#read"]
-      end
-
-      it "uses @attr_writer for the setter when both @attr_reader and @attr_writer are given" do
-        obj = Registry.at("#{struct}#fourth=")
-        expect(obj.tag(:param).types).to eq ["IO"]
-      end
-
-      it "extracts text from @attr_reader" do
-        expect(Registry.at("#{struct}#fourth").docstring).to eq "returns a proc that reads"
-      end
-
-      it "extracts text from @attr_writer" do
-        expect(Registry.at("#{struct}#fourth=").docstring).to eq "sets the proc that writes stuff"
-      end
-    end
-  end
-
-  it "inherits from a regular struct" do
-    expect(Registry.at('RegularStruct').superclass).to eq P(:Struct)
-    expect(Registry.at('RegularStruct2').superclass).to eq P(:Struct)
-  end
-
-  it "handles inheritance from 'self'" do
-    expect(Registry.at('Outer1::Inner1').superclass).to eq Registry.at('Outer1')
-  end
-end

data/spec/handlers/class_method_handler_shared_examples.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-RSpec.shared_examples "class method visibility decorator" do
-  # Use let(:visibility) to specify the name of the x_class_method
-  # visibility decorator to test.
-
-  describe do
-    before do
-      StubbedSourceParser.parse_string <<-CODE
-        class A
-          def self.b; end
-          def self.c; end
-          def self.d; end
-          def self.e; end
-
-          #{visibility}_class_method(:c, :d)
-          #{visibility}_class_method("e")
-        end
-      CODE
-    end
-
-    it "handles private_class_method statement" do
-      expect(Registry.at('A.c').visibility).to eq visibility
-      expect(Registry.at('A.d').visibility).to eq visibility
-      expect(Registry.at('A.e').visibility).to eq visibility
-    end
-
-    # Issue #760
-    # https://github.com/lsegal/yard/issues/760
-    it "handles singleton classes" do
-      # Note: It's important to def a method within the singleton class or
-      #       the bug may not trigger.
-      code = <<-CODE
-        class SingletonClass
-          private_class_method :new
-          def self.foo
-            "foo"
-          end
-        end
-      CODE
-
-      StubbedSourceParser.parse_string(code) # Should be successful.
-    end unless LEGACY_PARSER
-  end
-
-  describe "handles reopened class" do
-    before do
-      StubbedSourceParser.parse_string <<-CODE
-        class SingletonClass
-
-          #{'private' unless visibility.to_sym == :private}
-
-          # != visibility
-          def self.foo
-            'foo'
-          end
-
-          # == visibility
-          def self.bar
-          end
-
-          # == visibility from reopening class.
-          def self.baz
-          end
-
-          #{visibility}_class_method :new, :bar
-
-        end
-      CODE
-
-      StubbedSourceParser.parse_string <<-CODE
-        # Reopening singleton class.
-        class SingletonClass
-          #{visibility}_class_method :baz
-
-          #{'private' unless visibility.to_sym == :private}
-          # != visibility from reopened class. (Verifies class was reopened.)
-          def self.bat
-          end
-
-        end
-      CODE
-    end
-
-    specify do
-      expect(Registry.at('SingletonClass.foo').visibility).not_to eq visibility
-      expect(Registry.at('SingletonClass.bar').visibility).to     eq visibility
-      expect(Registry.at('SingletonClass.baz').visibility).to     eq visibility
-      expect(Registry.at('SingletonClass.bat').visibility).not_to eq visibility
-    end
-  end unless LEGACY_PARSER # reopened class
-
-  describe "as method definition decorator" do
-    subject { Registry.at('SingletonClass.foo') }
-
-    # Valid as of Ruby 2.1.0:
-    # private_class_method def self.foo; end
-
-    let(:code) do
-      <<-CODE
-        class SingletonClass
-          # Valid Ruby 2.1.0 syntax.
-          #{method_def}
-            'it works'
-          end
-        end
-      CODE
-    end
-
-    let(:method_def) { "#{visibility}_class_method def self.foo param1, param2" }
-
-    before { StubbedSourceParser.parse_string code }
-
-    it "handles self.foo" do
-      expect(subject.visibility).to eq visibility
-    end
-
-    it "handles parameters correctly" do
-      expect(subject.parameters.map(&:first)).to eq ['param1', 'param2']
-    end
-
-    it "attaches documentation to method definition" do
-      expect(subject.docstring).to eq "Valid Ruby 2.1.0 syntax."
-    end
-
-    describe "handles SingletonClass.foo" do
-      let(:method_def) { "#{visibility}_class_method def SingletonClass.foo" }
-
-      specify do
-        expect(subject.visibility).to eq visibility
-      end
-    end
-  end unless LEGACY_PARSER
-end

data/spec/handlers/class_variable_handler_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassVariableHandler" do
-  before(:all) { parse_file :class_variable_handler_001, __FILE__ }
-
-  it "does not parse class variables inside methods" do
-    obj = Registry.at("A::B::@@somevar")
-    expect(obj.source).to eq "@@somevar = \"hello\""
-    expect(obj.value).to eq '"hello"'
-  end
-end

data/spec/handlers/constant_handler_spec.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ConstantHandler" do
-  before(:all) { parse_file :constant_handler_001, __FILE__ }
-
-  it "does not parse constants inside methods" do
-    expect(Registry.at("A::B::SOMECONSTANT").source).to eq "SOMECONSTANT= \"hello\""
-  end
-
-  it "only parses valid constants" do
-    expect(Registry.at("A::B::notaconstant")).to be nil
-  end
-
-  it "maintains newlines" do
-    expect(Registry.at("A::B::MYCONSTANT").value.delete("\r")).to eq "A +\nB +\nC +\nD"
-  end
-
-  it "turns Const = Struct.new(:sym) into class Const with attr :sym" do
-    obj = Registry.at("MyClass")
-    expect(obj).to be_kind_of(CodeObjects::ClassObject)
-    attrs = obj.attributes[:instance]
-    [:a, :b, :c].each do |key|
-      expect(attrs).to have_key(key)
-      expect(attrs[key][:read]).not_to be nil
-      expect(attrs[key][:write]).not_to be nil
-    end
-  end
-
-  it 'documents block for Struct.new if present' do
-    obj = Registry.at("MyStructWithConstant")
-    expect(obj).to be_kind_of(CodeObjects::ClassObject)
-    expect(obj.constants[0].docstring).to eq 'A constant.'
-    expect(obj.constants[0].name).to eq :CONSTANT
-    expect(obj.constants[0].value).to eq "42"
-    expect(obj.constants[1].docstring).to eq 'Special constant (empty symbol)'
-    expect(obj.constants[1].name).to eq :EMPTY
-    expect(obj.constants[1].value).to eq ":''"
-  end
-
-  it "turns Const = Struct.new('Name', :sym) into class Const with attr :sym" do
-    obj = Registry.at("NotMyClass")
-    expect(obj).to be_kind_of(CodeObjects::ClassObject)
-    attrs = obj.attributes[:instance]
-    [:b, :c].each do |key|
-      expect(attrs).to have_key(key)
-      expect(attrs[key][:read]).not_to be nil
-      expect(attrs[key][:write]).not_to be nil
-    end
-
-    expect(Registry.at("NotMyClass2")).to be nil
-  end
-
-  it "turns Const = Struct.new into empty struct" do
-    obj = Registry.at("MyEmptyStruct")
-    expect(obj).not_to be nil
-    expect(obj.attributes[:instance]).to be_empty
-  end
-
-  it "maintains docstrings on structs defined via constants" do
-    obj = Registry.at("DocstringStruct")
-    expect(obj).not_to be nil
-    expect(obj.docstring).to eq "A crazy struct."
-    expect(obj.attributes[:instance]).not_to be_empty
-    a1 = Registry.at("DocstringStruct#bar")
-    a2 = Registry.at("DocstringStruct#baz")
-    expect(a1.docstring).to eq "An attr"
-    expect(a1.tag(:return).types).to eq ["String"]
-    expect(a2.docstring).to eq "Another attr"
-    expect(a2.tag(:return).types).to eq ["Number"]
-    a3 = Registry.at("DocstringStruct#new_syntax")
-    expect(a3.docstring).to eq "Attribute defined with the new syntax"
-    expect(a3.tag(:return).types).to eq ["Symbol"]
-  end
-
-  it "raises undocumentable error in 1.9 parser for Struct.new assignment to non-const" do
-    undoc_error "nonconst = Struct.new"
-  end unless LEGACY_PARSER
-
-  %w(module class).each do |type|
-    it "does not allow #{type} to be redefined as constant" do
-      undoc_error <<-eof
-        #{type} Foo; end
-        Foo = "value"
-      eof
-    end
-  end unless LEGACY_PARSER
-
-  it "allows constant to have same name as constant in parent namespace" do
-    YARD.parse_string <<-eof
-      module A
-        class C; end
-        module B; C = 1 end
-      end
-    eof
-    expect(log.io.string).to eq ""
-    expect(Registry.at('A::B::C').type).to eq :constant
-  end
-
-  it "detects compound constant names" do
-    YARD.parse_string <<-eof
-      module A
-        class AA; end
-        AA::B = true
-      end
-      A::AA::C = true
-    eof
-
-    expect(Registry.at('A::AA::B').type).to eq :constant
-    expect(Registry.at('A::AA::C').type).to eq :constant
-  end if HAVE_RIPPER
-end