puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/spec/unit/pops/loaders/static_loader_spec.rb

@@ -37,6 +37,12 @@ describe 'the static loader' do
       it "uses the evaluator to format output" do
         expect(loader.load(:function, level).call({}, ['yay', 'surprise']).to_s).to eql('[yay, surprise]')
       end
+
+      it 'outputs name of source (scope) by passing it to the Log utility' do
+        the_scope = {}
+        Puppet::Util::Log.any_instance.expects(:source=).with(the_scope)
+        loader.load(:function, level).call(the_scope, 'x')
+      end
     end
   end
 

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

@@ -51,36 +51,65 @@ describe "epp parser" do
 
   context "handles parsing of" do
     it "text (and nothing else)" do
-      dump(parse("Hello World")).should == "(lambda (epp (block (render-s 'Hello World'))))"
+      dump(parse("Hello World")).should == [
+        "(lambda (epp (block",
+        "  (render-s 'Hello World')",
+        ")))"].join("\n")
     end
 
     it "template parameters" do
-      dump(parse("<%|$x|%>Hello World")).should == "(lambda (parameters x) (epp (block (render-s 'Hello World'))))"
+      dump(parse("<%|$x|%>Hello World")).should == [
+        "(lambda (parameters x) (epp (block",
+        "  (render-s 'Hello World')",
+        ")))"].join("\n")
     end
 
     it "template parameters with default" do
-      dump(parse("<%|$x='cigar'|%>Hello World")).should == "(lambda (parameters (= x 'cigar')) (epp (block (render-s 'Hello World'))))"
+      dump(parse("<%|$x='cigar'|%>Hello World")).should == [
+        "(lambda (parameters (= x 'cigar')) (epp (block",
+        "  (render-s 'Hello World')",
+        ")))"].join("\n")
     end
 
     it "template parameters with and without default" do
-      dump(parse("<%|$x='cigar', $y|%>Hello World")).should == "(lambda (parameters (= x 'cigar') y) (epp (block (render-s 'Hello World'))))"
+      dump(parse("<%|$x='cigar', $y|%>Hello World")).should == [
+        "(lambda (parameters (= x 'cigar') y) (epp (block",
+        "  (render-s 'Hello World')",
+        ")))"].join("\n")
     end
 
     it "template parameters + additional setup" do
-      dump(parse("<%|$x| $y = 10 %>Hello World")).should == "(lambda (parameters x) (epp (block (= $y 10) (render-s 'Hello World'))))"
+      dump(parse("<%|$x| $y = 10 %>Hello World")).should == [ 
+        "(lambda (parameters x) (epp (block",
+        "  (= $y 10)",
+        "  (render-s 'Hello World')",
+        ")))"].join("\n")
     end
 
     it "comments" do
-      dump(parse("<%#($x='cigar', $y)%>Hello World")).should == "(lambda (epp (block (render-s 'Hello World'))))"
+      dump(parse("<%#($x='cigar', $y)%>Hello World")).should == [
+        "(lambda (epp (block",
+        "  (render-s 'Hello World')",
+        ")))"
+        ].join("\n")
     end
 
     it "verbatim epp tags" do
-      dump(parse("<%% contemplating %%>Hello World")).should == "(lambda (epp (block (render-s '<% contemplating %>Hello World'))))"
+      dump(parse("<%% contemplating %%>Hello World")).should == [
+        "(lambda (epp (block",
+        "  (render-s '<% contemplating %>Hello World')",
+        ")))"
+        ].join("\n")
     end
 
     it "expressions" do
-      dump(parse("We all live in <%= 3.14 - 2.14 %> world")).should ==
-        "(lambda (epp (block (render-s 'We all live in ') (render (- 3.14 2.14)) (render-s ' world'))))"
+      dump(parse("We all live in <%= 3.14 - 2.14 %> world")).should == [
+        "(lambda (epp (block",
+        "  (render-s 'We all live in ')",
+        "  (render (- 3.14 2.14))",
+        "  (render-s ' world')",
+        ")))"
+      ].join("\n")
     end
   end
 end

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

@@ -9,7 +9,6 @@ describe 'The Evaluating Parser' do
   include PuppetSpec::Scope
 
   let(:acceptor) {  Puppet::Pops::Validation::Acceptor.new() }
-  let(:diag) { Puppet::Pops::Binder::Hiera2::DiagnosticProducer.new(acceptor) }
   let(:scope) { s = create_test_scope_for_node(node); s }
   let(:node) { 'node.example.com' }
 

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

@@ -21,7 +21,7 @@ describe 'Lexer2' do
   include EgrammarLexer2Spec
 
   {
-    :LBRACK => '[',
+    :LISTSTART => '[',
     :RBRACK => ']',
     :LBRACE => '{',
     :RBRACE => '}',
@@ -69,6 +69,10 @@ describe 'Lexer2' do
     end
   end
 
+  it "should lex [ in position after non whitespace as LBRACK" do
+    tokens_scanned_from("a[").should match_tokens2(:NAME, :LBRACK)
+  end
+
   {
     "case"     => :CASE,
     "class"    => :CLASS,
@@ -186,6 +190,16 @@ describe 'Lexer2' do
     end
   end
 
+  { "''"      => [2, ""],
+    "'a'"     => [3, "a"],
+    "'a\\'b'" => [6, "a'b"],
+    }.each do |source, expected|
+      it "should lex a single quoted STRING on the form #{source} as having length #{expected[0]}" do
+       length, value = expected
+       tokens_scanned_from(source).should match_tokens2([:STRING, value, {:line => 1, :pos=>1, :length=> length}])
+      end
+    end
+
   { '""'      => '',
     '"a"'     => 'a',
     '"a\'b"'  => "a'b",
@@ -229,7 +243,7 @@ describe 'Lexer2' do
 
   it "differentiates between foo[x] and foo [x] (whitespace)" do
     tokens_scanned_from("$a[1]").should match_tokens2(:VARIABLE, :LBRACK, :NUMBER, :RBRACK)
-    tokens_scanned_from("$a [1]").should match_tokens2(:VARIABLE, :LBRACK, :NUMBER, :RBRACK)
+    tokens_scanned_from("$a [1]").should match_tokens2(:VARIABLE, :LISTSTART, :NUMBER, :RBRACK)
     tokens_scanned_from("a[1]").should match_tokens2(:NAME, :LBRACK, :NUMBER, :RBRACK)
     tokens_scanned_from("a [1]").should match_tokens2(:NAME, :LISTSTART, :NUMBER, :RBRACK)
     tokens_scanned_from(" if \n\r\t\nif if ").should match_tokens2(:IF, :IF, :IF)
@@ -257,7 +271,9 @@ describe 'Lexer2' do
     "!~" => [:NOMATCH, "!~ /./"],
     ","  => [:COMMA, ", /./"],
     "("  => [:LPAREN, "( /./"],
-    "["  => [:LBRACK, "[ /./"],
+    "["  => [:LISTSTART, "[ /./"],
+    "["  => [[:NAME, :LBRACK], "a[ /./"],
+    "["  => [[:NAME, :LISTSTART], "a [ /./"],
     "{"  => [:LBRACE, "{ /./"],
     "+"  => [:PLUS, "+ /./"],
     "-"  => [:MINUS, "- /./"],
@@ -265,7 +281,8 @@ describe 'Lexer2' do
     ";"  => [:SEMIC, "; /./"],
   }.each do |token, entry|
     it "should lex regexp after '#{token}'" do
-      tokens_scanned_from(entry[1]).should match_tokens2(entry[0], :REGEX)
+      expected = [entry[0], :REGEX].flatten
+      tokens_scanned_from(entry[1]).should match_tokens2(*expected)
     end
   end
 

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

@@ -134,6 +134,11 @@ describe "egrammar parsing basic expressions" do
     it "$a = 'a' !~ 'b.*'"   do; dump(parse("$a = 'a' !~ 'b.*'")).should == "(= $a (!~ 'a' 'b.*'))"    ; end
   end
 
+  context "When parsing unfold" do
+    it "$a = *[1,2]" do; dump(parse("$a = *[1,2]")).should == "(= $a (unfold ([] 1 2)))" ; end
+    it "$a = *1"     do; dump(parse("$a = *1")).should == "(= $a (unfold 1))" ; end
+  end
+
   context "When parsing Lists" do
     it "$a = []" do
       dump(parse("$a = []")).should == "(= $a ([]))"

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

@@ -66,7 +66,7 @@ describe "egrammar parsing function calls" do
 
     # For egrammar where a bare word can be a "statement"
     it "$a = foo bar # illegal, must have parentheses" do
-      dump(parse("$a = foo bar")).should == "(block (= $a foo) bar)"
+      dump(parse("$a = foo bar")).should == "(block\n  (= $a foo)\n  bar\n)"
     end
 
     context "in nested scopes" do
@@ -94,8 +94,11 @@ describe "egrammar parsing function calls" do
     end
 
     it "$a.foo |$x|{ }" do
-      dump(parse("$a.foo |$x|{ $b = $x}")).should ==
-      "(call-method (. $a foo) (lambda (parameters x) (block (= $b $x))))"
+      dump(parse("$a.foo |$x|{ $b = $x}")).should == [
+        "(call-method (. $a foo) (lambda (parameters x) (block",
+        "  (= $b $x)",
+        ")))"
+        ].join("\n")
     end
   end
 end

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

@@ -30,10 +30,14 @@ describe "egrammar parsing conditionals" do
     end
 
     it "if true { $a = 10 $b = 10 } else {$a = 20}" do
-      dump(parse("if true { $a = 10 $b = 20} else {$a = 20}")).should ==
-      ["(if true",
-        "  (then (block (= $a 10) (= $b 20)))",
-        "  (else (= $a 20)))"].join("\n")
+      dump(parse("if true { $a = 10 $b = 20} else {$a = 20}")).should == [
+       "(if true",
+       "  (then (block",
+       "      (= $a 10)",
+       "      (= $b 20)",
+       "    ))",
+       "  (else (= $a 20)))"
+       ].join("\n")
     end
 
     it "allows a parenthesized conditional expression" do
@@ -142,7 +146,10 @@ describe "egrammar parsing conditionals" do
     it "case $a { a : {$b = 10 $c = 20}}" do
       dump(parse("case $a { a : {$b = 10 $c = 20}}")).should ==
       ["(case $a",
-        "  (when (a) (then (block (= $b 10) (= $c 20)))))"
+       "  (when (a) (then (block",
+       "    (= $b 10)",
+       "    (= $c 20)",
+       "  ))))"
       ].join("\n")
     end
   end

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

@@ -10,7 +10,12 @@ describe "egrammar parsing containers" do
 
   context "When parsing file scope" do
     it "$a = 10 $b = 20" do
-      dump(parse("$a = 10 $b = 20")).should == "(block (= $a 10) (= $b 20))"
+      dump(parse("$a = 10 $b = 20")).should == [
+        "(block",
+        "  (= $a 10)",
+        "  (= $b 20)",
+        ")"
+        ].join("\n")
     end
 
     it "$a = 10" do
@@ -24,7 +29,11 @@ describe "egrammar parsing containers" do
     end
 
     it "class foo { class bar {} }" do
-      dump(parse("class foo { class bar {}}")).should == "(class foo (block (class foo::bar ())))"
+      dump(parse("class foo { class bar {}}")).should == [
+        "(class foo (block",
+        "  (class foo::bar ())",
+        "))"
+        ].join("\n")
     end
 
     it "class foo::bar {}" do
@@ -52,7 +61,12 @@ describe "egrammar parsing containers" do
     end
 
     it "class foo {$a = 10 $b = 20}" do
-      dump(parse("class foo {$a = 10 $b = 20}")).should == "(class foo (block (= $a 10) (= $b 20)))"
+      dump(parse("class foo {$a = 10 $b = 20}")).should == [
+        "(class foo (block",
+        "  (= $a 10)",
+        "  (= $b 20)",
+        "))"
+        ].join("\n")
     end
 
     context "it should handle '3x weirdness'" do
@@ -100,6 +114,16 @@ describe "egrammar parsing containers" do
         }.to raise_error(/not a valid classname/)
       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'].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
@@ -108,12 +132,20 @@ describe "egrammar parsing containers" do
     end
 
     it "class foo { define bar {}}" do
-      dump(parse("class foo {define bar {}}")).should == "(class foo (block (define foo::bar ())))"
+      dump(parse("class foo {define bar {}}")).should == [
+        "(class foo (block",
+        "  (define foo::bar ())",
+        "))"
+        ].join("\n")
     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 ())))"
+      dump(parse("define foo { define bar {}}")).should == [
+        "(define foo (block",
+        "  (define bar ())",
+        "))"
+        ].join("\n")
     end
 
     it "define foo::bar {}" do
@@ -133,7 +165,12 @@ describe "egrammar parsing containers" do
     end
 
     it "define foo {$a = 10 $b = 20}" do
-      dump(parse("define foo {$a = 10 $b = 20}")).should == "(define foo (block (= $a 10) (= $b 20)))"
+      dump(parse("define foo {$a = 10 $b = 20}")).should == [
+        "(define foo (block",
+        "  (= $a 10)",
+        "  (= $b 20)",
+        "))"
+        ].join("\n")
     end
 
     context "it should handle '3x weirdness'" do
@@ -152,6 +189,15 @@ describe "egrammar parsing containers" do
         expect { dump(parse("define default {}")).should == "(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'].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
@@ -159,6 +205,10 @@ describe "egrammar parsing containers" do
       dump(parse("node foo {}")).should == "(node (matches 'foo') ())"
     end
 
+    it "node foo, {} # trailing comma" do
+      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
@@ -200,7 +250,12 @@ describe "egrammar parsing containers" do
     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)",
+        "))"
+        ].join("\n")
     end
   end
 end

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

@@ -9,72 +9,98 @@ describe "egrammar parsing resource declarations" do
   include ParserRspecHelper
 
   context "When parsing regular resource" do
-    it "file { 'title': }" do
-      dump(parse("file { 'title': }")).should == [
-        "(resource file",
-        "  ('title'))"
-      ].join("\n")
-    end
+    ["File", "file"].each do |word|
+      it "#{word} { 'title': }" do
+        dump(parse("#{word} { 'title': }")).should == [
+          "(resource file",
+          "  ('title'))"
+        ].join("\n")
+      end
 
-    it "file { 'title': path => '/somewhere', mode => 0777}" do
-      dump(parse("file { 'title': path => '/somewhere', mode => 0777}")).should == [
-        "(resource file",
-        "  ('title'",
-        "    (path => '/somewhere')",
-        "    (mode => 0777)))"
-      ].join("\n")
-    end
+      it "#{word} { 'title': path => '/somewhere', mode => '0777'}" do
+        dump(parse("#{word} { 'title': path => '/somewhere', mode => '0777'}")).should == [
+          "(resource file",
+          "  ('title'",
+          "    (path => '/somewhere')",
+          "    (mode => '0777')))"
+        ].join("\n")
+      end
 
-    it "file { 'title': path => '/somewhere', }" do
-      dump(parse("file { 'title': path => '/somewhere', }")).should == [
-        "(resource file",
-        "  ('title'",
-        "    (path => '/somewhere')))"
-      ].join("\n")
-    end
+      it "#{word} { 'title': path => '/somewhere', }" do
+        dump(parse("#{word} { 'title': path => '/somewhere', }")).should == [
+          "(resource file",
+          "  ('title'",
+          "    (path => '/somewhere')))"
+        ].join("\n")
+      end
 
-    it "file { 'title': , }" do
-      dump(parse("file { 'title': , }")).should == [
-        "(resource file",
-        "  ('title'))"
-      ].join("\n")
-    end
+      it "#{word} { 'title': , }" do
+        dump(parse("#{word} { 'title': , }")).should == [
+          "(resource file",
+          "  ('title'))"
+        ].join("\n")
+      end
 
-    it "file { 'title': ; }" do
-      dump(parse("file { 'title': ; }")).should == [
-        "(resource file",
-        "  ('title'))"
-      ].join("\n")
-    end
+      it "#{word} { 'title': ; }" do
+        dump(parse("#{word} { 'title': ; }")).should == [
+          "(resource file",
+          "  ('title'))"
+        ].join("\n")
+      end
 
-    it "file { 'title': ; 'other_title': }" do
-      dump(parse("file { 'title': ; 'other_title': }")).should == [
-        "(resource file",
-        "  ('title')",
-        "  ('other_title'))"
-      ].join("\n")
-    end
+      it "#{word} { 'title': ; 'other_title': }" do
+        dump(parse("#{word} { 'title': ; 'other_title': }")).should == [
+          "(resource file",
+          "  ('title')",
+          "  ('other_title'))"
+        ].join("\n")
+      end
 
-    it "file { 'title1': path => 'x'; 'title2': path => 'y'}" do
-      dump(parse("file { 'title1': path => 'x'; 'title2': path => 'y'}")).should == [
-        "(resource file",
-        "  ('title1'",
-        "    (path => 'x'))",
-        "  ('title2'",
-        "    (path => 'y')))",
-      ].join("\n")
+      # PUP-2898, trailing ';'
+      it "#{word} { 'title': ; 'other_title': ; }" do
+        dump(parse("#{word} { 'title': ; 'other_title': ; }")).should == [
+          "(resource file",
+          "  ('title')",
+          "  ('other_title'))"
+        ].join("\n")
+      end
+
+      it "#{word} { 'title1': path => 'x'; 'title2': path => 'y'}" do
+        dump(parse("#{word} { 'title1': path => 'x'; 'title2': path => 'y'}")).should == [
+          "(resource file",
+          "  ('title1'",
+          "    (path => 'x'))",
+          "  ('title2'",
+          "    (path => 'y')))",
+        ].join("\n")
+      end
+
+      it "#{word} { title: * => {mode => '0777'} }" do
+        dump(parse("#{word} { title: * => {mode => '0777'}}")).should == [
+          "(resource file",
+          "  (title",
+          "    (* => ({} (mode '0777')))))"
+        ].join("\n")
+      end
     end
   end
 
-  context "When parsing resource defaults" do
+  context "When parsing (type based) resource defaults" do
     it "File {  }" do
       dump(parse("File { }")).should == "(resource-defaults file)"
     end
 
-    it "File { mode => 0777 }" do
-      dump(parse("File { mode => 0777}")).should == [
+    it "File { mode => '0777' }" do
+      dump(parse("File { mode => '0777'}")).should == [
         "(resource-defaults file",
-        "  (mode => 0777))"
+        "  (mode => '0777'))"
+      ].join("\n")
+    end
+
+    it "File { * => {mode => '0777'} } (even if validated to be illegal)" do
+      dump(parse("File { * => {mode => '0777'}}")).should == [
+        "(resource-defaults file",
+        "  (* => ({} (mode '0777'))))"
       ].join("\n")
     end
   end
@@ -85,36 +111,92 @@ describe "egrammar parsing resource declarations" do
     end
 
     it "File['x'] { x => 1 }" do
-      dump(parse("File['x'] { x => 1}")).should == "(override (slice file 'x')\n  (x => 1))"
+      dump(parse("File['x'] { x => 1}")).should == [
+        "(override (slice file 'x')",
+        "  (x => 1))"
+        ].join("\n")
     end
 
+
     it "File['x', 'y'] { x => 1 }" do
-      dump(parse("File['x', 'y'] { x => 1}")).should == "(override (slice file ('x' 'y'))\n  (x => 1))"
+      dump(parse("File['x', 'y'] { x => 1}")).should == [
+        "(override (slice file ('x' 'y'))",
+        "  (x => 1))"
+        ].join("\n")
     end
 
     it "File['x'] { x => 1, y => 2 }" do
-      dump(parse("File['x'] { x => 1, y=> 2}")).should == "(override (slice file 'x')\n  (x => 1)\n  (y => 2))"
+      dump(parse("File['x'] { x => 1, y=> 2}")).should == [
+        "(override (slice file 'x')",
+        "  (x => 1)",
+        "  (y => 2))"
+        ].join("\n")
     end
 
     it "File['x'] { x +> 1 }" do
-      dump(parse("File['x'] { x +> 1}")).should == "(override (slice file 'x')\n  (x +> 1))"
+      dump(parse("File['x'] { x +> 1}")).should == [
+        "(override (slice file 'x')",
+        "  (x +> 1))"
+        ].join("\n")
+    end
+
+    it "File['x'] { * => {mode => '0777'} } (even if validated to be illegal)" do
+      dump(parse("File['x'] { * => {mode => '0777'}}")).should == [
+        "(override (slice file 'x')",
+        "  (* => ({} (mode '0777'))))"
+      ].join("\n")
     end
   end
 
   context "When parsing virtual and exported resources" do
-    it "@@file { 'title': }" do
+    it "parses exported @@file { 'title': }" do
       dump(parse("@@file { 'title': }")).should ==  "(exported-resource file\n  ('title'))"
     end
 
-    it "@file { 'title': }" do
+    it "parses virtual @file { 'title': }" do
       dump(parse("@file { 'title': }")).should ==  "(virtual-resource file\n  ('title'))"
     end
 
-    it "@file { mode => 0777 }" do
-      # Defaults are not virtualizeable
-      expect {
-        dump(parse("@file { mode => 0777 }")).should ==  ""
-      }.to raise_error(Puppet::ParseError, /Defaults are not virtualizable/)
+    it "nothing before the title colon is a syntax error" do
+      expect do
+        parse("@file {: mode => '0777' }")
+      end.to raise_error(/Syntax error/)
+    end
+
+    it "raises error for user error; not a resource" do
+      # The expression results in VIRTUAL, CALL FUNCTION('file', HASH) since the resource body has
+      # no title.
+      expect do
+        parse("@file { mode => '0777' }")
+      end.to raise_error(/Virtual \(@\) can only be applied to a Resource Expression/)
+    end
+
+    it "parses global defaults with @ (even if validated to be illegal)" do
+      dump(parse("@File { mode => '0777' }")).should == [
+        "(virtual-resource-defaults file",
+        "  (mode => '0777'))"
+        ].join("\n")
+    end
+
+    it "parses global defaults with @@ (even if validated to be illegal)" do
+      dump(parse("@@File { mode => '0777' }")).should == [
+        "(exported-resource-defaults file",
+        "  (mode => '0777'))"
+        ].join("\n")
+    end
+
+    it "parses override with @ (even if validated to be illegal)" do
+      dump(parse("@File[foo] { mode => '0777' }")).should == [
+        "(virtual-override (slice file foo)",
+        "  (mode => '0777'))"
+        ].join("\n")
+    end
+
+    it "parses override combined with @@ (even if validated to be illegal)" do
+      dump(parse("@@File[foo] { mode => '0777' }")).should == [
+        "(exported-override (slice file foo)",
+        "  (mode => '0777'))"
+        ].join("\n")
     end
   end
 
@@ -220,22 +302,22 @@ describe "egrammar parsing resource declarations" do
         dump(parse("File <| tag == 'foo' |>")).should == "(collect file\n  (<| |> (== tag 'foo')))"
       end
 
-      it "File <| tag == 'foo' and mode != 0777 |>" do
-        dump(parse("File <| tag == 'foo' and mode != 0777 |>")).should == "(collect file\n  (<| |> (&& (== tag 'foo') (!= mode 0777))))"
+      it "File <| tag == 'foo' and mode != '0777' |>" do
+        dump(parse("File <| tag == 'foo' and mode != '0777' |>")).should == "(collect file\n  (<| |> (&& (== tag 'foo') (!= mode '0777'))))"
       end
 
-      it "File <| tag == 'foo' or mode != 0777 |>" do
-        dump(parse("File <| tag == 'foo' or mode != 0777 |>")).should == "(collect file\n  (<| |> (|| (== tag 'foo') (!= mode 0777))))"
+      it "File <| tag == 'foo' or mode != '0777' |>" do
+        dump(parse("File <| tag == 'foo' or mode != '0777' |>")).should == "(collect file\n  (<| |> (|| (== tag 'foo') (!= mode '0777'))))"
       end
 
-      it "File <| tag == 'foo' or tag == 'bar' and mode != 0777 |>" do
-        dump(parse("File <| tag == 'foo' or tag == 'bar' and mode != 0777 |>")).should ==
-        "(collect file\n  (<| |> (|| (== tag 'foo') (&& (== tag 'bar') (!= mode 0777)))))"
+      it "File <| tag == 'foo' or tag == 'bar' and mode != '0777' |>" do
+        dump(parse("File <| tag == 'foo' or tag == 'bar' and mode != '0777' |>")).should ==
+        "(collect file\n  (<| |> (|| (== tag 'foo') (&& (== tag 'bar') (!= mode '0777')))))"
       end
 
-      it "File <| (tag == 'foo' or tag == 'bar') and mode != 0777 |>" do
-        dump(parse("File <| (tag == 'foo' or tag == 'bar') and mode != 0777 |>")).should ==
-        "(collect file\n  (<| |> (&& (|| (== tag 'foo') (== tag 'bar')) (!= mode 0777))))"
+      it "File <| (tag == 'foo' or tag == 'bar') and mode != '0777' |>" do
+        dump(parse("File <| (tag == 'foo' or tag == 'bar') and mode != '0777' |>")).should ==
+        "(collect file\n  (<| |> (&& (|| (== tag 'foo') (== tag 'bar')) (!= mode '0777'))))"
       end
     end
   end