puppet 3.3.2 → 3.4.0.rc1

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

@@ -148,8 +148,8 @@ class Puppet::Pops::Parser::Lexer
   TOKENS.add_tokens(
   '['   => :LBRACK,
   ']'   => :RBRACK,
-  #    '{'   => :LBRACE, # Specialized to handle lambda
-  '}'   => :RBRACE,
+  #    '{'   => :LBRACE, # Specialized to handle lambda and brace count
+  #    '}'   => :RBRACE, # Specialized to handle brace count
   '('   => :LPAREN,
   ')'   => :RPAREN,
   '='   => :EQUALS,
@@ -194,7 +194,6 @@ class Puppet::Pops::Parser::Lexer
   "<dqstring between two interpolations>" => :DQMID,
   "<dqstring after final interpolation>" => :DQPOST,
   "<boolean>" => :BOOLEAN,
-  "<lambda start>" => :LAMBDA, # A LBRACE followed by '|'
   "<select start>" => :SELBRACE # A QMARK followed by '{'
   )
 
@@ -214,10 +213,6 @@ class Puppet::Pops::Parser::Lexer
       REGEX_INTRODUCING_TOKENS.include? context[:after]
     end
 
-    IN_STRING_INTERPOLATION = Proc.new do |context|
-      context[:string_interpolation_depth] > 0
-    end
-
     DASHED_VARIABLES_ALLOWED = Proc.new do |context|
       Puppet[:allow_variables_with_dashes]
     end
@@ -227,20 +222,6 @@ class Puppet::Pops::Parser::Lexer
     end
   end
 
-  # LBRACE needs look ahead to differentiate between '{' and a '{'
-  # followed by a '|' (start of lambda) The racc grammar can only do one
-  # token lookahead.
-  #
-  TOKENS.add_token :LBRACE, /\{/ do | lexer, value |
-    if lexer.match?(/[ \t\r]*\|/)
-      [TOKENS[:LAMBDA], value]
-    elsif lexer.lexing_context[:after] == :QMARK
-      [TOKENS[:SELBRACE], value]
-    else
-      [TOKENS[:LBRACE], value]
-    end
-  end
-
   # Numbers are treated separately from names, so that they may contain dots.
   TOKENS.add_token :NUMBER, %r{\b(?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?)\b} do |lexer, value|
     lexer.assert_numeric(value)
@@ -305,10 +286,31 @@ class Puppet::Pops::Parser::Lexer
     lexer.tokenize_interpolated_string(DQ_initial_token_types)
   end
 
-  TOKENS.add_token :DQCONT, /\}/ do |lexer, value|
-    lexer.tokenize_interpolated_string(DQ_continuation_token_types)
+
+  # LBRACE needs look ahead to differentiate between '{' and a '{'
+  # followed by a '|' (start of lambda) The racc grammar can only do one
+  # token lookahead.
+  #
+  TOKENS.add_token :LBRACE, "{" do |lexer, value|
+    lexer.lexing_context[:brace_count] += 1
+    if lexer.lexing_context[:after] == :QMARK
+      [TOKENS[:SELBRACE], value]
+    else
+      [TOKENS[:LBRACE], value]
+    end
+  end
+
+  # RBRACE needs to differentiate between a regular brace that is part of
+  # syntax and one that is the ending of a string interpolation.
+  TOKENS.add_token :RBRACE, "}" do |lexer, value|
+    context = lexer.lexing_context
+    if context[:interpolation_stack].empty? || context[:brace_count] != context[:interpolation_stack][-1]
+      context[:brace_count] -= 1
+      [TOKENS[:RBRACE], value]
+    else
+      lexer.tokenize_interpolated_string(DQ_continuation_token_types)
+    end
   end
-  TOKENS[:DQCONT].acceptable_when Contextual::IN_STRING_INTERPOLATION
 
   TOKENS.add_token :DOLLAR_VAR_WITH_DASH, %r{\$(?:::)?(?:[-\w]+::)*[-\w]+} do |lexer, value|
     lexer.warn_if_variable_has_hyphen(value)
@@ -339,9 +341,21 @@ class Puppet::Pops::Parser::Lexer
     # reference.
     #
     if lexer.match?(%r{[ \t\r]*\(})
-      [TOKENS[:NAME],value]
+      # followed by ( is a function call
+      [TOKENS[:NAME], value]
+
+    elsif kwd_token = KEYWORDS.lookup(value)
+      # true, false, if, unless, case, and undef are keywords that cannot be used as variables
+      # but node, and several others are variables
+      if [ :TRUE, :FALSE ].include?(kwd_token.name)
+        [ TOKENS[:BOOLEAN], eval(value) ]
+      elsif [ :IF, :UNLESS, :CASE, :UNDEF ].include?(kwd_token.name)
+        [kwd_token, value]
+      else
+        [TOKENS[:VARIABLE], value]
+      end
     else
-      [TOKENS[:VARIABLE],value]
+      [TOKENS[:VARIABLE], value]
     end
 
   end
@@ -404,7 +418,7 @@ class Puppet::Pops::Parser::Lexer
 
   def file=(file)
     @file = file
-    contents = File.exists?(file) ? File.read(file) : ""
+    contents = Puppet::FileSystem::File.exist?(file) ? File.read(file) : ""
     @scanner = StringScanner.new(contents)
     @locator = Locator.new(contents, multibyte?)
   end
@@ -501,7 +515,8 @@ class Puppet::Pops::Parser::Lexer
       :start_of_line => true,
       :offset => 0,      # byte offset before where token starts
       :end_offset => 0,  # byte offset after scanned token
-      :string_interpolation_depth => 0
+      :brace_count => 0,  # nested depth of braces
+      :interpolation_stack => []   # matching interpolation brace level
     }
   end
 
@@ -592,8 +607,11 @@ class Puppet::Pops::Parser::Lexer
       end
 
       lexing_context[:after] = final_token.name unless newline
-      lexing_context[:string_interpolation_depth] += 1 if final_token.name == :DQPRE
-      lexing_context[:string_interpolation_depth] -= 1 if final_token.name == :DQPOST
+      if final_token.name == :DQPRE
+        lexing_context[:interpolation_stack] << lexing_context[:brace_count]
+      elsif final_token.name == :DQPOST
+        lexing_context[:interpolation_stack].pop
+      end
 
       value = token_value[:value]
 

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

@@ -63,7 +63,7 @@ class Puppet::Pops::Parser::Parser
 
   # Parses a file expected to contain pp DSL logic.
   def parse_file(file)
-    unless FileTest.exist?(file)
+    unless Puppet::FileSystem::File.exist?(file)
       unless file =~ /\.pp$/
         file = file + ".pp"
       end

data/lib/puppet/pops/patterns.rb

@@ -18,18 +18,18 @@ module Puppet::Pops::Patterns
 
   # NAME matches a name the same way as the lexer.
   # This name includes hyphen, which may be illegal in variables, and names in general.
-  NAME = %r{((::)?[a-z0-9][-\w]*)(::[a-z0-9][-\w]*)*}
+  NAME = %r{\A((::)?[a-z0-9]\w*)(::[a-z0-9]\w*)*\z}
 
   # CLASSREF_EXT matches a class reference the same way as the lexer - i.e. the external source form
   # where each part must start with a capital letter A-Z.
   # This name includes hyphen, which may be illegal in some cases.
   #
-  CLASSREF_EXT = %r{((::){0,1}[A-Z][-\w]*)+}
+  CLASSREF_EXT = %r{\A((::){0,1}[A-Z][-\w]*)+\z}
 
-  # CLASSREF matches a class reference the way it is represented internall in the
+  # CLASSREF matches a class reference the way it is represented internally in the
   # model (i.e. in lower case).
   # This name includes hyphen, which may be illegal in some cases.
   #
-  CLASSREF = %r{((::){0,1}[a-z][-\w]*)+}
+  CLASSREF = %r{\A((::){0,1}[a-z][-\w]*)+\z}
 
 end

data/lib/puppet/pops/utils.rb

@@ -35,7 +35,7 @@ module Puppet::Pops::Utils
           radix = 10
           if match[1].to_s.length > 0
             radix = 16
-          elsif match[2].to_s.length > 0 && match[2][0] == '0'
+          elsif match[2].to_s.length > 1 && match[2][0] == '0'
             radix = 8
           end
           [Integer(match[0], radix), radix]

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

@@ -20,7 +20,7 @@ class Puppet::Pops::Validation::Checker3_1
   def initialize(diagnostics_producer)
     @@check_visitor       ||= Puppet::Pops::Visitor.new(nil, "check", 0, 0)
     @@rvalue_visitor      ||= Puppet::Pops::Visitor.new(nil, "rvalue", 0, 0)
-    @@hostname_visitor    ||= Puppet::Pops::Visitor.new(nil, "hostname", 1, 1)
+    @@hostname_visitor    ||= Puppet::Pops::Visitor.new(nil, "hostname", 1, 2)
     @@assignment_visitor  ||= Puppet::Pops::Visitor.new(nil, "assign", 0, 1)
     @@query_visitor       ||= Puppet::Pops::Visitor.new(nil, "query", 0, 0)
     @@top_visitor         ||= Puppet::Pops::Visitor.new(nil, "top", 1, 1)
@@ -45,8 +45,9 @@ class Puppet::Pops::Validation::Checker3_1
   end
 
   # Performs check if this is a vaid hostname expression
-  def hostname(o, semantic)
-    @@hostname_visitor.visit_this(self, o, semantic)
+  # @param single_feature_name [String, nil] the name of a single valued hostname feature of the value's container. e.g. 'parent'
+  def hostname(o, semantic, single_feature_name = nil)
+    @@hostname_visitor.visit_this(self, o, semantic, single_feature_name)
   end
 
   # Performs check if this is valid as a query
@@ -125,7 +126,7 @@ class Puppet::Pops::Validation::Checker3_1
     case o.left_expr
     when Model::QualifiedName
       # allows many keys, but the name should really be a QualifiedReference
-      acceptor.accept(Issues::DEPRECATED_NAME_AS_TYPE, o, :name => o.value)
+      acceptor.accept(Issues::DEPRECATED_NAME_AS_TYPE, o, :name => o.left_expr.value)
     when Model::QualifiedReference
       # ok, allows many - this is a resource reference
 
@@ -255,6 +256,7 @@ class Puppet::Pops::Validation::Checker3_1
   def check_NodeDefinition(o)
     # Check that hostnames are valid hostnames (or regular expressons)
     hostname(o.host_matches, o)
+    hostname(o.parent, o, 'parent') unless o.parent.nil?
     top(o.eContainer, o)
   end
 
@@ -385,11 +387,14 @@ class Puppet::Pops::Validation::Checker3_1
   #--- HOSTNAME CHECKS
 
   # Transforms Array of host matching expressions into a (Ruby) array of AST::HostName
-  def hostname_Array(o, semantic)
-    o.each {|x| hostname x, semantic }
+  def hostname_Array(o, semantic, single_feature_name)
+    if single_feature_name
+      acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=>single_feature_name, :container=>semantic})
+    end
+    o.each {|x| hostname(x, semantic, false) }
   end
 
-  def hostname_String(o, semantic)
+  def hostname_String(o, semantic, single_feature_name)
     # The 3.x checker only checks for illegal characters - if matching /[^-\w.]/ the name is invalid,
     # but this allows pathological names like "a..b......c", "----"
     # TODO: Investigate if more illegal hostnames should be flagged.
@@ -399,11 +404,11 @@ class Puppet::Pops::Validation::Checker3_1
     end
   end
 
-  def hostname_LiteralValue(o, semantic)
-    hostname_String(o.value.to_s, o)
+  def hostname_LiteralValue(o, semantic, single_feature_name)
+    hostname_String(o.value.to_s, o, single_feature_name)
   end
 
-  def hostname_ConcatenatedString(o, semantic)
+  def hostname_ConcatenatedString(o, semantic, single_feature_name)
     # Puppet 3.1. only accepts a concatenated string without interpolated expressions
     if the_expr = o.segments.index {|s| s.is_a?(Model::TextExpression) }
       acceptor.accept(Issues::ILLEGAL_HOSTNAME_INTERPOLATION, o.segments[the_expr].expr)
@@ -413,32 +418,32 @@ class Puppet::Pops::Validation::Checker3_1
     else
       # corner case, may be ok, but lexer may have replaced with plain string, this is
       # here if it does not
-      hostname_String(o.segments[0], o.segments[0])
+      hostname_String(o.segments[0], o.segments[0], false)
     end
   end
 
-  def hostname_QualifiedName(o, semantic)
-    hostname_String(o.value.to_s, o)
+  def hostname_QualifiedName(o, semantic, single_feature_name)
+    hostname_String(o.value.to_s, o, single_feature_name)
   end
 
-  def hostname_QualifiedReference(o, semantic)
-    hostname_String(o.value.to_s, o)
+  def hostname_QualifiedReference(o, semantic, single_feature_name)
+    hostname_String(o.value.to_s, o, single_feature_name)
   end
 
-  def hostname_LiteralNumber(o, semantic)
+  def hostname_LiteralNumber(o, semantic, single_feature_name)
     # always ok
   end
 
-  def hostname_LiteralDefault(o, semantic)
+  def hostname_LiteralDefault(o, semantic, single_feature_name)
     # always ok
   end
 
-  def hostname_LiteralRegularExpression(o, semantic)
+  def hostname_LiteralRegularExpression(o, semantic, single_feature_name)
     # always ok
   end
 
-  def hostname_Object(o, semantic)
-    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=>'hostname', :container=>semantic})
+  def hostname_Object(o, semantic, single_feature_name)
+    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=> single_feature_name || 'hostname', :container=>semantic})
   end
 
   #---QUERY CHECKS

data/lib/puppet/provider.rb

@@ -40,10 +40,10 @@ class Puppet::Provider
   include Puppet::Util::Warnings
   extend Puppet::Util::Warnings
 
-  require 'puppet/provider/confiner'
+  require 'puppet/confiner'
   require 'puppet/provider/command'
 
-  extend Puppet::Provider::Confiner
+  extend Puppet::Confiner
 
   Puppet::Util.logmethods(self, true)
 
@@ -148,6 +148,7 @@ class Puppet::Provider
   # @raise [Puppet::DevError] if the name does not reference an existing command.
   # @return [String] the absolute path to the found executable for the command
   # @see which
+  # @api public
   def self.command(name)
     name = name.intern
 
@@ -163,7 +164,7 @@ class Puppet::Provider
   end
 
   # Confines this provider to be suitable only on hosts where the given commands are present.
-  # Also see {Puppet::Provider::Confiner#confine} for other types of confinement of a provider by use of other types of
+  # Also see {Puppet::Confiner#confine} for other types of confinement of a provider by use of other types of
   # predicates.
   #
   # @note It is preferred if the commands are not entered with absolute paths as this allows puppet
@@ -173,6 +174,7 @@ class Puppet::Provider
   #   be executing on the system. Each command is specified with a name and the path of the executable.
   # @return [void]
   # @see optional_commands
+  # @api public
   #
   def self.commands(command_specs)
     command_specs.each do |name, path|
@@ -189,6 +191,7 @@ class Puppet::Provider
   #   be executing on the system. Each command is specified with a name and the path of the executable.
   # (@see #has_command)
   # @see commands
+  # @api public
   def self.optional_commands(hash)
     hash.each do |name, target|
       has_command(name, target) do
@@ -221,6 +224,7 @@ class Puppet::Provider
   # @comment a yield [ ] produces {|| ...} in the signature, do not remove the space.
   # @note the name ´has_command´ looks odd in an API context, but makes more sense when seen in the internal
   #   DSL context where a Provider is declaratively defined.
+  # @api public
   #
   def self.has_command(name, path, &block)
     name = name.intern
@@ -485,7 +489,7 @@ class Puppet::Provider
     if @defaults.length > 0
       return "Default for " + @defaults.collect do |f, v|
         "`#{f}` == `#{[v].flatten.join(', ')}`"
-      end.join(" and ") + "."
+      end.sort.join(" and ") + "."
     end
   end
 
@@ -493,7 +497,7 @@ class Puppet::Provider
     if @commands.length > 0
       return "Required binaries: " + @commands.collect do |n, c|
         "`#{c}`"
-      end.join(", ") + "."
+      end.sort.join(", ") + "."
     end
   end
 
@@ -501,7 +505,7 @@ class Puppet::Provider
     if features.length > 0
       return "Supported features: " + features.collect do |f|
         "`#{f}`"
-      end.join(", ") + "."
+      end.sort.join(", ") + "."
     end
   end
 
@@ -602,6 +606,18 @@ class Puppet::Provider
   # fetched state (i.e. what is returned from the {instances} method).
   # @param resources_hash [Hash<{String => Puppet::Resource}>] map from name to resource of resources to prefetch
   # @return [void]
+  # @api public
+
+  # @comment Document post_resource_eval here as it does not exist anywhere else (called from transaction if implemented)
+  # @!method self.post_resource_eval()
+  # @since 3.4.0
+  # @api public
+  # @abstract A subclass may implement this - it is not implemented in the Provider class
+  # This method may be implemented by a provider in order to perform any
+  # cleanup actions needed.  It will be called at the end of the transaction if
+  # any resources in the catalog make use of the provider, regardless of
+  # whether the resources are changed or not and even if resource failures occur.
+  # @return [void]
 
   # @comment Document flush here as it does not exist anywhere (called from transaction if implemented)
   # @!method flush()
@@ -609,5 +625,6 @@ class Puppet::Provider
   # This method may be implemented by a provider in order to flush properties that has not been individually
   # applied to the managed entity's current state.
   # @return [void]
+  # @api public
 end
 

data/lib/puppet/provider/augeas/augeas.rb

@@ -125,7 +125,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
           end
           fail("missing string argument #{narg} for #{cmd}") unless argline[-1]
         elsif f == :comparator
-          argline << sc.scan(/(==|!=|=~|<|<=|>|>=)/)
+          argline << sc.scan(/(==|!=|=~|<=|>=|<|>)/)
           unless argline[-1]
             puts sc.rest
             fail("invalid comparator for command #{cmd}")
@@ -198,6 +198,17 @@ Puppet::Type.type(:augeas).provide(:augeas) do
     end
   end
 
+  def is_numeric?(s)
+    case s
+    when Fixnum
+      true
+    when String
+      s.match(/\A[+-]?\d+?(\.\d+)?\Z/n) == nil ? false : true
+    else
+      false
+    end
+  end
+
   # Used by the need_to_run? method to process get filters. Returns
   # true if there is a match, false if otherwise
   # Assumes a syntax of get /files/path [COMPARATOR] value
@@ -213,10 +224,15 @@ Puppet::Type.type(:augeas).provide(:augeas) do
 
     #check the value in augeas
     result = @aug.get(path) || ''
-    case comparator
-    when "!="
+
+    if ['<', '<=', '>=', '>'].include? comparator and is_numeric?(result) and
+                                                      is_numeric?(arg)
+      resultf = result.to_f
+      argf = arg.to_f
+      return_value = (resultf.send(comparator, argf))
+    elsif comparator == "!="
       return_value = (result != arg)
-    when "=~"
+    elsif comparator == "=~"
       regex = Regexp.new(arg)
       return_value = (result =~ regex)
     else
@@ -292,7 +308,7 @@ Puppet::Type.type(:augeas).provide(:augeas) do
       load_path.flatten!
     end
 
-    if File.exists?("#{Puppet[:libdir]}/augeas/lenses")
+    if Puppet::FileSystem::File.exist?("#{Puppet[:libdir]}/augeas/lenses")
       load_path << "#{Puppet[:libdir]}/augeas/lenses"
     end