puppet 4.3.2-x64-mingw32 → 4.4.0-x64-mingw32

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

@@ -26,6 +26,10 @@ describe "egrammar parsing function calls" do
         expect(dump(parse("foo(bar)"))).to eq("(invoke foo bar)")
       end
 
+      it "notice {a=>2}" do
+        expect(dump(parse("notice {a => 2}"))).to eq("(invoke notice ({} ('a' 2)))")
+      end
+
       it "foo(bar,)" do
         expect(dump(parse("foo(bar,)"))).to eq("(invoke foo bar)")
       end
@@ -37,6 +41,10 @@ describe "egrammar parsing function calls" do
       it "notice fqdn_rand(30)" do
         expect(dump(parse("notice fqdn_rand(30)"))).to eq('(invoke notice (call fqdn_rand 30))')
       end
+
+      it "notice type(42)" do
+        expect(dump(parse("notice type(42)"))).to eq('(invoke notice (call type 42))')
+      end
     end
 
     context "in nested scopes" do

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

@@ -31,6 +31,16 @@ describe Puppet::Pops::Parser::Parser do
     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

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/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

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

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'puppet/pops/types/recursion_guard'
+
+describe 'the Puppet::Pops::Types::RecursionGuard' do
+  let(:guard) { Puppet::Pops::Types::RecursionGuard.new }
+
+  it "should detect recursion in 'this' context" do
+    x = Object.new
+    expect(guard.add_this(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_this(x)).to eq(Puppet::Pops::Types::RecursionGuard::SELF_RECURSION_IN_THIS)
+  end
+
+  it "should detect recursion in 'that' context" do
+    x = Object.new
+    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::SELF_RECURSION_IN_THAT)
+  end
+
+  it "should keep 'this' and 'that' context separate" do
+    x = Object.new
+    expect(guard.add_this(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+  end
+
+  it "should detect when there's a recursion in both 'this' and 'that' context" do
+    x = Object.new
+    y = Object.new
+    expect(guard.add_this(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_that(y)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+    expect(guard.add_this(x)).to eq(Puppet::Pops::Types::RecursionGuard::SELF_RECURSION_IN_THIS)
+    expect(guard.add_that(y)).to eq(Puppet::Pops::Types::RecursionGuard::SELF_RECURSION_IN_BOTH)
+  end
+
+  it "should report that 'this' is recursive after a recursion has been detected" do
+    x = Object.new
+    guard.add_this(x)
+    guard.add_this(x)
+    expect(guard.recursive_this?(x)).to be_truthy
+  end
+
+  it "should report that 'that' is recursive after a recursion has been detected" do
+    x = Object.new
+    guard.add_that(x)
+    guard.add_that(x)
+    expect(guard.recursive_that?(x)).to be_truthy
+  end
+
+  it "should not report that 'this' is recursive after a recursion of 'that' has been detected" do
+    x = Object.new
+    guard.add_that(x)
+    guard.add_that(x)
+    expect(guard.recursive_this?(x)).to be_falsey
+  end
+
+  it "should not report that 'that' is recursive after a recursion of 'this' has been detected" do
+    x = Object.new
+    guard.add_that(x)
+    guard.add_that(x)
+    expect(guard.recursive_this?(x)).to be_falsey
+  end
+
+  it "should not call 'hash' on an added instance" do
+    x = mock
+    x.expects(:hash).never
+    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+  end
+
+  it "should not call '==' on an added instance" do
+    x = mock
+    x.expects(:==).never
+    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+  end
+
+  it "should not call 'eq?' on an added instance" do
+    x = mock
+    x.expects(:eq?).never
+    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+  end
+
+  it "should not call 'eql?' on an added instance" do
+    x = mock
+    x.expects(:eql?).never
+    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+  end
+
+  it "should not call 'equal?' on an added instance" do
+    x = mock
+    x.expects(:equal?).never
+    expect(guard.add_that(x)).to eq(Puppet::Pops::Types::RecursionGuard::NO_SELF_RECURSION)
+  end
+end

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

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'puppet/pops/types/type_acceptor'
+
+module Puppet::Pops::Types
+describe 'the Puppet::Pops::Types::TypeAcceptor' do
+  let!(:acceptor_class) do
+    Class.new do
+      include TypeAcceptor
+      attr_reader :visitors, :guard
+
+      def initialize
+        @visitors = []
+        @guard = nil
+      end
+
+      def visit(type, guard)
+        @visitors << type
+        @guard = guard
+      end
+    end
+  end
+
+  let(:acceptor) { acceptor_class.new }
+  let(:guard) { RecursionGuard.new }
+
+  it "should get a visit from the type that accepts it" do
+    PAnyType::DEFAULT.accept(acceptor, nil)
+    expect(acceptor.visitors).to include(PAnyType::DEFAULT)
+  end
+
+  it "should receive the guard as an argument" do
+    PAnyType::DEFAULT.accept(acceptor, guard)
+    expect(acceptor.guard).to equal(guard)
+  end
+
+  it "should get a visit from the type of a Type that accepts it" do
+    t = PType.new(PAnyType::DEFAULT)
+    t.accept(acceptor, nil)
+    expect(acceptor.visitors).to include(t, PAnyType::DEFAULT)
+  end
+
+  [
+    PType,
+    PNotUndefType,
+    PIterableType,
+    PIteratorType,
+    POptionalType
+  ].each do |tc|
+    it "should get a visit from the contained type of an #{tc.class.name} that accepts it" do
+      t = tc.new(PDataType::DEFAULT)
+      t.accept(acceptor, nil)
+      expect(acceptor.visitors).to include(t, PDataType::DEFAULT)
+    end
+  end
+
+  it "should get a visit from the size type of String type that accepts it" do
+    sz = PIntegerType.new(0,4)
+    t = PStringType.new(sz)
+    t.accept(acceptor, nil)
+    expect(acceptor.visitors).to include(t, sz)
+  end
+
+  it "should get a visit from all contained types of an Array type that accepts it" do
+    sz = PIntegerType.new(0,4)
+    t = PArrayType.new(PAnyType::DEFAULT, sz)
+    t.accept(acceptor, nil)
+    expect(acceptor.visitors).to include(t, PAnyType::DEFAULT, sz)
+  end
+
+  it "should get a visit from all contained types of a Hash type that accepts it" do
+    sz = PIntegerType.new(0,4)
+    t = PHashType.new(PStringType::DEFAULT, PAnyType::DEFAULT, sz)
+    t.accept(acceptor, nil)
+    expect(acceptor.visitors).to include(t, PStringType::DEFAULT, PAnyType::DEFAULT, sz)
+  end
+
+  it "should get a visit from all contained types of a Tuple type that accepts it" do
+    sz = PIntegerType.new(0,4)
+    t = PTupleType.new([PStringType::DEFAULT, PIntegerType::DEFAULT], sz)
+    t.accept(acceptor, nil)
+    expect(acceptor.visitors).to include(t, PStringType::DEFAULT, PIntegerType::DEFAULT, sz)
+  end
+
+  it "should get a visit from all contained types of a Struct type that accepts it" do
+    t = PStructType.new([PStructElement.new(PStringType::DEFAULT, PIntegerType::DEFAULT)])
+    t.accept(acceptor, nil)
+    expect(acceptor.visitors).to include(t, PStringType::DEFAULT, PIntegerType::DEFAULT)
+  end
+
+  it "should get a visit from all contained types of a Callable type that accepts it" do
+    sz = PIntegerType.new(0,4)
+    args = PTupleType.new([PStringType::DEFAULT, PIntegerType::DEFAULT], sz)
+    block = PCallableType::DEFAULT
+    t = PCallableType.new(args, block)
+    t.accept(acceptor, nil)
+    expect(acceptor.visitors).to include(t, PStringType::DEFAULT, PIntegerType::DEFAULT, sz, args, block)
+  end
+
+  it "should get a visit from all contained types of a Variant type that accepts it" do
+    t = PVariantType.new([PStringType::DEFAULT, PIntegerType::DEFAULT])
+    t.accept(acceptor, nil)
+    expect(acceptor.visitors).to include(t, PStringType::DEFAULT, PIntegerType::DEFAULT)
+  end
+end
+end