puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/ast/comparison_operator.rb

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

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/ast/definition.rb

@@ -0,0 +1,17 @@
+require 'puppet/parser/ast/top_level_construct'
+
+class Puppet::Parser::AST::Definition < Puppet::Parser::AST::TopLevelConstruct
+  attr_accessor :context
+
+  def initialize(name, context = {}, &ruby_code)
+    @name = name
+    @context = context
+    @ruby_code = ruby_code
+  end
+
+  def instantiate(modname)
+    new_definition = Puppet::Resource::Type.new(:definition, @name, @context.merge(:module_name => modname))
+    new_definition.ruby_code = @ruby_code if @ruby_code
+    [new_definition]
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/ast/else.rb

@@ -0,0 +1,22 @@
+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/vendor/gems/puppet-3.7.3/lib/puppet/parser/ast/function.rb

@@ -0,0 +1,59 @@
+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/vendor/gems/puppet-3.7.3/lib/puppet/parser/ast/hostclass.rb

@@ -0,0 +1,29 @@
+require 'puppet/parser/ast/top_level_construct'
+
+class Puppet::Parser::AST::Hostclass < Puppet::Parser::AST::TopLevelConstruct
+  attr_accessor :name, :context
+
+  def initialize(name, context = {}, &ruby_code)
+    @context = context
+    @name = name
+    @ruby_code = ruby_code
+  end
+
+  def instantiate(modname)
+    new_class = Puppet::Resource::Type.new(:hostclass, @name, @context.merge(:module_name => modname))
+    new_class.ruby_code = @ruby_code if @ruby_code
+    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/vendor/gems/puppet-3.7.3/lib/puppet/parser/ast/ifstatement.rb

@@ -0,0 +1,34 @@
+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/vendor/gems/puppet-3.7.3/lib/puppet/parser/ast/in_operator.rb

@@ -0,0 +1,24 @@
+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/vendor/gems/puppet-3.7.3/lib/puppet/parser/ast/lambda.rb

@@ -0,0 +1,135 @@
+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/vendor/gems/puppet-3.7.3/lib/puppet/parser/ast/leaf.rb

@@ -0,0 +1,232 @@
+class Puppet::Parser::AST
+  # 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 Leaf < 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
+  end
+
+  # The boolean class.  True or false.  Converts the string it receives
+  # to a Ruby boolean.
+  class Boolean < AST::Leaf
+    def initialize(hash)
+      super
+
+      unless @value == true or @value == false
+        raise Puppet::DevError, "'#{@value}' is not a boolean"
+      end
+      @value
+    end
+  end
+
+  # The base string class.
+  class String < AST::Leaf
+    def evaluate(scope)
+      @value.dup
+    end
+
+    def to_s
+      @value.inspect
+    end
+  end
+
+  # An uninterpreted string.
+  class FlatString < AST::Leaf
+    def evaluate(scope)
+      @value
+    end
+
+    def to_s
+      @value.inspect
+    end
+  end
+
+  class Concat < AST::Leaf
+    def evaluate(scope)
+      @value.collect { |x| x.evaluate(scope) }.collect{ |x| x == :undef ? '' : x }.join
+    end
+
+    def to_s
+      "#{@value.map { |s| s.to_s.gsub(/^"(.*)"$/, '\1') }.join}"
+    end
+  end
+
+  # The 'default' option on case statements and selectors.
+  class Default < AST::Leaf; end
+
+  # Capitalized words; used mostly for type-defaults, but also
+  # get returned by the lexer any other time an unquoted capitalized
+  # word is found.
+  class Type < AST::Leaf; end
+
+  # Lower-case words.
+  class Name < AST::Leaf; end
+
+  # double-colon separated class names
+  class ClassName < AST::Leaf; end
+
+  # undef values; equiv to nil
+  class Undef < AST::Leaf; end
+
+  # Host names, either fully qualified or just the short name, or even a regex
+  class HostName < 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
+        @value =~ /[^-\w.]/ and
+          raise Puppet::DevError, "'#{@value}' is not a valid hostname"
+      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 = value.value if value.is_a?(HostName)
+      @value.eql?(value)
+    end
+
+    def hash
+      @value.hash
+    end
+  end
+
+  # A simple variable.  This object is only used during interpolation;
+  # the VarDef class is used for assignment.
+  class Variable < Name
+    # Looks up the value of the object in the scope tree (does
+    # not include syntactical constructs, like '$' and '{}').
+    def evaluate(scope)
+      parsewrap do
+        if scope.include?(@value)
+          scope[@value, {:file => file, :line => line}]
+        else
+          :undef
+        end
+      end
+    end
+
+    def to_s
+      "\$#{value}"
+    end
+  end
+
+  class HashOrArrayAccess < AST::Leaf
+    attr_accessor :variable, :key
+
+    def evaluate_container(scope)
+      container = variable.respond_to?(:evaluate) ? variable.safeevaluate(scope) : variable
+      if container.is_a?(Hash) || container.is_a?(Array)
+        container
+      elsif container.is_a?(::String)
+        scope[container, {:file => file, :line => line}]
+      else
+        raise Puppet::ParseError, "#{variable} is #{container.inspect}, not a hash or array"
+      end
+    end
+
+    def evaluate_key(scope)
+      key.respond_to?(:evaluate) ? key.safeevaluate(scope) : key
+    end
+
+    def array_index_or_key(object, key)
+      if object.is_a?(Array)
+        raise Puppet::ParseError, "#{key} is not an integer, but is used as an index of an array" unless key = Puppet::Parser::Scope.number?(key)
+      end
+      key
+    end
+
+    def evaluate(scope)
+      object = evaluate_container(scope)
+      accesskey = evaluate_key(scope)
+      raise Puppet::ParseError, "#{variable} is not a hash or array when accessing it with #{accesskey}" unless object.is_a?(Hash) or object.is_a?(Array)
+
+      result = object[array_index_or_key(object, accesskey)]
+      result.nil? ? :undef : result
+    end
+
+    # Assign value to this hashkey or array index
+    def assign(scope, value)
+      object = evaluate_container(scope)
+      accesskey = evaluate_key(scope)
+
+      if object.is_a?(Hash) and object.include?(accesskey)
+        raise Puppet::ParseError, "Assigning to the hash '#{variable}' with an existing key '#{accesskey}' is forbidden"
+      end
+
+      mutation_deprecation()
+
+      # assign to hash or array
+      object[array_index_or_key(object, accesskey)] = value
+    end
+
+    def to_s
+      "\$#{variable.to_s}[#{key.to_s}]"
+    end
+
+    def mutation_deprecation
+      deprecation_location_text =
+      if file && line
+        " at #{file}:#{line}"
+      elsif file
+        " in file #{file}"
+      elsif line
+        " at #{line}"
+      end
+      Puppet.warning(["The use of mutating operations on Array/Hash is deprecated#{deprecation_location_text}.",
+         " See http://links.puppetlabs.com/puppet-mutation-deprecation"].join(''))
+    end
+  end
+
+  class Regex < AST::Leaf
+    def initialize(hash)
+      super
+      @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 evaluate_match(value, scope, options = {})
+      value = value == :undef ? '' : value.to_s
+
+      if matched = @value.match(value)
+        scope.ephemeral_from(matched, options[:file], options[:line])
+      end
+      matched
+    end
+
+    def match(value)
+      @value.match(value)
+    end
+
+    def to_s
+      "/#{@value.source}/"
+    end
+  end
+end