puppet 4.2.0 → 4.3.0

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

@@ -132,12 +132,41 @@ class Puppet::Pops::Parser::Lexer2
     "attr"     => [:ATTR,     'attr',     4],
     "private"  => [:PRIVATE,  'private',  7],
   }
+
   KEYWORDS.each {|k,v| v[1].freeze; v.freeze }
   KEYWORDS.freeze
 
+  # We maintain two different tables of tokens for the constructs
+  # introduced by application management. Which ones we use is decided in
+  # +initvars+; by selecting one or the other variant, we select whether we
+  # hit the appmgmt-specific code paths
+  APP_MANAGEMENT_TOKENS = {
+    :with_appm => {
+      "application"  => [:APPLICATION,  'application',  11],
+      "consumes"     => [:CONSUMES,  'consumes',  8],
+      "produces"     => [:PRODUCES,  'produces',  8],
+      "site"         => [:SITE,      'site',  4]
+    },
+    :without_appm => {
+      "application"  => [:APPLICATION_R,  'application',  11],
+      "consumes"     => [:CONSUMES_R,  'consumes',  8],
+      "produces"     => [:PRODUCES_R,  'produces',  8],
+      "site"         => [:SITE_R,      'site',  4]
+    }
+  }
+
+  APP_MANAGEMENT_TOKENS.each do |_, variant|
+    variant.each { |_,v| v[1].freeze; v.freeze }
+    variant.freeze
+  end
+  APP_MANAGEMENT_TOKENS.freeze
+
   # Reverse lookup of keyword name to string
   KEYWORD_NAMES = {}
   KEYWORDS.each {|k, v| KEYWORD_NAMES[v[0]] = k }
+  APP_MANAGEMENT_TOKENS.each do |_, variant|
+    variant.each { |k,v| KEYWORD_NAMES[v[0]] = k }
+  end
   KEYWORD_NAMES.freeze
 
   PATTERN_WS        = %r{[[:blank:]\r]+}
@@ -247,6 +276,8 @@ class Puppet::Pops::Parser::Lexer2
       :brace_count => 0,
       :after => nil,
     }
+    appm_mode = Puppet[:app_management] ? :with_appm : :without_appm
+    @appm_keywords = APP_MANAGEMENT_TOKENS[appm_mode]
   end
 
   # Scans all of the content and returns it in an array
@@ -604,7 +635,7 @@ class Puppet::Pops::Parser::Lexer2
 
       value = scn.scan(PATTERN_BARE_WORD)
       if value && value =~ PATTERN_NAME
-        emit_completed(KEYWORDS[value] || [:NAME, value.freeze, scn.pos - before], before)
+        emit_completed(KEYWORDS[value] || @appm_keywords[value] || [:NAME, value.freeze, scn.pos - before], before)
       elsif value
         emit_completed([:WORD, value.freeze, scn.pos - before], before)
       else

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

@@ -5,7 +5,7 @@ class Puppet::Pops::Parser::Locator
   # performed of the given source string.
   #
   def self.locator(string, file, index = nil, char_offsets = false)
-    if(char_offsets)
+    if char_offsets
       LocatorForChars.new(string, file, index);
     else
       Locator19.new(string, file, index)

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

@@ -50,21 +50,28 @@ class Puppet::Pops::Parser::Parser
   # lexer. Line and position is produced if the given semantic is a Positioned object and have been given an offset.
   #
   def error(semantic, message)
-    semantic = semantic.current() if semantic.is_a?(Puppet::Pops::Model::Factory)
-    # Adapt the model so it is possible to get location information.
-    # The model may not have been added to the source tree, so give it the lexer's locator
-    # directly instead of searching for the root Program where the locator is normally stored.
-    #
-    if semantic.is_a?(Puppet::Pops::Model::Positioned)
-      adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(semantic)
-      adapter.locator = @lexer.locator
+    except = Puppet::ParseError.new(message)
+    if semantic.is_a?(Puppet::Pops::Parser::LexerSupport::TokenValue)
+      except.file = semantic[:file];
+      except.line = semantic[:line];
+      except.pos = semantic[:pos];
     else
-      adapter = nil
+      semantic = semantic.current() if semantic.is_a?(Puppet::Pops::Model::Factory)
+
+      # Adapt the model so it is possible to get location information.
+      # The model may not have been added to the source tree, so give it the lexer's locator
+      # directly instead of searching for the root Program where the locator is normally stored.
+      #
+      if semantic.is_a?(Puppet::Pops::Model::Positioned)
+        adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(semantic)
+        adapter.locator = @lexer.locator
+      else
+        adapter = nil
+      end
+      except.file = @lexer.locator.file
+      except.line = adapter.line if adapter
+      except.pos = adapter.pos if adapter
     end
-    except = Puppet::ParseError.new(message)
-    except.file = @lexer.locator.file
-    except.line = adapter.line if adapter
-    except.pos = adapter.pos if adapter
     raise except
   end
 
@@ -167,6 +174,11 @@ class Puppet::Pops::Parser::Parser
     definition
   end
 
+  def add_mapping(produces)
+    # The actual handling of mappings happens in PopsBridge
+    add_definition(produces)
+  end
+
   # Transforms an array of expressions containing literal name expressions to calls if followed by an
   # expression, or expression list
   #

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/enumeration.rb

@@ -25,8 +25,7 @@ class Puppet::Pops::Types::Enumeration
       o.each
     when Puppet::Pops::Types::PIntegerType
       # Not enumerable if representing an infinite range
-      return nil if o.to.nil? || o.from.nil?
-      o.each
+      o.enumerable? ? o.each : nil
     else
       nil
     end

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

@@ -1,6 +1,7 @@
 # Utility module for type assertion
 #
-module Puppet::Pops::Types::TypeAsserter
+module Puppet::Pops::Types
+module TypeAsserter
   # Asserts that a type_to_check is assignable to required_type and raises
   # a {Puppet::ParseError} if that's not the case
   #
@@ -9,8 +10,9 @@ module Puppet::Pops::Types::TypeAsserter
   # @param type_to_check [PAnyType] Type to check against the required type
   # @return The type_to_check argument
   #
+  # @api public
   def self.assert_assignable(subject, expected_type, type_to_check)
-    check_assignability(Puppet::Pops::Types::TypeCalculator.singleton, subject, expected_type, type_to_check)
+    report_type_mismatch(subject, expected_type, type_to_check) unless expected_type.assignable?(type_to_check)
     type_to_check
   end
 
@@ -23,23 +25,22 @@ module Puppet::Pops::Types::TypeAsserter
   # @param nil_ok [Boolean] Can be true to allow nil value. Optional and defaults to false
   # @return The value argument
   #
+  # @api public
   def self.assert_instance_of(subject, expected_type, value, nil_ok = false)
-    if !(value.nil? && nil_ok)
-      tc = Puppet::Pops::Types::TypeCalculator.singleton
-      check_assignability(tc, subject, expected_type, tc.infer_set(value), true)
+    unless value.nil? && nil_ok
+      report_type_mismatch(subject, expected_type, TypeCalculator.singleton.infer_set(value).generalize) unless expected_type.instance?(value)
     end
     value
   end
 
-  def self.check_assignability(tc, subject, expected_type, actual_type, inferred = false)
-    unless tc.assignable?(expected_type, actual_type)
-      # Do not give all the details for inferred types - i.e. format as Integer, instead of Integer[n, n] for exact
-      # value, which is just confusing. (OTOH: may need to revisit, or provide a better "type diff" output).
-      #
-      actual_type = Puppet::Pops::Types::TypeCalculator.generalize!(actual_type) if inferred
-      raise Puppet::Pops::Types::TypeAssertionError.new(
-        "#{subject} value has wrong type, expected #{tc.string(expected_type)}, actual #{tc.string(actual_type)}", expected_type, actual_type)
-    end
+  def self.report_type_mismatch(subject, expected_type, actual_type)
+    # Do not give all the details for inferred types - i.e. format as Integer, instead of Integer[n, n] for exact
+    # value, which is just confusing. (OTOH: may need to revisit, or provide a better "type diff" output).
+    #
+    raise TypeAssertionError.new(
+        "#{subject} value has wrong type, expected #{expected_type}, actual #{actual_type}", expected_type, actual_type)
   end
-  private_class_method :check_assignability
+  private_class_method :report_type_mismatch
+end
 end
+

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

@@ -1,3 +1,4 @@
+
 module Puppet::Pops::Types
   # Raised when an assertion of actual type against an expected type fails.
   #