puppet 3.2.4 → 3.3.0.rc2

data/lib/puppet/pops/issues.rb

@@ -44,8 +44,12 @@ module Puppet::Pops::Issues
       # Create a Message Data where all hash keys become methods for convenient interpolation
       # in issue text.
       msgdata = MessageData.new(*arg_names)
-      # Evaluate the message block in the msg data's binding
-      msgdata.format(hash, &message_block)
+      begin
+        # Evaluate the message block in the msg data's binding
+        msgdata.format(hash, &message_block)
+      rescue StandardError => e
+        raise RuntimeError, "Error while reporting issue: #{issue_code}. #{e.message}", caller
+      end
     end
   end
 
@@ -91,8 +95,8 @@ module Puppet::Pops::Issues
   #
   # @param issue_code [Symbol] the issue code for the issue used as an identifier, should be the same as the constant
   #   the issue is bound to.
-  # @param *args [Symbol] required arguments that must be passed when formatting the message, may be empty
-  # @param &block [Proc] a block producing the message string, evaluated in a MessageData scope. The produced string
+  # @param args [Symbol] required arguments that must be passed when formatting the message, may be empty
+  # @param block [Proc] a block producing the message string, evaluated in a MessageData scope. The produced string
   #   should not end with a period as additional information may be appended.
   #
   # @see MessageData
@@ -123,7 +127,7 @@ module Puppet::Pops::Issues
   # @todo configuration
   #
   NAME_WITH_HYPHEN = issue :NAME_WITH_HYPHEN, :name do
-    "#{label.a_an_uc(semantic)} may not have a name contain a hyphen. The name '#{name}' is not legal"
+    "#{label.a_an_uc(semantic)} may not have a name containing a hyphen. The name '#{name}' is not legal"
   end
 
   # When a variable name contains a hyphen and these are illegal.

data/lib/puppet/pops/model/ast_transformer.rb

@@ -93,7 +93,7 @@ class Puppet::Pops::Model::AstTransformer
   end
 
   def transform_ArithmeticExpression(o)
-    ast o, AST::ArithmeticOperator, :lval => transform(o.left_expr), :rval=>transform(o.right_expr),
+    ast o, AST::ArithmeticOperator2, :lval => transform(o.left_expr), :rval=>transform(o.right_expr),
     :operator => o.operator.to_s
   end
 
@@ -533,7 +533,7 @@ class Puppet::Pops::Model::AstTransformer
   def transform_IfExpression(o)
     args = { :test => transform(o.test), :statements => transform(o.then_expr) }
     args[:else] = transform(o.else_expr) # Tests say Nop should be there (unless is_nop? o.else_expr), probably not needed
-    result = ast o, AST::IfStatement, args
+    ast o, AST::IfStatement, args
   end
 
   # Unless is not an AST object, instead an AST::IfStatement is used with an AST::Not around the test
@@ -541,9 +541,9 @@ class Puppet::Pops::Model::AstTransformer
   def transform_UnlessExpression(o)
     args = { :test => ast(o, AST::Not, :value => transform(o.test)),
       :statements => transform(o.then_expr) }
-    # AST 3.1 does not allow else on unless in the grammar, but it is ok since unless is encoded as a if !x
+    # AST 3.1 does not allow else on unless in the grammar, but it is ok since unless is encoded as an if !x
     args.merge!({:else => transform(o.else_expr)}) unless is_nop?(o.else_expr)
-    result = ast o, AST::IfStatement, args
+    ast o, AST::IfStatement, args
   end
 
   # Puppet 3.1 AST only supports calling a function by name (it is not possible to produce a function

data/lib/puppet/pops/model/ast_tree_dumper.rb

@@ -131,7 +131,7 @@ class Puppet::Pops::Model::AstTreeDumper < Puppet::Pops::Model::TreeDumper
 
     if o.is_a? String
       o               # A Ruby String, not quoted
-    elsif n = Puppet::Pops::Utils.to_n(o.value)
+    elsif Puppet::Pops::Utils.to_n(o.value)
       o.value         # AST::String that is a number without quotes
     else
       "'#{o.value}'"  # AST::String that is not a number

data/lib/puppet/pops/model/factory.rb

@@ -11,6 +11,8 @@ class Puppet::Pops::Model::Factory
 
   attr_accessor :current
 
+  alias_method :model, :current
+
   # Shared build_visitor, since there are many instances of Factory being used
   @@build_visitor = Puppet::Pops::Visitor.new(self, "build")
   # Initialize a factory with a single object, or a class with arguments applied to build of
@@ -180,10 +182,14 @@ class Puppet::Pops::Model::Factory
   end
 
   # Builds body :) from different kinds of input
-  # @param body [nil] unchanged, produces nil
-  # @param body [Array<Expression>] turns into a BlockExpression
-  # @param body [Expression] produces the given expression
-  # @param body [Object] produces the result of calling #build with body as argument
+  # @overload f_build_body(nothing)
+  #   @param nothing [nil] unchanged, produces nil
+  # @overload f_build_body(array)
+  #   @param array [Array<Expression>] turns into a BlockExpression
+  # @overload f_build_body(expr)
+  #   @param expr [Expression] produces the given expression
+  # @overload f_build_body(obj)
+  #   @param obj [Object] produces the result of calling #build with body as argument
   def f_build_body(body)
     case body
     when NilClass
@@ -429,7 +435,7 @@ class Puppet::Pops::Model::Factory
   # Does nothing if file is nil.
   #
   # @param file [String,nil] the file/path to the origin, may contain URI scheme of file: or some other URI scheme
-  # @returns [Factory] returns self
+  # @return [Factory] returns self
   #
   def record_origin(file)
     return self unless file
@@ -457,11 +463,11 @@ class Puppet::Pops::Model::Factory
     a.documentation = doc_string
   end
 
-  # Returns symbolic information about a expected share of a resource expression given the LHS of a resource expr.
+  # Returns symbolic information about an expected share of a resource expression given the LHS of a resource expr.
   #
   # * `name { }` => `:resource`,  create a resource of the given type
-  # * `Name { }` => ':defaults`, set defauls for the referenced type
-  # * `Name[] { }` => `:override`, ioverrides nstances referenced by LHS
+  # * `Name { }` => ':defaults`, set defaults for the referenced type
+  # * `Name[] { }` => `:override`, overrides instances referenced by LHS
   # * _any other_ => ':error', all other are considered illegal
   #
   def self.resource_shape(expr)
@@ -657,14 +663,20 @@ class Puppet::Pops::Model::Factory
           memo[-1] = Puppet::Pops::Model::Factory.IMPORT(expr.is_a?(Array) ? expr : [expr])
         else
           memo[-1] = Puppet::Pops::Model::Factory.CALL_NAMED(name, false, expr.is_a?(Array) ? expr : [expr])
+          if expr.is_a?(Model::CallNamedFunctionExpression)
+            # Patch statement function call to expression style
+            # This is needed because it is first parsed as a "statement" and the requirement changes as it becomes
+            # an argument to the name to call transform above.
+            expr.rval_required = true
+          end
         end
       else
         memo << expr
-      end
-      if expr.is_a?(Model::CallNamedFunctionExpression)
-        # patch expression function call to statement style
-        # TODO: This is kind of meaningless, but to make it compatible...
-        expr.rval_required = false
+        if expr.is_a?(Model::CallNamedFunctionExpression)
+          # Patch rvalue expression function call to statement style.
+          # This is not really required but done to be AST model compliant
+          expr.rval_required = false
+        end
       end
       memo
     end

data/lib/puppet/pops/model/model.rb

@@ -5,7 +5,7 @@
 # It describes a Metamodel containing DSL instructions, a description of PuppetType and related
 # classes needed to evaluate puppet logic.
 # The metamodel resembles the existing AST model, but it is a semantic model of instructions and
-# the types that they operate on rather than a Abstract Syntax Tree, although closely related.
+# the types that they operate on rather than an Abstract Syntax Tree, although closely related.
 #
 # The metamodel is anemic (has no behavior) except basic datatype and type
 # assertions and reference/containment assertions.

data/lib/puppet/pops/model/tree_dumper.rb

@@ -25,9 +25,9 @@ class Puppet::Pops::Model::TreeDumper
     parts.each_index do |i|
       if i > 0
         # separate with space unless previous ends with whitepsace or (
-        result << ' ' if parts[i] != ")" && parts[i-1] !~ /.*(?:\s+|\()$/ && parts[i] !~ /\s+/
+        result << ' ' if parts[i] != ")" && parts[i-1] !~ /.*(?:\s+|\()$/ && parts[i] !~ /^\s+/
       end
-      result << parts[i]
+      result << parts[i].to_s
     end
     result
   end

data/lib/puppet/pops/parser/egrammar.ra

@@ -706,7 +706,6 @@ end
 
 ---- header ----
 require 'puppet'
-require 'puppet/util/loadedfile'
 require 'puppet/pops'
 
 module Puppet

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

@@ -7,7 +7,6 @@
 require 'racc/parser.rb'
 
 require 'puppet'
-require 'puppet/util/loadedfile'
 require 'puppet/pops'
 
 module Puppet
@@ -21,7 +20,7 @@ module Puppet
     module Parser
       class Parser < Racc::Parser
 
-module_eval(<<'...end egrammar.ra/module_eval...', 'egrammar.ra', 719)
+module_eval(<<'...end egrammar.ra/module_eval...', 'egrammar.ra', 718)
 
 # Make emacs happy
 # Local Variables:

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

@@ -0,0 +1,162 @@
+
+# Does not support "import" and parsing ruby files
+#
+class Puppet::Pops::Parser::EvaluatingParser
+
+  def initialize()
+    @parser = Puppet::Pops::Parser::Parser.new()
+  end
+
+  def parse_string(s, file_source = 'unknown')
+    @file_source = file_source
+    clear()
+    # Handling of syntax error can be much improved (in general), now it bails out of the parser
+    # and does not have as rich information (when parsing a string), need to update it with the file source
+    # (ideally, a syntax error should be entered as an issue, and not just thrown - but that is a general problem
+    # and an improvement that can be made in the eparser (rather than here).
+    # Also a possible improvement (if the YAML parser returns positions) is to provide correct output of position.
+    #
+    begin
+      assert_and_report(@parser.parse_string(s))
+    rescue Puppet::ParseError => e
+      e.file = @file_source unless e.file
+      raise e
+    end
+  end
+
+  def parse_file(file)
+    @file_source = file
+    clear()
+    assert_and_report(@parser.parse_file(file))
+  end
+
+  def evaluate_string(scope, s, file_source='unknown')
+    evaluate(scope, parse_string(s, file_source))
+  end
+
+  def evaluate_file(file)
+    evaluate(parse_file(file))
+  end
+
+  def clear()
+    @acceptor = nil
+  end
+
+  def evaluate(scope, model)
+    return nil unless model
+    ast = Puppet::Pops::Model::AstTransformer.new(@file_source, nil).transform(model)
+    return nil unless ast
+    ast.safeevaluate(scope)
+  end
+
+  def acceptor()
+    @acceptor ||= Puppet::Pops::Validation::Acceptor.new
+    @acceptor
+  end
+
+  def validator()
+    @validator ||= Puppet::Pops::Validation::ValidatorFactory_3_1.new().validator(acceptor)
+  end
+
+  def assert_and_report(parse_result)
+    return nil unless parse_result
+    # make sure the result has an origin (if parsed from a string)
+    unless Puppet::Pops::Adapters::OriginAdapter.get(parse_result.model)
+      Puppet::Pops::Adapters::OriginAdapter.adapt(parse_result.model).origin = @file_source
+    end
+    validator.validate(parse_result)
+
+    max_errors = Puppet[:max_errors]
+    max_warnings = Puppet[:max_warnings] + 1
+    max_deprecations = Puppet[:max_deprecations] + 1
+
+    # If there are warnings output them
+    warnings = acceptor.warnings
+    if warnings.size > 0
+      formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
+      emitted_w = 0
+      emitted_dw = 0
+      acceptor.warnings.each {|w|
+        if w.severity == :deprecation
+          # Do *not* call Puppet.deprecation_warning it is for internal deprecation, not
+          # deprecation of constructs in manifests! (It is not designed for that purpose even if
+          # used throughout the code base).
+          #
+          Puppet.warning(formatter.format(w)) if emitted_dw < max_deprecations
+          emitted_dw += 1
+        else
+          Puppet.warning(formatter.format(w)) if emitted_w < max_warnings
+          emitted_w += 1
+        end
+        break if emitted_w > max_warnings && emitted_dw > max_deprecations # but only then
+      }
+    end
+
+    # If there were errors, report the first found. Use a puppet style formatter.
+    errors = acceptor.errors
+    if errors.size > 0
+      formatter = Puppet::Pops::Validation::DiagnosticFormatterPuppetStyle.new
+      if errors.size == 1 || max_errors <= 1
+        # raise immediately
+        require 'debugger'; debugger
+        raise Puppet::ParseError.new(formatter.format(errors[0]))
+      end
+      emitted = 0
+      errors.each do |e|
+        Puppet.err(formatter.format(e))
+        emitted += 1
+        break if emitted >= max_errors
+      end
+      warnings_message = warnings.size > 0 ? ", and #{warnings.size} warnings" : ""
+      giving_up_message = "Found #{errors.size} errors#{warnings_message}. Giving up"
+      exception = Puppet::ParseError.new(giving_up_message)
+      exception.file = errors[0].file
+      raise exception
+    end
+    parse_result
+  end
+
+  def quote(x)
+    self.class.quote(x)
+  end
+
+  # Translates an already parsed string that contains control characters, quotes
+  # and backslashes into a quoted string where all such constructs have been escaped.
+  # Parsing the return value of this method using the puppet parser should yield
+  # exactly the same string as the argument passed to this method
+  #
+  # The method makes an exception for the two character sequences \$ and \s. They
+  # will not be escaped since they have a special meaning in puppet syntax.
+  #
+  # @param x [String] The string to quote and "unparse"
+  # @return [String] The quoted string
+  #
+  def self.quote(x)
+    escaped = '"'
+    p = nil
+    x.each_char do |c|
+      case p
+      when nil
+        # do nothing
+      when "\t"
+        escaped << '\\t'
+      when "\n"
+        escaped << '\\n'
+      when "\f"
+        escaped << '\\f'
+      # TODO: \cx is a range of characters - skip for now
+      #      when "\c"
+      #        escaped << '\\c'
+      when '"'
+        escaped << '\\"'
+      when '\\'
+        escaped << if c == '$' || c == 's'; p; else '\\\\'; end # don't escape \ when followed by s or $
+      else
+        escaped << p
+      end
+      p = c
+    end
+    escaped << p unless p.nil?
+    escaped << '"'
+  end
+end

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

@@ -31,10 +31,14 @@ class Puppet::Pops::Parser::Lexer
     attr_accessor :regex, :name, :string, :skip, :skip_text
     alias skip? skip
 
-    # @param string_or_regex[String] a literal string token matcher
-    # @param string_or_regex[Regexp] a regular expression token text matcher
-    # @param name [String] the token name (what it is known as in the grammar)
-    # @param options [Hash] see {#set_options}
+    # @overload initialize(string)
+    #   @param string [String] a literal string token matcher
+    #   @param name [String] the token name (what it is known as in the grammar)
+    #   @param options [Hash] see {#set_options}
+    # @overload initialize(regex)
+    #   @param regex [Regexp] a regular expression token text matcher
+    #   @param name [String] the token name (what it is known as in the grammar)
+    #   @param options [Hash] see {#set_options}
     #
     def initialize(string_or_regex, name, options = {})
       if string_or_regex.is_a?(String)
@@ -565,7 +569,6 @@ class Puppet::Pops::Parser::Lexer
     skip
 
     until token_queue.empty? and @scanner.eos? do
-      yielded = false
       offset = @scanner.pos
       matched_token, value = find_token
       end_offset = @scanner.pos
@@ -646,7 +649,6 @@ class Puppet::Pops::Parser::Lexer
     # we search for the next quote that isn't preceded by a
     # backslash; the caret is there to match empty strings
     last = @scanner.matched
-    tmp_offset = @scanner.pos
     str = @scanner.scan_until(/([^\\]|^|[^\\])([\\]{2})*[#{terminators}]/) || lex_error(positioned_message("Unclosed quote after #{format_quote(last)} followed by '#{followed_by}'"))
     str.gsub!(/\\(.)/m) {
       ch = $1

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

@@ -0,0 +1,118 @@
+require 'rgen/metamodel_builder'
+
+# The ClassLoader provides a Class instance given a class name or a meta-type.
+# If the class is not already loaded, it is loaded using the Puppet Autoloader.
+# This means it can load a class from a gem, or from puppet modules.
+#
+class Puppet::Pops::Types::ClassLoader
+  @autoloader = Puppet::Util::Autoload.new("ClassLoader", "", :wrap => false)
+
+  # Returns a Class given a fully qualified class name.
+  # Lookup of class is never relative to the calling namespace.
+  # @param name [String, Array<String>, Array<Symbol>, Puppet::Pops::Types::PObjectType] A fully qualified
+  #   class name String (e.g. '::Foo::Bar', 'Foo::Bar'), a PObjectType, or a fully qualified name in Array form where each part
+  #   is either a String or a Symbol, e.g. `%w{Puppetx Puppetlabs SomeExtension}`.
+  # @return [Class, nil] the looked up class or nil if no such class is loaded
+  # @raise ArgumentError If the given argument has the wrong type
+  # @api public
+  #
+  def self.provide(name)
+    case name
+    when String
+      provide_from_string(name)
+
+    when Array
+      provide_from_name_path(name.join('::'), name)
+
+    when Puppet::Pops::Types::PObjectType, Puppet::Pops::Types::PType
+      provide_from_type(name)
+
+    else
+      raise ArgumentError, "Cannot provide a class from a '#{name.class.name}'"
+    end
+  end
+
+  private
+
+  def self.provide_from_type(type)
+    case type
+    when Puppet::Pops::Types::PRubyType
+      provide_from_string(type.ruby_class)
+
+    when Puppet::Pops::Types::PBooleanType
+      # There is no other thing to load except this Enum meta type
+      RGen::MetamodelBuilder::MMBase::Boolean
+
+    when Puppet::Pops::Types::PType
+      # TODO: PType should have a type argument (a PObjectType)
+      Class
+
+    # Although not expected to be the first choice for getting a concrete class for these
+    # types, these are of value if the calling logic just has a reference to type.
+    #
+    when Puppet::Pops::Types::PArrayType   ; Array
+    when Puppet::Pops::Types::PHashType    ; Hash
+    when Puppet::Pops::Types::PPatternType ; Regexp
+    when Puppet::Pops::Types::PIntegerType ; Integer
+    when Puppet::Pops::Types::PStringType  ; String
+    when Puppet::Pops::Types::PFloatType   ; Float
+    when Puppet::Pops::Types::PNilType     ; NilClass
+    else
+      nil
+    end
+  end
+
+  def self.provide_from_string(name)
+    name_path = name.split('::')
+    # always from the root, so remove an empty first segment
+    if name_path[0].empty?
+      name_path = name_path[1..-1]
+    end
+    provide_from_name_path(name, name_path)
+  end
+
+  def self.provide_from_name_path(name, name_path)
+    # If class is already loaded, try this first
+    result = find_class(name_path)
+
+    unless result.is_a?(Class)
+      # Attempt to load it using the auto loader
+      loaded_path = nil
+      if paths_for_name(name).find {|path| loaded_path = path; @autoloader.load(path) }
+        result = find_class(name_path)
+        unless result.is_a?(Class)
+          raise RuntimeError, "Loading of #{name} using relative path: '#{loaded_path}' did not create expected class"
+        end
+      end
+    end
+    return nil unless result.is_a?(Class)
+    result
+  end
+
+  def self.find_class(name_path)
+    name_path.reduce(Object) do |ns, name|
+      begin
+        ns.const_get(name)
+      rescue NameError
+        return nil
+      end
+    end
+  end
+
+  def self.paths_for_name(fq_name)
+    [de_camel(fq_name), downcased_path(fq_name)]
+  end
+
+  def self.downcased_path(fq_name)
+    fq_name.to_s.gsub(/::/, '/').downcase
+  end
+
+  def self.de_camel(fq_name)
+    fq_name.to_s.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+
+end