puppet 5.4.0-x86-mingw32 → 5.5.0-x86-mingw32

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

@@ -138,7 +138,7 @@ describe "egrammar parsing function calls" do
     end
 
     it 'notice Hash.assert_type(a => 42)' do
-      expect(dump(parse('notice Hash.assert_type(a => 42)'))).to eq('(invoke notice (call-method (. hash assert_type) ({} (a 42))))')
+      expect(dump(parse('notice Hash.assert_type(a => 42)'))).to eq('(invoke notice (call-method (. Hash assert_type) ({} (a 42))))')
     end
 
     it "notice 42.type(detailed)" do

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

@@ -13,7 +13,7 @@ describe 'egrammar parsing function definitions' do
 
   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))")
+      expect(dump(parse('function foo() >> Integer { 1 }'))).to eq("(function foo (return_type Integer) (block\n  1\n))")
     end
   end
 end

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

@@ -66,7 +66,7 @@ describe "egrammar parsing heredoc" do
     CODE
     expect(dump(parse(src))).to eq([
       "(@()",
-      "  (sublocated (cat 'Hello ' (str $name) ''))",
+      "  (sublocated (cat 'Hello ' (str $name)))",
       ")"
     ].join("\n"))
   end
@@ -79,7 +79,7 @@ describe "egrammar parsing heredoc" do
     CODE
     expect(dump(parse(src))).to eq([
       "(@()",
-      "  (sublocated (cat 'Hello \\' (str $name) ''))",
+      "  (sublocated (cat 'Hello \\' (str $name)))",
       ")"
     ].join("\n"))
   end
@@ -92,7 +92,7 @@ describe "egrammar parsing heredoc" do
     CODE
     expect(dump(parse(src))).to eq([
       "(@()",
-      "  (sublocated (cat 'Hello \\' (str $name) ''))",
+      "  (sublocated (cat 'Hello \\' (str $name)))",
       ")"
     ].join("\n"))
   end

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

@@ -13,7 +13,7 @@ describe 'egrammar parsing lambda definitions' do
 
   context 'with return type' do
     it 'f() |$x| >> Integer { 1 }' do
-      expect(dump(parse('f() |$x| >> Integer { 1 }'))).to eq("(invoke f (lambda (parameters x) (return_type integer) (block\n  1\n)))")
+      expect(dump(parse('f() |$x| >> Integer { 1 }'))).to eq("(invoke f (lambda (parameters x) (return_type Integer) (block\n  1\n)))")
     end
   end
 end

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

@@ -12,14 +12,14 @@ describe "egrammar parsing resource declarations" do
     ["File", "file"].each do |word|
       it "#{word} { 'title': }" do
         expect(dump(parse("#{word} { 'title': }"))).to eq([
-          "(resource file",
+          "(resource #{word}",
           "  ('title'))"
         ].join("\n"))
       end
 
       it "#{word} { 'title': path => '/somewhere', mode => '0777'}" do
         expect(dump(parse("#{word} { 'title': path => '/somewhere', mode => '0777'}"))).to eq([
-          "(resource file",
+          "(resource #{word}",
           "  ('title'",
           "    (path => '/somewhere')",
           "    (mode => '0777')))"
@@ -28,7 +28,7 @@ describe "egrammar parsing resource declarations" do
 
       it "#{word} { 'title': path => '/somewhere', }" do
         expect(dump(parse("#{word} { 'title': path => '/somewhere', }"))).to eq([
-          "(resource file",
+          "(resource #{word}",
           "  ('title'",
           "    (path => '/somewhere')))"
         ].join("\n"))
@@ -36,21 +36,21 @@ describe "egrammar parsing resource declarations" do
 
       it "#{word} { 'title': , }" do
         expect(dump(parse("#{word} { 'title': , }"))).to eq([
-          "(resource file",
+          "(resource #{word}",
           "  ('title'))"
         ].join("\n"))
       end
 
       it "#{word} { 'title': ; }" do
         expect(dump(parse("#{word} { 'title': ; }"))).to eq([
-          "(resource file",
+          "(resource #{word}",
           "  ('title'))"
         ].join("\n"))
       end
 
       it "#{word} { 'title': ; 'other_title': }" do
         expect(dump(parse("#{word} { 'title': ; 'other_title': }"))).to eq([
-          "(resource file",
+          "(resource #{word}",
           "  ('title')",
           "  ('other_title'))"
         ].join("\n"))
@@ -59,7 +59,7 @@ describe "egrammar parsing resource declarations" do
       # PUP-2898, trailing ';'
       it "#{word} { 'title': ; 'other_title': ; }" do
         expect(dump(parse("#{word} { 'title': ; 'other_title': ; }"))).to eq([
-          "(resource file",
+          "(resource #{word}",
           "  ('title')",
           "  ('other_title'))"
         ].join("\n"))
@@ -67,7 +67,7 @@ describe "egrammar parsing resource declarations" do
 
       it "#{word} { 'title1': path => 'x'; 'title2': path => 'y'}" do
         expect(dump(parse("#{word} { 'title1': path => 'x'; 'title2': path => 'y'}"))).to eq([
-          "(resource file",
+          "(resource #{word}",
           "  ('title1'",
           "    (path => 'x'))",
           "  ('title2'",
@@ -77,7 +77,7 @@ describe "egrammar parsing resource declarations" do
 
       it "#{word} { title: * => {mode => '0777'} }" do
         expect(dump(parse("#{word} { title: * => {mode => '0777'}}"))).to eq([
-          "(resource file",
+          "(resource #{word}",
           "  (title",
           "    (* => ({} (mode '0777')))))"
         ].join("\n"))
@@ -87,19 +87,19 @@ describe "egrammar parsing resource declarations" do
 
   context "When parsing (type based) resource defaults" do
     it "File {  }" do
-      expect(dump(parse("File { }"))).to eq("(resource-defaults file)")
+      expect(dump(parse("File { }"))).to eq("(resource-defaults File)")
     end
 
     it "File { mode => '0777' }" do
       expect(dump(parse("File { mode => '0777'}"))).to eq([
-        "(resource-defaults file",
+        "(resource-defaults File",
         "  (mode => '0777'))"
       ].join("\n"))
     end
 
     it "File { * => {mode => '0777'} } (even if validated to be illegal)" do
       expect(dump(parse("File { * => {mode => '0777'}}"))).to eq([
-        "(resource-defaults file",
+        "(resource-defaults File",
         "  (* => ({} (mode '0777'))))"
       ].join("\n"))
     end
@@ -107,12 +107,12 @@ describe "egrammar parsing resource declarations" do
 
   context "When parsing resource override" do
     it "File['x'] {  }" do
-      expect(dump(parse("File['x'] { }"))).to eq("(override (slice file 'x'))")
+      expect(dump(parse("File['x'] { }"))).to eq("(override (slice File 'x'))")
     end
 
     it "File['x'] { x => 1 }" do
       expect(dump(parse("File['x'] { x => 1}"))).to eq([
-        "(override (slice file 'x')",
+        "(override (slice File 'x')",
         "  (x => 1))"
         ].join("\n"))
     end
@@ -120,14 +120,14 @@ describe "egrammar parsing resource declarations" do
 
     it "File['x', 'y'] { x => 1 }" do
       expect(dump(parse("File['x', 'y'] { x => 1}"))).to eq([
-        "(override (slice file ('x' 'y'))",
+        "(override (slice File ('x' 'y'))",
         "  (x => 1))"
         ].join("\n"))
     end
 
     it "File['x'] { x => 1, y => 2 }" do
       expect(dump(parse("File['x'] { x => 1, y=> 2}"))).to eq([
-        "(override (slice file 'x')",
+        "(override (slice File 'x')",
         "  (x => 1)",
         "  (y => 2))"
         ].join("\n"))
@@ -135,14 +135,14 @@ describe "egrammar parsing resource declarations" do
 
     it "File['x'] { x +> 1 }" do
       expect(dump(parse("File['x'] { x +> 1}"))).to eq([
-        "(override (slice file 'x')",
+        "(override (slice File 'x')",
         "  (x +> 1))"
         ].join("\n"))
     end
 
     it "File['x'] { * => {mode => '0777'} } (even if validated to be illegal)" do
       expect(dump(parse("File['x'] { * => {mode => '0777'}}"))).to eq([
-        "(override (slice file 'x')",
+        "(override (slice File 'x')",
         "  (* => ({} (mode '0777'))))"
       ].join("\n"))
     end
@@ -173,28 +173,28 @@ describe "egrammar parsing resource declarations" do
 
     it "parses global defaults with @ (even if validated to be illegal)" do
       expect(dump(parse("@File { mode => '0777' }"))).to eq([
-        "(virtual-resource-defaults file",
+        "(virtual-resource-defaults File",
         "  (mode => '0777'))"
         ].join("\n"))
     end
 
     it "parses global defaults with @@ (even if validated to be illegal)" do
       expect(dump(parse("@@File { mode => '0777' }"))).to eq([
-        "(exported-resource-defaults file",
+        "(exported-resource-defaults File",
         "  (mode => '0777'))"
         ].join("\n"))
     end
 
     it "parses override with @ (even if validated to be illegal)" do
       expect(dump(parse("@File[foo] { mode => '0777' }"))).to eq([
-        "(virtual-override (slice file foo)",
+        "(virtual-override (slice File foo)",
         "  (mode => '0777'))"
         ].join("\n"))
     end
 
     it "parses override combined with @@ (even if validated to be illegal)" do
       expect(dump(parse("@@File[foo] { mode => '0777' }"))).to eq([
-        "(exported-override (slice file foo)",
+        "(exported-override (slice File foo)",
         "  (mode => '0777'))"
         ].join("\n"))
     end
@@ -253,19 +253,19 @@ describe "egrammar parsing resource declarations" do
 
   context "When parsing Relationships" do
     it "File[a] -> File[b]" do
-      expect(dump(parse("File[a] -> File[b]"))).to eq("(-> (slice file a) (slice file b))")
+      expect(dump(parse("File[a] -> File[b]"))).to eq("(-> (slice File a) (slice File b))")
     end
 
     it "File[a] <- File[b]" do
-      expect(dump(parse("File[a] <- File[b]"))).to eq("(<- (slice file a) (slice file b))")
+      expect(dump(parse("File[a] <- File[b]"))).to eq("(<- (slice File a) (slice File b))")
     end
 
     it "File[a] ~> File[b]" do
-      expect(dump(parse("File[a] ~> File[b]"))).to eq("(~> (slice file a) (slice file b))")
+      expect(dump(parse("File[a] ~> File[b]"))).to eq("(~> (slice File a) (slice File b))")
     end
 
     it "File[a] <~ File[b]" do
-      expect(dump(parse("File[a] <~ File[b]"))).to eq("(<~ (slice file a) (slice file b))")
+      expect(dump(parse("File[a] <~ File[b]"))).to eq("(<~ (slice File a) (slice File b))")
     end
 
     it "Should chain relationships" do
@@ -276,13 +276,13 @@ describe "egrammar parsing resource declarations" do
 
     it "Should chain relationships" do
       expect(dump(parse("File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]"))).to eq(
-      "(<~ (<- (~> (-> (slice file a) (slice file b)) (slice file c)) (slice file d)) (slice file e))"
+      "(<~ (<- (~> (-> (slice File a) (slice File b)) (slice File c)) (slice File d)) (slice File e))"
       )
     end
 
     it "should create relationships between collects" do
       expect(dump(parse("File <| mode == 0644 |> -> File <| mode == 0755 |>"))).to eq(
-      "(-> (collect file\n  (<| |> (== mode 0644))) (collect file\n  (<| |> (== mode 0755))))"
+      "(-> (collect File\n  (<| |> (== mode 0644))) (collect File\n  (<| |> (== mode 0755))))"
       )
     end
   end
@@ -290,38 +290,38 @@ describe "egrammar parsing resource declarations" do
   context "When parsing collection" do
     context "of virtual resources" do
       it "File <| |>" do
-        expect(dump(parse("File <| |>"))).to eq("(collect file\n  (<| |>))")
+        expect(dump(parse("File <| |>"))).to eq("(collect File\n  (<| |>))")
       end
     end
 
     context "of exported resources" do
       it "File <<| |>>" do
-        expect(dump(parse("File <<| |>>"))).to eq("(collect file\n  (<<| |>>))")
+        expect(dump(parse("File <<| |>>"))).to eq("(collect File\n  (<<| |>>))")
       end
     end
 
     context "queries are parsed with correct precedence" do
       it "File <| tag == 'foo' |>" do
-        expect(dump(parse("File <| tag == 'foo' |>"))).to eq("(collect file\n  (<| |> (== tag 'foo')))")
+        expect(dump(parse("File <| tag == 'foo' |>"))).to eq("(collect File\n  (<| |> (== tag 'foo')))")
       end
 
       it "File <| tag == 'foo' and mode != '0777' |>" do
-        expect(dump(parse("File <| tag == 'foo' and mode != '0777' |>"))).to eq("(collect file\n  (<| |> (&& (== tag 'foo') (!= mode '0777'))))")
+        expect(dump(parse("File <| tag == 'foo' and mode != '0777' |>"))).to eq("(collect File\n  (<| |> (&& (== tag 'foo') (!= mode '0777'))))")
       end
 
       it "File <| tag == 'foo' or mode != '0777' |>" do
-        expect(dump(parse("File <| tag == 'foo' or mode != '0777' |>"))).to eq("(collect file\n  (<| |> (|| (== tag 'foo') (!= mode '0777'))))")
+        expect(dump(parse("File <| tag == 'foo' or mode != '0777' |>"))).to eq("(collect File\n  (<| |> (|| (== tag 'foo') (!= mode '0777'))))")
       end
 
       it "File <| tag == 'foo' or tag == 'bar' and mode != '0777' |>" do
         expect(dump(parse("File <| tag == 'foo' or tag == 'bar' and mode != '0777' |>"))).to eq(
-        "(collect file\n  (<| |> (|| (== tag 'foo') (&& (== tag 'bar') (!= mode '0777')))))"
+        "(collect File\n  (<| |> (|| (== tag 'foo') (&& (== tag 'bar') (!= mode '0777')))))"
         )
       end
 
       it "File <| (tag == 'foo' or tag == 'bar') and mode != '0777' |>" do
         expect(dump(parse("File <| (tag == 'foo' or tag == 'bar') and mode != '0777' |>"))).to eq(
-        "(collect file\n  (<| |> (&& (|| (== tag 'foo') (== tag 'bar')) (!= mode '0777'))))"
+        "(collect File\n  (<| |> (&& (|| (== tag 'foo') (== tag 'bar')) (!= mode '0777'))))"
         )
       end
     end

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

@@ -0,0 +1,101 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet/pops/pn'
+
+module Puppet::Pops
+module Parser
+
+describe 'Puppet::Pops::Parser::PNParser' do
+  context 'parses the text' do
+    it '"true" to PN::Literal(true)' do
+      expect(PNParser.new.parse('true')).to eql(lit(true))
+    end
+
+    it '"false" to PN::Literal(false)' do
+      expect(PNParser.new.parse('false')).to eql(lit(false))
+    end
+
+    it '"nil" to PN::Literal(nil)' do
+      expect(PNParser.new.parse('nil')).to eql(lit(nil))
+    end
+
+    it '"123" to PN::Literal(123)' do
+      expect(PNParser.new.parse('123')).to eql(lit(123))
+    end
+
+    it '"-123" to PN::Literal(-123)' do
+      expect(PNParser.new.parse('-123')).to eql(lit(-123))
+    end
+
+    it '"123.45" to PN::Literal(123.45)' do
+      expect(PNParser.new.parse('123.45')).to eql(lit(123.45))
+    end
+
+    it '"-123.45" to PN::Literal(-123.45)' do
+      expect(PNParser.new.parse('-123.45')).to eql(lit(-123.45))
+    end
+
+    it '"123.45e12" to PN::Literal(123.45e12)' do
+      expect(PNParser.new.parse('123.45e12')).to eql(lit(123.45e12))
+    end
+
+    it '"123.45e+12" to PN::Literal(123.45e+12)' do
+      expect(PNParser.new.parse('123.45e+12')).to eql(lit(123.45e+12))
+    end
+
+    it '"123.45e-12" to PN::Literal(123.45e-12)' do
+      expect(PNParser.new.parse('123.45e-12')).to eql(lit(123.45e-12))
+    end
+
+    it '"hello" to PN::Literal("hello")' do
+      expect(PNParser.new.parse('"hello"')).to eql(lit('hello'))
+    end
+
+    it '"\t" to PN::Literal("\t")' do
+      expect(PNParser.new.parse('"\t"')).to eql(lit("\t"))
+    end
+
+    it '"\r" to PN::Literal("\r")' do
+      expect(PNParser.new.parse('"\r"')).to eql(lit("\r"))
+    end
+
+    it '"\n" to PN::Literal("\n")' do
+      expect(PNParser.new.parse('"\n"')).to eql(lit("\n"))
+    end
+
+    it '"\"" to PN::Literal("\"")' do
+      expect(PNParser.new.parse('"\""')).to eql(lit('"'))
+    end
+
+    it '"\\\\" to PN::Literal("\\")' do
+      expect(PNParser.new.parse('"\\\\"')).to eql(lit("\\"))
+    end
+
+    it '"\o024" to PN::Literal("\u{14}")' do
+      expect(PNParser.new.parse('"\o024"')).to eql(lit("\u{14}"))
+    end
+  end
+
+  it 'parses elements enclosed in brackets to a PN::List' do
+    expect(PNParser.new.parse('[1 "2" true false nil]')).to eql(PN::List.new([lit(1), lit('2'), lit(true), lit(false), lit(nil)]))
+  end
+
+  it 'parses elements enclosed in parenthesis to a PN::Call' do
+    expect(PNParser.new.parse('(+ 1 2)')).to eql(PN::Call.new('+', lit(1), lit(2)))
+  end
+
+  it 'parses entries enclosed in curly braces to a PN::Map' do
+    expect(PNParser.new.parse('{:a 1 :b "2" :c true}')).to eql(PN::Map.new([entry('a', 1), entry('b', '2'), entry('c', true)]))
+  end
+
+  def entry(k, v)
+    PN::Entry.new(k, lit(v))
+  end
+
+  def lit(v)
+    PN::Literal.new(v)
+  end
+end
+end
+end

data/spec/unit/pops/pn_spec.rb

@@ -0,0 +1,148 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet/pops/pn'
+
+module Puppet::Pops
+module PN
+
+describe 'Puppet::Pops::PN' do
+  context 'Literal' do
+    context 'containing the value' do
+      it 'true produces the text "true"' do
+        expect(lit(true).to_s).to eql('true')
+      end
+
+      it 'false produces the text "false"' do
+        expect(lit(false).to_s).to eql('false')
+      end
+
+      it 'nil produces the text "nil"' do
+        expect(lit(nil).to_s).to eql('nil')
+      end
+
+      it '34 produces the text "34"' do
+        expect(lit(34).to_s).to eql('34')
+      end
+
+      it '3.0 produces the text "3.0"' do
+        expect(lit(3.0).to_s).to eql('3.0')
+      end
+    end
+
+    context 'produces a double quoted text from a string such that' do
+      it '"plain" produces "plain"' do
+        expect(lit('plain').to_s).to eql('"plain"')
+      end
+
+      it '"\t" produces a text containing a tab character' do
+        expect(lit("\t").to_s).to eql('"\t"')
+      end
+
+      it '"\r" produces a text containing a return character' do
+        expect(lit("\r").to_s).to eql('"\r"')
+      end
+
+      it '"\n" produces a text containing a newline character' do
+        expect(lit("\n").to_s).to eql('"\n"')
+      end
+
+      it '"\"" produces a text containing a double quote' do
+        expect(lit("\"").to_s).to eql('"\""')
+      end
+
+      it '"\\" produces a text containing a backslash' do
+        expect(lit("\\").to_s).to eql('"\\\\"')
+      end
+
+      it '"\u{14}" produces "\o024"' do
+        expect(lit("\u{14}").to_s).to eql('"\o024"')
+      end
+    end
+  end
+
+  context 'List' do
+    it 'produces a text where its elements are enclosed in brackets' do
+      expect(List.new([lit(3), lit('a'), lit(true)]).to_s).to eql('[3 "a" true]')
+    end
+
+    it 'produces a text where the elements of nested lists are enclosed in brackets' do
+      expect(List.new([lit(3), lit('a'), List.new([lit(true), lit(false)])]).to_s).to eql('[3 "a" [true false]]')
+    end
+
+    context 'with indent' do
+      it 'produces a text where the each element is on an indented line ' do
+        s = ''
+        List.new([lit(3), lit('a'), List.new([lit(true), lit(false)])]).format(Indent.new('  '), s)
+        expect(s).to eql(<<-RESULT.unindent[0..-2]) # unindent and strip last newline
+        [
+          3
+          "a"
+          [
+            true
+            false]]
+        RESULT
+      end
+    end
+  end
+
+  context 'Map' do
+    it 'raises error when illegal keys are used' do
+      expect { Map.new([Entry.new('123', lit(3))]) }.to raise_error(ArgumentError, /key 123 does not conform to pattern/)
+    end
+
+    it 'produces a text where entries are enclosed in curly braces' do
+      expect(Map.new([Entry.new('a', lit(3))]).to_s).to eql('{:a 3}')
+    end
+
+    it 'produces a text where the entries of nested maps are enclosed in curly braces' do
+      expect(Map.new([
+        Map.new([Entry.new('a', lit(3))]).with_name('o')]).to_s).to eql('{:o {:a 3}}')
+    end
+
+    context 'with indent' do
+      it 'produces a text where the each element is on an indented line ' do
+        s = ''
+        Map.new([
+          Map.new([Entry.new('a', lit(3)), Entry.new('b', lit(5))]).with_name('o')]).format(Indent.new('  '), s)
+        expect(s).to eql(<<-RESULT.unindent[0..-2]) # unindent and strip last newline
+        {
+          :o {
+            :a 3
+            :b 5}}
+        RESULT
+      end
+    end
+  end
+
+  context 'Call' do
+    it 'produces a text where elements are enclosed in parenthesis' do
+      expect(Call.new('+', lit(3), lit(5)).to_s).to eql('(+ 3 5)')
+    end
+
+    it 'produces a text where the elements of nested calls are enclosed in parenthesis' do
+      expect(Map.new([
+        Call.new('+', lit(3), lit(5)).with_name('o')]).to_s).to eql('{:o (+ 3 5)}')
+    end
+
+    context 'with indent' do
+      it 'produces a text where the each element is on an indented line ' do
+        s = ''
+        Call.new('+', lit(3), lit(Call.new('-', lit(10), lit(5)))).format(Indent.new('  '), s)
+        expect(s).to eql(<<-RESULT.unindent[0..-2]) # unindent and strip last newline
+        (+
+          3
+          (-
+            10
+            5))
+        RESULT
+      end
+    end
+  end
+
+  def lit(v)
+    v.is_a?(PN) ? v : Literal.new(v)
+  end
+end
+end
+end