puppet 4.4.0-universal-darwin

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

@@ -0,0 +1,38 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+
+# relative to this spec file (./) does not work as this file is loaded by rspec
+require File.join(File.dirname(__FILE__), '/parser_rspec_helper')
+
+describe "egrammar parsing of site expression" do
+  include ParserRspecHelper
+
+  before(:each) do
+    with_app_management(true)
+  end
+
+  after(:each) do
+    with_app_management(false)
+  end
+
+  context "when parsing 'site'" do
+    it "an empty body is allowed" do
+      prog = "site { }"
+      ast = "(site ())"
+      expect(dump(parse(prog))).to eq(ast)
+    end
+
+    it "a body with one expression is allowed" do
+      prog = "site { $x = 1 }"
+      ast = "(site (block\n  (= $x 1)\n))"
+      expect(dump(parse(prog))).to eq(ast)
+    end
+
+    it "a body with more than one expression is allowed" do
+      prog = "site { $x = 1 $y = 2}"
+      ast = "(site (block\n  (= $x 1)\n  (= $y 2)\n))"
+      expect(dump(parse(prog))).to eq(ast)
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'puppet/pops'
+
+require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
+
+module ParserRspecHelper
+  include FactoryRspecHelper
+
+  def with_app_management(flag)
+    Puppet[:app_management] = flag
+  end
+
+  def parse(code)
+    parser = Puppet::Pops::Parser::Parser.new()
+    parser.parse_string(code)
+  end
+
+  def parse_epp(code)
+    parser = Puppet::Pops::Parser::EppParser.new()
+    parser.parse_string(code)
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+describe Puppet::Pops::Parser::Parser do
+  it "should instantiate a parser" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    expect(parser.class).to eq(Puppet::Pops::Parser::Parser)
+  end
+
+  it "should parse a code string and return a model" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string("$a = 10").current
+    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
+    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
+    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)
+  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
+    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)
+  end
+
+  it "should raise an error with position information when error is raised from within parser" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    the_error = nil
+    begin
+      parser.parse_string("File [1] { }", 'fakefile.pp')
+    rescue Puppet::ParseError => e
+      the_error = e
+    end
+    expect(the_error).to be_a(Puppet::ParseError)
+    expect(the_error.file).to eq('fakefile.pp')
+    expect(the_error.line).to eq(1)
+    expect(the_error.pos).to eq(6)
+  end
+
+  it "should raise an error with position information when error is raised on token" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    the_error = nil
+    begin
+      parser.parse_string(<<-EOF, 'fakefile.pp')
+class whoops($a,$b,$c) {
+  $d = "oh noes",  "b"
+}
+      EOF
+    rescue Puppet::ParseError => e
+      the_error = e
+    end
+    expect(the_error).to be_a(Puppet::ParseError)
+    expect(the_error.file).to eq('fakefile.pp')
+    expect(the_error.line).to eq(2)
+    expect(the_error.pos).to eq(17)
+  end
+end

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

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/evaluator/evaluator_impl'
+require 'puppet_spec/pops'
+require 'puppet_spec/scope'
+require 'puppet/parser/e4_parser_adapter'
+
+
+# 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 PuppetSpec::Pops
+  include PuppetSpec::Scope
+
+  let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
+
+  context "captures-rest parameter" do
+    it 'is allowed in lambda when placed last' do
+      source = <<-CODE
+        foo() |$a, *$b| { $a + $b[0] }
+      CODE
+      expect do
+        parser.parse_string(source, __FILE__)
+      end.to_not raise_error()
+    end
+
+    it 'allows a type annotation' do
+      source = <<-CODE
+        foo() |$a, Integer *$b| { $a + $b[0] }
+      CODE
+      expect do
+        parser.parse_string(source, __FILE__)
+      end.to_not raise_error()
+    end
+
+    it 'is not allowed in lambda except last' do
+      source = <<-CODE
+        foo() |*$a, $b| { $a + $b[0] }
+      CODE
+      expect do
+        parser.parse_string(source, __FILE__)
+      end.to raise_error(Puppet::ParseError, /Parameter \$a is not last, and has 'captures rest'/)
+    end
+
+    it 'is not allowed in define' do
+      source = <<-CODE
+        define foo(*$a) { }
+      CODE
+      expect do
+        parser.parse_string(source, __FILE__)
+      end.to raise_error(Puppet::ParseError, /Parameter \$a has 'captures rest' - not supported in a 'define'/)
+    end
+
+    it 'is not allowed in class' do
+      source = <<-CODE
+        class foo(*$a) { }
+      CODE
+      expect do
+        parser.parse_string(source, __FILE__)
+      end.to raise_error(Puppet::ParseError, /Parameter \$a has 'captures rest' - not supported in a Host Class Definition/)
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+
+require 'rgen/array_extensions'
+
+describe "RGen extensions to core classes" do
+  it "should be possible to create an empty hash after having required the files above" do
+    # If this fails, it means the rgen addition to Array is not monkey patched as it
+    # should (it will return an array instead of fail in a method_missing), and thus
+    # screw up Hash's check if it can do "to_hash' or not.
+    #
+    Hash[[]]
+  end
+
+  it "should be possible to automatically stringify a nested, empty array during join" do
+    # When this fails it means that rgen has incorrectly implemented
+    # method_missing on array and is returning an array for to_str instead of
+    # failing as is expected allowing stringification to occur
+    expect([[]].join(":")).to eq("")
+    expect(["1", []].join(":")).to eq("1:")
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+describe Puppet::Pops::Adapters::SourcePosAdapter 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
+    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')
+  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
+    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')
+  end
+
+end

data/spec/unit/pops/types/class_loader_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+describe 'the Puppet::Pops::Types::ClassLoader' do
+  it 'should produce path alternatives for CamelCase classes' do
+    expected_paths = ['puppet_x/some_thing', 'puppetx/something']
+    # path_for_name method is private
+    expect(Puppet::Pops::Types::ClassLoader.send(:paths_for_name, ['PuppetX', 'SomeThing'])).to include(*expected_paths)
+  end
+end

data/spec/unit/pops/types/enumeration_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+describe 'The enumeration support' do
+  it 'produces an enumerator for Array' do
+  expect(Puppet::Pops::Types::Enumeration.enumerator([1,2,3]).respond_to?(:next)).to eql(true)
+  end
+
+  it 'produces an enumerator for Hash' do
+    expect(Puppet::Pops::Types::Enumeration.enumerator({:a=>1}).respond_to?(:next)).to eql(true)
+  end
+
+  it 'produces a char enumerator for String' do
+    enum = Puppet::Pops::Types::Enumeration.enumerator("abc")
+    expect(enum.respond_to?(:next)).to eql(true)
+    expect(enum.next).to eql('a')
+  end
+
+  it 'produces an enumerator for integer times' do
+    enum = Puppet::Pops::Types::Enumeration.enumerator(2)
+    expect(enum.next).to eql(0)
+    expect(enum.next).to eql(1)
+    expect{enum.next}.to raise_error(StopIteration)
+  end
+
+  it 'produces an enumerator for Integer range' do
+    range = Puppet::Pops::Types::TypeFactory.range(1,2)
+    enum = Puppet::Pops::Types::Enumeration.enumerator(range)
+    expect(enum.next).to eql(1)
+    expect(enum.next).to eql(2)
+    expect{enum.next}.to raise_error(StopIteration)
+  end
+
+  it 'does not produce an enumerator for infinite Integer range' do
+    range = Puppet::Pops::Types::TypeFactory.range(1,:default)
+    enum = Puppet::Pops::Types::Enumeration.enumerator(range)
+    expect(enum).to be_nil
+    range = Puppet::Pops::Types::TypeFactory.range(:default,2)
+    enum = Puppet::Pops::Types::Enumeration.enumerator(range)
+    expect(enum).to be_nil
+  end
+
+  [3.14, /.*/, true, false, nil, :something].each do |x|
+    it "does not produce an enumerator for object of type #{x.class}" do
+      enum = Puppet::Pops::Types::Enumeration.enumerator(x)
+      expect(enum).to be_nil
+    end
+  end
+
+end

data/spec/unit/pops/types/iterable_spec.rb

@@ -0,0 +1,262 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+module Puppet::Pops::Types
+describe 'The iterable support' do
+
+  [
+    0,
+    5,
+    (3..10),
+    %w(a b c),
+    {'a'=>2},
+    'hello',
+    PIntegerType.new(1, 4),
+    PEnumType.new(%w(yes no))
+  ].each do |obj|
+    it "should consider instances of #{obj.class.name} to be Iterable" do
+      expect(PIterableType::DEFAULT.instance?(obj)).to eq(true)
+    end
+
+    it "should yield an Iterable instance when Iterable.on is called with a #{obj.class.name}" do
+      expect(Iterable.on(obj)).to be_a(Iterable)
+    end
+  end
+
+  {
+    -1 => 'a negative Integer',
+    5.times => 'an Enumerable',
+    PIntegerType.new(nil, nil) => 'an unbounded Integer type'
+  }.each_pair do |obj, desc|
+    it "does not consider #{desc} to be Iterable" do
+      expect(PIterableType::DEFAULT.instance?(obj)).to eq(false)
+    end
+
+    it "does not yield an Iterable when Iterable.on is called with #{desc}" do
+      expect(Iterable.on(obj)).to be_nil
+    end
+  end
+
+  context 'when testing assignability' do
+    iterable_types = [
+      PIntegerType::DEFAULT,
+      PStringType::DEFAULT,
+      PIterableType::DEFAULT,
+      PIteratorType::DEFAULT,
+      PCollectionType::DEFAULT,
+      PArrayType::DEFAULT,
+      PHashType::DEFAULT,
+      PTupleType::DEFAULT,
+      PStructType::DEFAULT,
+      PUnitType::DEFAULT
+    ]
+    iterable_types << PType.new(PIntegerType.new(0, 10))
+    iterable_types << PType.new(PEnumType.new(%w(yes no)))
+    iterable_types << PRuntimeType.new(:ruby, 'Puppet::Pops::Types::Iterator')
+    iterable_types << PVariantType.new(iterable_types.clone)
+
+    not_iterable_types = [
+      PAnyType::DEFAULT,
+      PBooleanType::DEFAULT,
+      PCallableType::DEFAULT,
+      PCatalogEntryType::DEFAULT,
+      PDataType::DEFAULT,
+      PDefaultType::DEFAULT,
+      PFloatType::DEFAULT,
+      PHostClassType::DEFAULT,
+      PNotUndefType::DEFAULT,
+      PNumericType::DEFAULT,
+      POptionalType::DEFAULT,
+      PPatternType::DEFAULT,
+      PRegexpType::DEFAULT,
+      PResourceType::DEFAULT,
+      PRuntimeType::DEFAULT,
+      PScalarType::DEFAULT,
+      PType::DEFAULT,
+      PUndefType::DEFAULT
+    ]
+    not_iterable_types << PType.new(PIntegerType::DEFAULT)
+    not_iterable_types << PVariantType.new([iterable_types[0], not_iterable_types[0]])
+
+    iterable_types.each do |type|
+      it "should consider #{type} to be assignable to Iterable type" do
+        expect(PIterableType::DEFAULT.assignable?(type)).to eq(true)
+      end
+    end
+
+    not_iterable_types.each do |type|
+      it "should not consider #{type} to be assignable to Iterable type" do
+        expect(PIterableType::DEFAULT.assignable?(type)).to eq(false)
+      end
+    end
+
+    it "should consider Type[Integer[0,5]] to be assignable to Iterable[Integer[0,5]]" do
+      expect(PIterableType.new(PIntegerType.new(0,5)).assignable?(PType.new(PIntegerType.new(0,5)))).to eq(true)
+    end
+
+    it "should consider Type[Enum[yes,no]] to be assignable to Iterable[Enum[yes,no]]" do
+      expect(PIterableType.new(PEnumType.new(%w(yes no))).assignable?(PType.new(PEnumType.new(%w(yes no))))).to eq(true)
+    end
+
+    it "should not consider Type[Enum[ok,fail]] to be assignable to Iterable[Enum[yes,no]]" do
+      expect(PIterableType.new(PEnumType.new(%w(ok fail))).assignable?(PType.new(PEnumType.new(%w(yes no))))).to eq(false)
+    end
+
+    it "should not consider Type[String] to be assignable to Iterable[String]" do
+      expect(PIterableType.new(PStringType::DEFAULT).assignable?(PType.new(PStringType::DEFAULT))).to eq(false)
+    end
+  end
+
+  it 'does not wrap an Iterable in another Iterable' do
+    x = Iterable.on(5)
+    expect(Iterable.on(x)).to equal(x)
+  end
+
+  it 'produces a "times" iterable on integer' do
+    expect{ |b| Iterable.on(3).each(&b) }.to yield_successive_args(0,1,2)
+  end
+
+  it 'produces an iterable with element type Integer[0,X-1] for an iterable on an integer X' do
+    expect(Iterable.on(3).element_type).to eq(PIntegerType.new(0,2))
+  end
+
+  it 'produces a step iterable on an integer' do
+    expect{ |b| Iterable.on(8).step(3, &b) }.to yield_successive_args(0, 3, 6)
+  end
+
+  it 'produces a reverse iterable on an integer' do
+    expect{ |b| Iterable.on(5).reverse_each(&b) }.to yield_successive_args(4,3,2,1,0)
+  end
+
+  it 'produces an iterable on a integer range' do
+    expect{ |b| Iterable.on(2..7).each(&b) }.to yield_successive_args(2,3,4,5,6,7)
+  end
+
+  it 'produces an iterable with element type Integer[X,Y] for an iterable on an integer range (X..Y)' do
+    expect(Iterable.on(2..7).element_type).to eq(PIntegerType.new(2,7))
+  end
+
+  it 'produces an iterable on a character range' do
+    expect{ |b| Iterable.on('a'..'f').each(&b) }.to yield_successive_args('a', 'b', 'c', 'd', 'e', 'f')
+  end
+
+  it 'produces a step iterable on a range' do
+    expect{ |b| Iterable.on(1..5).step(2, &b) }.to yield_successive_args(1,3,5)
+  end
+
+  it 'produces a reverse iterable on a range' do
+    expect{ |b| Iterable.on(2..7).reverse_each(&b) }.to yield_successive_args(7,6,5,4,3,2)
+  end
+
+  it 'produces an iterable with element type String with a size constraint for an iterable on a character range' do
+    expect(Iterable.on('a'..'fe').element_type).to eq(PStringType.new(PIntegerType.new(1,2)))
+  end
+
+  it 'produces an iterable on a bounded Integer type' do
+    expect{ |b| Iterable.on(PIntegerType.new(2,7)).each(&b) }.to yield_successive_args(2,3,4,5,6,7)
+  end
+
+  it 'produces an iterable with element type Integer[X,Y] for an iterable on Integer[X,Y]' do
+    expect(Iterable.on(PIntegerType.new(2,7)).element_type).to eq(PIntegerType.new(2,7))
+  end
+
+  it 'produces an iterable on String' do
+    expect{ |b| Iterable.on('eat this').each(&b) }.to yield_successive_args('e', 'a', 't', ' ', 't', 'h', 'i', 's')
+  end
+
+  it 'produces an iterable with element type String[1,1] for an iterable created on a String' do
+    expect(Iterable.on('eat this').element_type).to eq(PStringType.new(PIntegerType.new(1,1)))
+ end
+
+  it 'produces an iterable on Array' do
+    expect{ |b| Iterable.on([1,5,9]).each(&b) }.to yield_successive_args(1,5,9)
+  end
+
+  it 'produces an iterable with element type inferred from the array elements for an iterable on Array' do
+    expect(Iterable.on([1,5,5,9,9,9]).element_type).to eq(PVariantType.new([PIntegerType.new(1,1), PIntegerType.new(5,5), PIntegerType.new(9,9)]))
+  end
+
+  it 'can chain reverse_each after step on Iterable' do
+    expect{ |b| Iterable.on(6).step(2).reverse_each(&b) }.to yield_successive_args(4,2,0)
+  end
+
+  it 'can chain reverse_each after step on Integer range' do
+    expect{ |b| Iterable.on(PIntegerType.new(0, 5)).step(2).reverse_each(&b) }.to yield_successive_args(4,2,0)
+  end
+
+  it 'can chain step after reverse_each on Iterable' do
+    expect{ |b| Iterable.on(6).reverse_each.step(2, &b) }.to yield_successive_args(5,3,1)
+  end
+
+  it 'can chain step after reverse_each on Integer range' do
+    expect{ |b| Iterable.on(PIntegerType.new(0, 5)).reverse_each.step(2, &b) }.to yield_successive_args(5,3,1)
+  end
+
+  it 'will produce the same result for each as for reverse_each.reverse_each' do
+    x1 = Iterable.on(5)
+    x2 = Iterable.on(5)
+    expect(x1.reduce([]) { |a,i| a << i; a}).to eq(x2.reverse_each.reverse_each.reduce([]) { |a,i| a << i; a})
+  end
+
+  it 'can chain many nested step/reverse_each calls' do
+    # x = Iterable.on(18).step(3) (0, 3, 6, 9, 12, 15)
+    # x = x.reverse_each (15, 12, 9, 6, 3, 0)
+    # x = x.step(2) (15, 9, 3)
+    # x = x.reverse_each(3, 9, 15)
+    expect{ |b| Iterable.on(18).step(3).reverse_each.step(2).reverse_each(&b) }.to yield_successive_args(3, 9, 15)
+  end
+
+  it 'can chain many nested step/reverse_each calls on Array iterable' do
+    expect{ |b| Iterable.on(18.times.to_a).step(3).reverse_each.step(2).reverse_each(&b) }.to yield_successive_args(3, 9, 15)
+  end
+
+  it 'produces an steppable iterable for Array' do
+    expect{ |b| Iterable.on(%w(a b c d e f g h i)).step(3, &b) }.to yield_successive_args('a', 'd', 'g')
+  end
+
+  it 'produces an reverse steppable iterable for Array' do
+    expect{ |b| Iterable.on(%w(a b c d e f g h i)).reverse_each.step(3, &b) }.to yield_successive_args('i', 'f', 'c')
+  end
+
+  it 'responds false when a bounded Iterable is passed to Iterable.unbounded?' do
+    expect(Iterable.unbounded?(Iterable.on(%w(a b c d e f g h i)))).to eq(false)
+  end
+
+  it 'can create an Array from a bounded Iterable' do
+    expect(Iterable.on(%w(a b c d e f g h i)).to_a).to eq(%w(a b c d e f g h i))
+  end
+
+  class TestUnboundedIterator
+    include Enumerable
+    include Iterable
+
+     def step(step_size)
+      if block_given?
+        begin
+          current = 0
+          loop do
+            yield(@current)
+            current = current + step_size
+          end
+        rescue StopIteration
+        end
+      end
+      self
+    end
+  end
+
+  it 'responds true when an unbounded Iterable is passed to Iterable.unbounded?' do
+    ubi = TestUnboundedIterator.new
+    expect(Iterable.unbounded?(Iterable.on(ubi))).to eq(true)
+  end
+
+  it 'can not create an Array from an unbounded Iterable' do
+    ubi = TestUnboundedIterator.new
+    expect{ Iterable.on(ubi).to_a }.to raise_error(Puppet::Error, /Attempt to create an Array from an unbounded Iterable/)
+  end
+
+  it 'will produce the string Iterator[T] on to_s on an iterator instance with element type T' do
+    expect(Iterable.on(18).to_s).to eq('Iterator[Integer] value')
+  end
+end
+end