puppet 3.8.7 → 4.0.0.rc1

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

@@ -1,22 +0,0 @@
-require 'puppet/parser/ast/branch'
-
-class Puppet::Parser::AST
-  # A separate ElseIf statement; can function as an 'else' if there's no
-  # test.
-  class Else < AST::Branch
-
-    associates_doc
-
-    attr_accessor :statements
-
-    def each
-      yield @statements
-    end
-
-    # Evaluate the actual statements; this only gets called if
-    # our test was true matched.
-    def evaluate(scope)
-      @statements.safeevaluate(scope)
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-require 'puppet/parser/ast/branch'
-
-class Puppet::Parser::AST
-  # An AST object to call a function.
-  class Function < AST::Branch
-
-    associates_doc
-
-    attr_accessor :name, :arguments, :pblock
-
-    def evaluate(scope)
-      # Make sure it's a defined function
-      raise Puppet::ParseError, "Unknown function #{@name}" unless Puppet::Parser::Functions.function(@name)
-
-      # Now check that it's been used correctly
-      case @ftype
-      when :rvalue
-        raise Puppet::ParseError, "Function '#{@name}' does not return a value" unless Puppet::Parser::Functions.rvalue?(@name)
-
-      when :statement
-        # It is harmless to produce an ignored rvalue, the alternative is to mark functions
-        # as appropriate for both rvalue and statements
-        # Keeping the old behavior when a pblock is not present. This since it is not known
-        # if the lambda contains a statement or not (at least not without a costly search).
-        # The purpose of the check is to protect a user for producing a meaningless rvalue where the
-        # operation has no side effects.
-        #
-        if !pblock && Puppet::Parser::Functions.rvalue?(@name)
-          raise Puppet::ParseError,
-            "Function '#{@name}' must be the value of a statement"
-        end
-      else
-        raise Puppet::DevError, "Invalid function type #{@ftype.inspect}"
-      end
-
-      # We don't need to evaluate the name, because it's plaintext
-      args = @arguments.safeevaluate(scope).map { |x| x == :undef ? '' : x }
-
-      # append a puppet lambda (unevaluated) if it is defined
-      args << pblock if pblock
-
-      scope.send("function_#{@name}", args)
-    end
-
-    def initialize(hash)
-      @ftype = hash[:ftype] || :rvalue
-      hash.delete(:ftype) if hash.include? :ftype
-
-      super(hash)
-
-      # Lastly, check the parity
-    end
-
-    def to_s
-      args = arguments.is_a?(ASTArray) ? arguments.to_s.gsub(/\[(.*)\]/,'\1') : arguments
-      "#{name}(#{args})"
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require 'puppet/parser/ast/branch'
-
-class Puppet::Parser::AST
-  # A basic 'if/elsif/else' statement.
-  class IfStatement < AST::Branch
-
-    associates_doc
-
-    attr_accessor :test, :else, :statements
-
-    def each
-      [@test,@else,@statements].each { |child| yield child }
-    end
-
-    # Short-curcuit evaluation.  If we're true, evaluate our statements,
-    # else if there's an 'else' setting, evaluate it.
-    # the first option that matches.
-    def evaluate(scope)
-      level = scope.ephemeral_level
-      value = @test.safeevaluate(scope)
-
-      # let's emulate a new scope for each branches
-      begin
-        if Puppet::Parser::Scope.true?(value)
-          return @statements.safeevaluate(scope)
-        else
-          return defined?(@else) ? @else.safeevaluate(scope) : nil
-        end
-      ensure
-        scope.unset_ephemeral_var(level)
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require 'puppet'
-require 'puppet/parser/ast/branch'
-
-class Puppet::Parser::AST
-  class InOperator < AST::Branch
-
-    attr_accessor :lval, :rval
-
-    # Returns a boolean which is the result of the 'in' operation
-    # of lval and rval operands
-    def evaluate(scope)
-
-      # evaluate the operands, should return a boolean value
-      lval = @lval.safeevaluate(scope)
-      raise ArgumentError, "'#{lval}' from left operand of 'in' expression is not a string" unless lval.is_a?(::String)
-
-      rval = @rval.safeevaluate(scope)
-      unless rval.respond_to?(:include?)
-        raise ArgumentError, "'#{rval}' from right operand of 'in' expression is not of a supported type (string, array or hash)"
-      end
-      rval.include?(lval)
-    end
-  end
-end

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

@@ -1,135 +0,0 @@
-require 'puppet/parser/ast/block_expression'
-
-class Puppet::Parser::AST
-  # A block of statements/expressions with additional parameters
-  # Requires scope to contain the values for the defined parameters when evaluated
-  # If evaluated without a prepared scope, the lambda will behave like its super class.
-  #
-  class Lambda < AST::BlockExpression
-
-    # The lambda parameters.
-    # These are encoded as an array where each entry is an array of one or two object. The first
-    # is the parameter name, and the optional second object is the value expression (that will
-    # be evaluated when bound to a scope).
-    # The value expression is the default value for the parameter. All default values must be
-    # at the end of the parameter list.
-    #
-    # @return [Array<Array<String,String>>] list of parameter names with optional value expression
-    attr_accessor :parameters
-    # Evaluates each expression/statement and produce the last expression evaluation result
-    # @return [Object] what the last expression evaluated to
-    def evaluate(scope)
-      if @children.is_a? Puppet::Parser::AST::ASTArray
-        result = nil
-        @children.each {|expr| result = expr.evaluate(scope) }
-        result
-      else
-        @children.evaluate(scope)
-      end
-    end
-
-    # Calls the lambda.
-    # Assigns argument values in a nested local scope that should be used to evaluate the lambda
-    # and then evaluates the lambda.
-    # @param scope [Puppet::Scope] the calling scope
-    # @return [Object] the result of evaluating the expression(s) in the lambda
-    #
-    def call(scope, *args)
-      raise Puppet::ParseError, "Too many arguments: #{args.size} for #{parameters.size}" unless args.size <= parameters.size
-
-      # associate values with parameters
-      merged = parameters.zip(args)
-      # calculate missing arguments
-      missing = parameters.slice(args.size, parameters.size - args.size).select {|e| e.size == 1}
-      unless missing.empty?
-        optional = parameters.count { |p| p.size == 2 }
-        raise Puppet::ParseError, "Too few arguments; #{args.size} for #{optional > 0 ? ' min ' : ''}#{parameters.size - optional}"
-      end
-
-      evaluated = merged.collect do |m|
-        # m can be one of
-        # m = [["name"], "given"]
-        #   | [["name", default_expr], "given"]
-        #
-        # "given" is always an optional entry. If a parameter was provided then
-        # the entry will be in the array, otherwise the m array will be a
-        # single element.
-        given_argument = m[1]
-        argument_name = m[0][0]
-        default_expression = m[0][1]
-
-        value = if m.size == 1
-          default_expression.safeevaluate(scope)
-        else
-          given_argument
-        end
-        [argument_name, value]
-      end
-
-      # Store the evaluated name => value associations in a new inner/local/ephemeral scope
-      # (This is made complicated due to the fact that the implementation of scope is overloaded with
-      # functionality and an inner ephemeral scope must be used (as opposed to just pushing a local scope
-      # on a scope "stack").
-
-      # Ensure variable exists with nil value if error occurs. 
-      # Some ruby implementations does not like creating variable on return
-      result = nil
-      begin
-        elevel = scope.ephemeral_level
-        scope.ephemeral_from(Hash[evaluated], file, line)
-        result = safeevaluate(scope)
-      ensure
-        scope.unset_ephemeral_var(elevel)
-      end
-      result
-    end
-
-    # Validates the lambda.
-    # Validation checks if parameters with default values are at the end of the list. (It is illegal
-    # to have a parameter with default value followed by one without).
-    #
-    # @raise [Puppet::ParseError] if a parameter with a default comes before a parameter without default value
-    #
-    def validate
-      params = parameters || []
-      defaults = params.drop_while {|p| p.size < 2 }
-      trailing = defaults.drop_while {|p| p.size == 2 }
-      raise Puppet::ParseError, "Lambda parameters with default values must be placed last" unless trailing.empty?
-    end
-
-    # Returns the number of parameters (required and optional)
-    # @return [Integer] the total number of accepted parameters
-    def parameter_count
-      @parameters.size
-    end
-
-    # Returns the number of optional parameters.
-    # @return [Integer] the number of optional accepted parameters
-    def optional_parameter_count
-      @parameters.count {|p| p.size == 2 }
-    end
-
-    def initialize(options)
-      super(options)
-      # ensure there is an empty parameters structure if not given by creator
-      @parameters = [] unless options[:parameters]
-      validate
-    end
-
-    def to_s
-      result = ["{|"]
-      result += @parameters.collect {|p| "#{p[0]}" + (p.size == 2 && p[1]) ? p[1].to_s() : '' }.join(', ')
-      result << "| ... }"
-      result.join('')
-    end
-
-    # marker method checked with respond_to :puppet_lambda
-    def puppet_lambda()
-      true
-    end
-
-    def parameter_names
-      @parameters.collect {|p| p[0] }
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'puppet'
-require 'puppet/parser/ast/branch'
-
-class Puppet::Parser::AST
-  class MatchOperator < AST::Branch
-
-    attr_accessor :lval, :rval, :operator
-
-    # Iterate across all of our children.
-    def each
-      [@lval,@rval].each { |child| yield child }
-    end
-
-    # Returns a boolean which is the result of the boolean operation
-    # of lval and rval operands
-    def evaluate(scope)
-      lval = @lval.safeevaluate(scope)
-
-      return(rval.evaluate_match(lval, scope) ? @operator == "=~" : @operator == "!~")
-    end
-
-    def initialize(hash)
-      super
-
-      raise ArgumentError, "Invalid regexp operator #{@operator}" unless %w{!~ =~}.include?(@operator)
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-require 'puppet/parser/ast/branch'
-require 'puppet/parser/methods'
-
-class Puppet::Parser::AST
-  # An AST object to call a method
-  class MethodCall < AST::Branch
-
-    associates_doc
-
-    # An AST that evaluates to the object the method is applied to
-    # @return [Puppet::Parser::AST]
-    attr_accessor :receiver
-
-    # The name of the method
-    # @return [String]
-    attr_accessor :name
-
-    # The arguments to evaluate as arguments to the method.
-    # @return [Array<Puppet::Parser::AST>]
-    attr_accessor :arguments
-
-    # An optional lambda/block that will be yielded to by the called method (if it supports this)
-    # @return [Puppet::Parser::AST::Lambda]
-    attr_accessor :lambda
-
-    # Evaluates the method call and returns what the called method/function returns.
-    # The evaluation evaluates all arguments in the calling scope and then delegates
-    # to a "method" instance produced by Puppet::Parser::Methods for this method call.
-    # @see Puppet::Parser::Methods
-    # @return [Object] what the called method/function returns
-    def evaluate(scope)
-      # Make sure it's a defined method for the receiver
-      r = @receiver.evaluate(scope)
-      raise Puppet::ParseError, "No object to apply method #{@name} to" unless r
-      m = Puppet::Parser::Methods.find_method(scope, r, @name)
-      raise Puppet::ParseError, "Unknown method #{@name} for #{r}" unless m
-
-      # Now check if rvalue is required (in expressions)
-      case @ftype
-      when :rvalue
-        raise Puppet::ParseError, "Method '#{@name}' does not return a value" unless m.is_rvalue?
-      when :statement
-        # When used as a statement, ignore if it produces a rvalue (it is simply not used)
-      else
-        raise Puppet::DevError, "Invalid method type #{@ftype.inspect}"
-      end
-
-      # Evaluate arguments
-      args = @arguments ? @arguments.safeevaluate(scope).map { |x| x == :undef ? '' : x } : []
-
-      # There is no need to evaluate the name, since it is a literal ruby string
-
-      # call the method (it is already bound to the receiver and name)
-      m.invoke(scope, args, @lambda)
-    end
-
-    def initialize(hash)
-      @ftype = hash[:ftype] || :rvalue
-      hash.delete(:ftype) if hash.include? :ftype
-
-      super(hash)
-
-      # Lastly, check the parity
-    end
-
-    # Sets this method call in statement mode where a produced rvalue is ignored.
-    # @return [void]
-    def ignore_rvalue
-      @ftype = :statement
-    end
-
-    def to_s
-      args = arguments.is_a?(ASTArray) ? arguments.to_s.gsub(/\[(.*)\]/,'\1') : arguments
-      "#{@receiver.to_s}.#{name} (#{args})" + (@lambda ? " #{@lambda.to_s}" : '')
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-require 'puppet'
-require 'puppet/parser/ast/branch'
-
-# An object that returns a boolean which is the boolean not
-# of the given value.
-class Puppet::Parser::AST
-  class Minus < AST::Branch
-    attr_accessor :value
-
-    def each
-      yield @value
-    end
-
-    def evaluate(scope)
-      val = @value.safeevaluate(scope)
-      val = Puppet::Parser::Scope.number?(val)
-      if val == nil
-        raise ArgumentError, "minus operand #{val} is not a number"
-      end
-      -val
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-require 'puppet/parser/ast/branch'
-
-class Puppet::Parser::AST
-  # This class is a no-op, it doesn't produce anything
-  # when evaluated, hence its name :-)
-  class Nop < AST::Leaf
-    def evaluate(scope)
-      # nothing to do
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require 'puppet'
-require 'puppet/parser/ast/branch'
-
-# An object that returns a boolean which is the boolean not
-# of the given value.
-class Puppet::Parser::AST
-  class Not < AST::Branch
-    attr_accessor :value
-
-    def each
-      yield @value
-    end
-
-    def evaluate(scope)
-      val = @value.safeevaluate(scope)
-      ! Puppet::Parser::Scope.true?(val)
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-require 'puppet/parser/ast'
-require 'puppet/parser/ast/branch'
-require 'puppet/parser/relationship'
-
-class Puppet::Parser::AST::Relationship < Puppet::Parser::AST::Branch
-  RELATIONSHIP_TYPES = %w{-> <- ~> <~}
-
-  attr_accessor :left, :right, :arrow, :type
-
-  # Evaluate our object, but just return a simple array of the type
-  # and name.
-  def evaluate(scope)
-    real_left = left.safeevaluate(scope)
-    real_right = right.safeevaluate(scope)
-
-    source, target = sides2edge(real_left, real_right)
-    scope.compiler.add_relationship Puppet::Parser::Relationship.new(source, target, type)
-
-    real_right
-  end
-
-  def initialize(left, right, arrow, args = {})
-    super(args)
-    unless RELATIONSHIP_TYPES.include?(arrow)
-      raise ArgumentError, "Invalid relationship type #{arrow.inspect}; valid types are #{RELATIONSHIP_TYPES.collect { |r| r.to_s }.join(", ")}"
-    end
-    @left, @right, @arrow = left, right, arrow
-  end
-
-  def type
-    subscription? ? :subscription : :relationship
-  end
-
-  def sides2edge(left, right)
-    out_edge? ? [left, right] : [right, left]
-  end
-
-  private
-
-  def out_edge?
-    ["->", "~>"].include?(arrow)
-  end
-
-  def subscription?
-    ["~>", "<~"].include?(arrow)
-  end
-end