puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/pops/issues_spec.rb

@@ -16,7 +16,7 @@ describe "Puppet::Pops::Issues" do
     x.format(:name => 'Boo-Hoo',
       :label => Puppet::Pops::Model::ModelLabelProvider.new,
       :semantic => "dummy"
-      ).should == "A Ruby String may not have a name containing a hyphen. The name 'Boo-Hoo' is not legal"
+      ).should == "A String may not have a name containing a hyphen. The name 'Boo-Hoo' is not legal"
   end
 
   it "should should format a message that does not require an argument" do

data/spec/unit/pops/model/ast_transformer_spec.rb

@@ -46,7 +46,7 @@ describe Puppet::Pops::Model::AstTransformer do
     end
 
     it "converts an unknown radix to an error string" do
-      ast = transform(Puppet::Pops::Model::Factory.new(Puppet::Pops::Model::LiteralNumber, 3, 2))
+      ast = transform(Puppet::Pops::Model::Factory.new(Puppet::Pops::Model::LiteralInteger, 3, 2))
 
       ast.should be_kind_of(Puppet::Parser::AST::Name)
       ast.value.should == "bad radix:3"
@@ -55,7 +55,9 @@ describe Puppet::Pops::Model::AstTransformer do
 
   it "preserves the file location" do
     model = literal(1)
-    model.record_position(location(3, 1, 10), location(3, 2, 11))
+    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(model.current)
+    adapter.locator = Puppet::Pops::Parser::Locator.locator("\n\n1",filename)
+    model.record_position(location(2, 1), nil)
 
     ast = transform(model)
 
@@ -68,12 +70,7 @@ describe Puppet::Pops::Model::AstTransformer do
     transformer.transform(model)
   end
 
-  def location(line, column, offset)
-    position = Puppet::Pops::Adapters::SourcePosAdapter.new
-    position.line = line
-    position.pos = column
-    position.offset = offset
-
-    position
+  def location(offset, length)
+    Puppet::Pops::Parser::Locatable::Fixed.new(offset, length)
   end
 end

data/spec/unit/pops/model/model_spec.rb

@@ -19,8 +19,8 @@ describe Puppet::Pops::Model::Factory do
     current = x.current
     current.is_a?(Model::ArithmeticExpression).should == true
     current.operator.should == :'+'
-    current.left_expr.class.should == Model::LiteralNumber
-    current.right_expr.class.should == Model::LiteralNumber
+    current.left_expr.class.should == Model::LiteralInteger
+    current.right_expr.class.should == Model::LiteralInteger
     current.left_expr.value.should == 10
     current.right_expr.value.should == 20
   end

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

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
+
+module EppParserRspecHelper
+  include FactoryRspecHelper
+  def parse(code)
+    parser = Puppet::Pops::Parser::EppParser.new()
+    parser.parse_string(code)
+  end
+end
+
+describe "epp parser" do
+  include EppParserRspecHelper
+
+  it "should instantiate an epp parser" do
+    parser = Puppet::Pops::Parser::EppParser.new()
+    parser.class.should == Puppet::Pops::Parser::EppParser
+  end
+
+  it "should parse a code string and return a program with epp" do
+    parser = Puppet::Pops::Parser::EppParser.new()
+    model = parser.parse_string("Nothing to see here, move along...").current
+    model.class.should == Puppet::Pops::Model::Program
+    model.body.class.should == Puppet::Pops::Model::LambdaExpression
+    model.body.body.class.should == Puppet::Pops::Model::EppExpression
+  end
+
+  context "when facing bad input it reports" do
+    it "unbalanced tags" do
+      expect { dump(parse("<% missing end tag")) }.to raise_error(/Unbalanced/)
+    end
+
+    it "abrupt end" do
+      expect { dump(parse("dum di dum di dum <%")) }.to raise_error(/Unbalanced/)
+    end
+
+    it "nested epp tags" do
+      expect { dump(parse("<% $a = 10 <% $b = 20 %>%>")) }.to raise_error(/Syntax error/)
+    end
+
+    it "nested epp expression tags" do
+      expect { dump(parse("<%= 1+1 <%= 2+2 %>%>")) }.to raise_error(/Syntax error/)
+    end
+
+    it "rendering sequence of expressions" do
+      expect { dump(parse("<%= 1 2 3 %>")) }.to raise_error(/Syntax error/)
+    end
+  end
+
+  context "handles parsing of" do
+    it "text (and nothing else)" do
+      dump(parse("Hello World")).should == "(lambda (epp (block (render-s 'Hello World'))))"
+    end
+
+    it "template parameters" do
+      dump(parse("<%|$x|%>Hello World")).should == "(lambda (parameters x) (epp (block (render-s 'Hello World'))))"
+    end
+
+    it "template parameters with default" do
+      dump(parse("<%|$x='cigar'|%>Hello World")).should == "(lambda (parameters (= x 'cigar')) (epp (block (render-s 'Hello World'))))"
+    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'))))"
+    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'))))"
+    end
+
+    it "comments" do
+      dump(parse("<%#($x='cigar', $y)%>Hello World")).should == "(lambda (epp (block (render-s 'Hello World'))))"
+    end
+
+    it "verbatim epp tags" do
+      dump(parse("<%% contemplating %%>Hello World")).should == "(lambda (epp (block (render-s '<% contemplating %>Hello World'))))"
+    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'))))"
+    end
+  end
+end

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

@@ -1,14 +1,16 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet_spec/pops'
+require 'puppet_spec/scope'
 
-describe 'The hiera2 string evaluator' do
+describe 'The Evaluating Parser' do
 
   include PuppetSpec::Pops
+  include PuppetSpec::Scope
 
   let(:acceptor) {  Puppet::Pops::Validation::Acceptor.new() }
   let(:diag) { Puppet::Pops::Binder::Hiera2::DiagnosticProducer.new(acceptor) }
-  let(:scope) { s = Puppet::Parser::Scope.new_for_test_harness(node); s }
+  let(:scope) { s = create_test_scope_for_node(node); s }
   let(:node) { 'node.example.com' }
 
   def quote(x)

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

@@ -0,0 +1,428 @@
+require 'spec_helper'
+require 'matchers/match_tokens2'
+require 'puppet/pops'
+require 'puppet/pops/parser/lexer2'
+
+module EgrammarLexer2Spec
+  def tokens_scanned_from(s)
+    lexer = Puppet::Pops::Parser::Lexer2.new
+    lexer.string = s
+    tokens = lexer.fullscan[0..-2]
+  end
+
+  def epp_tokens_scanned_from(s)
+    lexer = Puppet::Pops::Parser::Lexer2.new
+    lexer.string = s
+    tokens = lexer.fullscan_epp[0..-2]
+  end
+end
+
+describe 'Lexer2' do
+  include EgrammarLexer2Spec
+
+  {
+    :LBRACK => '[',
+    :RBRACK => ']',
+    :LBRACE => '{',
+    :RBRACE => '}',
+    :LPAREN => '(',
+    :RPAREN => ')',
+    :EQUALS => '=',
+    :ISEQUAL => '==',
+    :GREATEREQUAL => '>=',
+    :GREATERTHAN => '>',
+    :LESSTHAN => '<',
+    :LESSEQUAL => '<=',
+    :NOTEQUAL => '!=',
+    :NOT => '!',
+    :COMMA => ',',
+    :DOT => '.',
+    :COLON => ':',
+    :AT => '@',
+    :LLCOLLECT => '<<|',
+    :RRCOLLECT => '|>>',
+    :LCOLLECT => '<|',
+    :RCOLLECT => '|>',
+    :SEMIC => ';',
+    :QMARK => '?',
+    :OTHER => '\\',
+    :FARROW => '=>',
+    :PARROW => '+>',
+    :APPENDS => '+=',
+    :DELETES => '-=',
+    :PLUS => '+',
+    :MINUS => '-',
+    :DIV => '/',
+    :TIMES => '*',
+    :LSHIFT => '<<',
+    :RSHIFT => '>>',
+    :MATCH => '=~',
+    :NOMATCH => '!~',
+    :IN_EDGE => '->',
+    :OUT_EDGE => '<-',
+    :IN_EDGE_SUB => '~>',
+    :OUT_EDGE_SUB => '<~',
+    :PIPE => '|',
+  }.each do |name, string|
+    it "should lex a token named #{name.to_s}" do
+      tokens_scanned_from(string).should match_tokens2(name)
+    end
+  end
+
+  {
+    "case"     => :CASE,
+    "class"    => :CLASS,
+    "default"  => :DEFAULT,
+    "define"   => :DEFINE,
+#    "import" => :IMPORT, # done as a function in egrammar
+    "if"       => :IF,
+    "elsif"    => :ELSIF,
+    "else"     => :ELSE,
+    "inherits" => :INHERITS,
+    "node"     => :NODE,
+    "and"      => :AND,
+    "or"       => :OR,
+    "undef"    => :UNDEF,
+    "false"    => :BOOLEAN,
+    "true"     => :BOOLEAN,
+    "in"       => :IN,
+    "unless"   => :UNLESS,
+  }.each do |string, name|
+    it "should lex a keyword from '#{string}'" do
+      tokens_scanned_from(string).should match_tokens2(name)
+    end
+  end
+
+  # TODO: Complete with all edge cases
+  [ 'A', 'A::B', '::A', '::A::B',].each do |string|
+    it "should lex a CLASSREF on the form '#{string}'" do
+      tokens_scanned_from(string).should match_tokens2([:CLASSREF, string])
+    end
+  end
+
+  # TODO: Complete with all edge cases
+  [ 'a', 'a::b', '::a', '::a::b',].each do |string|
+    it "should lex a NAME on the form '#{string}'" do
+      tokens_scanned_from(string).should match_tokens2([:NAME, string])
+    end
+  end
+
+  [ 'a-b', 'a--b', 'a-b-c'].each do |string|
+    it "should lex a BARE WORD STRING on the form '#{string}'" do
+      tokens_scanned_from(string).should match_tokens2([:STRING, string])
+    end
+  end
+
+  { '-a'   =>      [:MINUS, :NAME],
+    '--a'  =>      [:MINUS, :MINUS, :NAME],
+    'a-'   =>      [:NAME, :MINUS],
+    'a- b'   =>    [:NAME, :MINUS, :NAME],
+    'a--'  =>      [:NAME, :MINUS, :MINUS],
+    'a-$3' =>      [:NAME, :MINUS, :VARIABLE],
+  }.each do |source, expected|
+    it "should lex leading and trailing hyphens from #{source}" do
+      tokens_scanned_from(source).should match_tokens2(*expected)
+    end
+  end
+
+  { 'false'=>false, 'true'=>true}.each do |string, value|
+    it "should lex a BOOLEAN on the form '#{string}'" do
+      tokens_scanned_from(string).should match_tokens2([:BOOLEAN, value])
+    end
+  end
+
+  [ '0', '1', '2982383139'].each do |string|
+    it "should lex a decimal integer NUMBER on the form '#{string}'" do
+      tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
+    end
+  end
+
+  { ' 1' => '1', '1 ' => '1', ' 1 ' => '1'}.each do |string, value|
+    it "should lex a NUMBER with surrounding space '#{string}'" do
+      tokens_scanned_from(string).should match_tokens2([:NUMBER, value])
+    end
+  end
+
+  [ '0.0', '0.1', '0.2982383139', '29823.235', '10e23', '10e-23', '1.234e23'].each do |string|
+    it "should lex a decimal floating point NUMBER on the form '#{string}'" do
+      tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
+    end
+  end
+
+  [ '00', '01', '0123', '0777'].each do |string|
+    it "should lex an octal integer NUMBER on the form '#{string}'" do
+      tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
+    end
+  end
+
+  [ '0x0', '0x1', '0xa', '0xA', '0xabcdef', '0xABCDEF'].each do |string|
+    it "should lex an hex integer NUMBER on the form '#{string}'" do
+      tokens_scanned_from(string).should match_tokens2([:NUMBER, string])
+    end
+  end
+
+  { "''"      => '',
+    "'a'"     => 'a',
+    "'a\\'b'" =>"a'b",
+    "'a\\rb'" =>"a\\rb",
+    "'a\\nb'" =>"a\\nb",
+    "'a\\tb'" =>"a\\tb",
+    "'a\\sb'" =>"a\\sb",
+    "'a\\$b'" =>"a\\$b",
+    "'a\\\"b'" =>"a\\\"b",
+    "'a\\\\b'" =>"a\\b",
+    "'a\\\\'" =>"a\\",
+  }.each do |source, expected|
+    it "should lex a single quoted STRING on the form #{source}" do
+      tokens_scanned_from(source).should match_tokens2([:STRING, expected])
+    end
+  end
+
+  { '""'      => '',
+    '"a"'     => 'a',
+    '"a\'b"'  => "a'b",
+  }.each do |source, expected|
+    it "should lex a double quoted STRING on the form #{source}" do
+      tokens_scanned_from(source).should match_tokens2([:STRING, expected])
+    end
+  end
+
+  { '"a$x b"'  => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
+                   [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
+                   [:DQPOST,   ' b',  {:line => 1, :pos=>5, :length=>3 }]],
+
+    '"a$x.b"'  => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
+                   [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
+                   [:DQPOST,   '.b',  {:line => 1, :pos=>5, :length=>3 }]],
+
+    '"$x.b"'   => [[:DQPRE,    '',    {:line => 1, :pos=>1, :length=>1 }],
+                   [:VARIABLE, 'x',   {:line => 1, :pos=>2, :length=>2 }],
+                   [:DQPOST,   '.b',  {:line => 1, :pos=>4, :length=>3 }]],
+
+    '"a$x"'    => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>2 }],
+                   [:VARIABLE, 'x',   {:line => 1, :pos=>3, :length=>2 }],
+                   [:DQPOST,   '',    {:line => 1, :pos=>5, :length=>1 }]],
+  }.each do |source, expected|
+    it "should lex an interpolated variable 'x' from #{source}" do
+      tokens_scanned_from(source).should match_tokens2(*expected)
+    end
+  end
+
+  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(: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)
+  end
+
+  it "skips whitepsace" do
+    tokens_scanned_from(" if if if ").should match_tokens2(:IF, :IF, :IF)
+    tokens_scanned_from(" if \n\r\t\nif if ").should match_tokens2(:IF, :IF, :IF)
+  end
+
+  it "skips single line comments" do
+    tokens_scanned_from("if # comment\nif").should match_tokens2(:IF, :IF)
+  end
+
+  ["if /* comment */\nif",
+    "if /* comment\n */\nif",
+    "if /*\n comment\n */\nif",
+    ].each do |source|
+    it "skips multi line comments" do
+      tokens_scanned_from(source).should match_tokens2(:IF, :IF)
+    end
+  end
+
+  { "=~" => [:MATCH, "=~ /./"],
+    "!~" => [:NOMATCH, "!~ /./"],
+    ","  => [:COMMA, ", /./"],
+    "("  => [:LPAREN, "( /./"],
+    "["  => [:LBRACK, "[ /./"],
+    "{"  => [:LBRACE, "{ /./"],
+    "+"  => [:PLUS, "+ /./"],
+    "-"  => [:MINUS, "- /./"],
+    "*"  => [:TIMES, "* /./"],
+    ";"  => [:SEMIC, "; /./"],
+  }.each do |token, entry|
+    it "should lex regexp after '#{token}'" do
+      tokens_scanned_from(entry[1]).should match_tokens2(entry[0], :REGEX)
+    end
+  end
+
+  it "should lex a simple expression" do
+    tokens_scanned_from('1 + 1').should match_tokens2([:NUMBER, '1'], :PLUS, [:NUMBER, '1'])
+  end
+
+  { "1"     => ["1 /./",       [:NUMBER, :DIV, :DOT, :DIV]],
+    "'a'"   => ["'a' /./",     [:STRING, :DIV, :DOT, :DIV]],
+    "true"  => ["true /./",    [:BOOLEAN, :DIV, :DOT, :DIV]],
+    "false" => ["false /./",   [:BOOLEAN, :DIV, :DOT, :DIV]],
+    "/./"   => ["/./ /./",     [:REGEX, :DIV, :DOT, :DIV]],
+    "a"     => ["a /./",       [:NAME, :DIV, :DOT, :DIV]],
+    "A"     => ["A /./",       [:CLASSREF, :DIV, :DOT, :DIV]],
+    ")"     => [") /./",       [:RPAREN, :DIV, :DOT, :DIV]],
+    "]"     => ["] /./",       [:RBRACK, :DIV, :DOT, :DIV]],
+    "|>"     => ["|> /./",     [:RCOLLECT, :DIV, :DOT, :DIV]],
+    "|>>"    => ["|>> /./",    [:RRCOLLECT, :DIV, :DOT, :DIV]],
+    '"a$a"'  => ['"a$a" /./',  [:DQPRE, :VARIABLE, :DQPOST, :DIV, :DOT, :DIV]],
+  }.each do |token, entry|
+    it "should not lex regexp after '#{token}'" do
+      tokens_scanned_from(entry[ 0 ]).should match_tokens2(*entry[ 1 ])
+    end
+  end
+
+  it 'should lex assignment' do
+    tokens_scanned_from("$a = 10").should match_tokens2([:VARIABLE, "a"], :EQUALS, [:NUMBER, '10'])
+  end
+
+# TODO: Tricky, and heredoc not supported yet
+#  it "should not lex regexp after heredoc" do
+#    tokens_scanned_from("1 / /./").should match_tokens2(:NUMBER, :DIV, :REGEX)
+#  end
+
+  it "should lex regexp at beginning of input" do
+    tokens_scanned_from(" /./").should match_tokens2(:REGEX)
+  end
+
+  it "should lex regexp right of div" do
+    tokens_scanned_from("1 / /./").should match_tokens2(:NUMBER, :DIV, :REGEX)
+  end
+
+  context 'when lexer lexes heredoc' do
+    it 'lexes tag, syntax and escapes, margin and right trim' do
+      code = <<-CODE
+      @(END:syntax/t)
+      Tex\\tt\\n
+      |- END
+      CODE
+      tokens_scanned_from(code).should match_tokens2([:HEREDOC, 'syntax'], :SUBLOCATE, [:STRING, "Tex\tt\\n"])
+    end
+
+    it 'lexes "tag", syntax and escapes, margin, right trim and interpolation' do
+      code = <<-CODE
+      @("END":syntax/t)
+      Tex\\tt\\n$var After
+      |- END
+      CODE
+      tokens_scanned_from(code).should match_tokens2(
+        [:HEREDOC, 'syntax'],
+        :SUBLOCATE,
+        [:DQPRE, "Tex\tt\\n"],
+        [:VARIABLE, "var"],
+        [:DQPOST, " After"]
+        )
+    end
+  end
+
+  it 'should support unicode characters' do
+    code = <<-CODE
+    "x\\u2713y"
+    CODE
+    if Puppet::Pops::Parser::Locator::RUBYVER < Puppet::Pops::Parser::Locator::RUBY_1_9_3
+      # Ruby 1.8.7 reports the multibyte char as several octal characters
+      tokens_scanned_from(code).should match_tokens2([:STRING, "x\342\234\223y"])
+    else
+      # >= Ruby 1.9.3 reports \u
+      tokens_scanned_from(code).should match_tokens2([:STRING, "x\u2713y"])
+    end
+  end
+
+  context 'when lexing epp' do
+    it 'epp can contain just text' do
+      code = <<-CODE
+      This is just text
+      CODE
+      epp_tokens_scanned_from(code).should match_tokens2(:EPP_START, [:RENDER_STRING, "      This is just text\n"])
+    end
+
+    it 'epp can contain text with interpolated rendered expressions' do
+      code = <<-CODE
+      This is <%= $x %> just text
+      CODE
+      epp_tokens_scanned_from(code).should match_tokens2(
+      :EPP_START,
+      [:RENDER_STRING, "      This is "],
+      [:RENDER_EXPR, nil],
+      [:VARIABLE, "x"],
+      [:EPP_END, "%>"],
+      [:RENDER_STRING, " just text\n"]
+      )
+    end
+
+    it 'epp can contain text with trimmed interpolated rendered expressions' do
+      code = <<-CODE
+      This is <%= $x -%> just text
+      CODE
+      epp_tokens_scanned_from(code).should match_tokens2(
+      :EPP_START,
+      [:RENDER_STRING, "      This is "],
+      [:RENDER_EXPR, nil],
+      [:VARIABLE, "x"],
+      [:EPP_END_TRIM, "-%>"],
+      [:RENDER_STRING, "just text\n"]
+      )
+    end
+
+    it 'epp can contain text with expressions that are not rendered' do
+      code = <<-CODE
+      This is <% $x=10 %> just text
+      CODE
+      epp_tokens_scanned_from(code).should match_tokens2(
+      :EPP_START,
+      [:RENDER_STRING, "      This is "],
+      [:VARIABLE, "x"],
+      :EQUALS,
+      [:NUMBER, "10"],
+      [:RENDER_STRING, " just text\n"]
+      )
+    end
+
+    it 'epp can skip leading space in tail text' do
+      code = <<-CODE
+      This is <% $x=10 -%>
+      just text
+      CODE
+      epp_tokens_scanned_from(code).should match_tokens2(
+      :EPP_START,
+      [:RENDER_STRING, "      This is "],
+      [:VARIABLE, "x"],
+      :EQUALS,
+      [:NUMBER, "10"],
+      [:RENDER_STRING, "just text\n"]
+      )
+    end
+
+    it 'epp can skip comments' do
+      code = <<-CODE
+      This is <% $x=10 -%>
+      <%# This is an epp comment -%>
+      just text
+      CODE
+      epp_tokens_scanned_from(code).should match_tokens2(
+      :EPP_START,
+      [:RENDER_STRING, "      This is "],
+      [:VARIABLE, "x"],
+      :EQUALS,
+      [:NUMBER, "10"],
+      [:RENDER_STRING, "just text\n"]
+      )
+    end
+
+    it 'epp can escape epp tags' do
+      code = <<-CODE
+      This is <% $x=10 -%>
+      <%% this is escaped epp %%>
+      CODE
+      epp_tokens_scanned_from(code).should match_tokens2(
+      :EPP_START,
+      [:RENDER_STRING, "      This is "],
+      [:VARIABLE, "x"],
+      :EQUALS,
+      [:NUMBER, "10"],
+      [:RENDER_STRING, "<% this is escaped epp %>\n"]
+      )
+    end
+  end
+end
+