puppet 7.27.0-x64-mingw32 → 7.29.0-x64-mingw32

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

@@ -1,184 +0,0 @@
-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 conditionals" do
-  include ParserRspecHelper
-
-  context "When parsing if statements" do
-    it "if true { $a = 10 }" do
-      expect(dump(parse("if true { $a = 10 }"))).to eq("(if true\n  (then (= $a 10)))")
-    end
-
-    it "if true { $a = 10 } else {$a = 20}" do
-      expect(dump(parse("if true { $a = 10 } else {$a = 20}"))).to eq(
-      ["(if true",
-        "  (then (= $a 10))",
-        "  (else (= $a 20)))"].join("\n")
-      )
-    end
-
-    it "if true { $a = 10 } elsif false { $a = 15} else {$a = 20}" do
-      expect(dump(parse("if true { $a = 10 } elsif false { $a = 15} else {$a = 20}"))).to eq(
-      ["(if true",
-        "  (then (= $a 10))",
-        "  (else (if false",
-        "      (then (= $a 15))",
-        "      (else (= $a 20)))))"].join("\n")
-      )
-    end
-
-    it "if true { $a = 10 $b = 10 } else {$a = 20}" do
-      expect(dump(parse("if true { $a = 10 $b = 20} else {$a = 20}"))).to eq([
-       "(if true",
-       "  (then (block",
-       "      (= $a 10)",
-       "      (= $b 20)",
-       "    ))",
-       "  (else (= $a 20)))"
-       ].join("\n"))
-    end
-
-    it "allows a parenthesized conditional expression" do
-      expect(dump(parse("if (true) { 10 }"))).to eq("(if true\n  (then 10))")
-    end
-
-    it "allows a parenthesized elsif conditional expression" do
-      expect(dump(parse("if true { 10 } elsif (false) { 20 }"))).to eq(
-        ["(if true",
-         "  (then 10)",
-         "  (else (if false",
-         "      (then 20))))"].join("\n")
-      )
-    end
-  end
-
-  context "When parsing unless statements" do
-    it "unless true { $a = 10 }" do
-      expect(dump(parse("unless true { $a = 10 }"))).to eq("(unless true\n  (then (= $a 10)))")
-    end
-
-    it "unless true { $a = 10 } else {$a = 20}" do
-      expect(dump(parse("unless true { $a = 10 } else {$a = 20}"))).to eq(
-      ["(unless true",
-        "  (then (= $a 10))",
-        "  (else (= $a 20)))"].join("\n")
-      )
-    end
-
-    it "allows a parenthesized conditional expression" do
-      expect(dump(parse("unless (true) { 10 }"))).to eq("(unless true\n  (then 10))")
-    end
-
-    it "unless true { $a = 10 } elsif false { $a = 15} else {$a = 20} # is illegal" do
-      expect { parse("unless true { $a = 10 } elsif false { $a = 15} else {$a = 20}")}.to raise_error(Puppet::ParseError)
-    end
-  end
-
-  context "When parsing selector expressions" do
-    it "$a = $b ? banana => fruit " do
-      expect(dump(parse("$a = $b ? banana => fruit"))).to eq(
-      "(= $a (? $b (banana => fruit)))"
-      )
-    end
-
-    it "$a = $b ? { banana => fruit}" do
-      expect(dump(parse("$a = $b ? { banana => fruit }"))).to eq(
-      "(= $a (? $b (banana => fruit)))"
-      )
-    end
-
-    it "does not fail on a trailing blank line" do
-      expect(dump(parse("$a = $b ? { banana => fruit }\n\n"))).to eq(
-      "(= $a (? $b (banana => fruit)))"
-      )
-    end
-
-    it "$a = $b ? { banana => fruit, grape => berry }" do
-      expect(dump(parse("$a = $b ? {banana => fruit, grape => berry}"))).to eq(
-      "(= $a (? $b (banana => fruit) (grape => berry)))"
-      )
-    end
-
-    it "$a = $b ? { banana => fruit, grape => berry, default => wat }" do
-      expect(dump(parse("$a = $b ? {banana => fruit, grape => berry, default => wat}"))).to eq(
-      "(= $a (? $b (banana => fruit) (grape => berry) (:default => wat)))"
-      )
-    end
-
-    it "$a = $b ? { default => wat, banana => fruit, grape => berry,  }" do
-      expect(dump(parse("$a = $b ? {default => wat, banana => fruit, grape => berry}"))).to eq(
-      "(= $a (? $b (:default => wat) (banana => fruit) (grape => berry)))"
-      )
-    end
-
-    it '1+2 ? 3 => yes' do
-      expect(dump(parse("1+2 ? 3 => yes"))).to eq(
-      "(? (+ 1 2) (3 => yes))"
-      )
-    end
-
-    it 'true and 1+2 ? 3 => yes' do
-      expect(dump(parse("true and 1+2 ? 3 => yes"))).to eq(
-      "(&& true (? (+ 1 2) (3 => yes)))"
-      )
-    end
-  end
-
-  context "When parsing case statements" do
-    it "case $a { a : {}}" do
-      expect(dump(parse("case $a { a : {}}"))).to eq(
-      ["(case $a",
-        "  (when (a) (then ())))"
-      ].join("\n")
-      )
-    end
-
-    it "allows a parenthesized value expression" do
-      expect(dump(parse("case ($a) { a : {}}"))).to eq(
-      ["(case $a",
-        "  (when (a) (then ())))"
-      ].join("\n")
-      )
-    end
-
-    it "case $a { /.*/ : {}}" do
-      expect(dump(parse("case $a { /.*/ : {}}"))).to eq(
-      ["(case $a",
-        "  (when (/.*/) (then ())))"
-      ].join("\n")
-      )
-    end
-
-    it "case $a { a, b : {}}" do
-      expect(dump(parse("case $a { a, b : {}}"))).to eq(
-      ["(case $a",
-        "  (when (a b) (then ())))"
-      ].join("\n")
-      )
-    end
-
-    it "case $a { a, b : {} default : {}}" do
-      expect(dump(parse("case $a { a, b : {} default : {}}"))).to eq(
-      ["(case $a",
-        "  (when (a b) (then ()))",
-        "  (when (:default) (then ())))"
-      ].join("\n")
-      )
-    end
-
-    it "case $a { a : {$b = 10 $c = 20}}" do
-      expect(dump(parse("case $a { a : {$b = 10 $c = 20}}"))).to eq(
-      ["(case $a",
-       "  (when (a) (then (block",
-       "    (= $b 10)",
-       "    (= $c 20)",
-       "  ))))"
-      ].join("\n")
-      )
-    end
-  end
-
-end

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

@@ -1,247 +0,0 @@
-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 containers" do
-  include ParserRspecHelper
-
-  context "When parsing file scope" do
-    it "$a = 10 $b = 20" do
-      expect(dump(parse("$a = 10 $b = 20"))).to eq([
-        "(block",
-        "  (= $a 10)",
-        "  (= $b 20)",
-        ")"
-        ].join("\n"))
-    end
-
-    it "$a = 10" do
-      expect(dump(parse("$a = 10"))).to eq("(= $a 10)")
-    end
-  end
-
-  context "When parsing class" do
-    it "class foo {}" do
-      expect(dump(parse("class foo {}"))).to eq("(class foo ())")
-    end
-
-    it "class foo { class bar {} }" do
-      expect(dump(parse("class foo { class bar {}}"))).to eq([
-        "(class foo (block",
-        "  (class foo::bar ())",
-        "))"
-        ].join("\n"))
-    end
-
-    it "class foo::bar {}" do
-      expect(dump(parse("class foo::bar {}"))).to eq("(class foo::bar ())")
-    end
-
-    it "class foo inherits bar {}" do
-      expect(dump(parse("class foo inherits bar {}"))).to eq("(class foo (inherits bar) ())")
-    end
-
-    it "class foo($a) {}" do
-      expect(dump(parse("class foo($a) {}"))).to eq("(class foo (parameters a) ())")
-    end
-
-    it "class foo($a, $b) {}" do
-      expect(dump(parse("class foo($a, $b) {}"))).to eq("(class foo (parameters a b) ())")
-    end
-
-    it "class foo($a, $b=10) {}" do
-      expect(dump(parse("class foo($a, $b=10) {}"))).to eq("(class foo (parameters a (= b 10)) ())")
-    end
-
-    it "class foo($a, $b) inherits belgo::bar {}" do
-      expect(dump(parse("class foo($a, $b) inherits belgo::bar{}"))).to eq("(class foo (inherits belgo::bar) (parameters a b) ())")
-    end
-
-    it "class foo {$a = 10 $b = 20}" do
-      expect(dump(parse("class foo {$a = 10 $b = 20}"))).to eq([
-        "(class foo (block",
-        "  (= $a 10)",
-        "  (= $b 20)",
-        "))"
-        ].join("\n"))
-    end
-
-    context "it should handle '3x weirdness'" do
-      it "class class {} # a class named 'class'" do
-        # Not as much weird as confusing that it is possible to name a class 'class'. Can have
-        # a very confusing effect when resolving relative names, getting the global hardwired "Class"
-        # instead of some foo::class etc.
-        # This was allowed in 3.x.
-        expect { parse("class class {}") }.to raise_error(/'class' keyword not allowed at this location/)
-      end
-
-      it "class default {} # a class named 'default'" do
-        # The weirdness here is that a class can inherit 'default' but not declare a class called default.
-        # (It will work with relative names i.e. foo::default though). The whole idea with keywords as
-        # names is flawed to begin with - it generally just a very bad idea.
-        expect { parse("class default {}") }.to raise_error(Puppet::ParseError)
-      end
-
-      it "class 'foo' {} # a string as class name" do
-        # A common error is to put quotes around the class name, the parser should provide the error message at the right location
-        # See PUP-7471
-        expect { parse("class 'foo' {}") }.to raise_error(/A quoted string is not valid as a name here \(line: 1, column: 7\)/)
-      end
-
-
-      it "class foo::default {} # a nested name 'default'" do
-        expect(dump(parse("class foo::default {}"))).to eq("(class foo::default ())")
-      end
-
-      it "class class inherits default {} # inherits default" do
-        expect { parse("class class inherits default {}") }.to raise_error(/'class' keyword not allowed at this location/)
-      end
-
-      it "class foo inherits class" do
-        expect { parse("class foo inherits class {}") }.to raise_error(/'class' keyword not allowed at this location/)
-      end
-    end
-
-    context 'it should allow keywords as attribute names' do
-      ['and', 'case', 'class', 'default', 'define', 'else', 'elsif', 'if', 'in', 'inherits', 'node', 'or',
-        'undef', 'unless', 'type', 'attr', 'function', 'private', 'plan', 'apply'].each do |keyword|
-        it "such as #{keyword}" do
-          expect { parse("class x ($#{keyword}){} class { x: #{keyword} => 1 }") }.to_not raise_error
-        end
-      end
-    end
-
-  end
-
-  context "When the parser parses define" do
-    it "define foo {}" do
-      expect(dump(parse("define foo {}"))).to eq("(define foo ())")
-    end
-
-    it "class foo { define bar {}}" do
-      expect(dump(parse("class foo {define bar {}}"))).to eq([
-        "(class foo (block",
-        "  (define foo::bar ())",
-        "))"
-        ].join("\n"))
-    end
-
-    it "define foo { define bar {}}" do
-      # This is illegal, but handled as part of validation
-      expect(dump(parse("define foo { define bar {}}"))).to eq([
-        "(define foo (block",
-        "  (define bar ())",
-        "))"
-        ].join("\n"))
-    end
-
-    it "define foo::bar {}" do
-      expect(dump(parse("define foo::bar {}"))).to eq("(define foo::bar ())")
-    end
-
-    it "define foo($a) {}" do
-      expect(dump(parse("define foo($a) {}"))).to eq("(define foo (parameters a) ())")
-    end
-
-    it "define foo($a, $b) {}" do
-      expect(dump(parse("define foo($a, $b) {}"))).to eq("(define foo (parameters a b) ())")
-    end
-
-    it "define foo($a, $b=10) {}" do
-      expect(dump(parse("define foo($a, $b=10) {}"))).to eq("(define foo (parameters a (= b 10)) ())")
-    end
-
-    it "define foo {$a = 10 $b = 20}" do
-      expect(dump(parse("define foo {$a = 10 $b = 20}"))).to eq([
-        "(define foo (block",
-        "  (= $a 10)",
-        "  (= $b 20)",
-        "))"
-        ].join("\n"))
-    end
-
-    context "it should handle '3x weirdness'" do
-      it "define class {} # a define named 'class'" do
-        # This is weird because Class already exists, and instantiating this define will probably not
-        # work
-        expect { parse("define class {}") }.to raise_error(/'class' keyword not allowed at this location/)
-      end
-
-      it "define default {} # a define named 'default'" do
-        # Check unwanted ability to define 'default'.
-        # The expression below is not allowed (which is good).
-        expect { parse("define default {}") }.to raise_error(Puppet::ParseError)
-      end
-    end
-
-    context 'it should allow keywords as attribute names' do
-      ['and', 'case', 'class', 'default', 'define', 'else', 'elsif', 'if', 'in', 'inherits', 'node', 'or',
-        'undef', 'unless', 'type', 'attr', 'function', 'private', 'plan', 'apply'].each do |keyword|
-        it "such as #{keyword}" do
-          expect {parse("define x ($#{keyword}){} x { y: #{keyword} => 1 }")}.to_not raise_error
-        end
-      end
-    end
-  end
-
-  context "When parsing node" do
-    it "node foo {}" do
-      expect(dump(parse("node foo {}"))).to eq("(node (matches 'foo') ())")
-    end
-
-    it "node foo, {} # trailing comma" do
-      expect(dump(parse("node foo, {}"))).to eq("(node (matches 'foo') ())")
-    end
-
-    it "node kermit.example.com {}" do
-      expect(dump(parse("node kermit.example.com {}"))).to eq("(node (matches 'kermit.example.com') ())")
-    end
-
-    it "node kermit . example . com {}" do
-      expect(dump(parse("node kermit . example . com {}"))).to eq("(node (matches 'kermit.example.com') ())")
-    end
-
-    it "node foo, x::bar, default {}" do
-      expect(dump(parse("node foo, x::bar, default {}"))).to eq("(node (matches 'foo' 'x::bar' :default) ())")
-    end
-
-    it "node 'foo' {}" do
-      expect(dump(parse("node 'foo' {}"))).to eq("(node (matches 'foo') ())")
-    end
-
-    it "node foo inherits x::bar {}" do
-      expect(dump(parse("node foo inherits x::bar {}"))).to eq("(node (matches 'foo') (parent 'x::bar') ())")
-    end
-
-    it "node foo inherits 'bar' {}" do
-      expect(dump(parse("node foo inherits 'bar' {}"))).to eq("(node (matches 'foo') (parent 'bar') ())")
-    end
-
-    it "node foo inherits default {}" do
-      expect(dump(parse("node foo inherits default {}"))).to eq("(node (matches 'foo') (parent :default) ())")
-    end
-
-    it "node /web.*/ {}" do
-      expect(dump(parse("node /web.*/ {}"))).to eq("(node (matches /web.*/) ())")
-    end
-
-    it "node /web.*/, /do\.wop.*/, and.so.on {}" do
-      expect(dump(parse("node /web.*/, /do\.wop.*/, 'and.so.on' {}"))).to eq("(node (matches /web.*/ /do\.wop.*/ 'and.so.on') ())")
-    end
-
-    it "node wat inherits /apache.*/ {}" do
-      expect(dump(parse("node wat inherits /apache.*/ {}"))).to eq("(node (matches 'wat') (parent /apache.*/) ())")
-    end
-
-    it "node foo inherits bar {$a = 10 $b = 20}" do
-      expect(dump(parse("node foo inherits bar {$a = 10 $b = 20}"))).to eq([
-        "(node (matches 'foo') (parent 'bar') (block",
-        "  (= $a 10)",
-        "  (= $b 20)",
-        "))"
-        ].join("\n"))
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require_relative 'parser_rspec_helper'
-
-describe 'egrammar parsing function definitions' do
-  include ParserRspecHelper
-
-  context 'without return type' do
-    it 'function foo() { 1 }' do
-      expect(dump(parse('function foo() { 1 }'))).to eq("(function foo (block\n  1\n))")
-    end
-  end
-
-  context 'with return type' do
-    it 'function foo() >> Integer { 1 }' do
-      expect(dump(parse('function foo() >> Integer { 1 }'))).to eq("(function foo (return_type Integer) (block\n  1\n))")
-    end
-  end
-end