puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/e4_parser_adapter.rb

@@ -0,0 +1,81 @@
+require 'puppet/pops'
+
+module Puppet; module Parser; end; end;
+# Adapts an egrammar/eparser to respond to the public API of the classic parser
+# and makes use of the new evaluator.
+#
+class Puppet::Parser::E4ParserAdapter
+
+  # Empty adapter fulfills watch_file contract without doing anything.
+  # @api private
+  class NullFileWatcher
+    def watch_file(file)
+      #nop
+    end
+  end
+
+  # @param file_watcher [#watch_file] something that can watch a file
+  def initialize(file_watcher = nil)
+    @file_watcher = file_watcher || NullFileWatcher.new
+    @file = ''
+    @string = ''
+    @use = :unspecified
+    @@evaluating_parser ||= Puppet::Pops::Parser::EvaluatingParser.new()
+  end
+
+  def file=(file)
+    @file = file
+    @use = :file
+    # watch if possible, but only if the file is something worth watching
+    @file_watcher.watch_file(file) if !file.nil? && file != ''
+  end
+
+  def parse(string = nil)
+    self.string= string if string
+
+    if @file =~ /\.rb$/ && @use != :string
+      # Will throw an error
+      parse_ruby_file
+    end
+
+    parse_result =
+    if @use == :string
+      # Parse with a source_file to set in created AST objects (it was either given, or it may be unknown
+      # if caller did not set a file and the present a string.
+      #
+      @@evaluating_parser.parse_string(@string, @file || "unknown-source-location")
+    else
+      @@evaluating_parser.parse_file(@file)
+    end
+
+    # the parse_result may be
+    # * empty / nil (no input)
+    # * a Model::Program
+    # * a Model::Expression
+    #
+    model = parse_result.nil? ? nil : parse_result.current 
+    args = {}
+    Puppet::Pops::Model::AstTransformer.new(@file).merge_location(args, model)
+
+    ast_code =
+    if model.is_a? Puppet::Pops::Model::Program
+      Puppet::Parser::AST::PopsBridge::Program.new(model, args)
+    else
+      args[:value] = model
+      Puppet::Parser::AST::PopsBridge::Expression.new(args)
+    end
+
+    # Create the "main" class for the content - this content will get merged with all other "main" content
+    Puppet::Parser::AST::Hostclass.new('', :code => ast_code)
+
+  end
+
+  def string=(string)
+    @string = string
+    @use = :string
+  end
+
+  def parse_ruby_file
+    raise Puppet::ParseError, "Ruby DSL is no longer supported. Attempt to parse #{@file}"
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/files.rb

@@ -0,0 +1,137 @@
+require 'puppet/module'
+
+module Puppet::Parser::Files
+
+  module_function
+
+  # Return a list of manifests as absolute filenames matching the given
+  # pattern.
+  #
+  # @param pattern [String] A reference for a file in a module. It is the format "<modulename>/<file glob>"
+  # @param environment [Puppet::Node::Environment] the environment of modules
+  #
+  # @return [Array(String, Array<String>)] the module name and the list of files found
+  # @api private
+  def find_manifests_in_modules(pattern, environment)
+    module_name, file_pattern = split_file_path(pattern)
+    begin
+      if mod = environment.module(module_name)
+        return [mod.name, mod.match_manifests(file_pattern)]
+      end
+    rescue Puppet::Module::InvalidName
+      # one of the modules being loaded might have an invalid name and so
+      # looking for one might blow up since we load them lazily.
+    end
+    [nil, []]
+  end
+
+  # Find the path to the given file selector. Files can be selected in
+  # one of two ways:
+  #   * absolute path: the path is simply returned
+  #   * modulename/filename selector: a file is found in the file directory
+  #     of the named module.
+  #
+  # In the second case a nil is returned if there isn't a file found. In the
+  # first case (absolute path), there is no existence check done and so the
+  # path will be returned even if there isn't a file available.
+  #
+  # @param template [String] the file selector
+  # @param environment [Puppet::Node::Environment] the environment in which to search
+  # @return [String, nil] the absolute path to the file or nil if there is no file found
+  #
+  # @api private
+  def find_file(file, environment)
+    if Puppet::Util.absolute_path?(file)
+      file
+    else
+      path, module_file = split_file_path(file)
+      mod = environment.module(path)
+
+      if module_file && mod
+        mod.file(module_file)
+      else
+        nil
+      end
+    end
+  end
+
+  # Find the path to the given template selector. Templates can be selected in
+  # a number of ways:
+  #   * absolute path: the path is simply returned
+  #   * path relative to the templatepath setting: a file is found and the path
+  #     is returned
+  #   * modulename/filename selector: a file is found in the template directory
+  #     of the named module.
+  #
+  # In the last two cases a nil is returned if there isn't a file found. In the
+  # first case (absolute path), there is no existence check done and so the
+  # path will be returned even if there isn't a file available.
+  #
+  # @param template [String] the template selector
+  # @param environment [Puppet::Node::Environment] the environment in which to search
+  # @return [String, nil] the absolute path to the template file or nil if there is no file found
+  #
+  # @api private
+  def find_template(template, environment)
+    if Puppet::Util.absolute_path?(template)
+      template
+    else
+      in_templatepath = find_template_in_templatepath(template, environment)
+      if in_templatepath
+        in_templatepath
+      else
+        find_template_in_module(template, environment)
+      end
+    end
+  end
+
+  # Templatepaths are deprecated functionality, this will be going away in
+  # Puppet 4.
+  #
+  # @api private
+  def find_template_in_templatepath(template, environment)
+    template_paths = templatepath(environment)
+    if template_paths
+      template_paths.collect do |path|
+        File::join(path, template)
+      end.find do |f|
+        Puppet::FileSystem.exist?(f)
+      end
+    else
+      nil
+    end
+  end
+
+  # @api private
+  def find_template_in_module(template, environment)
+    path, file = split_file_path(template)
+    mod = environment.module(path)
+
+    if file && mod
+      mod.template(file)
+    else
+      nil
+    end
+  end
+
+  # Return an array of paths by splitting the +templatedir+ config
+  # parameter.
+  # @api private
+  def templatepath(environment)
+    dirs = Puppet.settings.value(:templatedir, environment.to_s).split(File::PATH_SEPARATOR)
+    dirs.select do |p|
+      File::directory?(p)
+    end
+  end
+
+  # Split the path into the module and the rest of the path, or return
+  # nil if the path is empty or absolute (starts with a /).
+  # @api private
+  def split_file_path(path)
+    if path == "" || Puppet::Util.absolute_path?(path)
+      nil
+    else
+      path.split(File::SEPARATOR, 2)
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/parser/functions.rb

@@ -0,0 +1,262 @@
+require 'puppet/util/autoload'
+require 'puppet/parser/scope'
+
+# A module for managing parser functions.  Each specified function
+# is added to a central module that then gets included into the Scope
+# class.
+#
+# @api public
+module Puppet::Parser::Functions
+  Environment = Puppet::Node::Environment
+
+  class << self
+    include Puppet::Util
+  end
+
+  # Reset the list of loaded functions.
+  #
+  # @api private
+  def self.reset
+    @modules = {}
+
+    # Runs a newfunction to create a function for each of the log levels
+    Puppet::Util::Log.levels.each do |level|
+      newfunction(level,
+                  :environment => Puppet.lookup(:root_environment),
+                  :doc => "Log a message on the server at level #{level.to_s}.") do |vals|
+        send(level, vals.join(" "))
+      end
+    end
+  end
+
+  # Accessor for singleton autoloader
+  #
+  # @api private
+  def self.autoloader
+    @autoloader ||= Puppet::Util::Autoload.new(
+      self, "puppet/parser/functions", :wrap => false
+    )
+  end
+
+  # Get the module that functions are mixed into corresponding to an
+  # environment
+  #
+  # @api private
+  def self.environment_module(env)
+    @modules[env.name] ||= Module.new do
+      @metadata = {}
+
+      def self.all_function_info
+        @metadata
+      end
+
+      def self.get_function_info(name)
+        @metadata[name]
+      end
+
+      def self.add_function_info(name, info)
+        @metadata[name] = info
+      end
+    end
+  end
+
+  # Create a new Puppet DSL function.
+  #
+  # **The {newfunction} method provides a public API.**
+  #
+  # This method is used both internally inside of Puppet to define parser
+  # functions.  For example, template() is defined in
+  # {file:lib/puppet/parser/functions/template.rb template.rb} using the
+  # {newfunction} method.  Third party Puppet modules such as
+  # [stdlib](https://forge.puppetlabs.com/puppetlabs/stdlib) use this method to
+  # extend the behavior and functionality of Puppet.
+  #
+  # See also [Docs: Custom
+  # Functions](http://docs.puppetlabs.com/guides/custom_functions.html)
+  #
+  # @example Define a new Puppet DSL Function
+  #     >> Puppet::Parser::Functions.newfunction(:double, :arity => 1,
+  #          :doc => "Doubles an object, typically a number or string.",
+  #          :type => :rvalue) {|i| i[0]*2 }
+  #     => {:arity=>1, :type=>:rvalue,
+  #         :name=>"function_double",
+  #         :doc=>"Doubles an object, typically a number or string."}
+  #
+  # @example Invoke the double function from irb as is done in RSpec examples:
+  #     >> require 'puppet_spec/scope'
+  #     >> scope = PuppetSpec::Scope.create_test_scope_for_node('example')
+  #     => Scope()
+  #     >> scope.function_double([2])
+  #     => 4
+  #     >> scope.function_double([4])
+  #     => 8
+  #     >> scope.function_double([])
+  #     ArgumentError: double(): Wrong number of arguments given (0 for 1)
+  #     >> scope.function_double([4,8])
+  #     ArgumentError: double(): Wrong number of arguments given (2 for 1)
+  #     >> scope.function_double(["hello"])
+  #     => "hellohello"
+  #
+  # @param [Symbol] name the name of the function represented as a ruby Symbol.
+  #   The {newfunction} method will define a Ruby method based on this name on
+  #   the parser scope instance.
+  #
+  # @param [Proc] block the block provided to the {newfunction} method will be
+  #   executed when the Puppet DSL function is evaluated during catalog
+  #   compilation.  The arguments to the function will be passed as an array to
+  #   the first argument of the block.  The return value of the block will be
+  #   the return value of the Puppet DSL function for `:rvalue` functions.
+  #
+  # @option options [:rvalue, :statement] :type (:statement) the type of function.
+  #   Either `:rvalue` for functions that return a value, or `:statement` for
+  #   functions that do not return a value.
+  #
+  # @option options [String] :doc ('') the documentation for the function.
+  #   This string will be extracted by documentation generation tools.
+  #
+  # @option options [Integer] :arity (-1) the
+  #   [arity](http://en.wikipedia.org/wiki/Arity) of the function.  When
+  #   specified as a positive integer the function is expected to receive
+  #   _exactly_ the specified number of arguments.  When specified as a
+  #   negative number, the function is expected to receive _at least_ the
+  #   absolute value of the specified number of arguments incremented by one.
+  #   For example, a function with an arity of `-4` is expected to receive at
+  #   minimum 3 arguments.  A function with the default arity of `-1` accepts
+  #   zero or more arguments.  A function with an arity of 2 must be provided
+  #   with exactly two arguments, no more and no less.  Added in Puppet 3.1.0.
+  #
+  # @option options [Puppet::Node::Environment] :environment (nil) can
+  #   explicitly pass the environment we wanted the function added to.  Only used
+  #   to set logging functions in root environment
+  #
+  # @return [Hash] describing the function.
+  #
+  # @api public
+  def self.newfunction(name, options = {}, &block)
+    name = name.intern
+    environment = options[:environment] || Puppet.lookup(:current_environment)
+
+    Puppet.warning "Overwriting previous definition for function #{name}" if get_function(name, environment)
+
+    arity = options[:arity] || -1
+    ftype = options[:type] || :statement
+
+    unless ftype == :statement or ftype == :rvalue
+      raise Puppet::DevError, "Invalid statement type #{ftype.inspect}"
+    end
+
+    # the block must be installed as a method because it may use "return",
+    # which is not allowed from procs.
+    real_fname = "real_function_#{name}"
+    environment_module(environment).send(:define_method, real_fname, &block)
+
+    fname = "function_#{name}"
+    env_module = environment_module(environment)
+
+    env_module.send(:define_method, fname) do |*args|
+      Puppet::Util::Profiler.profile("Called #{name}", [:functions, name]) do
+        if args[0].is_a? Array
+          if arity >= 0 and args[0].size != arity
+            raise ArgumentError, "#{name}(): Wrong number of arguments given (#{args[0].size} for #{arity})"
+          elsif arity < 0 and args[0].size < (arity+1).abs
+            raise ArgumentError, "#{name}(): Wrong number of arguments given (#{args[0].size} for minimum #{(arity+1).abs})"
+          end
+          self.send(real_fname, args[0])
+        else
+          raise ArgumentError, "custom functions must be called with a single array that contains the arguments. For example, function_example([1]) instead of function_example(1)"
+        end
+      end
+    end
+
+    func = {:arity => arity, :type => ftype, :name => fname}
+    func[:doc] = options[:doc] if options[:doc]
+
+    env_module.add_function_info(name, func)
+
+    func
+  end
+
+  # Determine if a function is defined
+  #
+  # @param [Symbol] name the function
+  # @param [Puppet::Node::Environment] environment the environment to find the function in
+  #
+  # @return [Symbol, false] The name of the function if it's defined,
+  #   otherwise false.
+  #
+  # @api public
+  def self.function(name, environment = Puppet.lookup(:current_environment))
+    name = name.intern
+
+    func = nil
+    unless func = get_function(name, environment)
+      autoloader.load(name, environment)
+      func = get_function(name, environment)
+    end
+
+    if func
+      func[:name]
+    else
+      false
+    end
+  end
+
+  def self.functiondocs(environment = Puppet.lookup(:current_environment))
+    autoloader.loadall
+
+    ret = ""
+
+    merged_functions(environment).sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, hash|
+      ret << "#{name}\n#{"-" * name.to_s.length}\n"
+      if hash[:doc]
+        ret << Puppet::Util::Docs.scrub(hash[:doc])
+      else
+        ret << "Undocumented.\n"
+      end
+
+      ret << "\n\n- *Type*: #{hash[:type]}\n\n"
+    end
+
+    ret
+  end
+
+  # Determine whether a given function returns a value.
+  #
+  # @param [Symbol] name the function
+  # @param [Puppet::Node::Environment] environment The environment to find the function in
+  # @return [Boolean] whether it is an rvalue function
+  #
+  # @api public
+  def self.rvalue?(name, environment = Puppet.lookup(:current_environment))
+    func = get_function(name, environment)
+    func ? func[:type] == :rvalue : false
+  end
+
+  # Return the number of arguments a function expects.
+  #
+  # @param [Symbol] name the function
+  # @param [Puppet::Node::Environment] environment The environment to find the function in
+  # @return [Integer] The arity of the function. See {newfunction} for
+  #   the meaning of negative values.
+  #
+  # @api public
+  def self.arity(name, environment = Puppet.lookup(:current_environment))
+    func = get_function(name, environment)
+    func ? func[:arity] : -1
+  end
+
+  class << self
+    private
+
+    def merged_functions(environment)
+      root = environment_module(Puppet.lookup(:root_environment))
+      env = environment_module(environment)
+
+      root.all_function_info.merge(env.all_function_info)
+    end
+
+    def get_function(name, environment)
+      environment_module(environment).get_function_info(name.intern) || environment_module(Puppet.lookup(:root_environment)).get_function_info(name.intern)
+    end
+  end
+end