puppet 4.10.12 → 5.0.0

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

@@ -4,7 +4,7 @@ require 'puppet/pops'
 
 describe Puppet::Pops::Model do
   it "should be possible to create an instance of a model object" do
-    nop = Puppet::Pops::Model::Nop.new
+    nop = Puppet::Pops::Model::Nop.new(Puppet::Pops::Parser::Locator.locator('code', 'file'), 0, 0)
     expect(nop.class).to eq(Puppet::Pops::Model::Nop)
   end
 end
@@ -16,22 +16,22 @@ describe Puppet::Pops::Model::Factory do
   it "construct an arithmetic expression" do
     x = Factory.literal(10) + Factory.literal(20)
     expect(x.is_a?(Factory)).to eq(true)
-    current = x.current
-    expect(current.is_a?(Model::ArithmeticExpression)).to eq(true)
-    expect(current.operator).to eq(:'+')
-    expect(current.left_expr.class).to eq(Model::LiteralInteger)
-    expect(current.right_expr.class).to eq(Model::LiteralInteger)
-    expect(current.left_expr.value).to eq(10)
-    expect(current.right_expr.value).to eq(20)
+    model = x.model
+    expect(model.is_a?(Model::ArithmeticExpression)).to eq(true)
+    expect(model.operator).to eq('+')
+    expect(model.left_expr.class).to eq(Model::LiteralInteger)
+    expect(model.right_expr.class).to eq(Model::LiteralInteger)
+    expect(model.left_expr.value).to eq(10)
+    expect(model.right_expr.value).to eq(20)
   end
 
   it "should be easy to compare using a model tree dumper" do
     x = Factory.literal(10) + Factory.literal(20)
-    expect(Puppet::Pops::Model::ModelTreeDumper.new.dump(x.current)).to eq("(+ 10 20)")
+    expect(Puppet::Pops::Model::ModelTreeDumper.new.dump(x.model)).to eq("(+ 10 20)")
   end
 
   it "builder should apply precedence" do
     x = Factory.literal(2) * Factory.literal(10) + Factory.literal(20)
-    expect(Puppet::Pops::Model::ModelTreeDumper.new.dump(x.current)).to eq("(+ (* 2 10) 20)")
+    expect(Puppet::Pops::Model::ModelTreeDumper.new.dump(x.model)).to eq("(+ (* 2 10) 20)")
   end
 end

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

@@ -21,7 +21,7 @@ describe "epp parser" do
 
   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 = parser.parse_string("Nothing to see here, move along...").model
     expect(model.class).to eq(Puppet::Pops::Model::Program)
     expect(model.body.class).to eq(Puppet::Pops::Model::LambdaExpression)
     expect(model.body.body.class).to eq(Puppet::Pops::Model::EppExpression)

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

@@ -94,41 +94,16 @@ describe 'Lexer2' do
     "private"  => :PRIVATE,
     "type"     => :TYPE,
     "attr"     => :ATTR,
+    "application"  => :APPLICATION,
+    "consumes"     => :CONSUMES,
+    "produces"     => :PRODUCES,
+    "site"         => :SITE,
   }.each do |string, name|
     it "should lex a keyword from '#{string}'" do
       expect(tokens_scanned_from(string)).to match_tokens2(name)
     end
   end
 
-  context 'when app_management is off (by default)' do
-    {
-      "application"  => :APPLICATION_R,
-      "consumes"     => :CONSUMES_R,
-      "produces"     => :PRODUCES_R,
-      "site"         => :SITE_R,
-    }.each do |string, name|
-      it "should lex a (future reserved) keyword from '#{string}'" do
-        expect(tokens_scanned_from(string)).to match_tokens2(name)
-      end
-    end
-  end
-
-  context 'when app_managment is (turned) on' do
-    before(:each) { Puppet[:app_management] = true }
-    after(:each) { Puppet[:app_management] = false }
-
-    {
-      "application"  => :APPLICATION,
-      "consumes"     => :CONSUMES,
-      "produces"     => :PRODUCES,
-      "site"         => :SITE,
-    }.each do |string, name|
-      it "should lex a keyword from '#{string}'" do
-        expect(tokens_scanned_from(string)).to match_tokens2(name)
-      end
-    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
@@ -473,36 +448,6 @@ describe 'Lexer2' do
         )
     end
 
-    it 'strips only last newline when using trim option' do
-      code = <<-CODE.unindent
-        @(END)
-        Line 1
-        
-        Line 2
-        -END
-        CODE
-      expect(tokens_scanned_from(code)).to match_tokens2(
-        [:HEREDOC, ''],
-        [:SUBLOCATE, ["Line 1\n", "\n", "Line 2\n"]],
-        [:STRING, "Line 1\n\nLine 2"],
-      )
-    end
-
-    it 'strips only one newline at the end when using trim option' do
-      code = <<-CODE.unindent
-        @(END)
-        Line 1
-        Line 2
-        
-        -END
-      CODE
-      expect(tokens_scanned_from(code)).to match_tokens2(
-        [:HEREDOC, ''],
-        [:SUBLOCATE, ["Line 1\n", "Line 2\n", "\n"]],
-        [:STRING, "Line 1\nLine 2\n"],
-      )
-    end
-
     context 'with bad syntax' do
       def expect_issue(code, issue)
         expect { tokens_scanned_from(code) }.to raise_error(Puppet::ParseErrorWithIssue) { |e|

data/spec/unit/pops/parser/{source_pos_adapter_spec.rb → locator_spec.rb}

@@ -1,26 +1,24 @@
 require 'spec_helper'
 require 'puppet/pops'
 
-describe Puppet::Pops::Adapters::SourcePosAdapter do
+describe Puppet::Pops::Parser::Locator do
 
   it "multi byte characters in a comment does not interfere with AST node text extraction" do
     parser = Puppet::Pops::Parser::Parser.new()
-    model = parser.parse_string("# \u{0400}comment\nabcdef#XXXXXXXXXX").current
+    model = parser.parse_string("# \u{0400}comment\nabcdef#XXXXXXXXXX").model
     expect(model.class).to eq(Puppet::Pops::Model::Program)
-    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(model.body)
-    expect(adapter.offset).to eq(12)
-    expect(adapter.length).to eq(6)
-    expect(adapter.extract_text).to eq('abcdef')
+    expect(model.body.offset).to eq(12)
+    expect(model.body.length).to eq(6)
+    expect(model.body.locator.extract_text(model.body.offset, model.body.length)).to eq('abcdef')
   end
 
   it "multi byte characters in a comment does not interfere with AST node text extraction" do
     parser = Puppet::Pops::Parser::Parser.new()
-    model = parser.parse_string("# \u{0400}comment\n1 + 2#XXXXXXXXXX").current
+    model = parser.parse_string("# \u{0400}comment\n1 + 2#XXXXXXXXXX").model
     expect(model.class).to eq(Puppet::Pops::Model::Program)
-    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(model.body)
-    expect(adapter.offset).to eq(14) # The '+'
-    expect(adapter.length).to eq(1)
-    expect(adapter.extract_tree_text).to eq('1 + 2')
+    expect(model.body.offset).to eq(14) # The '+'
+    expect(model.body.length).to eq(1)
+    expect(model.body.locator.extract_tree_text(model.body)).to eq('1 + 2')
   end
 
 end

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

@@ -6,9 +6,6 @@ require_relative 'parser_rspec_helper'
 describe "egrammar parsing of 'application'" do
   include ParserRspecHelper
 
-  before(:each) { Puppet[:app_management] = true }
-  after(:each) { Puppet[:app_management] = false }
-
   it "an empty body" do
     expect(dump(parse("application foo { }"))).to eq("(application foo () ())")
   end

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

@@ -165,8 +165,8 @@ describe "egrammar parsing basic expressions" do
     end
 
     it "calculates the text length of an empty array" do
-      expect(parse("[]").current.body.length).to eq(2)
-      expect(parse("[ ]").current.body.length).to eq(3)
+      expect(parse("[]").model.body.length).to eq(2)
+      expect(parse("[ ]").model.body.length).to eq(3)
     end
 
     {
@@ -251,8 +251,8 @@ describe "egrammar parsing basic expressions" do
     end
 
     it "calculates the text length of an empty hash" do
-      expect(parse("{}").current.body.length).to eq(2)
-      expect(parse("{ }").current.body.length).to eq(3)
+      expect(parse("{}").model.body.length).to eq(2)
+      expect(parse("{ }").model.body.length).to eq(3)
     end
   end
 

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

@@ -6,9 +6,6 @@ require_relative 'parser_rspec_helper'
 describe "egrammar parsing of capability mappings" do
   include ParserRspecHelper
 
-  before(:each) { Puppet[:app_management] = true }
-  after(:each) { Puppet[:app_management] = false }
-
   context "when parsing 'produces'" do
     it "the ast contains produces and attributes" do
       prog = "Foo produces Sql { name => value }"

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

@@ -74,26 +74,31 @@ describe "egrammar parsing containers" 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 is allowed in 3.x.
-        expect {
-          expect(dump(parse("class class {}"))).to eq("(class class ())")
-        }.to raise_error(/not a valid classname/)
+        # 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 { expect(dump(parse("class default {}"))).to eq("(class default ())") }.to raise_error(Puppet::ParseError)
+        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 at line 1: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", :broken => true do
         expect {
-          expect(dump(parse("class class inherits default {}"))).to eq("(class class (inherits default) ())")
+          parse("class class inherits default {}")
         }.to raise_error(/not a valid classname/)
       end
 
@@ -102,16 +107,12 @@ describe "egrammar parsing containers" do
         # this because a class is named at parse time (since class evaluation is lazy, the model must have the
         # full class name for nested classes - only, it gets this wrong when a class is named "class" - or at least
         # I think it is wrong.)
-        # 
-        expect {
-        expect(dump(parse("class class inherits default {}"))).to eq("(class class::class (inherits default) ())")
-          }.to raise_error(/not a valid classname/)
+        #
+        expect { parse("class class inherits default {}") }.to raise_error(/'class' keyword not allowed at this location/)
       end
 
       it "class foo inherits class" do
-        expect {
-          expect(dump(parse("class foo inherits class {}"))).to eq("(class foo (inherits class) ())")
-        }.to raise_error(/not a valid classname/)
+        expect { parse("class foo inherits class {}") }.to raise_error(/'class' keyword not allowed at this location/)
       end
     end
 
@@ -119,7 +120,7 @@ describe "egrammar parsing containers" 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
+          expect { parse("class x ($#{keyword}){} class { x: #{keyword} => 1 }") }.to_not raise_error
         end
       end
     end
@@ -177,16 +178,13 @@ describe "egrammar parsing containers" 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 {
-          expect(dump(parse("define class {}"))).to eq("(define class ())")
-          }.to raise_error(/not a valid classname/)
+        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 { expect(dump(parse("define default {}"))).to eq("(define default ())")}.to raise_error(Puppet::ParseError)
+        expect { parse("define default {}") }.to raise_error(Puppet::ParseError)
       end
     end
 

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

@@ -6,9 +6,6 @@ require_relative 'parser_rspec_helper'
 describe "egrammar parsing of site expression" do
   include ParserRspecHelper
 
-  before(:each) { Puppet[:app_management] = true }
-  after(:each) { Puppet[:app_management] = false }
-
   context "when parsing 'site'" do
     it "an empty body is allowed" do
       prog = "site { }"

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

@@ -9,36 +9,34 @@ describe Puppet::Pops::Parser::Parser do
 
   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 = parser.parse_string("$a = 10").model
     expect(model.class).to eq(Puppet::Pops::Model::Program)
     expect(model.body.class).to eq(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 = parser.parse_string("").model
     expect(model.class).to eq(Puppet::Pops::Model::Program)
     expect(model.body.class).to eq(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 = parser.parse_string("# comment\n").model
     expect(model.class).to eq(Puppet::Pops::Model::Program)
     expect(model.body.class).to eq(Puppet::Pops::Model::Nop)
-    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(model.body)
-    expect(adapter.offset).to eq(10)
-    expect(adapter.length).to eq(0)
+    expect(model.body.offset).to eq(10)
+    expect(model.body.length).to eq(0)
   end
 
   it "multi byte characters in a comment are counted as individual bytes" do
     parser = Puppet::Pops::Parser::Parser.new()
-    model = parser.parse_string("# \u{0400}comment\n").current
+    model = parser.parse_string("# \u{0400}comment\n").model
     expect(model.class).to eq(Puppet::Pops::Model::Program)
     expect(model.body.class).to eq(Puppet::Pops::Model::Nop)
-    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(model.body)
-    expect(adapter.offset).to eq(12)
-    expect(adapter.length).to eq(0)
+    expect(model.body.offset).to eq(12)
+    expect(model.body.length).to eq(0)
   end
 
   it "should raise an error with position information when error is raised from within parser" do

data/spec/unit/pops/resource/resource_type_impl_spec.rb

@@ -14,7 +14,7 @@ describe "Puppet::Pops::Resource" do
   let(:factory) { TypeFactory }
 
   context 'when creating resources' do
-    let!(:resource_type) { ResourceTypeImpl._ptype }
+    let!(:resource_type) { ResourceTypeImpl._pcore_type }
 
     it 'can create an instance of a ResourceType' do
       code = <<-CODE
@@ -93,13 +93,11 @@ describe "Puppet::Pops::Resource" do
     let(:env) { Puppet::Node::Environment.create(:'spec', [File.join(env_dir, 'spec', 'modules')]) }
     let(:node) { Puppet::Node.new('test', :environment => env) }
     around(:each) do |example|
-      Puppet[:app_management] = true
       Puppet[:environment] = env_name
       Puppet.override(:environments => environments, :current_environment => env) do
         example.run
       end
       Puppet::Type.rmtype(:capability)
-      Puppet[:app_management] = false
     end
 
     it 'does not load the Ruby resource' do

data/spec/unit/pops/serialization/serialization_spec.rb

@@ -34,7 +34,7 @@ module Serialization
   end
 
   def parse(string)
-    parser.parse_string(string, '/home/tester/experiments/manifests/init.pp').current
+    parser.parse_string(string, '/home/tester/experiments/manifests/init.pp')
   end
 
   context 'can write and read a' do
@@ -283,6 +283,92 @@ module Serialization
         expect(dumper.dump(expr)).to eq(dumper.dump(expr2))
       end
     end
+
+    context 'PuppetObject' do
+      before(:each) do
+        class DerivedArray < Array
+          include Types::PuppetObject
+
+          def self._pcore_type
+            @type
+          end
+
+          def self.register_ptype(loader, ir)
+            @type = Pcore.create_object_type(loader, ir, DerivedArray, 'DerivedArray', nil, 'values' => Types::PArrayType::DEFAULT)
+              .resolve(Types::TypeParser.singleton, loader)
+          end
+
+          def initialize(values)
+            concat(values)
+          end
+
+          def values
+            Array.new(self)
+          end
+        end
+
+        class DerivedHash < Hash
+          include Types::PuppetObject
+
+          def self._pcore_type
+            @type
+          end
+
+          def self.register_ptype(loader, ir)
+            @type = Pcore.create_object_type(loader, ir, DerivedHash, 'DerivedHash', nil, '_pcore_init_hash' => Types::PHashType::DEFAULT)
+              .resolve(Types::TypeParser.singleton, loader)
+          end
+
+          def initialize(_pcore_init_hash)
+            merge!(_pcore_init_hash)
+          end
+
+          def _pcore_init_hash
+            result = {}
+            result.merge!(self)
+            result
+          end
+        end
+      end
+
+      after(:each) do
+        x = Puppet::Pops::Serialization
+        x.send(:remove_const, :DerivedArray) if x.const_defined?(:DerivedArray)
+        x.send(:remove_const, :DerivedHash) if x.const_defined?(:DerivedHash)
+      end
+
+      it 'derived from Array' do
+        DerivedArray.register_ptype(loader, loaders.implementation_registry)
+
+        # Sensitive omitted because it doesn't respond to ==
+        val = DerivedArray.new([
+          Time::Timespan.from_fields(false, 3, 12, 40, 31, 123),
+          Time::Timestamp.now,
+          SemanticPuppet::Version.parse('1.2.3-alpha2'),
+          SemanticPuppet::VersionRange.parse('>=1.2.3-alpha2 <1.2.4'),
+          Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
+        ])
+        write(val)
+        val2 = read
+        expect(val2).to eql(val)
+      end
+
+      it 'derived from Hash' do
+        DerivedHash.register_ptype(loader, loaders.implementation_registry)
+
+        # Sensitive omitted because it doesn't respond to ==
+        val = DerivedHash.new({
+          'duration' => Time::Timespan.from_fields(false, 3, 12, 40, 31, 123),
+          'time' => Time::Timestamp.now,
+          'version' => SemanticPuppet::Version.parse('1.2.3-alpha2'),
+          'range' => SemanticPuppet::VersionRange.parse('>=1.2.3-alpha2 <1.2.4'),
+          'binary' => Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
+        })
+        write(val)
+        val2 = read
+        expect(val2).to eql(val)
+      end
+    end
   end
 
   context 'deserializing an instance whose Object type was serialized by reference' do