puppet 3.8.1-x86-mingw32 → 3.8.2-x86-mingw32

data/lib/puppet/pops/parser/epp_support.rb

@@ -183,7 +183,7 @@ module Puppet::Pops::Parser::EppSupport
       until scanner.eos?
         part = @scanner.scan_until(/(<%)|\z/)
         if @skip_leading
-          part.gsub!(/^[ \t]*\r?\n?/,'')
+          part.sub!(/^[ \t]*\r?(?:\n|\z)?/,'')
           @skip_leading = false
         end
         # The spec for %%> is to transform it into a literal %>. This is done here, as %%> otherwise would go
@@ -208,7 +208,7 @@ module Puppet::Pops::Parser::EppSupport
           # trim trailing whitespace on same line from accumulated s
           # return text and signal switch to pp mode
           @scanner.getch # drop the -
-          s.gsub!(/\r?\n?[ \t]*<%\z/, '')
+          s.sub!(/[ \t]*<%\z/, '')
           @mode = :epp
           return s
 
@@ -240,6 +240,8 @@ module Puppet::Pops::Parser::EppSupport
             @mode = :error
             return s
           end
+          # Always trim leading whitespace on the same line when there is a comment
+          s.sub!(/[ \t]*\z/, '')
           @skip_leading = true if part.end_with?("-%>")
           # Continue scanning for more text
 

data/lib/puppet/pops/parser/lexer2.rb

@@ -131,7 +131,13 @@ class Puppet::Pops::Parser::Lexer2
     "type"     => [:TYPE,     'type',     4],
     "attr"     => [:ATTR,     'attr',     4],
     "private"  => [:PRIVATE,  'private',  7],
+    # The following tokens exist in reserved form. Later they will be made
+    # live subject to a feature switch.
+    "application"  => [:APPLICATION_R,  'application',  11],
+    "consumes"     => [:CONSUMES_R,  'consumes',  8],
+    "produces"     => [:PRODUCES_R,  'produces',  8],
   }
+
   KEYWORDS.each {|k,v| v[1].freeze; v.freeze }
   KEYWORDS.freeze
 

data/lib/puppet/pops/patterns.rb

@@ -38,6 +38,9 @@ module Puppet::Pops::Patterns
   # Note, that only the final segment may start with an underscore.
   VAR_NAME = %r{\A(:?(::)?[a-z]\w*)*(:?(::)?[a-z_]\w*)\z}
 
+  # PARAM_NAME matches the name part of a parameter (The $ character is not included)
+  PARAM_NAME = %r{\A[a-z_]\w*\z}
+
   # A Numeric var name must be the decimal number 0, or a decimal number not starting with 0
   NUMERIC_VAR_NAME = %r{\A(?:0|(?:[1-9][0-9]*))\z}
 

data/lib/puppet/pops/types/type_parser.rb

@@ -356,7 +356,7 @@ class Puppet::Pops::Types::TypeParser
       if parameters.size == 1
         case parameters[0]
         when Integer
-          TYPES.range(parameters[0], parameters[0])
+          TYPES.range(parameters[0], :default)
         when :default
           TYPES.integer # unbound
         end
@@ -370,7 +370,7 @@ class Puppet::Pops::Types::TypeParser
       if parameters.size == 1
         case parameters[0]
         when Integer, Float
-          TYPES.float_range(parameters[0], parameters[0])
+          TYPES.float_range(parameters[0], :default)
         when :default
           TYPES.float # unbound
         end

data/lib/puppet/pops/validation/checker4_0.rb

@@ -427,6 +427,10 @@ class Puppet::Pops::Validation::Checker4_0
     if o.name =~ /^(?:0x)?[0-9]+$/
       acceptor.accept(Issues::ILLEGAL_NUMERIC_PARAMETER, o, :name => o.name)
     end
+
+    unless o.name =~ Puppet::Pops::Patterns::PARAM_NAME
+      acceptor.accept(Issues::ILLEGAL_PARAM_NAME, o, :name => o.name)
+    end
   end
 
   #relationship_side: resource
@@ -476,7 +480,11 @@ class Puppet::Pops::Validation::Checker4_0
   end
 
   def check_ReservedWord(o)
-    acceptor.accept(Issues::RESERVED_WORD, o, :word => o.word)
+    if o.future
+      acceptor.accept(Issues::FUTURE_RESERVED_WORD, o, :word => o.word)
+    else
+      acceptor.accept(Issues::RESERVED_WORD, o, :word => o.word)
+    end
   end
 
   def check_SelectorExpression(o)

data/lib/puppet/pops/validation/validator_factory_4_0.rb

@@ -23,7 +23,9 @@ class Puppet::Pops::Validation::ValidatorFactory_4_0 < Puppet::Pops::Validation:
     p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
     p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
 
-    p[Issues::NAME_WITH_HYPHEN]             = :error
+    p[Issues::FUTURE_RESERVED_WORD]          = :deprecation
+
+    p[Issues::NAME_WITH_HYPHEN]              = :error
     p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
     p
   end

data/lib/puppet/provider/group/pw.rb

@@ -7,6 +7,7 @@ Puppet::Type.type(:group).provide :pw, :parent => Puppet::Provider::NameService:
   has_features :manages_members
 
   defaultfor :operatingsystem => [:freebsd, :dragonfly]
+  confine    :operatingsystem => [:freebsd, :dragonfly]
 
   options :members, :flag => "-M", :method => :mem
 

data/lib/puppet/provider/service/debian.rb

@@ -38,7 +38,8 @@ Puppet::Type.type(:service).provide :debian, :parent => :init do
     # See x-man-page://invoke-rc.d
     if [104, 106].include?($CHILD_STATUS.exitstatus)
       return :true
-    elsif [105].include?($CHILD_STATUS.exitstatus)
+    elsif [101, 105].include?($CHILD_STATUS.exitstatus)
+      # 101 is action not allowed, which means we have to do the check manually.
       # 105 is unknown, which generally means the iniscript does not support query
       # The debian policy states that the initscript should support methods of query
       # For those that do not, peform the checks manually

data/lib/puppet/provider/user/pw.rb

@@ -8,6 +8,7 @@ Puppet::Type.type(:user).provide :pw, :parent => Puppet::Provider::NameService::
   has_features :manages_homedir, :allows_duplicates, :manages_passwords, :manages_expiry, :manages_shell
 
   defaultfor :operatingsystem => [:freebsd, :dragonfly]
+  confine    :operatingsystem => [:freebsd, :dragonfly]
 
   options :home, :flag => "-d", :method => :dir
   options :comment, :method => :gecos

data/lib/puppet/resource.rb

@@ -430,6 +430,8 @@ class Puppet::Resource
     result.environment = environment
     result.instance_variable_set(:@rstype, resource_type)
 
+    future_parser_not_in_use = !Puppet.future_parser?(result.environment)
+
     to_hash.each do |p, v|
       if v.is_a?(Puppet::Resource)
         v = Puppet::Resource.new(v.type, v.title)
@@ -442,7 +444,7 @@ class Puppet::Resource
         end
       end
 
-      if !Puppet.future_parser?
+      if future_parser_not_in_use # !Puppet.future_parser?
         # If the value is an array with only one value, then
         # convert it to a single value.  This is largely so that
         # the database interaction doesn't have to worry about

data/lib/puppet/resource/type.rb

@@ -82,8 +82,10 @@ class Puppet::Resource::Type
 
     # External documentation uses "parameters" but the internal name
     # is "arguments"
-    data['parameters'] = arguments.dup unless arguments.empty?
-
+    # Dump any arguments as source
+    data['parameters'] = Hash[arguments.map do |k,v|
+                                [k, v.respond_to?(:source_text) ? v.source_text : v]
+                              end]
     data['name'] = name
 
     unless RESOURCE_KINDS_TO_EXTERNAL_NAMES.has_key?(type)

data/lib/puppet/util.rb

@@ -292,7 +292,15 @@ module Util
       $stdout.reopen(stdout)
       $stderr.reopen(stderr)
 
-      3.upto(256){|fd| IO::new(fd).close rescue nil}
+      begin
+        Dir.foreach('/proc/self/fd') do |f|
+          if f != '.' && f != '..' && f.to_i >= 3
+            IO::new(f.to_i).close rescue nil
+          end
+        end
+      rescue Errno::ENOENT # /proc/self/fd not found
+        3.upto(256){|fd| IO::new(fd).close rescue nil}
+      end
 
       block.call if block
     end

data/lib/puppet/util/log.rb

@@ -336,7 +336,7 @@ class Puppet::Util::Log
   # If they pass a source in to us, we make sure it is a string, and
   # we retrieve any tags we can.
   def source=(source)
-    if source.respond_to?(:path)
+    if defined?(Puppet::Type) && source.is_a?(Puppet::Type)
       @source = source.path
       source.tags.each { |t| tag(t) }
       self.file = source.file

data/lib/puppet/version.rb

@@ -7,7 +7,7 @@
 
 
 module Puppet
-  PUPPETVERSION = '3.8.1'
+  PUPPETVERSION = '3.8.2'
 
   ##
   # version is a public API method intended to always provide a fast and

data/spec/integration/parser/compiler_spec.rb

@@ -121,15 +121,17 @@ describe "Puppet::Parser::Compiler" do
     end
   end
 
-  it "should recompute the version after input files are re-parsed" do
+  it 'should recompute the version after input files are re-parsed' do
     Puppet[:code] = 'class foo { }'
-    Time.stubs(:now).returns(1)
+    first_time = Time.at(1)
+    second_time = Time.at(200)
+    Time.stubs(:now).returns(first_time)
     node = Puppet::Node.new('mynode')
-    Puppet::Parser::Compiler.compile(node).version.should == 1
-    Time.stubs(:now).returns(2)
-    Puppet::Parser::Compiler.compile(node).version.should == 1 # no change because files didn't change
-    Puppet::Resource::TypeCollection.any_instance.stubs(:stale?).returns(true).then.returns(false) # pretend change
-    Puppet::Parser::Compiler.compile(node).version.should == 2
+    expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i)
+    Time.stubs(:now).returns(second_time)
+    expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i) # no change because files didn't change
+    Puppet[:code] = nil
+    expect(Puppet::Parser::Compiler.compile(node).version).to eq(second_time.to_i)
   end
 
   ['class', 'define', 'node'].each do |thing|

data/spec/integration/parser/future_compiler_spec.rb

@@ -185,15 +185,17 @@ describe "Puppet::Parser::Compiler" do
       end
     end
 
-    it "should recompute the version after input files are re-parsed" do
+    it 'should recompute the version after input files are re-parsed' do
       Puppet[:code] = 'class foo { }'
-      Time.stubs(:now).returns(1)
+      first_time = Time.at(1)
+      second_time = Time.at(200)
+      Time.stubs(:now).returns(first_time)
       node = Puppet::Node.new('mynode')
-      Puppet::Parser::Compiler.compile(node).version.should == 1
-      Time.stubs(:now).returns(2)
-      Puppet::Parser::Compiler.compile(node).version.should == 1 # no change because files didn't change
-      Puppet::Resource::TypeCollection.any_instance.stubs(:stale?).returns(true).then.returns(false) # pretend change
-      Puppet::Parser::Compiler.compile(node).version.should == 2
+      expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i)
+      Time.stubs(:now).returns(second_time)
+      expect(Puppet::Parser::Compiler.compile(node).version).to eq(first_time.to_i) # no change because files didn't change
+      Puppet[:code] = nil
+      expect(Puppet::Parser::Compiler.compile(node).version).to eq(second_time.to_i)
     end
 
     ['define', 'class', 'node'].each do |thing|

data/spec/integration/parser/scope_spec.rb

@@ -32,6 +32,25 @@ describe "Two step scoping for variables" do
         end
       end
     end
+
+    describe 'handles 3.x/4.x functions' do
+      it 'can call a 3.x function via call_function' do
+        expect_the_message_to_be('yes') do <<-MANIFEST
+          $msg = inline_template('<%= scope().call_function("fqdn_rand", [30]).to_i <= 30 ? "yes" : "no" %>')
+          notify { 'something': message => $msg }
+          MANIFEST
+        end
+      end
+
+      it 'can cannot call a 4.x function via call_function' do
+        expect do 
+          catalog = compile_to_catalog(<<-MANIFEST)
+          $msg = inline_template('<%= scope().call_function("with", ["yes"]) { |x| x } %>')
+          notify { 'something': message => $msg }
+          MANIFEST
+        end.to raise_error
+      end
+    end
   end
 
   context 'using future parser' do
@@ -120,6 +139,24 @@ describe "Two step scoping for variables" do
         MANIFEST
       end
     end
+
+    describe 'handles 3.x/4.x functions' do
+      it 'can call a 3.x function via call_function' do
+        expect_the_message_to_be('yes') do <<-MANIFEST
+          $msg = inline_template('<%= scope().call_function("fqdn_rand", [30]).to_i <= 30 ? "yes" : "no" %>')
+          notify { 'something': message => $msg }
+          MANIFEST
+        end
+      end
+
+      it 'it can call a 4.x function via call_function' do
+        expect_the_message_to_be('yes') do <<-MANIFEST
+          $msg = inline_template('<%= scope().call_function("with", ["yes"]) { |x| x } %>')
+          notify { 'something': message => $msg }
+          MANIFEST
+        end
+      end
+    end
   end
 
   shared_examples_for "the scope" do

data/spec/unit/environments_spec.rb

@@ -642,6 +642,8 @@ config_version=$vardir/random/scripts
     end
 
     def expired?(env_name)
+      # make expired? idempotent
+      return true if @expired_envs.include? (env_name)
       @expired_envs << env_name
       @expiration_sequence.pop
     end

data/spec/unit/functions/hiera_spec.rb

@@ -112,7 +112,7 @@ describe 'when calling' do
 
     it 'should use the array resolution_type' do
       Hiera.any_instance.expects(:lookup).with { |*args| args[4].should be(:array) }.returns(%w[foo bar baz])
-      hiera_include.expects(:call_function).with('include', %w[foo bar baz])
+      hiera_include.expects(:call_function_with_scope).with(scope, 'include', %w[foo bar baz])
       hiera_include.call(scope, 'key', {'key' => 'foo_result'})
     end
 
@@ -122,7 +122,7 @@ describe 'when calling' do
     end
 
     it 'should use default block' do
-      hiera_include.expects(:call_function).with('include', %w[key foo])
+      hiera_include.expects(:call_function_with_scope).with(scope,'include', %w[key foo])
       hiera_include.call(scope, 'foo') { |k| ['key', k] }
     end
   end

data/spec/unit/parser/scope_spec.rb

@@ -33,6 +33,15 @@ describe Puppet::Parser::Scope do
     end
   end
 
+  it "should generate a simple string when inspecting a scope" do
+    @scope.inspect.should eq("Scope()")
+  end
+
+  it "should generate a simple string when inspecting a scope with a resource" do
+    @scope.resource="foo::bar"
+    @scope.inspect.should eq("Scope(foo::bar)")
+  end
+
   it "should return a scope for use in a test harness" do
     create_test_scope_for_node("node_name_foo").should be_a_kind_of(Puppet::Parser::Scope)
   end

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

@@ -0,0 +1,19 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/types/type_factory'
+
+describe 'when converting to 3.x' do
+  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 = Puppet::Pops::Evaluator::Runtime3Converter.instance.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 = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(t)
+    expect(converted).to eql(['class', 'kermit'])
+  end
+end

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

@@ -41,7 +41,7 @@ describe 'Puppet::Pops::Impl::EvaluatorImpl' do
 
       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(var('::a')+literal(2)), var('::a'))
+        local_scope_block   = block( var('a').set(literal(100)), var('b').set(var('::a')+literal(2)), var('b'))
         evaluate_l(top_scope_block, local_scope_block).should == 6
       end
 

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

@@ -91,12 +91,25 @@ describe 'Lexer2' do
     "true"     => :BOOLEAN,
     "in"       => :IN,
     "unless"   => :UNLESS,
+    "private"  => :PRIVATE,
+    "type"     => :TYPE,
+    "attr"     => :ATTR,
   }.each do |string, name|
     it "should lex a keyword from '#{string}'" do
       tokens_scanned_from(string).should match_tokens2(name)
     end
   end
 
+  {
+    "application"  => :APPLICATION_R,
+    "consumes"     => :CONSUMES_R,
+    "produces"     => :PRODUCES_R,
+  }.each do |string, name|
+    it "should lex a (future reserved) 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
@@ -535,7 +548,7 @@ describe 'Lexer2' do
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
-      [:RENDER_STRING, "just text\n"]
+      [:RENDER_STRING, "      just text\n"]
       )
     end
 
@@ -551,7 +564,39 @@ describe 'Lexer2' do
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
-      [:RENDER_STRING, "just text\n"]
+      [:RENDER_STRING, "      just text\n"]
+      )
+    end
+
+    it 'epp comments strips left whitespace when preceding is right trim' do
+      code = <<-CODE
+      This is <% $x=10 -%>
+      space-before-me-but-not-after   <%# This is an epp comment %>
+      just text
+      CODE
+      expect(epp_tokens_scanned_from(code)).to match_tokens2(
+      :EPP_START,
+      [:RENDER_STRING, "      This is "],
+      [:VARIABLE, "x"],
+      :EQUALS,
+      [:NUMBER, "10"],
+      [:RENDER_STRING, "      space-before-me-but-not-after\n      just text\n"]
+      )
+    end
+
+    it 'epp comments strips left whitespace on same line when preceding is not right trim' do
+      code = <<-CODE
+      This is <% $x=10 %>
+      <%# This is an epp comment -%>
+      just text
+      CODE
+      expect(epp_tokens_scanned_from(code)).to match_tokens2(
+      :EPP_START,
+      [:RENDER_STRING, "      This is "],
+      [:VARIABLE, "x"],
+      :EQUALS,
+      [:NUMBER, "10"],
+      [:RENDER_STRING, "\n      just text\n"]
       )
     end
 
@@ -566,7 +611,7 @@ describe 'Lexer2' do
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
-      [:RENDER_STRING, "<% this is escaped epp %>\n"]
+      [:RENDER_STRING, "      <% this is escaped epp %>\n"]
       )
     end