puppet 8.3.1-universal-darwin → 8.5.0-universal-darwin

data/spec/unit/pops/evaluator/evaluator_rspec_helper.rb

@@ -1,75 +0,0 @@
-require 'puppet/pops'
-require 'puppet/pops/evaluator/evaluator_impl'
-
-require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
-
-module EvaluatorRspecHelper
-  include FactoryRspecHelper
-
-  # Evaluate a Factory wrapper round a model object in top scope + named scope
-  # Optionally pass two or three model objects (typically blocks) to be executed
-  # in top scope, named scope, and then top scope again. If a named_scope is used, it must
-  # be preceded by the name of the scope.
-  # The optional block is executed before the result of the last specified model object
-  # is evaluated. This block gets the top scope as an argument. The intent is to pass
-  # a block that asserts the state of the top scope after the operations.
-  #
-  def evaluate in_top_scope, scopename="x", in_named_scope = nil, in_top_scope_again = nil, &block
-    node = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-
-    # compiler creates the top scope if one is not present
-    top_scope = compiler.topscope()
-    # top_scope = Puppet::Parser::Scope.new(compiler)
-
-    evaluator = Puppet::Pops::Evaluator::EvaluatorImpl.new
-    Puppet.override(:loaders => compiler.loaders) do
-      result = evaluator.evaluate(in_top_scope.model, top_scope)
-      if in_named_scope
-        other_scope = Puppet::Parser::Scope.new(compiler)
-        result = evaluator.evaluate(in_named_scope.model, other_scope)
-      end
-      if in_top_scope_again
-        result = evaluator.evaluate(in_top_scope_again.model, top_scope)
-      end
-      if block_given?
-        block.call(top_scope)
-      end
-      result
-    end
-  end
-
-  # Evaluate a Factory wrapper round a model object in top scope + local scope
-  # Optionally pass two or three model objects (typically blocks) to be executed
-  # in top scope, local scope, and then top scope again
-  # The optional block is executed before the result of the last specified model object
-  # is evaluated. This block gets the top scope as an argument. The intent is to pass
-  # a block that asserts the state of the top scope after the operations.
-  #
-  def evaluate_l in_top_scope, in_local_scope = nil, in_top_scope_again = nil, &block
-    node = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-
-    # compiler creates the top scope if one is not present
-    top_scope = compiler.topscope()
-
-    evaluator = Puppet::Pops::Evaluator::EvaluatorImpl.new
-    Puppet.override(:loaders => compiler.loaders) do
-      result = evaluator.evaluate(in_top_scope.model, top_scope)
-      if in_local_scope
-        # This is really bad in 3.x scope
-        top_scope.with_guarded_scope do
-          top_scope.new_ephemeral(true)
-          result = evaluator.evaluate(in_local_scope.model, top_scope)
-        end
-      end
-      if in_top_scope_again
-        result = evaluator.evaluate(in_top_scope_again.model, top_scope)
-      end
-      if block_given?
-        block.call(top_scope)
-      end
-      result
-    end
-  end
-end

data/spec/unit/pops/evaluator/json_strict_literal_evaluator_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/pops'
-require 'puppet/pops/evaluator/json_strict_literal_evaluator'
-
-describe "Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator" do
-  let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
-  let(:leval)  {  Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator.new }
-
-  { "1"       => 1,
-    "3.14"    => 3.14,
-    "true"    => true,
-    "false"   => false,
-    "'1'"     => '1',
-    "'a'"     => 'a',
-    '"a"'     => 'a',
-    'a'       => 'a',
-    'a::b'    => 'a::b',
-    'undef'   => nil,
-
-    # collections
-    '[1,2,3]'     => [1,2,3],
-    '{a=>1,b=>2}' => {'a' => 1, 'b' => 2},
-    '[undef]'     => [nil],
-    '{a=>undef}'  => { 'a' => nil }
-
-  }.each do |source, result|
-    it "evaluates '#{source}' to #{result}" do
-      expect(leval.literal(parser.parse_string(source))).to eq(result)
-    end
-  end
-
-  [ '1+1', 
-    'File',
-    '[1,2, 1+2]',
-    '{a=>1+1}', 
-    'Integer[1]', 
-    '"x$y"', 
-    '"x${y}z"'
-  ].each do |source|
-    it "throws :not_literal for non literal expression '#{source}'" do
-      expect{leval.literal(parser.parse_string('1+1'))}.to throw_symbol(:not_literal)
-    end
-  end
-
-  [ 'default', 
-    '/.*/', 
-    '{1=>100}', 
-    '{undef => 10}',
-    '{default => 10}',
-    '{/.*/ => 10}',
-    '{"ok" => {1 => 100}}',
-    '[default]',
-    '[[default]]',
-    '[/.*/]',
-    '[[/.*/]]',
-    '[{1 => 100}]',
-  ].each do |source|
-    it "throws :not_literal for values not representable as pure JSON '#{source}'" do
-      expect{leval.literal(parser.parse_string('1+1'))}.to throw_symbol(:not_literal)
-    end
-  end
-end

data/spec/unit/pops/evaluator/literal_evaluator_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/pops'
-require 'puppet/pops/evaluator/literal_evaluator'
-
-describe "Puppet::Pops::Evaluator::LiteralEvaluator" do
-  let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
-  let(:leval)  {  Puppet::Pops::Evaluator::LiteralEvaluator.new }
-
-  { "1"       => 1,
-    "3.14"    => 3.14,
-    "true"    => true,
-    "false"   => false,
-    "'1'"     => '1',
-    "'a'"     => 'a',
-    '"a"'     => 'a',
-    'a'       => 'a',
-    'a::b'    => 'a::b',
-
-    # special values
-    'default' => :default,
-    '/.*/'    => /.*/,
-
-    # collections
-    '[1,2,3]'     => [1,2,3],
-    '{a=>1,b=>2}' => {'a' => 1, 'b' => 2},
-
-  }.each do |source, result|
-    it "evaluates '#{source}' to #{result}" do
-      expect(leval.literal(parser.parse_string(source))).to eq(result)
-    end
-  end
-
-  it "evaluates undef to nil" do
-    expect(leval.literal(parser.parse_string('undef'))).to be_nil
-  end
-
-  ['1+1', 'File', '[1,2, 1+2]', '{a=>1+1}', 'Integer[1]', '"x$y"', '"x${y}z"'].each do |source|
-    it "throws :not_literal for non literal expression '#{source}'" do
-      expect{leval.literal(parser.parse_string('1+1'))}.to throw_symbol(:not_literal)
-    end
-  end
-end

data/spec/unit/pops/evaluator/logical_ops_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/pops'
-require 'puppet/pops/evaluator/evaluator_impl'
-
-
-# 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 EvaluatorRspecHelper
-
-  context "When the evaluator performs boolean operations" do
-    context "using operator AND" do
-      it "true  && true  == true" do
-        expect(evaluate(literal(true).and(literal(true)))).to eq(true)
-      end
-
-      it "false && true  == false" do
-        expect(evaluate(literal(false).and(literal(true)))).to eq(false)
-      end
-
-      it "true  && false == false" do
-        expect(evaluate(literal(true).and(literal(false)))).to eq(false)
-      end
-
-      it "false && false == false" do
-        expect(evaluate(literal(false).and(literal(false)))).to eq(false)
-      end
-    end
-
-    context "using operator OR" do
-      it "true  || true  == true" do
-        expect(evaluate(literal(true).or(literal(true)))).to eq(true)
-      end
-
-      it "false || true  == true" do
-        expect(evaluate(literal(false).or(literal(true)))).to eq(true)
-      end
-
-      it "true  || false == true" do
-        expect(evaluate(literal(true).or(literal(false)))).to eq(true)
-      end
-
-      it "false || false == false" do
-        expect(evaluate(literal(false).or(literal(false)))).to eq(false)
-      end
-    end
-
-    context "using operator NOT" do
-      it "!false         == true" do
-        expect(evaluate(literal(false).not())).to eq(true)
-      end
-
-      it "!true          == false" do
-        expect(evaluate(literal(true).not())).to eq(false)
-      end
-    end
-
-    context "on values requiring boxing to Boolean" do
-      it "'x'            == true" do
-        expect(evaluate(literal('x').not())).to eq(false)
-      end
-
-      it "''             == true" do
-        expect(evaluate(literal('').not())).to eq(false)
-      end
-
-      it ":undef         == false" do
-        expect(evaluate(literal(:undef).not())).to eq(true)
-      end
-    end
-
-    context "connectives should stop when truth is obtained" do
-      it "true && false && error  == false (and no failure)" do
-        expect(evaluate(literal(false).and(literal('0xwtf') + literal(1)).and(literal(true)))).to eq(false)
-      end
-
-      it "false || true || error  == true (and no failure)" do
-        expect(evaluate(literal(true).or(literal('0xwtf') + literal(1)).or(literal(false)))).to eq(true)
-      end
-
-      it "false || false || error == error (false positive test)" do
-        # TODO: Change the exception type
-        expect {evaluate(literal(true).and(literal('0xwtf') + literal(1)).or(literal(false)))}.to raise_error(Puppet::ParseError)
-      end
-    end
-  end
-end

data/spec/unit/pops/evaluator/runtime3_converter_spec.rb

@@ -1,181 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/pops'
-require 'puppet/pops/types/type_factory'
-
-describe 'when converting to 3.x' do
-  let(:converter) { Puppet::Pops::Evaluator::Runtime3Converter.instance }
-
-  it "converts a resource type starting with Class without confusing it with exact match on 'class'" do
-    t = Puppet::Pops::Types::TypeFactory.resource('classroom', 'kermit')
-    converted = converter.catalog_type_to_split_type_title(t)
-    expect(converted).to eql(['classroom', 'kermit'])
-  end
-
-  it "converts a resource type of exactly 'Class'" do
-    t = Puppet::Pops::Types::TypeFactory.resource('class', 'kermit')
-    converted = converter.catalog_type_to_split_type_title(t)
-    expect(converted).to eql(['class', 'kermit'])
-  end
-
-  it "errors on attempts to convert an 'Iterator'" do
-    expect {
-      converter.convert(Puppet::Pops::Types::Iterable.on((1..3)), {}, nil)
-    }.to raise_error(Puppet::Error, /Use of an Iterator is not supported here/)
-  end
-
-  it 'does not convert a SemVer instance to string' do
-    v = SemanticPuppet::Version.parse('1.0.0')
-    expect(converter.convert(v, {}, nil)).to equal(v)
-  end
-
-  it 'converts top level symbol :undef to the given undef value' do
-    expect(converter.convert(:undef, {}, 'undef value')).to eql('undef value')
-  end
-
-  it 'converts top level nil value to the given undef value' do
-    expect(converter.convert(nil, {}, 'undef value')).to eql('undef value')
-  end
-
-  it 'converts nested :undef in a hash to nil' do
-    expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => nil})
-  end
-
-  it 'converts nested :undef in an array to nil' do
-    expect(converter.convert(['boo', :undef], {}, 'undef value')).to eql(['boo', nil])
-  end
-
-  it 'converts deeply nested :undef in to nil' do
-    expect(converter.convert({'foo' => [[:undef]], 'bar' => { 'x' => :undef }}, {}, 'undef value')).to eql({'foo' => [[nil]], 'bar' => { 'x' => nil}})
-  end
-
-  it 'does not converts nil to given undef value when nested in an array' do
-    expect(converter.convert({'foo' => nil}, {}, 'undef value')).to eql({'foo' => nil})
-  end
-
-  it 'does not convert top level symbols' do
-    expect(converter.convert(:default, {}, 'undef value')).to eql(:default)
-    expect(converter.convert(:whatever, {}, 'undef value')).to eql(:whatever)
-  end
-
-  it 'does not convert nested symbols' do
-    expect(converter.convert([:default], {}, 'undef value')).to eql([:default])
-    expect(converter.convert([:whatever], {}, 'undef value')).to eql([:whatever])
-  end
-
-  it 'does not convert a Regex instance to string' do
-    v = /^[A-Z]$/
-    expect(converter.convert(v, {}, nil)).to equal(v)
-  end
-
-  it 'does not convert a Version instance to string' do
-    v = SemanticPuppet::Version.parse('1.0.0')
-    expect(converter.convert(v, {}, nil)).to equal(v)
-  end
-
-  it 'does not convert a VersionRange instance to string' do
-    v = SemanticPuppet::VersionRange.parse('>=1.0.0')
-    expect(converter.convert(v, {}, nil)).to equal(v)
-  end
-
-  it 'does not convert a Timespan instance to string' do
-    v = Puppet::Pops::Time::Timespan.new(1234)
-    expect(converter.convert(v, {}, nil)).to equal(v)
-  end
-
-  it 'does not convert a Timestamp instance to string' do
-    v = Puppet::Pops::Time::Timestamp.now
-    expect(converter.convert(v, {}, nil)).to equal(v)
-  end
-
-  it 'does not convert a Sensitive instance to string' do
-    v = Puppet::Pops::Types::PSensitiveType::Sensitive.new("don't reveal this")
-    expect(converter.convert(v, {}, nil)).to equal(v)
-  end
-
-  it 'does not convert a Binary instance to string' do
-    v = Puppet::Pops::Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
-    expect(converter.convert(v, {}, nil)).to equal(v)
-  end
-
-  context 'the Runtime3FunctionArgumentConverter' do
-    let(:converter) { Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.instance }
-
-    it 'converts a Regex instance to string' do
-      c = converter.convert(/^[A-Z]$/, {}, nil)
-      expect(c).to be_a(String)
-      expect(c).to eql('/^[A-Z]$/')
-    end
-
-    it 'converts a Version instance to string' do
-      c = converter.convert(SemanticPuppet::Version.parse('1.0.0'), {}, nil)
-      expect(c).to be_a(String)
-      expect(c).to eql('1.0.0')
-    end
-
-    it 'converts a VersionRange instance to string' do
-      c = converter.convert(SemanticPuppet::VersionRange.parse('>=1.0.0'), {}, nil)
-      expect(c).to be_a(String)
-      expect(c).to eql('>=1.0.0')
-    end
-
-    it 'converts a Timespan instance to string' do
-      c = converter.convert(Puppet::Pops::Time::Timespan.new(1234), {}, nil)
-      expect(c).to be_a(String)
-      expect(c).to eql('0-00:00:00.1234')
-    end
-
-    it 'converts a Timestamp instance to string' do
-      c = converter.convert(Puppet::Pops::Time::Timestamp.parse('2016-09-15T12:24:47.193 UTC'), {}, nil)
-      expect(c).to be_a(String)
-      expect(c).to eql('2016-09-15T12:24:47.193000000 UTC')
-    end
-
-    it 'converts a Binary instance to string' do
-      b64 = 'w5ZzdGVuIG1lZCByw7ZzdGVuCg=='
-      c = converter.convert(Puppet::Pops::Types::PBinaryType::Binary.from_base64(b64), {}, nil)
-      expect(c).to be_a(String)
-      expect(c).to eql(b64)
-    end
-
-    it 'does not convert a Sensitive instance to string' do
-      v = Puppet::Pops::Types::PSensitiveType::Sensitive.new("don't reveal this")
-      expect(converter.convert(v, {}, nil)).to equal(v)
-    end
-
-    it 'errors if an Integer is too big' do
-      too_big = 0x7fffffffffffffff + 1
-      expect do
-        converter.convert(too_big, {}, nil)
-        end.to raise_error(/Use of a Ruby Integer outside of Puppet Integer max range, got/)
-    end
-
-    it 'errors if an Integer is too small' do
-      too_small = -0x8000000000000000-1
-      expect do
-        converter.convert(too_small, {}, nil)
-      end.to raise_error(/Use of a Ruby Integer outside of Puppet Integer min range, got/)
-    end
-
-    it 'errors if a BigDecimal is out of range for Float' do
-      big_dec = BigDecimal("123456789123456789.1415")
-      expect do
-        converter.convert(big_dec, {}, nil)
-      end.to raise_error(/Use of a Ruby BigDecimal value outside Puppet Float range, got/)
-    end
-
-    it 'BigDecimal values in Float range are converted' do
-      big_dec = BigDecimal("3.1415")
-      f = converter.convert(big_dec, {}, nil)
-      expect(f.class).to be(Float)
-    end
-
-    it 'errors when Integer is out of range in a structure' do
-      structure = {'key' => [{ 'key' => [0x7fffffffffffffff + 1]}]}
-      expect do
-        converter.convert(structure, {}, nil)
-        end.to raise_error(/Use of a Ruby Integer outside of Puppet Integer max range, got/)
-    end
-
-  end
-end

data/spec/unit/pops/evaluator/string_interpolation_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/pops'
-require 'puppet/pops/evaluator/evaluator_impl'
-
-
-# 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 EvaluatorRspecHelper
-
-  context "When evaluator performs string interpolation" do
-    it "should interpolate a bare word as a variable name, \"${var}\"" do
-      a_block = block(var('a').set(literal(10)), string('value is ', text(fqn('a')), ' yo'))
-      expect(evaluate(a_block)).to eq('value is 10 yo')
-    end
-
-    it "should interpolate a variable in a text expression, \"${$var}\"" do
-      a_block = block(var('a').set(literal(10)), string('value is ', text(var(fqn('a'))), ' yo'))
-      expect(evaluate(a_block)).to eq('value is 10 yo')
-    end
-
-    it "should interpolate a variable, \"$var\"" do
-      a_block = block(var('a').set(literal(10)), string('value is ', var(fqn('a')), ' yo'))
-      expect(evaluate(a_block)).to eq('value is 10 yo')
-    end
-
-    it "should interpolate any expression in a text expression, \"${$var*2}\"" do
-      a_block = block(var('a').set(literal(5)), string('value is ', text(var(fqn('a')) * literal(2)) , ' yo'))
-      expect(evaluate(a_block)).to eq('value is 10 yo')
-    end
-
-    it "should interpolate any expression without a text expression, \"${$var*2}\"" do
-      # there is no concrete syntax for this, but the parser can generate this simpler
-      # equivalent form where the expression is not wrapped in a TextExpression
-      a_block = block(var('a').set(literal(5)), string('value is ', var(fqn('a')) * literal(2) , ' yo'))
-      expect(evaluate(a_block)).to eq('value is 10 yo')
-    end
-
-    # TODO: Add function call tests - Pending implementation of calls in the evaluator
-  end
-end

data/spec/unit/pops/evaluator/variables_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet/pops/evaluator/evaluator_impl'
-
-
-# This file contains basic testing of variable references and assignments
-# using a top scope and a local scope.
-# It does not test variables and named scopes.
-#
-
-# 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::Impl::EvaluatorImpl' do
-  include EvaluatorRspecHelper
-
-  context "When the evaluator deals with variables" do
-    context "it should handle" do
-      it "simple assignment and dereference" do
-        expect(evaluate_l(block( var('a').set(literal(2)+literal(2)), var('a')))).to eq(4)
-      end
-
-      it "local scope shadows top scope" do
-        top_scope_block   = block( var('a').set(literal(2)+literal(2)), var('a'))
-        local_scope_block = block( var('a').set(var('a') + literal(2)), var('a'))
-        expect(evaluate_l(top_scope_block, local_scope_block)).to eq(6)
-      end
-
-      it "shadowed in local does not affect parent scope" do
-        top_scope_block   = block( var('a').set(literal(2)+literal(2)), var('a'))
-        local_scope_block = block( var('a').set(var('a') + literal(2)), var('a'))
-        top_scope_again = var('a')
-        expect(evaluate_l(top_scope_block, local_scope_block, top_scope_again)).to eq(4)
-      end
-
-      it "access to global names works in top scope" do
-        top_scope_block   = block( var('a').set(literal(2)+literal(2)), var('::a'))
-        expect(evaluate_l(top_scope_block)).to eq(4)
-      end
-
-      it "access to global names works in local scope" do
-        top_scope_block     = block( var('a').set(literal(2)+literal(2)))
-        local_scope_block   = block( var('a').set(literal(100)), var('b').set(var('::a')+literal(2)), var('b'))
-        expect(evaluate_l(top_scope_block, local_scope_block)).to eq(6)
-      end
-
-      it "can not change a variable value in same scope" do
-        expect { evaluate_l(block(var('a').set(literal(10)), var('a').set(literal(20)))) }.to raise_error(/Cannot reassign variable '\$a'/)
-      end
-
-      context "access to numeric variables" do
-        it "without a match" do
-          expect(evaluate_l(block(literal(2) + literal(2),
-            [var(0), var(1), var(2), var(3)]))).to eq([nil, nil, nil, nil])
-        end
-
-        it "after a match" do
-          expect(evaluate_l(block(literal('abc') =~ literal(/(a)(b)(c)/),
-            [var(0), var(1), var(2), var(3)]))).to eq(['abc', 'a', 'b', 'c'])
-        end
-
-        it "after a failed match" do
-          expect(evaluate_l(block(literal('abc') =~ literal(/(x)(y)(z)/),
-            [var(0), var(1), var(2), var(3)]))).to eq([nil, nil, nil, nil])
-        end
-
-        it "a failed match does not alter previous match" do
-          expect(evaluate_l(block(
-            literal('abc') =~ literal(/(a)(b)(c)/),
-            literal('abc') =~ literal(/(x)(y)(z)/),
-            [var(0), var(1), var(2), var(3)]))).to eq(['abc', 'a', 'b', 'c'])
-        end
-
-        it "a new match completely shadows previous match" do
-          expect(evaluate_l(block(
-            literal('abc') =~ literal(/(a)(b)(c)/),
-            literal('abc') =~ literal(/(a)bc/),
-            [var(0), var(1), var(2), var(3)]))).to eq(['abc', 'a', nil, nil])
-        end
-
-        it "after a match with variable referencing a non existing group" do
-          expect(evaluate_l(block(literal('abc') =~ literal(/(a)(b)(c)/),
-            [var(0), var(1), var(2), var(3), var(4)]))).to eq(['abc', 'a', 'b', 'c', nil])
-        end
-      end
-    end
-  end
-end

data/spec/unit/pops/factory_rspec_helper.rb

@@ -1,65 +0,0 @@
-require 'puppet/pops'
-
-module FactoryRspecHelper
-  def literal(x)
-    Puppet::Pops::Model::Factory.literal(x)
-  end
-
-  def block(*args)
-    Puppet::Pops::Model::Factory.block(*args)
-  end
-
-  def var(x)
-    Puppet::Pops::Model::Factory.var(x)
-  end
-
-  def fqn(x)
-    Puppet::Pops::Model::Factory.fqn(x)
-  end
-
-  def string(*args)
-    Puppet::Pops::Model::Factory.string(*args)
-  end
-
-  def minus(x)
-    Puppet::Pops::Model::Factory.minus(x)
-  end
-
-  def IF(test, then_expr, else_expr=nil)
-    Puppet::Pops::Model::Factory.IF(test, then_expr, else_expr)
-  end
-
-  def UNLESS(test, then_expr, else_expr=nil)
-    Puppet::Pops::Model::Factory.UNLESS(test, then_expr, else_expr)
-  end
-
-  def CASE(test, *options)
-    Puppet::Pops::Model::Factory.CASE(test, *options)
-  end
-
-  def WHEN(values, block)
-    Puppet::Pops::Model::Factory.WHEN(values, block)
-  end
-
-  def method_missing(method, *args, &block)
-    if Puppet::Pops::Model::Factory.respond_to? method
-      Puppet::Pops::Model::Factory.send(method, *args, &block)
-    else
-      super
-    end
-  end
-
-  # i.e. Selector Entry 1 => 'hello'
-  def MAP(match, value)
-    Puppet::Pops::Model::Factory.MAP(match, value)
-  end
-
-  def dump(x)
-    Puppet::Pops::Model::ModelTreeDumper.new.dump(x)
-  end
-
-  def unindent x
-    x.gsub(/^#{x[/\A\s*/]}/, '').chomp
-  end
-  factory ||= Puppet::Pops::Model::Factory
-end