puppet 3.7.0-x64-mingw32

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

@@ -0,0 +1,11 @@
+require 'puppet/pops'
+
+require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
+
+module ParserRspecHelper
+  include FactoryRspecHelper
+  def parse(code)
+    parser = Puppet::Pops::Parser::Parser.new()
+    parser.parse_string(code)
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+describe Puppet::Pops::Parser::Parser do
+  it "should instantiate a parser" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    parser.class.should == Puppet::Pops::Parser::Parser
+  end
+
+  it "should parse a code string and return a model" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string("$a = 10").current
+    model.class.should == Puppet::Pops::Model::Program
+    model.body.class.should == Puppet::Pops::Model::AssignmentExpression
+  end
+
+  it "should accept empty input and return a model" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string("").current
+    model.class.should == Puppet::Pops::Model::Program
+    model.body.class.should == Puppet::Pops::Model::Nop
+  end
+
+  it "should accept empty input containing only comments and report location at end of input" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string("# comment\n").current
+    model.class.should == Puppet::Pops::Model::Program
+    model.body.class.should == Puppet::Pops::Model::Nop
+    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(model.body)
+    expect(adapter.offset).to eq(10)
+    expect(adapter.length).to eq(0)
+  end
+end

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

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/evaluator/evaluator_impl'
+require 'puppet_spec/pops'
+require 'puppet_spec/scope'
+require 'puppet/parser/e4_parser_adapter'
+
+
+# relative to this spec file (./) does not work as this file is loaded by rspec
+#require File.join(File.dirname(__FILE__), '/evaluator_rspec_helper')
+
+describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
+  include PuppetSpec::Pops
+  include PuppetSpec::Scope
+  before(:each) do
+
+    # These must be set since the is 3x logic that triggers on these even if the tests are explicit
+    # about selection of parser and evaluator
+    #
+    Puppet[:parser] = 'future'
+  end
+
+  let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
+
+  context "captures-rest parameter" do
+    it 'is allowed in lambda when placed last' do
+      source = <<-CODE
+        foo() |$a, *$b| { $a + $b[0] }
+      CODE
+      expect do
+        parser.parse_string(source, __FILE__)
+      end.to_not raise_error()
+    end
+
+    it 'allows a type annotation' do
+      source = <<-CODE
+        foo() |$a, Integer *$b| { $a + $b[0] }
+      CODE
+      expect do
+        parser.parse_string(source, __FILE__)
+      end.to_not raise_error()
+    end
+
+    it 'is not allowed in lambda except last' do
+      source = <<-CODE
+        foo() |*$a, $b| { $a + $b[0] }
+      CODE
+      expect do
+        parser.parse_string(source, __FILE__)
+      end.to raise_error(Puppet::ParseError, /Parameter \$a is not last, and has 'captures rest'/)
+    end
+
+    it 'is not allowed in define' do
+      source = <<-CODE
+        define foo(*$a) { }
+      CODE
+      expect do
+        parser.parse_string(source, __FILE__)
+      end.to raise_error(Puppet::ParseError, /Parameter \$a has 'captures rest' - not supported in a 'define'/)
+    end
+
+    it 'is not allowed in class' do
+      source = <<-CODE
+        class foo(*$a) { }
+      CODE
+      expect do
+        parser.parse_string(source, __FILE__)
+      end.to raise_error(Puppet::ParseError, /Parameter \$a has 'captures rest' - not supported in a Host Class Definition/)
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+
+require 'rgen/array_extensions'
+
+describe "RGen extensions to core classes" do
+  it "should be possible to create an empty hash after having required the files above" do
+    # If this fails, it means the rgen addition to Array is not monkey patched as it
+    # should (it will return an array instead of fail in a method_missing), and thus
+    # screw up Hash's check if it can do "to_hash' or not.
+    #
+    Hash[[]]
+  end
+
+  it "should be possible to automatically stringify a nested, empty array during join" do
+    # When this fails it means that rgen has incorrectly implemented
+    # method_missing on array and is returning an array for to_str instead of
+    # failing as is expected allowing stringification to occur
+    [[]].join(":").should == ""
+    ["1", []].join(":").should == "1:"
+  end
+end

data/spec/unit/pops/transformer/transform_basic_expressions_spec.rb

@@ -0,0 +1,243 @@
+#! /usr/bin/env ruby
+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__), '/transformer_rspec_helper')
+
+describe "transformation to Puppet AST for basic expressions" do
+  include TransformerRspecHelper
+
+  context "When transforming arithmetic" do
+    context "with Integers" do
+      it "$a = 2 + 2"   do; astdump(parse("$a = 2 + 2")).should == "(= $a (+ 2 2))"      ; end
+      it "$a = 7 - 3"   do; astdump(parse("$a = 7 - 3")).should == "(= $a (- 7 3))"      ; end
+      it "$a = 6 * 3"   do; astdump(parse("$a = 6 * 3")).should == "(= $a (* 6 3))"      ; end
+      it "$a = 6 / 3"   do; astdump(parse("$a = 6 / 3")).should == "(= $a (/ 6 3))"      ; end
+      it "$a = 6 % 3"   do; astdump(parse("$a = 6 % 3")).should == "(= $a (% 6 3))"      ; end
+      it "$a = -(6/3)"  do; astdump(parse("$a = -(6/3)")).should == "(= $a (- (/ 6 3)))" ; end
+      it "$a = -6/3"    do; astdump(parse("$a = -6/3")).should == "(= $a (/ (- 6) 3))"   ; end
+      it "$a = 8 >> 1 " do; astdump(parse("$a = 8 >> 1")).should == "(= $a (>> 8 1))"    ; end
+      it "$a = 8 << 1 " do; astdump(parse("$a = 8 << 1")).should == "(= $a (<< 8 1))"    ; end
+    end
+
+    context "with Floats" do
+      it "$a = 2.2 + 2.2"  do; astdump(parse("$a = 2.2 + 2.2")).should == "(= $a (+ 2.2 2.2))"      ; end
+      it "$a = 7.7 - 3.3"  do; astdump(parse("$a = 7.7 - 3.3")).should == "(= $a (- 7.7 3.3))"      ; end
+      it "$a = 6.1 * 3.1"  do; astdump(parse("$a = 6.1 - 3.1")).should == "(= $a (- 6.1 3.1))"      ; end
+      it "$a = 6.6 / 3.3"  do; astdump(parse("$a = 6.6 / 3.3")).should == "(= $a (/ 6.6 3.3))"      ; end
+      it "$a = -(6.0/3.0)" do; astdump(parse("$a = -(6.0/3.0)")).should == "(= $a (- (/ 6.0 3.0)))" ; end
+      it "$a = -6.0/3.0"   do; astdump(parse("$a = -6.0/3.0")).should == "(= $a (/ (- 6.0) 3.0))"   ; end
+      it "$a = 3.14 << 2"  do; astdump(parse("$a = 3.14 << 2")).should == "(= $a (<< 3.14 2))"      ; end
+      it "$a = 3.14 >> 2"  do; astdump(parse("$a = 3.14 >> 2")).should == "(= $a (>> 3.14 2))"      ; end
+    end
+
+    context "with hex and octal Integer values" do
+      it "$a = 0xAB + 0xCD" do; astdump(parse("$a = 0xAB + 0xCD")).should == "(= $a (+ 0xAB 0xCD))"  ; end
+      it "$a = 0777 - 0333" do; astdump(parse("$a = 0777 - 0333")).should == "(= $a (- 0777 0333))"  ; end
+    end
+
+    context "with strings requiring boxing to Numeric" do
+      # In AST, there is no difference, the ast dumper prints all numbers without quotes - they are still
+      # strings
+      it "$a = '2' + '2'"       do; astdump(parse("$a = '2' + '2'")).should == "(= $a (+ 2 2))"             ; end
+      it "$a = '2.2' + '0.2'"   do; astdump(parse("$a = '2.2' + '0.2'")).should == "(= $a (+ 2.2 0.2))"     ; end
+      it "$a = '0xab' + '0xcd'" do; astdump(parse("$a = '0xab' + '0xcd'")).should == "(= $a (+ 0xab 0xcd))" ; end
+      it "$a = '0777' + '0333'" do; astdump(parse("$a = '0777' + '0333'")).should == "(= $a (+ 0777 0333))" ; end
+    end
+
+    context "precedence should be correct" do
+      it "$a = 1 + 2 * 3" do; astdump(parse("$a = 1 + 2 * 3")).should == "(= $a (+ 1 (* 2 3)))"; end
+      it "$a = 1 + 2 % 3" do; astdump(parse("$a = 1 + 2 % 3")).should == "(= $a (+ 1 (% 2 3)))"; end
+      it "$a = 1 + 2 / 3" do; astdump(parse("$a = 1 + 2 / 3")).should == "(= $a (+ 1 (/ 2 3)))"; end
+      it "$a = 1 + 2 << 3" do; astdump(parse("$a = 1 + 2 << 3")).should == "(= $a (<< (+ 1 2) 3))"; end
+      it "$a = 1 + 2 >> 3" do; astdump(parse("$a = 1 + 2 >> 3")).should == "(= $a (>> (+ 1 2) 3))"; end
+    end
+
+    context "parentheses alter precedence" do
+      it "$a = (1 + 2) * 3" do; astdump(parse("$a = (1 + 2) * 3")).should == "(= $a (* (+ 1 2) 3))"; end
+      it "$a = (1 + 2) / 3" do; astdump(parse("$a = (1 + 2) / 3")).should == "(= $a (/ (+ 1 2) 3))"; end
+    end
+  end
+
+  context "When transforming boolean operations" do
+    context "using operators AND OR NOT" do
+      it "$a = true  and true" do; astdump(parse("$a = true and true")).should == "(= $a (&& true true))"; end
+      it "$a = true  or true"  do; astdump(parse("$a = true or true")).should == "(= $a (|| true true))" ; end
+      it "$a = !true"          do; astdump(parse("$a = !true")).should == "(= $a (! true))"              ; end
+    end
+
+    context "precedence should be correct" do
+      it "$a = false or true and true" do
+        astdump(parse("$a = false or true and true")).should == "(= $a (|| false (&& true true)))"
+      end
+
+      it "$a = (false or true) and true" do
+        astdump(parse("$a = (false or true) and true")).should == "(= $a (&& (|| false true) true))"
+      end
+
+      it "$a = !true or true and true" do
+        astdump(parse("$a = !false or true and true")).should == "(= $a (|| (! false) (&& true true)))"
+      end
+    end
+
+    # Possibly change to check of literal expressions
+    context "on values requiring boxing to Boolean" do
+      it "'x'            == true" do
+        astdump(parse("! 'x'")).should == "(! 'x')"
+      end
+
+      it "''             == false" do
+        astdump(parse("! ''")).should == "(! '')"
+      end
+
+      it ":undef         == false" do
+        astdump(parse("! undef")).should == "(! :undef)"
+      end
+    end
+  end
+
+  context "When transforming comparisons" do
+    context "of string values" do
+      it "$a = 'a' == 'a'"  do; astdump(parse("$a = 'a' == 'a'")).should == "(= $a (== 'a' 'a'))"   ; end
+      it "$a = 'a' != 'a'"  do; astdump(parse("$a = 'a' != 'a'")).should == "(= $a (!= 'a' 'a'))"   ; end
+      it "$a = 'a' < 'b'"   do; astdump(parse("$a = 'a' < 'b'")).should == "(= $a (< 'a' 'b'))"     ; end
+      it "$a = 'a' > 'b'"   do; astdump(parse("$a = 'a' > 'b'")).should == "(= $a (> 'a' 'b'))"     ; end
+      it "$a = 'a' <= 'b'"  do; astdump(parse("$a = 'a' <= 'b'")).should == "(= $a (<= 'a' 'b'))"   ; end
+      it "$a = 'a' >= 'b'"  do; astdump(parse("$a = 'a' >= 'b'")).should == "(= $a (>= 'a' 'b'))"   ; end
+    end
+
+    context "of integer values" do
+      it "$a = 1 == 1"  do; astdump(parse("$a = 1 == 1")).should == "(= $a (== 1 1))"   ; end
+      it "$a = 1 != 1"  do; astdump(parse("$a = 1 != 1")).should == "(= $a (!= 1 1))"   ; end
+      it "$a = 1 < 2"   do; astdump(parse("$a = 1 < 2")).should == "(= $a (< 1 2))"     ; end
+      it "$a = 1 > 2"   do; astdump(parse("$a = 1 > 2")).should == "(= $a (> 1 2))"     ; end
+      it "$a = 1 <= 2"  do; astdump(parse("$a = 1 <= 2")).should == "(= $a (<= 1 2))"   ; end
+      it "$a = 1 >= 2"  do; astdump(parse("$a = 1 >= 2")).should == "(= $a (>= 1 2))"   ; end
+    end
+
+    context "of regular expressions (parse errors)" do
+      # Not supported in concrete syntax (until Lexer2)
+      it "$a = /.*/ == /.*/" do
+        astdump(parse("$a = /.*/ == /.*/")).should == "(= $a (== /.*/ /.*/))"
+      end
+
+      it "$a = /.*/ != /a.*/" do
+        astdump(parse("$a = /.*/ != /.*/")).should == "(= $a (!= /.*/ /.*/))"
+      end
+    end
+  end
+
+  context "When transforming Regular Expression matching" do
+    it "$a = 'a' =~ /.*/"    do; astdump(parse("$a = 'a' =~ /.*/")).should == "(= $a (=~ 'a' /.*/))"      ; end
+    it "$a = 'a' =~ '.*'"    do; astdump(parse("$a = 'a' =~ '.*'")).should == "(= $a (=~ 'a' '.*'))"      ; end
+    it "$a = 'a' !~ /b.*/"   do; astdump(parse("$a = 'a' !~ /b.*/")).should == "(= $a (!~ 'a' /b.*/))"    ; end
+    it "$a = 'a' !~ 'b.*'"   do; astdump(parse("$a = 'a' !~ 'b.*'")).should == "(= $a (!~ 'a' 'b.*'))"    ; end
+  end
+
+  context "When transforming Lists" do
+    it "$a = []" do
+      astdump(parse("$a = []")).should == "(= $a ([]))"
+    end
+
+    it "$a = [1]" do
+      astdump(parse("$a = [1]")).should == "(= $a ([] 1))"
+    end
+
+    it "$a = [1,2,3]" do
+      astdump(parse("$a = [1,2,3]")).should == "(= $a ([] 1 2 3))"
+    end
+
+    it "[...[...[]]] should create nested arrays without trouble" do
+      astdump(parse("$a = [1,[2.0, 2.1, [2.2]],[3.0, 3.1]]")).should == "(= $a ([] 1 ([] 2.0 2.1 ([] 2.2)) ([] 3.0 3.1)))"
+    end
+
+    it "$a = [2 + 2]" do
+      astdump(parse("$a = [2+2]")).should == "(= $a ([] (+ 2 2)))"
+    end
+
+    it "$a [1,2,3] == [1,2,3]" do
+      astdump(parse("$a = [1,2,3] == [1,2,3]")).should == "(= $a (== ([] 1 2 3) ([] 1 2 3)))"
+    end
+  end
+
+  context "When transforming indexed access" do
+    it "$a = $b[2]" do
+      astdump(parse("$a = $b[2]")).should == "(= $a (slice $b 2))"
+    end
+
+    it "$a = [1, 2, 3][2]" do
+      astdump(parse("$a = [1,2,3][2]")).should == "(= $a (slice ([] 1 2 3) 2))"
+    end
+
+    it "$a = {'a' => 1, 'b' => 2}['b']" do
+      astdump(parse("$a = {'a'=>1,'b' =>2}[b]")).should == "(= $a (slice ({} ('a' 1) ('b' 2)) b))"
+    end
+  end
+
+  context "When transforming Hashes" do
+    it "should create a  Hash when evaluating a LiteralHash" do
+      astdump(parse("$a = {'a'=>1,'b'=>2}")).should == "(= $a ({} ('a' 1) ('b' 2)))"
+    end
+
+    it "$a = {...{...{}}} should create nested hashes without trouble" do
+      astdump(parse("$a = {'a'=>1,'b'=>{'x'=>2.1,'y'=>2.2}}")).should == "(= $a ({} ('a' 1) ('b' ({} ('x' 2.1) ('y' 2.2)))))"
+    end
+
+    it "$a = {'a'=> 2 + 2} should evaluate values in entries" do
+      astdump(parse("$a = {'a'=>2+2}")).should == "(= $a ({} ('a' (+ 2 2))))"
+    end
+
+    it "$a = {'a'=> 1, 'b'=>2} == {'a'=> 1, 'b'=>2}" do
+      astdump(parse("$a = {'a'=>1,'b'=>2} == {'a'=>1,'b'=>2}")).should == "(= $a (== ({} ('a' 1) ('b' 2)) ({} ('a' 1) ('b' 2))))"
+    end
+
+    it "$a = {'a'=> 1, 'b'=>2} != {'x'=> 1, 'y'=>3}" do
+      astdump(parse("$a = {'a'=>1,'b'=>2} != {'a'=>1,'b'=>2}")).should == "(= $a (!= ({} ('a' 1) ('b' 2)) ({} ('a' 1) ('b' 2))))"
+    end
+  end
+
+  context "When transforming the 'in' operator" do
+    it "with integer in a list" do
+      astdump(parse("$a = 1 in [1,2,3]")).should == "(= $a (in 1 ([] 1 2 3)))"
+    end
+
+    it "with string key in a hash" do
+      astdump(parse("$a = 'a' in {'x'=>1, 'a'=>2, 'y'=> 3}")).should == "(= $a (in 'a' ({} ('a' 2) ('x' 1) ('y' 3))))"
+    end
+
+    it "with substrings of a string" do
+      astdump(parse("$a = 'ana' in 'bananas'")).should == "(= $a (in 'ana' 'bananas'))"
+    end
+
+    it "with sublist in a list" do
+      astdump(parse("$a = [2,3] in [1,2,3]")).should == "(= $a (in ([] 2 3) ([] 1 2 3)))"
+    end
+  end
+
+  context "When transforming string interpolation" do
+    it "should interpolate a bare word as a variable name, \"${var}\"" do
+      astdump(parse("$a = \"$var\"")).should == "(= $a (cat '' (str $var) ''))"
+    end
+
+    it "should interpolate a variable in a text expression, \"${$var}\"" do
+      astdump(parse("$a = \"${$var}\"")).should == "(= $a (cat '' (str $var) ''))"
+    end
+
+    it "should interpolate two variables in a text expression" do
+      astdump(parse(%q{$a = "xxx $x and $y end"})).should == "(= $a (cat 'xxx ' (str $x) ' and ' (str $y) ' end'))"
+    end
+
+    it "should interpolate one variables  followed by parentheses" do
+      astdump(parse(%q{$a = "xxx ${x} (yay)"})).should == "(= $a (cat 'xxx ' (str $x) ' (yay)'))"
+    end
+
+    it "should interpolate a variable, \"yo${var}yo\"" do
+      astdump(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
+      astdump(parse("$a = \"yo${$var+2}yo\"")).should == "(= $a (cat 'yo' (str (+ $var 2)) 'yo'))"
+    end
+  end
+end

data/spec/unit/pops/transformer/transform_calls_spec.rb

@@ -0,0 +1,115 @@
+#! /usr/bin/env ruby
+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__), '/transformer_rspec_helper')
+
+describe "transformation to Puppet AST for function calls" do
+  include TransformerRspecHelper
+
+  context "When transforming calls as statements" do
+    context "in top level scope" do
+      it "foo()" do
+        astdump(parse("foo()")).should == "(invoke foo)"
+      end
+
+      it "notice bar" do
+        astdump(parse("notice bar")).should == "(invoke notice bar)"
+      end
+    end
+
+    context "in nested scopes" do
+      it "if true { foo() }" do
+        astdump(parse("if true {foo()}")).should == "(if true\n  (then (invoke foo)))"
+      end
+
+      it "if true { notice bar}" do
+        astdump(parse("if true {notice bar}")).should == "(if true\n  (then (invoke notice bar)))"
+      end
+    end
+    context "in general" do
+      {
+        "require bar"      => '(invoke require bar)',
+        "realize bar"      => '(invoke realize bar)',
+        "contain bar"      => '(invoke contain bar)',
+        "include bar"      => '(invoke include bar)',
+        "tag bar"          => '(invoke tag bar)',
+
+        "info bar"         => '(invoke info bar)',
+        "notice bar"       => '(invoke notice bar)',
+        "error bar"        => '(invoke error bar)',
+        "warning bar"      => '(invoke warning bar)',
+        "debug bar"        => '(invoke debug bar)',
+
+        "fail bar"         => '(invoke fail bar)',
+
+        "notice {a => 1}"  => "(invoke notice ({} ('a' 1)))",
+        "notice 1,2,3"     => "(invoke notice 1 2 3)",
+        "notice(1,2,3)"    => "(invoke notice 1 2 3)",
+      }.each do |source, result|
+        it "should transform #{source} to #{result}" do
+          astdump(parse(source)).should == result
+        end
+      end
+
+      {
+        "foo bar"      => '(block foo bar)',
+        "tag"          => 'tag',
+      }.each do |source, result|
+        it "should not transform #{source}, and instead produce #{result}" do
+          astdump(parse(source)).should == result
+        end
+      end
+
+    end
+  end
+
+  context "When transforming calls as expressions" do
+    it "$a = foo()" do
+      astdump(parse("$a = foo()")).should == "(= $a (call foo))"
+    end
+
+    it "$a = foo(bar)" do
+      astdump(parse("$a = foo()")).should == "(= $a (call foo))"
+    end
+
+    # For egrammar where a bare word can be a "statement"
+    it "$a = foo bar # assignment followed by bare word is ok in egrammar" do
+      astdump(parse("$a = foo bar")).should == "(block (= $a foo) bar)"
+    end
+
+    context "in nested scopes" do
+      it "if true { $a = foo() }" do
+        astdump(parse("if true { $a = foo()}")).should == "(if true\n  (then (= $a (call foo))))"
+      end
+
+      it "if true { $a= foo(bar)}" do
+        astdump(parse("if true {$a = foo(bar)}")).should == "(if true\n  (then (= $a (call foo bar))))"
+      end
+    end
+  end
+
+  context "When transforming method calls" do
+    it "$a.foo" do
+      astdump(parse("$a.foo")).should == "(call-method (. $a foo))"
+    end
+
+    it "$a.foo || { }" do
+      astdump(parse("$a.foo || { }")).should == "(call-method (. $a foo) (lambda ()))"
+    end
+
+    it "$a.foo ||{[]} # check transformation to block with empty array" do
+      astdump(parse("$a.foo || {[]}")).should == "(call-method (. $a foo) (lambda (block ([]))))"
+    end
+
+    it "$a.foo |$x| { }" do
+      astdump(parse("$a.foo |$x| { }")).should == "(call-method (. $a foo) (lambda (parameters x) ()))"
+    end
+
+    it "$a.foo |$x| { $b = $x}" do
+      astdump(parse("$a.foo |$x| { $b = $x}")).should ==
+      "(call-method (. $a foo) (lambda (parameters x) (block (= $b $x))))"
+    end
+  end
+end