yard 0.9.18 → 0.9.19

data/spec/handlers/class_method_handler_shared_examples.rb

@@ -1,133 +1,133 @@
-# 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
+# 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 +1,12 @@
-# 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
+# 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 +1,112 @@
-# 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
+# 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