bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/parser/ast.rb

@@ -1,61 +0,0 @@
-# The base class for the 3x "parse tree", now only used by the top level
-# constructs and the compiler.
-# Handles things like file name, line #, and also does the initialization
-# for all of the parameters of all of the child objects.
-#
-class Puppet::Parser::AST
-  AST = Puppet::Parser::AST
-
-  include Puppet::Util::Errors
-
-  attr_accessor :parent, :scope, :file, :line, :pos
-
-  def inspect
-    "( #{self.class} #{self.to_s} #{@children.inspect} )"
-  end
-
-  # Evaluate the current object.  Just a stub method, since the subclass
-  # should override this method.
-  def evaluate(scope)
-  end
-
-  # The version of the evaluate method that should be called, because it
-  # correctly handles errors.  It is critical to use this method because
-  # it can enable you to catch the error where it happens, rather than
-  # much higher up the stack.
-  def safeevaluate(scope)
-    # We duplicate code here, rather than using exceptwrap, because this
-    # is called so many times during parsing.
-    begin
-      return self.evaluate(scope)
-    rescue Puppet::Pops::Evaluator::PuppetStopIteration => detail
-      raise detail
-#      # Only deals with StopIteration from the break() function as a general
-#      # StopIteration is a general runtime problem
-#      raise Puppet::ParseError.new(detail.message, detail.file, detail.line, detail)
-    rescue Puppet::Error => detail
-      raise adderrorcontext(detail)
-    rescue => detail
-      error = Puppet::ParseError.new(detail.to_s, nil, nil, detail)
-      # We can't use self.fail here because it always expects strings,
-      # not exceptions.
-      raise adderrorcontext(error, detail)
-    end
-  end
-
-  def initialize(file: nil, line: nil, pos: nil)
-    @file = file
-    @line = line
-    @pos = pos
-  end
-end
-
-# And include all of the AST subclasses.
-require 'puppet/parser/ast/branch'
-require 'puppet/parser/ast/leaf'
-require 'puppet/parser/ast/block_expression'
-require 'puppet/parser/ast/hostclass'
-require 'puppet/parser/ast/node'
-require 'puppet/parser/ast/resource'
-require 'puppet/parser/ast/resource_instance'
-require 'puppet/parser/ast/resourceparam'

data/vendored/puppet/lib/puppet/parser/ast/block_expression.rb

@@ -1,15 +0,0 @@
-# Evaluates contained expressions, produce result of the last
-#
-class Puppet::Parser::AST::BlockExpression < Puppet::Parser::AST::Branch
-  def evaluate(scope)
-    @children.reduce(nil) { |_, child| child.safeevaluate(scope) }
-  end
-
-  def sequence_with(other)
-    Puppet::Parser::AST::BlockExpression.new(:children => self.children + other.children)
-  end
-
-  def to_s
-    "[" + @children.collect { |c| c.to_s }.join(', ') + "]"
-  end
-end

data/vendored/puppet/lib/puppet/parser/ast/branch.rb

@@ -1,19 +0,0 @@
-# The parent class of all AST objects that contain other AST objects.
-# Everything but the really simple objects descend from this.  It is
-# important to note that Branch objects contain other AST objects only --
-# if you want to contain values, use a descendant of the AST::Leaf class.
-#
-# @api private
-class Puppet::Parser::AST::Branch < Puppet::Parser::AST
-  include Enumerable
-  attr_accessor :pin, :children
-
-  def each
-    @children.each { |child| yield child }
-  end
-
-  def initialize(children: [], **args)
-    @children = children
-    super(**args)
-  end
-end

data/vendored/puppet/lib/puppet/parser/ast/hostclass.rb

@@ -1,27 +0,0 @@
-require 'puppet/parser/ast/top_level_construct'
-
-class Puppet::Parser::AST::Hostclass < Puppet::Parser::AST::TopLevelConstruct
-  attr_accessor :name, :context
-
-  def initialize(name, context = {})
-    @context = context
-    @name = name
-  end
-
-  def instantiate(modname)
-    new_class = Puppet::Resource::Type.new(:hostclass, @name, @context.merge(:module_name => modname))
-    all_types = [new_class]
-    if code
-      code.each do |nested_ast_node|
-        if nested_ast_node.respond_to? :instantiate
-          all_types += nested_ast_node.instantiate(modname)
-        end
-      end
-    end
-    return all_types
-  end
-
-  def code()
-    @context[:code]
-  end
-end

data/vendored/puppet/lib/puppet/parser/ast/leaf.rb

@@ -1,80 +0,0 @@
-# The base class for all of the leaves of the parse trees.  These
-# basically just have types and values.  Both of these parameters
-# are simple values, not AST objects.
-#
-class Puppet::Parser::AST::Leaf < Puppet::Parser::AST
-  attr_accessor :value, :type
-  # Return our value.
-  def evaluate(scope)
-    @value
-  end
-
-  def match(value)
-    @value == value
-  end
-
-  def to_s
-    @value.to_s unless @value.nil?
-  end
-
-  def initialize(value: nil, **options)
-    @value = value
-    super(**options)
-  end
-end
-
-# Host names, either fully qualified or just the short name, or even a regex
-#
-class Puppet::Parser::AST::HostName < Puppet::Parser::AST::Leaf
-  def initialize(hash)
-    super
-
-    # Note that this is an AST::Regex, not a Regexp
-    unless @value.is_a?(Regex)
-      @value = @value.to_s.downcase
-      if @value =~ /[^-\w.]/
-        raise Puppet::DevError, _("'%{value}' is not a valid hostname") % { value: @value }
-      end
-    end
-  end
-
-  # implementing eql? and hash so that when an HostName is stored
-  # in a hash it has the same hashing properties as the underlying value
-  def eql?(value)
-    @value.eql?(value.is_a?(HostName) ? value.value : value)
-  end
-
-  def hash
-    @value.hash
-  end
-end
-
-class Puppet::Parser::AST::Regex < Puppet::Parser::AST::Leaf
-  def initialize(hash)
-    super
-    # transform value from hash options unless it is already a regular expression
-    @value = Regexp.new(@value) unless @value.is_a?(Regexp)
-  end
-
-  # we're returning self here to wrap the regexp and to be used in places
-  # where a string would have been used, without modifying any client code.
-  # For instance, in many places we have the following code snippet:
-  #  val = @val.safeevaluate(@scope)
-  #  if val.match(otherval)
-  #      ...
-  #  end
-  # this way, we don't have to modify this test specifically for handling
-  # regexes.
-  #
-  def evaluate(scope)
-    self
-  end
-
-  def match(value)
-    @value.match(value)
-  end
-
-  def to_s
-    Puppet::Pops::Types::PRegexpType.regexp_to_s_with_delimiters(@value)
-  end
-end

data/vendored/puppet/lib/puppet/parser/ast/node.rb

@@ -1,17 +0,0 @@
-class Puppet::Parser::AST::Node < Puppet::Parser::AST::TopLevelConstruct
-  attr_accessor :names, :context
-
-  def initialize(names, context = {})
-    raise ArgumentError, _("names should be an array") unless names.is_a? Array
-    if context[:parent]
-      raise Puppet::DevError, _("Node inheritance is removed in Puppet 4.0.0. See http://links.puppet.com/puppet-node-inheritance-deprecation")
-    end
-
-    @names = names
-    @context = context
-  end
-
-  def instantiate(modname)
-    @names.map { |name| Puppet::Resource::Type.new(:node, name, @context.merge(:module_name => modname)) }
-  end
-end

data/vendored/puppet/lib/puppet/parser/ast/pops_bridge.rb

@@ -1,291 +0,0 @@
-require 'puppet/parser/ast/top_level_construct'
-require 'puppet/pops'
-
-# The AST::Bridge contains classes that bridges between the new Pops based model
-# and the 3.x AST. This is required to be able to reuse the Puppet::Resource::Type which is
-# fundamental for the rest of the logic.
-#
-class Puppet::Parser::AST::PopsBridge
-
-  # Bridges to one Pops Model Expression
-  # The @value is the expression
-  # This is used to represent the body of a class, definition, or node, and for each parameter's default value
-  # expression.
-  #
-  class Expression < Puppet::Parser::AST::Leaf
-
-    def initialize args
-      super
-      @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
-    end
-
-    def to_s
-      Puppet::Pops::Model::ModelTreeDumper.new.dump(@value)
-    end
-
-    def source_text
-      source_adapter = Puppet::Pops::Utils.find_closest_positioned(@value)
-      source_adapter ? source_adapter.extract_text() : nil
-    end
-
-    def evaluate(scope)
-      object = @@evaluator.evaluate(scope, @value)
-      @@evaluator.convert_to_3x(object, scope)
-    end
-
-    # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
-    # by yielding self. By adding this there is no need to wrap a pops expression inside an AST::BlockExpression
-    #
-    def each
-      yield self
-    end
-
-    def sequence_with(other)
-      if value.nil?
-        # This happens when testing and not having a complete setup
-        other
-      else
-        # When does this happen ? Ever ?
-        raise "sequence_with called on Puppet::Parser::AST::PopsBridge::Expression - please report use case"
-        # What should be done if the above happens (We don't want this to happen).
-        # Puppet::Parser::AST::BlockExpression.new(:children => [self] + other.children)
-      end
-    end
-
-    # The 3x requires code plugged in to an AST to have this in certain positions in the tree. The purpose
-    # is to either print the content, or to look for things that needs to be defined. This implementation
-    # cheats by always returning an empty array. (This allows simple files to not require a "Program" at the top.
-    #
-    def children
-      []
-    end
-  end
-
-  class ExpressionSupportingReturn < Expression
-    def initialize args
-      super
-    end
-
-    def evaluate(scope)
-      return catch(:return) do
-        return catch(:next) do
-          return super(scope)
-        end
-      end
-    end
-  end
-  # Bridges the top level "Program" produced by the pops parser.
-  # Its main purpose is to give one point where all definitions are instantiated (actually defined since the
-  # Puppet 3x terminology is somewhat misleading - the definitions are instantiated, but instances of the created types
-  # are not created, that happens when classes are included / required, nodes are matched and when resources are instantiated
-  # by a resource expression (which is also used to instantiate a host class).
-  #
-  class Program < Puppet::Parser::AST::TopLevelConstruct
-    attr_reader :program_model, :context
-
-    def initialize(program_model, context = {})
-      @program_model = program_model
-      @context = context
-      @ast_transformer ||= Puppet::Pops::Model::AstTransformer.new(@context[:file])
-      @@evaluator ||= Puppet::Pops::Parser::EvaluatingParser.new()
-    end
-
-    # This is the 3x API, the 3x AST searches through all code to find the instructions that can be instantiated.
-    # This Pops-model based instantiation relies on the parser to build this list while parsing (which is more
-    # efficient as it avoids one full scan of all logic via recursive enumeration/yield)
-    #
-    def instantiate(modname)
-
-      @program_model.definitions.map do |d|
-        case d
-        when Puppet::Pops::Model::HostClassDefinition
-          instantiate_HostClassDefinition(d, modname)
-        when Puppet::Pops::Model::ResourceTypeDefinition
-          instantiate_ResourceTypeDefinition(d, modname)
-        when Puppet::Pops::Model::CapabilityMapping
-          instantiate_CapabilityMapping(d, modname)
-        when Puppet::Pops::Model::NodeDefinition
-          instantiate_NodeDefinition(d, modname)
-        when Puppet::Pops::Model::SiteDefinition
-            instantiate_SiteDefinition(d, modname)
-        when Puppet::Pops::Model::Application
-          instantiate_ApplicationDefinition(d, modname)
-        else
-          loaders = Puppet::Pops::Loaders.loaders
-          loaders.instantiate_definition(d, loaders.find_loader(modname))
-
-          # The 3x logic calling this will not know what to do with the result, it is compacted away at the end
-          nil
-        end
-      end.flatten().compact() # flatten since node definition may have returned an array
-                              # Compact since 4x definitions are not understood by compiler
-    end
-
-    def evaluate(scope)
-      @@evaluator.evaluate(scope, program_model)
-    end
-
-    # Adapts to 3x where top level constructs needs to have each to iterate over children. Short circuit this
-    # by yielding self. This means that the HostClass container will call this bridge instance with `instantiate`.
-    #
-    def each
-      yield self
-    end
-
-    # Returns true if this Program only contains definitions
-    def is_definitions_only?
-      is_definition?(program_model)
-    end
-
-    private
-
-    def is_definition?(o)
-      case o
-      when Puppet::Pops::Model::Program
-        is_definition?(o.body)
-      when Puppet::Pops::Model::BlockExpression
-        o.statements.all {|s| is_definition?(s) }
-      when Puppet::Pops::Model::Definition
-        true
-      else
-        false
-      end
-    end
-
-    def instantiate_Parameter(o)
-      # 3x needs parameters as an array of `[name]` or `[name, value_expr]`
-      if o.value
-        [o.name, Expression.new(:value => o.value)]
-      else
-        [o.name]
-      end
-    end
-
-    def create_type_map(definition)
-      result = {}
-      # No need to do anything if there are no parameters
-      return result unless definition.parameters.size > 0
-
-      # No need to do anything if there are no typed parameters
-      typed_parameters = definition.parameters.select {|p| p.type_expr }
-      return result if typed_parameters.empty?
-
-      # If there are typed parameters, they need to be evaluated to produce the corresponding type
-      # instances. This evaluation requires a scope. A scope is not available when doing deserialization
-      # (there is also no initialized evaluator). When running apply and test however, the environment is
-      # reused and we may reenter without a scope (which is fine). A debug message is then output in case
-      # there is the need to track down the odd corner case. See {#obtain_scope}.
-      #
-      if scope = obtain_scope
-        typed_parameters.each do |p|
-          result[p.name] =  @@evaluator.evaluate(scope, p.type_expr)
-        end
-      end
-      result
-    end
-
-    # Obtains the scope or issues a warning if :global_scope is not bound
-    def obtain_scope
-      scope = Puppet.lookup(:global_scope) do
-        # This occurs when testing and when applying a catalog (there is no scope available then), and
-        # when running tests that run a partial setup.
-        # This is bad if the logic is trying to compile, but a warning can not be issues since it is a normal
-        # use case that there is no scope when requesting the type in order to just get the parameters.
-        Puppet.debug {_("Instantiating Resource with type checked parameters - scope is missing, skipping type checking.")}
-        nil
-      end
-      scope
-    end
-
-    # Produces a hash with data for Definition and HostClass
-    def args_from_definition(o, modname, expr_class = Expression)
-      args = {
-       :arguments => o.parameters.collect {|p| instantiate_Parameter(p) },
-       :argument_types => create_type_map(o),
-       :module_name => modname
-      }
-      unless is_nop?(o.body)
-        args[:code] = expr_class.new(:value => o.body)
-      end
-      @ast_transformer.merge_location(args, o)
-    end
-
-    def instantiate_HostClassDefinition(o, modname)
-      args = args_from_definition(o, modname, ExpressionSupportingReturn)
-      args[:parent] = absolute_reference(o.parent_class)
-      Puppet::Resource::Type.new(:hostclass, o.name, @context.merge(args))
-    end
-
-    def instantiate_ResourceTypeDefinition(o, modname)
-      instance = Puppet::Resource::Type.new(:definition, o.name, @context.merge(args_from_definition(o, modname, ExpressionSupportingReturn)))
-      Puppet::Pops::Loaders.register_runtime3_type(instance.name, o.locator.to_uri(o))
-      instance
-    end
-
-    def instantiate_CapabilityMapping(o, modname)
-      # Use an intermediate 'capability_mapping' type to pass this info to the compiler where the
-      # actual mapping takes place
-      Puppet::Resource::Type.new(:capability_mapping, "#{o.component} #{o.kind} #{o.capability}", { :arguments => {
-        'component'     => o.component,
-        'kind'          => o.kind,
-        'blueprint'     => {
-          :capability => o.capability,
-          :mappings   => o.mappings.reduce({}) do |memo, mapping|
-            memo[mapping.attribute_name] =
-              Expression.new(:value => mapping.value_expr)
-            memo
-          end
-      }}})
-    end
-
-    def instantiate_ApplicationDefinition(o, modname)
-      args = args_from_definition(o, modname)
-      Puppet::Resource::Type.new(:application, o.name, @context.merge(args))
-    end
-
-    def instantiate_NodeDefinition(o, modname)
-      args = { :module_name => modname }
-
-      unless is_nop?(o.body)
-        args[:code] = Expression.new(:value => o.body)
-      end
-
-      unless is_nop?(o.parent)
-        args[:parent] = @ast_transformer.hostname(o.parent)
-      end
-      args = @ast_transformer.merge_location(args, o)
-
-      host_matches = @ast_transformer.hostname(o.host_matches)
-      host_matches.collect do |name|
-        Puppet::Resource::Type.new(:node, name, @context.merge(args))
-      end
-    end
-
-    def instantiate_SiteDefinition(o, modname)
-      args = { :module_name => modname }
-
-      unless is_nop?(o.body)
-        args[:code] = Expression.new(:value => o.body)
-      end
-
-      args = @ast_transformer.merge_location(args, o)
-      Puppet::Resource::Type.new(:site, 'site', @context.merge(args))
-    end
-
-    def code()
-      Expression.new(:value => @value)
-    end
-
-    def is_nop?(o)
-      @ast_transformer.is_nop?(o)
-    end
-
-    def absolute_reference(ref)
-      if ref.nil? || ref.empty? || ref.start_with?('::')
-        ref
-      else
-        "::#{ref}"
-      end
-    end
-  end
-end