yard 0.9.23 → 0.9.27

data/spec/code_objects/class_object_spec.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::CodeObjects::ClassObject do
-  describe "#inheritance_tree" do
-    before(:all) do
-      Registry.clear
-      @mixin = ModuleObject.new(:root, :SomeMixin)
-      @mixin2 = ModuleObject.new(:root, :SomeMixin2)
-      @mixin2.instance_mixins << @mixin
-      @mixin3 = ModuleObject.new(:root, :SomeMixin3)
-      @mixin4 = ModuleObject.new(:root, :SomeMixin4)
-      @mixin2.instance_mixins << @mixin3
-      @superyard = ClassObject.new(:root, :SuperYard)
-      @superyard.superclass = P("String")
-      @superyard.instance_mixins << @mixin2
-      @superyard.class_mixins << @mixin4
-      @yard = ClassObject.new(:root, :YARD)
-      @yard.superclass = @superyard
-      @yard.instance_mixins << @mixin
-    end
-
-    it "shows the proper inheritance tree" do
-      expect(@yard.inheritance_tree).to eq [@yard, @superyard, P(:String)]
-    end
-
-    it "shows proper inheritance tree when mixins are included" do
-      expect(@yard.inheritance_tree(true)).to eq [@yard, @mixin, @superyard, @mixin4, @mixin2, @mixin3, P(:String)]
-    end
-
-    it "does not modify the object's mixin list when mixins are included" do
-      @class1 = ClassObject.new(:root, :A)
-      @class2 = ClassObject.new(:root, :B)
-      @class2.superclass = @class1
-
-      @class2.inheritance_tree(true)
-      expect(@class2.mixins).to eq []
-    end
-
-    it "lists class mixins in inheritance tree" do
-      mod = ModuleObject.new(:root, :ClassMethods)
-      klass = ClassObject.new(:root, :ReceivingClass)
-      klass.class_mixins << mod
-      expect(klass.inheritance_tree(true)).to eq [klass, mod]
-    end
-  end
-
-  describe "#meths / #inherited_meths" do
-    before(:all) do
-      Registry.clear
-
-      YARD.parse_string <<-eof
-        class SuperYard < String
-          def foo; end
-          def foo2; end
-          def bar; end
-          def middle; end
-          protected :foo2
-          private
-          def self.bar; end
-        end
-
-        class MiddleYard < SuperYard
-          def middle; end
-        end
-
-        class YARD < MiddleYard
-          def mymethod; end
-          def bar; end
-        end
-
-        module IncludedYard
-          def foo; end
-        end
-
-        class FinalYard < SuperYard
-          include IncludedYard
-        end
-      eof
-    end
-
-    it "shows inherited methods by default" do
-      meths = P(:YARD).meths
-      expect(meths).to include(P("YARD#mymethod"))
-      expect(meths).to include(P("SuperYard#foo"))
-      expect(meths).to include(P("SuperYard#foo2"))
-      expect(meths).to include(P("SuperYard.bar"))
-    end
-
-    it "allows :inherited to be set to false" do
-      meths = P(:YARD).meths(:inherited => false)
-      expect(meths).to include(P("YARD#mymethod"))
-      expect(meths).not_to include(P("SuperYard#foo"))
-      expect(meths).not_to include(P("SuperYard#foo2"))
-      expect(meths).not_to include(P("SuperYard.bar"))
-    end
-
-    it "does not show overridden methods" do
-      meths = P(:YARD).meths
-      expect(meths).to include(P("YARD#bar"))
-      expect(meths).not_to include(P("SuperYard#bar"))
-
-      meths = P(:YARD).inherited_meths
-      expect(meths).not_to include(P("YARD#bar"))
-      expect(meths).not_to include(P("YARD#mymethod"))
-      expect(meths).to include(P("SuperYard#foo"))
-      expect(meths).to include(P("SuperYard#foo2"))
-      expect(meths).to include(P("SuperYard.bar"))
-    end
-
-    it "does not show inherited methods overridden by other subclasses" do
-      meths = P(:YARD).inherited_meths
-      expect(meths).to include(P('MiddleYard#middle'))
-      expect(meths).not_to include(P('SuperYard#middle'))
-    end
-
-    it "shows mixed in methods before superclass method" do
-      meths = P(:FinalYard).meths
-      expect(meths).to include(P('IncludedYard#foo'))
-      expect(meths).not_to include(P('SuperYard#foo'))
-    end
-  end
-
-  describe "#constants / #inherited_constants" do
-    before(:all) do
-      Registry.clear
-
-      Parser::SourceParser.parse_string <<-eof
-        class YARD
-          CONST1 = 1
-          CONST2 = "hello"
-          CONST4 = 0
-        end
-
-        class SUPERYARD < YARD
-          CONST4 = 5
-        end
-
-        class SubYard < SUPERYARD
-          CONST2 = "hi"
-          CONST3 = "foo"
-        end
-      eof
-    end
-
-    it "lists inherited constants by default" do
-      consts = P(:SubYard).constants
-      expect(consts).to include(P("YARD::CONST1"))
-      expect(consts).to include(P("SubYard::CONST3"))
-
-      consts = P(:SubYard).inherited_constants
-      expect(consts).to include(P("YARD::CONST1"))
-      expect(consts).not_to include(P("YARD::CONST2"))
-      expect(consts).not_to include(P("SubYard::CONST2"))
-      expect(consts).not_to include(P("SubYard::CONST3"))
-    end
-
-    it "does not list inherited constants if turned off" do
-      consts = P(:SubYard).constants(:inherited => false)
-      expect(consts).not_to include(P("YARD::CONST1"))
-      expect(consts).to include(P("SubYard::CONST3"))
-    end
-
-    it "does not include an inherited constant if it is overridden by the object" do
-      consts = P(:SubYard).constants
-      expect(consts).to include(P("SubYard::CONST2"))
-      expect(consts).not_to include(P("YARD::CONST2"))
-    end
-
-    it "does not include an inherited constant if it is overridden by another subclass" do
-      consts = P(:SubYard).inherited_constants
-      expect(consts).to include(P("SUPERYARD::CONST4"))
-      expect(consts).not_to include(P("YARD::CONST4"))
-    end
-
-    it "does not set a superclass on BasicObject class" do
-      o = ClassObject.new(:root, :BasicObject)
-      expect(o.superclass).to be nil
-    end
-
-    it "sets superclass of Object to BasicObject" do
-      o = ClassObject.new(:root, :Object)
-      expect(o.superclass).to eq P(:BasicObject)
-    end
-
-    it "raises ArgumentError if superclass == self" do
-      expect do
-        ClassObject.new(:root, :Object) do |o|
-          o.superclass = :Object
-        end
-      end.to raise_error(ArgumentError)
-    end
-
-    it "tells the world if it is an exception class" do
-      o = ClassObject.new(:root, :MyClass)
-      o2 = ClassObject.new(:root, :OtherClass)
-      o2.superclass = :SystemCallError
-      o3 = ClassObject.new(:root, :StandardError)
-      o3.superclass = :Object
-      ClassObject.new(:root, :Object)
-
-      o.superclass = :Object
-      expect(o.is_exception?).to be false
-
-      o.superclass = :Exception
-      expect(o.is_exception?).to be true
-
-      o.superclass = :NoMethodError
-      expect(o.is_exception?).to be true
-
-      o.superclass = o2
-      expect(o.is_exception?).to be true
-
-      o.superclass = o3
-      expect(o.is_exception?).to be true
-    end
-
-    it "does not raise ArgumentError if superclass is proxy in different namespace" do
-      expect do
-        ClassObject.new(:root, :X) do |o|
-          o.superclass = P('OTHER::X')
-        end
-      end.not_to raise_error
-    end
-  end
-end

data/spec/code_objects/code_object_list_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::CodeObjects::CodeObjectList do
-  before { Registry.clear }
-
-  describe "#push" do
-    it "only allows CodeObjects::Base, String or Symbol" do
-      list = CodeObjectList.new(nil)
-      expect { list.push(:hash => 1) }.to raise_error(ArgumentError)
-      list << "Test"
-      list << :Test2
-      list << ModuleObject.new(nil, :YARD)
-      expect(list.size).to eq 3
-    end
-  end
-
-  it "added value should be a proxy if parameter was String or Symbol" do
-    list = CodeObjectList.new(nil)
-    list << "Test"
-    expect(list.first.class).to eq Proxy
-  end
-
-  it "contains a unique list of objects" do
-    obj = ModuleObject.new(nil, :YARD)
-    list = CodeObjectList.new(nil)
-
-    list << P(:YARD)
-    list << obj
-    expect(list.size).to eq 1
-
-    list << :Test
-    list << "Test"
-    expect(list.size).to eq 2
-  end
-end

data/spec/code_objects/constants_spec.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::CodeObjects do
-  def silence_warnings
-    origverb = $VERBOSE
-    $VERBOSE = nil
-    yield
-    $VERBOSE = origverb
-  end
-
-  describe :CONSTANTMATCH do
-    it "matches a constant" do
-      expect("Constant"[CodeObjects::CONSTANTMATCH]).to eq "Constant"
-      expect("identifier"[CodeObjects::CONSTANTMATCH]).to be nil
-      expect("File.new"[CodeObjects::CONSTANTMATCH]).to eq "File"
-    end
-  end
-
-  describe :CONSTANTSTART do
-    it "matches a constant" do
-      expect("Constant"[CodeObjects::CONSTANTSTART]).to eq "C"
-      expect("identifier"[CodeObjects::CONSTANTSTART]).to be nil
-      expect("File.new"[CodeObjects::CONSTANTSTART]).to eq "F"
-    end
-  end
-
-  describe :NAMESPACEMATCH do
-    it "matches a namespace (multiple constants with ::)" do
-      expect("Constant"[CodeObjects::NAMESPACEMATCH]).to eq "Constant"
-      expect("A::B::C.new"[CodeObjects::NAMESPACEMATCH]).to eq "A::B::C"
-    end
-  end
-
-  describe :METHODNAMEMATCH do
-    it "matches a method name" do
-      expect("method"[CodeObjects::METHODNAMEMATCH]).to eq "method"
-      expect("[]()"[CodeObjects::METHODNAMEMATCH]).to eq "[]"
-      expect("-@"[CodeObjects::METHODNAMEMATCH]).to eq "-@"
-      expect("method?"[CodeObjects::METHODNAMEMATCH]).to eq "method?"
-      expect("method!!"[CodeObjects::METHODNAMEMATCH]).to eq "method!"
-    end
-  end
-
-  describe :METHODMATCH do
-    it "matches a full class method path" do
-      expect("method"[CodeObjects::METHODMATCH]).to eq "method"
-      expect("A::B::C.method?"[CodeObjects::METHODMATCH]).to eq "A::B::C.method?"
-      expect("A::B::C :: method"[CodeObjects::METHODMATCH]).to eq "A::B::C :: method"
-      expect("SomeClass . method"[CodeObjects::METHODMATCH]).to eq "SomeClass . method"
-    end
-
-    it "matches self.method" do
-      expect("self :: method!"[CodeObjects::METHODMATCH]).to eq "self :: method!"
-      expect("self.is_a?"[CodeObjects::METHODMATCH]).to eq "self.is_a?"
-    end
-  end
-
-  describe :BUILTIN_EXCEPTIONS do
-    it "includes all base exceptions" do
-      bad_names = []
-      silence_warnings do
-        YARD::CodeObjects::BUILTIN_EXCEPTIONS.each do |name|
-          begin
-            bad_names << name unless eval(name) <= Exception
-          rescue NameError
-            nil # noop
-          end
-        end
-      end
-      expect(bad_names).to be_empty
-    end
-  end
-
-  describe :BUILTIN_CLASSES do
-    it "includes all base classes" do
-      bad_names = []
-      silence_warnings do
-        YARD::CodeObjects::BUILTIN_CLASSES.each do |name|
-          begin
-            bad_names << name unless eval(name).is_a?(Class)
-          rescue NameError
-            nil # noop
-          end
-        end
-      end
-      expect(bad_names).to be_empty
-    end
-
-    it "includes all exceptions" do
-      YARD::CodeObjects::BUILTIN_EXCEPTIONS.each do |name|
-        expect(YARD::CodeObjects::BUILTIN_CLASSES).to include(name)
-      end
-    end
-  end
-
-  describe :BUILTIN_ALL do
-    it "includes classes, modules, and exceptions" do
-      a = YARD::CodeObjects::BUILTIN_ALL
-      b = YARD::CodeObjects::BUILTIN_CLASSES
-      c = YARD::CodeObjects::BUILTIN_MODULES
-      expect(a).to eq b + c
-    end
-  end
-
-  describe :BUILTIN_MODULES do
-    it "includes all base modules" do
-      silence_warnings do
-        YARD::CodeObjects::BUILTIN_MODULES.each do |name|
-          next if YARD.ruby19? && ["Precision"].include?(name)
-          expect(eval(name)).to be_instance_of(Module)
-        end
-      end
-    end
-  end
-end

data/spec/code_objects/extra_file_object_spec.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::CodeObjects::ExtraFileObject do
-  describe "#initialize" do
-    it "attempts to read contents from filesystem if contents=nil" do
-      expect(File).to receive(:read).with('file.txt').and_return('')
-      ExtraFileObject.new('file.txt')
-    end
-
-    it "raises Errno::ENOENT if contents=nil and file does not exist" do
-      expect { ExtraFileObject.new('file.txt') }.to raise_error(Errno::ENOENT)
-    end
-
-    it "does not attempt to read from disk if contents are provided" do
-      # TODO: no assertions here!
-      ExtraFileObject.new('file.txt', 'CONTENTS')
-    end
-
-    it "sets filename to filename" do
-      file = ExtraFileObject.new('a/b/c/file.txt', 'CONTENTS')
-      expect(file.filename).to eq "a/b/c/file.txt"
-    end
-
-    it "parses out attributes at top of the file" do
-      file = ExtraFileObject.new('file.txt', "# @title X\n# @some_attribute Y\nFOO BAR")
-      expect(file.attributes[:title]).to eq "X"
-      expect(file.attributes[:some_attribute]).to eq "Y"
-      expect(file.contents).to eq "FOO BAR"
-    end
-
-    it "allows whitespace prior to '#' marker when parsing attributes" do
-      file = ExtraFileObject.new('file.txt', " \t # @title X\nFOO BAR")
-      expect(file.attributes[:title]).to eq "X"
-      expect(file.contents).to eq "FOO BAR"
-    end
-
-    it "allows the attributes section to be wrapped in an HTML comment" do
-      file = ExtraFileObject.new('file.txt', "<!--\n# @title X\n-->\nFOO BAR")
-      expect(file.attributes[:title]).to eq "X"
-      expect(file.contents).to eq "FOO BAR"
-    end
-
-    it "allows whitespace around ignored HTML comment" do
-      file = ExtraFileObject.new('file.txt', " \t <!-- \n# @title X\n \t --> \nFOO BAR")
-      expect(file.attributes[:title]).to eq "X"
-      expect(file.contents).to eq "FOO BAR"
-    end
-
-    it "parses out old-style #!markup shebang format" do
-      file = ExtraFileObject.new('file.txt', "#!foobar\nHello")
-      expect(file.attributes[:markup]).to eq "foobar"
-    end
-
-    it "does not parse old-style #!markup if any whitespace is found" do
-      file = ExtraFileObject.new('file.txt', " #!foobar\nHello")
-      expect(file.attributes[:markup]).to be nil
-      expect(file.contents).to eq " #!foobar\nHello"
-    end
-
-    it "does not parse out attributes if there are newlines prior to attributes" do
-      file = ExtraFileObject.new('file.txt', "\n# @title\nFOO BAR")
-      expect(file.attributes).to be_empty
-      expect(file.contents).to eq "\n# @title\nFOO BAR"
-    end
-
-    it "sets contents to data after attributes" do
-      file = ExtraFileObject.new('file.txt', "# @title\nFOO BAR")
-      expect(file.contents).to eq "FOO BAR"
-    end
-
-    it "preserves newlines" do
-      file = ExtraFileObject.new('file.txt', "FOO\r\nBAR\nBAZ")
-      expect(file.contents).to eq "FOO\r\nBAR\nBAZ"
-    end
-
-    it "does not include newlines in attribute data" do
-      file = ExtraFileObject.new('file.txt', "# @title FooBar\r\nHello world")
-      expect(file.attributes[:title]).to eq "FooBar"
-    end
-
-    it "forces encoding to @encoding attribute if present" do
-      expect(log).not_to receive(:warn)
-      data = String.new("# @encoding sjis\nFOO")
-      data.force_encoding('binary')
-      file = ExtraFileObject.new('file.txt', data)
-      expect(['Shift_JIS', 'Windows-31J']).to include(file.contents.encoding.to_s)
-    end if YARD.ruby19?
-
-    it "warns if @encoding is invalid" do
-      expect(log).to receive(:warn).with("Invalid encoding `INVALID' in file.txt")
-      data = String.new("# @encoding INVALID\nFOO")
-      encoding = data.encoding
-      file = ExtraFileObject.new('file.txt', data)
-      expect(file.contents.encoding).to eq encoding
-    end if YARD.ruby19?
-
-    it "ignores encoding in 1.8.x (or encoding-unaware platforms)" do
-      expect(log).not_to receive(:warn)
-      ExtraFileObject.new('file.txt', "# @encoding INVALID\nFOO")
-    end if YARD.ruby18?
-
-    it "attempts to re-parse data as 8-bit ascii if parsing fails" do
-      expect(log).not_to receive(:warn)
-      str, out = *([String.new("\xB0")] * 2)
-      if str.respond_to?(:force_encoding!)
-        str.force_encoding!('utf-8')
-        out.force_encoding!('binary')
-      end
-      expect(str.valid_encoding?).to be(false)
-      file = ExtraFileObject.new('file.txt', str)
-      expect(file.contents).to eq out
-    end
-  end
-
-  describe "#name" do
-    it "returns basename (not extension) of filename" do
-      file = ExtraFileObject.new('file.txt', '')
-      expect(file.name).to eq 'file'
-    end
-  end
-
-  describe "#title" do
-    it "returns @title attribute if present" do
-      file = ExtraFileObject.new('file.txt', '# @title FOO')
-      expect(file.title).to eq 'FOO'
-    end
-
-    it "returns #name if no @title attribute exists" do
-      file = ExtraFileObject.new('file.txt', '')
-      expect(file.title).to eq 'file'
-    end
-  end
-
-  describe "#locale=" do
-    it "translates contents" do
-      file = ExtraFileObject.new('file.txt', 'Hello')
-      file.locale = 'fr'
-      fr_locale = I18n::Locale.new('fr')
-      fr_messages = fr_locale.instance_variable_get(:@messages)
-      fr_messages["Hello"] = 'Bonjour'
-      expect(Registry).to receive(:locale).with('fr').and_return(fr_locale)
-      expect(file.contents).to eq 'Bonjour'
-    end
-  end
-
-  describe "#==" do
-    it "defines equality based on filename alone" do
-      file1 = ExtraFileObject.new('file.txt', 'A')
-      file2 = ExtraFileObject.new('file.txt', 'B')
-      expect(file1).to eq file2
-      expect(file1).to eql file2
-      expect(file1).to equal file2
-
-      # Another way to test the equality interface
-      a = [file1]
-      a |= [file2]
-      expect(a.size).to eq 1
-    end
-  end
-end

data/spec/code_objects/macro_object_spec.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::CodeObjects::MacroObject do
-  before do
-    Registry.clear
-  end
-
-  describe ".create" do
-    def create(*args) MacroObject.create(*args) end
-
-    it "creates an object" do
-      create('foo', '')
-      obj = Registry.at('.macro.foo')
-      expect(obj).not_to be nil
-    end
-
-    it "uses identity map" do
-      obj1 = create('foo', '')
-      obj2 = create('foo', '')
-      expect(obj1.object_id).to eq obj2.object_id
-    end
-
-    it "allows specifying of macro data" do
-      obj = create('foo', 'MACRODATA')
-      expect(obj.macro_data).to eq 'MACRODATA'
-    end
-
-    context "if a method object is provided" do
-      it "attaches it" do
-        obj = create('foo', 'MACRODATA', P('Foo.property'))
-        expect(obj.method_object).to eq P('Foo.property')
-        expect(obj).to be_attached
-      end
-    end
-  end
-
-  describe ".find" do
-    before { MacroObject.create('foo', 'DATA') }
-
-    it "searches for an object by name" do
-      expect(MacroObject.find('foo').macro_data).to eq 'DATA'
-    end
-
-    it "accepts Symbol" do
-      expect(MacroObject.find(:foo).macro_data).to eq 'DATA'
-    end
-  end
-
-  describe ".find_or_create" do
-    it "looks up name if @!macro is present and find object" do
-      macro1 = MacroObject.create('foo', 'FOO')
-      macro2 = MacroObject.find_or_create('foo', "a b c")
-      expect(macro1).to eq macro2
-    end
-
-    it "creates new macro if macro by that name does not exist" do
-      MacroObject.find_or_create('foo', "@!method $1")
-      expect(MacroObject.find('foo').macro_data).to eq "@!method $1"
-    end
-  end
-
-  describe ".apply" do
-    let(:args) { %w(foo a b c) }
-
-    def apply(comments)
-      MacroObject.apply(comments, args)
-    end
-
-    it "only expands macros if @macro is present" do
-      expect(apply("$1$2$3")).to eq "$1$2$3"
-    end
-
-    it "handles macro text inside block" do
-      expect(apply("@!macro\n  foo$1$2$3\nfoobaz")).to eq "fooabc\nfoobaz"
-    end
-
-    it "appends docstring to existing macro" do
-      MacroObject.create('name', '$3$2$1')
-      result = MacroObject.apply("@!macro name\nfoobar", args)
-      expect(result).to eq "cba\nfoobar"
-    end
-
-    it "uses only non-macro data if docstring is an existing macro" do
-      data = "@!macro name\n  $3$2$1\nEXTRA"
-      result = MacroObject.apply(data, args, 'SOURCE')
-      expect(result).to eq "cba\nEXTRA"
-      expect(MacroObject.apply("@!macro name\nFOO", args)).to eq "cba\nFOO"
-    end
-
-    it "creates macros if they don't exist" do
-      result = MacroObject.apply("@!macro name\n  foo!$1", args, 'SOURCE')
-      expect(result).to eq "foo!a"
-      expect(MacroObject.find('name').macro_data).to eq 'foo!$1'
-    end
-
-    it "keeps other tags" do
-      expect(apply("@!macro\n  foo$1$2$3\n@param name foo\nfoo")).to eq(
-        "fooabc\nfoo\n@param name\n  foo"
-      )
-    end
-  end
-
-  describe ".expand" do
-    def expand(comments)
-      args = %w(foo a b c)
-      full_line = 'foo :bar, :baz'
-      MacroObject.expand(comments, args, full_line)
-    end
-
-    it "allows escaping of macro syntax" do
-      expect(expand("$1\\$2$3")).to eq "a$2c"
-    end
-
-    it "replaces $* with the whole statement" do
-      expect(expand("$* ${*}")).to eq "foo :bar, :baz foo :bar, :baz"
-    end
-
-    it "replaces $0 with method name" do
-      expect(expand("$0 ${0}")).to eq "foo foo"
-    end
-
-    it "replaces all $N values with the Nth argument in the method call" do
-      expect(expand("$1$2$3${3}\nfoobar")).to eq "abcc\nfoobar"
-    end
-
-    it "replaces ${N-M} ranges with N-M arguments (incl. commas)" do
-      expect(expand("${1-2}x")).to eq "a, bx"
-    end
-
-    it "handles open ended ranges (${N-})" do
-      expect(expand("${2-}")).to eq "b, c"
-    end
-
-    it "handles negative indexes ($-N)" do
-      expect(expand("$-1 ${-2-} ${-2--2}")).to eq "c b, c b"
-    end
-
-    it "accepts Docstring objects" do
-      expect(expand(Docstring.new("$1\n@param name foo"))).to eq "a\n@param name foo"
-    end
-  end
-
-  describe "#expand" do
-    it "expands a macro given its data" do
-      macro = MacroObject.create_docstring('foo', '$1 $2 THREE!')
-      expect(macro.expand(['NAME', 'ONE', 'TWO'])).to eq "ONE TWO THREE!"
-    end
-  end
-end