puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/pops/parser/lexer_spec.rb

@@ -16,7 +16,20 @@ module EgrammarLexerSpec
   def self.tokens_scanned_from(s)
     lexer = Puppet::Pops::Parser::Lexer.new
     lexer.string = s
-    lexer.fullscan[0..-2]
+    tokens = lexer.fullscan[0..-2]
+    tokens.map do |t|
+      key = t[0]
+      options = t[1]
+      if options[:locator]
+        # unresolved locations needs to be resolved for tests that check positioning
+        [key,
+          options[:locator].to_location_hash(
+            options[:offset],
+            options[:end_offset]).merge({:value => options[:value]}) ]
+      else
+        t
+      end
+    end
   end
 end
 
@@ -179,6 +192,7 @@ describe Puppet::Pops::Parser::Lexer::TOKENS do
     :FARROW => '=>',
     :PARROW => '+>',
     :APPENDS => '+=',
+    :DELETES => '-=',
     :PLUS => '+',
     :MINUS => '-',
     :DIV => '/',
@@ -349,8 +363,11 @@ describe Puppet::Pops::Parser::Lexer::TOKENS[:COMMENT] do
     @token.skip?.should be_true
   end
 
-  it "'s block should return the comment without the #" do
-    @token.convert(@lexer,"# this is a comment")[1].should == "this is a comment"
+  it "'s block should return the comment without any text" do
+    # This is a silly test, the original tested that the comments was processed, but
+    # all comments are skipped anyway, and never collected for documentation.
+    #
+    @token.convert(@lexer,"# this is a comment")[1].should == ""
   end
 end
 
@@ -382,9 +399,12 @@ describe Puppet::Pops::Parser::Lexer::TOKENS[:MLCOMMENT] do
   end
 
   it "'s block should return the comment without the comment marks" do
+    # This is a silly test, the original tested that the comments was processed, but
+    # all comments are skipped anyway, and never collected for documentation.
+    #
     @lexer.stubs(:line=).with(0)
 
-    @token.convert(@lexer,"/* this is a comment */")[1].should == "this is a comment"
+    @token.convert(@lexer,"/* this is a comment */")[1].should == ""
   end
 end
 
@@ -443,63 +463,10 @@ describe Puppet::Pops::Parser::Lexer::TOKENS[:VARIABLE] do
 end
 
 describe "the horrible deprecation / compatibility variables with dashes" do
-  ENamesWithDashes = %w{f- f-o -f f::-o f::o- f::o-o}
-
-  { Puppet::Pops::Parser::Lexer::TOKENS[:DOLLAR_VAR_WITH_DASH] => '$',
-    Puppet::Pops::Parser::Lexer::TOKENS[:VARIABLE_WITH_DASH]   => ''
-  }.each do |token, prefix|
-    describe token do
-      its(:skip_text) { should be_false }
-
-      context "when compatibly is disabled" do
-        before :each do Puppet[:allow_variables_with_dashes] = false end
-        Puppet::Pops::Parser::Lexer::TOKENS.each do |name, value|
-          it "should be unacceptable after #{name}" do
-            token.acceptable?(:after => name).should be_false
-          end
-        end
-
-        # Yes, this should still *match*, just not be acceptable.
-        ENamesWithDashes.each do |name|
-          ["", "::"].each do |global_scope|
-            var = prefix + global_scope + name
-            it "should match #{var.inspect}" do
-              subject.regex.match(var).to_a.should == [var]
-            end
-          end
-        end
-      end
-
-      context "when compatibility is enabled" do
-        before :each do Puppet[:allow_variables_with_dashes] = true end
-
-        it "should be acceptable after DQPRE" do
-          token.acceptable?(:after => :DQPRE).should be_true
-        end
-
-        ENamesWithDashes.each do |name|
-          ["", "::"].each do |global_scope|
-            var = prefix + global_scope + name
-            it "should match #{var.inspect}" do
-              subject.regex.match(var).to_a.should == [var]
-            end
-          end
-        end
-      end
-    end
-  end
 
   context "deprecation warnings" do
     before :each do Puppet[:allow_variables_with_dashes] = true end
 
-    it "should match a top level variable" do
-      Puppet.expects(:deprecation_warning).once
-
-      EgrammarLexerSpec.tokens_scanned_from('$foo-bar').should == [
-        [:VARIABLE, {:value=>"foo-bar", :line=>1, :pos=>1, :offset=>0, :length=>8}]
-      ]
-    end
-
     it "does not warn about a variable without a dash" do
       Puppet.expects(:deprecation_warning).never
 
@@ -515,34 +482,6 @@ describe "the horrible deprecation / compatibility variables with dashes" do
         [:NAME, {:value=>"foo-bar", :line=>1, :pos=>1, :offset=>0, :length=>7}]
       ]
     end
-
-    it "warns about reference to variable" do
-      Puppet.expects(:deprecation_warning).once
-
-      EgrammarLexerSpec.tokens_scanned_from('$::foo-bar::baz-quux').should == [
-        [:VARIABLE, {:value=>"::foo-bar::baz-quux", :line=>1, :pos=>1, :offset=>0, :length=>20}]
-      ]
-    end
-
-    it "warns about reference to variable interpolated in a string" do
-      Puppet.expects(:deprecation_warning).once
-
-      EgrammarLexerSpec.tokens_scanned_from('"$::foo-bar::baz-quux"').should == [
-        [:DQPRE,    {:value=>"", :line=>1, :pos=>1, :offset=>0, :length=>2}],  # length since preamble includes start and terminator
-        [:VARIABLE, {:value=>"::foo-bar::baz-quux", :line=>1, :pos=>3, :offset=>2, :length=>19}],
-        [:DQPOST,   {:value=>"", :line=>1, :pos=>22, :offset=>21, :length=>1}],
-      ]
-    end
-
-    it "warns about reference to variable interpolated in a string as an expression" do
-      Puppet.expects(:deprecation_warning).once
-
-      EgrammarLexerSpec.tokens_scanned_from('"${::foo-bar::baz-quux}"').should == [
-        [:DQPRE,    {:value=>"", :line=>1, :pos=>1, :offset=>0, :length=>3}],
-        [:VARIABLE, {:value=>"::foo-bar::baz-quux", :line=>1, :pos=>4, :offset=>3, :length=>19}],
-        [:DQPOST,   {:value=>"", :line=>1, :pos=>23, :offset=>22, :length=>2}],
-      ]
-    end
   end
 end
 
@@ -786,7 +725,7 @@ describe "when trying to lex a non-existent file" do
   it "should return an empty list of tokens" do
     lexer = Puppet::Pops::Parser::Lexer.new
     lexer.file = nofile = tmpfile('lexer')
-    Puppet::FileSystem::File.exist?(nofile).should == false
+    Puppet::FileSystem.exist?(nofile).should == false
 
     lexer.fullscan.should == [[false,false]]
   end

data/spec/unit/pops/parser/parse_basic_expressions_spec.rb

@@ -118,11 +118,11 @@ describe "egrammar parsing basic expressions" do
     context "of regular expressions (parse errors)" do
       # Not supported in concrete syntax
       it "$a = /.*/ == /.*/" do
-        expect {  parse("$a = /.*/ == /.*/") }.to raise_error(Puppet::ParseError)
+        dump(parse("$a = /.*/ == /.*/")).should == "(= $a (== /.*/ /.*/))"
       end
 
       it "$a = /.*/ != /a.*/" do
-        expect {  parse("$a = /.*/ != /.*/") }.to raise_error(Puppet::ParseError)
+        dump(parse("$a = /.*/ != /.*/")).should == "(= $a (!= /.*/ /.*/))"
       end
     end
   end
@@ -179,6 +179,14 @@ describe "egrammar parsing basic expressions" do
       dump(parse("$a = 10")).should == "(= $a 10)"
     end
 
+    it "Should allow append assignment" do
+      dump(parse("$a += 10")).should == "(+= $a 10)"
+    end
+
+    it "Should allow without assignment" do
+      dump(parse("$a -= 10")).should == "(-= $a 10)"
+    end
+
     it "Should allow chained assignment" do
       dump(parse("$a = $b = 10")).should == "(= $a (= $b 10))"
     end
@@ -241,8 +249,25 @@ describe "egrammar parsing basic expressions" do
       dump(parse("$a = \"yo${var}yo\"")).should == "(= $a (cat 'yo' (str $var) 'yo'))"
     end
 
-    it "should interpolate any expression in a text expression, \"${var*2}\"" do
-      dump(parse("$a = \"yo${var+2}yo\"")).should == "(= $a (cat 'yo' (str (+ $var 2)) 'yo'))"
+    it "should interpolate any expression in a text expression, \"${$var*2}\"" do
+      dump(parse("$a = \"yo${$var+2}yo\"")).should == "(= $a (cat 'yo' (str (+ $var 2)) 'yo'))"
+    end
+
+    it "should not interpolate names as variable in expression, \"${notvar*2}\"" do
+      dump(parse("$a = \"yo${notvar+2}yo\"")).should == "(= $a (cat 'yo' (str (+ notvar 2)) 'yo'))"
+    end
+
+    it "should interpolate name as variable in access expression, \"${var[0]}\"" do
+      dump(parse("$a = \"yo${var[0]}yo\"")).should == "(= $a (cat 'yo' (str (slice $var 0)) 'yo'))"
+    end
+
+    it "should interpolate name as variable in method call, \"${var.foo}\"" do
+      dump(parse("$a = \"yo${$var.foo}yo\"")).should == "(= $a (cat 'yo' (str (call-method (. $var foo))) 'yo'))"
+    end
+
+    it "should interpolate name as variable in method call, \"${var.foo}\"" do
+      dump(parse("$a = \"yo${var.foo}yo\"")).should == "(= $a (cat 'yo' (str (call-method (. $var foo))) 'yo'))"
+      dump(parse("$a = \"yo${var.foo.bar}yo\"")).should == "(= $a (cat 'yo' (str (call-method (. (call-method (. $var foo)) bar))) 'yo'))"
     end
   end
 end

data/spec/unit/pops/parser/parse_calls_spec.rb

@@ -14,8 +14,12 @@ describe "egrammar parsing function calls" do
         dump(parse("foo()")).should == "(invoke foo)"
       end
 
-      it "foo bar" do
-        dump(parse("foo bar")).should == "(invoke foo bar)"
+      it "notice bar" do
+        dump(parse("notice bar")).should == "(invoke notice bar)"
+      end
+
+      it "notice(bar)" do
+        dump(parse("notice bar")).should == "(invoke notice bar)"
       end
 
       it "foo(bar)" do
@@ -30,8 +34,8 @@ describe "egrammar parsing function calls" do
         dump(parse("foo(bar,fum,)")).should == "(invoke foo bar fum)"
       end
 
-      it "foo fqdn_rand(30)" do
-        dump(parse("foo fqdn_rand(30)")).should == '(invoke foo (call fqdn_rand 30))'
+      it "notice fqdn_rand(30)" do
+        dump(parse("notice fqdn_rand(30)")).should == '(invoke notice (call fqdn_rand 30))'
       end
     end
 
@@ -40,8 +44,8 @@ describe "egrammar parsing function calls" do
         dump(parse("if true {foo()}")).should == "(if true\n  (then (invoke foo)))"
       end
 
-      it "if true { foo bar}" do
-        dump(parse("if true {foo bar}")).should == "(if true\n  (then (invoke foo bar)))"
+      it "if true { notice bar}" do
+        dump(parse("if true {notice bar}")).should == "(if true\n  (then (invoke notice bar)))"
       end
     end
   end

data/spec/unit/pops/parser/parse_conditionals_spec.rb

@@ -147,13 +147,4 @@ describe "egrammar parsing conditionals" do
     end
   end
 
-  context "When parsing imports" do
-    it "import 'foo'" do
-      dump(parse("import 'foo'")).should == "(import 'foo')"
-    end
-
-    it "import 'foo', 'bar'" do
-      dump(parse("import 'foo', 'bar'")).should == "(import 'foo' 'bar')"
-    end
-  end
 end

data/spec/unit/pops/parser/parse_containers_spec.rb

@@ -23,6 +23,10 @@ describe "egrammar parsing containers" do
       dump(parse("class foo {}")).should == "(class foo ())"
     end
 
+    it "class foo { class bar {} }" do
+      dump(parse("class foo { class bar {}}")).should == "(class foo (block (class foo::bar ())))"
+    end
+
     it "class foo::bar {}" do
       dump(parse("class foo::bar {}")).should == "(class foo::bar ())"
     end
@@ -57,7 +61,9 @@ describe "egrammar parsing containers" do
         # a very confusing effect when resolving relative names, getting the global hardwired "Class"
         # instead of some foo::class etc.
         # This is allowed in 3.x.
-        dump(parse("class class {}")).should == "(class class ())"
+        expect {
+          dump(parse("class class {}")).should == "(class class ())"
+        }.to raise_error(/not a valid classname/)
       end
 
       it "class default {} # a class named 'default'" do
@@ -72,7 +78,9 @@ describe "egrammar parsing containers" do
       end
 
       it "class class inherits default {} # inherits default", :broken => true do
-        dump(parse("class class inherits default {}")).should == "(class class (inherits default) ())"
+        expect {
+          dump(parse("class class inherits default {}")).should == "(class class (inherits default) ())"
+        }.to raise_error(/not a valid classname/)
       end
 
       it "class class inherits default {} # inherits default" do
@@ -80,12 +88,16 @@ describe "egrammar parsing containers" do
         # this because a class is named at parse time (since class evaluation is lazy, the model must have the
         # full class name for nested classes - only, it gets this wrong when a class is named "class" - or at least
         # I think it is wrong.)
-        #
+        # 
+        expect {
         dump(parse("class class inherits default {}")).should == "(class class::class (inherits default) ())"
+          }.to raise_error(/not a valid classname/)
       end
 
       it "class foo inherits class" do
-        dump(parse("class foo inherits class {}")).should == "(class foo (inherits class) ())"
+        expect {
+          dump(parse("class foo inherits class {}")).should == "(class foo (inherits class) ())"
+        }.to raise_error(/not a valid classname/)
       end
     end
   end
@@ -95,6 +107,15 @@ describe "egrammar parsing containers" do
       dump(parse("define foo {}")).should == "(define foo ())"
     end
 
+    it "class foo { define bar {}}" do
+      dump(parse("class foo {define bar {}}")).should == "(class foo (block (define foo::bar ())))"
+    end
+
+    it "define foo { define bar {}}" do
+      # This is illegal, but handled as part of validation
+      dump(parse("define foo { define bar {}}")).should == "(define foo (block (define bar ())))"
+    end
+
     it "define foo::bar {}" do
       dump(parse("define foo::bar {}")).should == "(define foo::bar ())"
     end
@@ -119,7 +140,9 @@ describe "egrammar parsing containers" do
       it "define class {} # a define named 'class'" do
         # This is weird because Class already exists, and instantiating this define will probably not
         # work
-        dump(parse("define class {}")).should == "(define class ())"
+        expect {
+          dump(parse("define class {}")).should == "(define class ())"
+          }.to raise_error(/not a valid classname/)
       end
 
       it "define default {} # a define named 'default'" do
@@ -133,11 +156,19 @@ describe "egrammar parsing containers" do
 
   context "When parsing node" do
     it "node foo {}" do
-      dump(parse("node foo {}")).should == "(node (matches foo) ())"
+      dump(parse("node foo {}")).should == "(node (matches 'foo') ())"
+    end
+
+    it "node kermit.example.com {}" do
+      dump(parse("node kermit.example.com {}")).should == "(node (matches 'kermit.example.com') ())"
+    end
+
+    it "node kermit . example . com {}" do
+      dump(parse("node kermit . example . com {}")).should == "(node (matches 'kermit.example.com') ())"
     end
 
     it "node foo, x::bar, default {}" do
-      dump(parse("node foo, x::bar, default {}")).should == "(node (matches foo x::bar :default) ())"
+      dump(parse("node foo, x::bar, default {}")).should == "(node (matches 'foo' 'x::bar' :default) ())"
     end
 
     it "node 'foo' {}" do
@@ -145,15 +176,15 @@ describe "egrammar parsing containers" do
     end
 
     it "node foo inherits x::bar {}" do
-      dump(parse("node foo inherits x::bar {}")).should == "(node (matches foo) (parent x::bar) ())"
+      dump(parse("node foo inherits x::bar {}")).should == "(node (matches 'foo') (parent 'x::bar') ())"
     end
 
     it "node foo inherits 'bar' {}" do
-      dump(parse("node foo inherits 'bar' {}")).should == "(node (matches foo) (parent 'bar') ())"
+      dump(parse("node foo inherits 'bar' {}")).should == "(node (matches 'foo') (parent 'bar') ())"
     end
 
     it "node foo inherits default {}" do
-      dump(parse("node foo inherits default {}")).should == "(node (matches foo) (parent :default) ())"
+      dump(parse("node foo inherits default {}")).should == "(node (matches 'foo') (parent :default) ())"
     end
 
     it "node /web.*/ {}" do
@@ -165,11 +196,11 @@ describe "egrammar parsing containers" do
     end
 
     it "node wat inherits /apache.*/ {}" do
-      expect { parse("node wat inherits /apache.*/ {}")}.to raise_error(Puppet::ParseError)
+      dump(parse("node wat inherits /apache.*/ {}")).should == "(node (matches 'wat') (parent /apache.*/) ())"
     end
 
     it "node foo inherits bar {$a = 10 $b = 20}" do
-      dump(parse("node foo inherits bar {$a = 10 $b = 20}")).should == "(node (matches foo) (parent bar) (block (= $a 10) (= $b 20)))"
+      dump(parse("node foo inherits bar {$a = 10 $b = 20}")).should == "(node (matches 'foo') (parent 'bar') (block (= $a 10) (= $b 20)))"
     end
   end
 end

data/spec/unit/pops/parser/parse_heredoc_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+# relative to this spec file (./) does not work as this file is loaded by rspec
+require File.join(File.dirname(__FILE__), '/parser_rspec_helper')
+
+describe "egrammar parsing heredoc" do
+  include ParserRspecHelper
+
+  it "parses plain heredoc" do
+    dump(parse("@(END)\nThis is\nheredoc text\nEND\n")).should == [
+      "(@()",
+      "  (sublocated 'This is\nheredoc text\n')",
+      ")"
+    ].join("\n")
+  end
+
+  it "parses heredoc with margin" do
+    src = [
+    "@(END)",
+    "   This is",
+    "   heredoc text",
+    "   | END",
+    ""
+    ].join("\n")
+    dump(parse(src)).should == [
+      "(@()",
+      "  (sublocated 'This is\nheredoc text\n')",
+      ")"
+    ].join("\n")
+  end
+
+  it "parses heredoc with margin and right newline trim" do
+    src = [
+    "@(END)",
+    "   This is",
+    "   heredoc text",
+    "   |- END",
+    ""
+    ].join("\n")
+    dump(parse(src)).should == [
+      "(@()",
+      "  (sublocated 'This is\nheredoc text')",
+      ")"
+    ].join("\n")
+  end
+
+  it "parses syntax and escape specification" do
+    src = <<-CODE
+    @(END:syntax/t)
+    Tex\\tt\\n
+    |- END
+    CODE
+    dump(parse(src)).should == [
+      "(@(syntax)",
+      "  (sublocated 'Tex\tt\\n')",
+      ")"
+    ].join("\n")
+  end
+
+  it "parses interpolated heredoc epression" do
+    src = <<-CODE
+    @("END")
+    Hello $name
+    |- END
+    CODE
+    dump(parse(src)).should == [
+      "(@()",
+      "  (sublocated (cat 'Hello ' (str $name) ''))",
+      ")"
+    ].join("\n")
+  end
+end