puppet-debugger 0.4.0

data/lib/puppet-debugger/debugger_code.rb

@@ -0,0 +1,318 @@
+require_relative 'code/loc'
+require_relative 'code/code_range'
+require_relative 'code/code_file'
+
+  # `Pry::Code` is a class that encapsulates lines of source code and their
+  # line numbers and formats them for terminal output. It can read from a file
+  # or method definition or be instantiated with a `String` or an `Array`.
+  #
+  # In general, the formatting methods in `Code` return a new `Code` object
+  # which will format the text as specified when `#to_s` is called. This allows
+  # arbitrary chaining of formatting methods without mutating the original
+  # object.
+  class DebuggerCode
+    class << self
+     # include MethodSource::CodeHelpers
+
+      # Instantiate a `Code` object containing code loaded from a file or
+      # Pry's line buffer.
+      #
+      # @param [String] filename The name of a file, or "(pry)".
+      # @param [Symbol] code_type The type of code the file contains.
+      # @return [Code]
+      def from_file(filename, code_type = nil)
+        code_file = CodeFile.new(filename, code_type)
+        new(code_file.code, 1, code_file.code_type)
+      end
+
+      # Instantiate a `Code` object containing code loaded from a file or
+      # Pry's line buffer.
+      #
+      # @param [String] source code".
+      # @param [Symbol] code_type The type of code the file contains.
+      # @return [Code]
+      def from_string(code, code_type = nil)
+        new(code, 1, code_type)
+      end
+    end
+
+    # @return [Symbol] The type of code stored in this wrapper.
+    attr_accessor :code_type
+
+    # Instantiate a `Code` object containing code from the given `Array`,
+    # `String`, or `IO`. The first line will be line 1 unless specified
+    # otherwise. If you need non-contiguous line numbers, you can create an
+    # empty `Code` object and then use `#push` to insert the lines.
+    #
+    # @param [Array<String>, String, IO] lines
+    # @param [Integer?] start_line
+    # @param [Symbol?] code_type
+    def initialize(lines = [], start_line = 1, code_type = :ruby)
+      if lines.is_a? String
+        lines = lines.lines
+      end
+      @lines = lines.each_with_index.map { |line, lineno|
+        LOC.new(line, lineno + start_line.to_i) }
+      @code_type = code_type
+
+      @with_marker = @with_indentation = nil
+    end
+
+    # Append the given line. +lineno+ is one more than the last existing
+    # line, unless specified otherwise.
+    #
+    # @param [String] line
+    # @param [Integer?] lineno
+    # @return [String] The inserted line.
+    def push(line, lineno = nil)
+      if lineno.nil?
+        lineno = @lines.last.lineno + 1
+      end
+      @lines.push(LOC.new(line, lineno))
+      line
+    end
+    alias << push
+
+    # Filter the lines using the given block.
+    #
+    # @yield [LOC]
+    # @return [Code]
+    def select(&block)
+      alter do
+        @lines = @lines.select(&block)
+      end
+    end
+
+    # Remove all lines that aren't in the given range, expressed either as a
+    # `Range` object or a first and last line number (inclusive). Negative
+    # indices count from the end of the array of lines.
+    #
+    # @param [Range, Integer] start_line
+    # @param [Integer?] end_line
+    # @return [Code]
+    def between(start_line, end_line = nil)
+      return self unless start_line
+
+      code_range = CodeRange.new(start_line, end_line)
+
+      alter do
+        @lines = @lines[code_range.indices_range(@lines)] || []
+      end
+    end
+
+    # Take `num_lines` from `start_line`, forward or backwards.
+    #
+    # @param [Integer] start_line
+    # @param [Integer] num_lines
+    # @return [Code]
+    def take_lines(start_line, num_lines)
+      start_idx =
+        if start_line >= 0
+          @lines.index { |loc| loc.lineno >= start_line } || @lines.length
+        else
+          [@lines.length + start_line, 0].max
+        end
+
+      alter do
+        @lines = @lines.slice(start_idx, num_lines)
+      end
+    end
+
+    # Remove all lines except for the +lines+ up to and excluding +lineno+.
+    #
+    # @param [Integer] lineno
+    # @param [Integer] lines
+    # @return [Code]
+    def before(lineno, lines = 1)
+      return self unless lineno
+
+      select do |loc|
+        loc.lineno >= lineno - lines && loc.lineno < lineno
+      end
+    end
+
+    # Remove all lines except for the +lines+ on either side of and including
+    # +lineno+.
+    #
+    # @param [Integer] lineno
+    # @param [Integer] lines
+    # @return [Code]
+    def around(lineno, lines = 1)
+      return self unless lineno
+
+      select do |loc|
+        loc.lineno >= lineno - lines && loc.lineno <= lineno + lines
+      end
+    end
+
+    # Remove all lines except for the +lines+ after and excluding +lineno+.
+    #
+    # @param [Integer] lineno
+    # @param [Integer] lines
+    # @return [Code]
+    def after(lineno, lines = 1)
+      return self unless lineno
+
+      select do |loc|
+        loc.lineno > lineno && loc.lineno <= lineno + lines
+      end
+    end
+
+    # Remove all lines that don't match the given `pattern`.
+    #
+    # @param [Regexp] pattern
+    # @return [Code]
+    def grep(pattern)
+      return self unless pattern
+      pattern = Regexp.new(pattern)
+
+      select do |loc|
+        loc.line =~ pattern
+      end
+    end
+
+    # Format output with line numbers next to it, unless `y_n` is falsy.
+    #
+    # @param [Boolean?] y_n
+    # @return [Code]
+    def with_line_numbers(y_n = true)
+      alter do
+        @with_line_numbers = y_n
+      end
+    end
+
+    # Format output with a marker next to the given +lineno+, unless +lineno+ is
+    # falsy.
+    #
+    # @param [Integer?] lineno
+    # @return [Code]
+    def with_marker(lineno = 1)
+      alter do
+        @with_marker   = !!lineno
+        @marker_lineno = lineno
+      end
+    end
+
+    # Format output with the specified number of spaces in front of every line,
+    # unless `spaces` is falsy.
+    #
+    # @param [Integer?] spaces
+    # @return [Code]
+    def with_indentation(spaces = 0)
+      alter do
+        @with_indentation = !!spaces
+        @indentation_num  = spaces
+      end
+    end
+
+    # @return [String]
+    def inspect
+      Object.instance_method(:to_s).bind(self).call
+    end
+
+    # @return [Integer] the number of digits in the last line.
+    def max_lineno_width
+      @lines.length > 0 ? @lines.last.lineno.to_s.length : 0
+    end
+
+    # @return [String] a formatted representation (based on the configuration of
+    #   the object).
+    def to_s
+      print_to_output("", false)
+    end
+
+    # @return [String] a (possibly highlighted) copy of the source code.
+    def highlighted
+      print_to_output("", true)
+    end
+
+    # Writes a formatted representation (based on the configuration of the
+    # object) to the given output, which must respond to `#<<`.
+    def print_to_output(output, color=false)
+      @lines.each do |loc|
+        loc = loc.dup
+        loc.add_line_number(max_lineno_width) if @with_line_numbers
+        loc.add_marker(@marker_lineno)        if @with_marker
+        loc.indent(@indentation_num)          if @with_indentation
+        output << loc.line
+        output << "\n"
+      end
+      output
+    end
+
+    # Get the comment that describes the expression on the given line number.
+    #
+    # @param [Integer] line_number (1-based)
+    # @return [String] the code.
+    def comment_describing(line_number)
+      self.class.comment_describing(raw, line_number)
+    end
+
+    # Get the multiline expression that starts on the given line number.
+    #
+    # @param [Integer] line_number (1-based)
+    # @return [String] the code.
+    def expression_at(line_number, consume = 0)
+      self.class.expression_at(raw, line_number, :consume => consume)
+    end
+
+    # Get the multiline expression that starts on the given line number.
+    #
+    # @param [Integer] line_number (1-based)
+    # @return [String] the code.
+    def self.expression_at(raw, line_number, consume = 0)
+      #self.class.expression_at(raw, line_number, :consume => consume)
+      raw
+    end
+
+    # Get the (approximate) Module.nesting at the give line number.
+    #
+    # @param [Integer] line_number line number starting from 1
+    # @param [Module] top_module the module in which this code exists
+    # @return [Array<Module>] a list of open modules.
+    def nesting_at(line_number, top_module = Object)
+      Indent.nesting_at(raw, line_number)
+    end
+
+    # Return an unformatted String of the code.
+    #
+    # @return [String]
+    def raw
+      @lines.map(&:line).join("\n") << "\n"
+    end
+
+    # Return the number of lines stored.
+    #
+    # @return [Integer]
+    def length
+      @lines ? @lines.length : 0
+    end
+
+    # Two `Code` objects are equal if they contain the same lines with the same
+    # numbers. Otherwise, call `to_s` and `chomp` and compare as Strings.
+    #
+    # @param [Code, Object] other
+    # @return [Boolean]
+    def ==(other)
+      if other.is_a?(Code)
+        other_lines = other.instance_variable_get(:@lines)
+        @lines.each_with_index.all? { |loc, i| loc == other_lines[i] }
+      else
+        to_s.chomp == other.to_s.chomp
+      end
+    end
+
+    # Forward any missing methods to the output of `#to_s`.
+    def method_missing(name, *args, &block)
+      to_s.send(name, *args, &block)
+    end
+    undef =~
+
+    protected
+
+    # An abstraction of the `dup.instance_eval` pattern used throughout this
+    # class.
+    def alter(&block)
+      dup.tap { |o| o.instance_eval(&block) }
+    end
+  end

data/lib/puppet-debugger/support/compiler.rb

@@ -0,0 +1,20 @@
+require 'tempfile'
+
+module PuppetDebugger
+  module Support
+    module Compilier
+      def create_compiler(node)
+        Puppet::Parser::Compiler.new(node)
+      end
+
+      def compiler
+        @compiler
+      end
+
+      def set_compiler(value)
+        @compiler = value
+      end
+
+    end
+  end
+end

data/lib/puppet-debugger/support/environment.rb

@@ -0,0 +1,38 @@
+module PuppetDebugger
+  module Support
+    module Environment
+      # creates a puppet environment given a module path and environment name
+      # this is cached
+      def puppet_environment
+        @puppet_environment ||= create_environment
+      end
+
+      def create_environment
+        @puppet_environment = Puppet::Node::Environment.create(
+          default_puppet_env_name,
+          default_modules_paths,
+          default_manifests_dir
+        )
+      end
+
+      def set_environment(value)
+        @puppet_environment = value
+      end
+
+      def puppet_env_name
+        puppet_environment.name
+      end
+
+      # the cached name of the environment
+      def default_puppet_env_name
+         ENV['PUPPET_ENV'] || Puppet[:environment]
+      end
+
+      # currently this is not being used
+      def environment_loaders
+        name = compiler.loaders.public_environment_loader.loader_name
+      end
+
+    end
+  end
+end

data/lib/puppet-debugger/support/errors.rb

@@ -0,0 +1,75 @@
+module PuppetDebugger
+  module Exception
+    class Error < StandardError
+      attr_accessor :data
+      def initialize(data={})
+        @data = data
+      end
+
+    end
+
+    class FatalError < Error
+    end
+
+    class ConnectError < Error
+      def message
+        out = <<-EOF
+#{data[:message]}
+EOF
+      end
+    end
+
+    class BadFilter < FatalError
+      def message
+        data[:message]
+      end
+    end
+
+    class UndefinedNode < FatalError
+      def message
+        out = <<-EOF
+Cannot find node with name: #{data[:name]} on remote server
+    EOF
+      end
+    end
+
+    class TimeOutError < Error
+      #Errno::ETIMEDOUT
+    end
+
+    class NoClassError < FatalError
+      def message
+        out = <<-EOF
+#{data[:message]}
+You are missing puppet classes that are required for compilation.
+Please ensure these classes are installed on this machine in any of the following paths:
+#{data[:default_modules_paths]}
+EOF
+      end
+    end
+
+    class NodeDefinitionError < FatalError
+      def message
+        out = <<-EOF
+You are missing a default node definition in your site.pp that is required for compilation.
+Please ensure you have at least the following default node definition
+  node default {
+    # include classes here
+  }
+in your #{data[:default_site_manifest]} file.
+EOF
+        out.fatal
+      end
+    end
+
+    class AuthError < FatalError
+      def message
+        out = <<-EOF
+#{data[:message]}
+You will need to edit your auth.conf or conf.d/auth.conf (puppetserver) to allow node calls.
+EOF
+    end
+    end
+
+  end
+end

data/lib/puppet-debugger/support/facts.rb

@@ -0,0 +1,78 @@
+module PuppetDebugger
+  module Support
+    module Facts
+      # in the future we will want to grab real facts from real systems via puppetdb
+      # or enc data
+
+      # allow the user to specify the facterdb filter
+      def dynamic_facterdb_filter
+        ENV['REPL_FACTERDB_FILTER'] || default_facterdb_filter
+      end
+
+      def default_facterdb_filter
+        "operatingsystem=#{facter_os_name} and operatingsystemrelease=#{facter_os_version} and architecture=x86_64 and facterversion=#{facter_version}"
+      end
+
+      def facter_version
+        ENV['REPL_FACTER_VERSION'] || default_facter_version
+      end
+
+      # return the correct supported version of facter facts
+      def default_facter_version
+        if Gem::Version.new(Puppet.version) >= Gem::Version.new(4.4)
+          '/^3\.1/'
+        else
+          '/^2\.4/'
+        end
+      end
+
+      def facter_os_name
+        ENV['REPL_FACTER_OS_NAME'] || 'Fedora'
+      end
+
+      def facter_os_version
+        ENV['REPL_FACTER_OS_VERSION'] || '23'
+      end
+
+      def set_facts(value)
+        @facts = value
+      end
+
+      # uses facterdb (cached facts) and retrives the facts given a filter
+      # creates a new facts object
+      # we could also use fact_merge to get real facts from the real system or puppetdb
+      def node_facts
+        node_facts = FacterDB.get_facts(dynamic_facterdb_filter).first
+        if node_facts.nil?
+          message = <<-EOS
+Using filter: #{facterdb_filter}
+Bad FacterDB filter, please change the filter so it returns a result set.
+See https://github.com/camptocamp/facterdb/#with-a-string-filter
+          EOS
+          raise PuppetDebugger::Exception::BadFilter.new(:message => message)
+        end
+        # fix for when --show-legacy facts are not part of the facter 3 fact set
+        node_facts[:fqdn] = node_facts[:networking].fetch('fqdn',nil) unless node_facts[:fqdn]
+        node_facts
+      end
+
+      def default_facts
+        unless @facts
+          values = Hash[ node_facts.map { |k, v| [k.to_s, v] } ]
+          name = values['fqdn']
+          @facts ||= Puppet::Node::Facts.new(name, values)
+        end
+        @facts
+      end
+
+      def server_facts
+        data = {}
+        data["servername"] = Facter.value("fqdn") || Facter.value('networking')['fqdn']
+        data['serverip'] = Facter.value("ipaddress")
+        data["serverversion"] = Puppet.version.to_s
+        data
+      end
+
+    end
+  end
+end

data/lib/puppet-debugger/support/functions.rb

@@ -0,0 +1,72 @@
+module PuppetDebugger
+  module Support
+    module Functions
+      # returns a array of function files which is only required
+      # when displaying the function map, puppet will load each function on demand
+      # in the future we may want to utilize the puppet loaders to find these things
+      def function_files
+        search_dirs = lib_dirs.map do |lib_dir|
+          [File.join(lib_dir, 'puppet', 'functions', '**', '*.rb'),
+            File.join(lib_dir, 'functions', '**', '*.rb'),
+           File.join(lib_dir, 'puppet', 'parser', 'functions', '*.rb')
+           ]
+        end
+        # add puppet lib directories
+        search_dirs << [File.join(puppet_lib_dir, 'puppet', 'functions', '**', '*.rb'),
+          File.join(puppet_lib_dir, 'puppet', 'parser', 'functions', '*.rb')
+         ]
+        Dir.glob(search_dirs.flatten)
+      end
+
+      # returns either the module name or puppet version
+      def mod_finder
+        @mod_finder ||= Regexp.new('\/([\w\-\.]+)\/lib')
+      end
+
+      # returns a map of functions
+      def function_map
+        unless @functions
+          do_initialize
+          @functions = {}
+          function_files.each do |file|
+            obj = {}
+            name = File.basename(file, '.rb')
+            obj[:name] = name
+            obj[:parent] = mod_finder.match(file)[1]
+            @functions["#{obj[:parent]}::#{name}"] = obj
+          end
+        end
+        @functions
+      end
+
+      # returns an array of module loaders that we may need to use in the future
+      # in order to parse all types of code (ie. functions)  For now this is not
+      # being used.
+      def resolve_paths(loaders)
+        mod_resolver = loaders.instance_variable_get(:@module_resolver)
+        all_mods = mod_resolver.instance_variable_get(:@all_module_loaders)
+      end
+
+      # gather all the lib dirs
+      def lib_dirs
+        dirs = modules_paths.map do |mod_dir|
+          Dir["#{mod_dir}/*/lib"].entries
+        end.flatten
+        dirs + [puppet_repl_lib_dir]
+      end
+
+      # load all the lib dirs so puppet can find the functions
+      # at this time, this function is not being used
+      def load_lib_dirs
+        lib_dirs.each do |lib|
+          $LOAD_PATH << lib
+        end
+      end
+
+      # def functions
+      #   @functions = []
+      #   @functions << compiler.loaders.static_loader.loaded.keys.find_all {|l| l.type == :function}
+      # end
+    end
+  end
+end