puppet-debugger 0.4.0

data/lib/awesome_print/ext/awesome_puppet.rb

@@ -0,0 +1,40 @@
+module AwesomePrint
+  module Puppet
+    def self.included(base)
+      base.send :alias_method, :cast_without_puppet_resource, :cast
+      base.send :alias_method, :cast, :cast_with_puppet_resource
+    end
+
+    # this tells ap how to cast our object so we can be specific
+    # about printing different puppet objects
+    def cast_with_puppet_resource(object, type)
+      cast = cast_without_puppet_resource(object, type)
+      # check the object to see if it has an acestor (< ) of the specified type
+      if (defined?(::Puppet::Type)) && (object.class < ::Puppet::Type)
+        cast = :puppet_type
+      elsif (defined?(::Puppet::Pops::Types)) && (object.class < ::Puppet::Pops::Types)
+        cast = :puppet_type
+      elsif (defined?(::Puppet::Parser::Resource)) && (object.class < ::Puppet::Parser::Resource)
+        cast = :puppet_resource
+      elsif /Puppet::Pops::Types/.match(object.class.to_s)
+        cast = :puppet_type
+      end
+      cast
+    end
+
+    def awesome_puppet_resource(object)
+      return '' if object.nil?
+      awesome_puppet_type(object.to_ral)
+    end
+
+    def awesome_puppet_type(object)
+      return '' if object.nil?
+      return object.to_s unless object.respond_to?(:name) && object.respond_to?(:title)
+      h = object.to_hash.merge(:name => object.name, :title => object.title)
+      res_str = awesome_hash(h)
+      "#{object.class} #{res_str.gsub(':', '')}"
+    end
+  end
+end
+
+AwesomePrint::Formatter.send(:include, AwesomePrint::Puppet)

data/lib/puppet-debugger/cli.rb

@@ -0,0 +1,247 @@
+require 'puppet'
+require 'readline'
+require 'json'
+require_relative 'support'
+
+module PuppetDebugger
+  class Cli
+    include PuppetDebugger::Support
+
+    attr_accessor :settings, :log_level, :in_buffer, :out_buffer, :html_mode
+
+    def initialize(options={})
+      @log_level = 'notice'
+      @out_buffer = options[:out_buffer] || $stdout
+      @html_mode = options[:html_mode] || false
+      @source_file = options[:source_file] || nil
+      @source_line_num = options[:source_line] || nil
+      @in_buffer = options[:in_buffer] || $stdin
+      comp = Proc.new do |s|
+        key_words.grep(/^#{Regexp.escape(s)}/)
+      end
+      Readline.completion_append_character = ""
+      Readline.basic_word_break_characters = " "
+      Readline.completion_proc = comp
+      AwesomePrint.defaults = {
+        :html => @html_mode,
+        :sort_keys => true,
+        :indent => 2
+      }
+      do_initialize
+    end
+
+    # returns a cached list of key words
+    def key_words
+      # because dollar signs don't work we can't display a $ sign in the keyword
+      # list so its not explicitly clear what the keyword
+      variables = scope.to_hash.keys
+      # prepend a :: to topscope variables
+      scoped_vars = variables.map { |k,v| scope.compiler.topscope.exist?(k) ? "$::#{k}" : "$#{k}" }
+      # append a () to functions so we know they are functions
+      funcs = function_map.keys.map { |k| "#{k.split('::').last}()"}
+      (scoped_vars + funcs + static_responder_list).uniq.sort
+    end
+
+    # looks up the type in the catalog by using the type and title
+    # and returns the resource in ral format
+    def to_resource_declaration(type)
+      if type.respond_to?(:type_name) and type.respond_to?(:title)
+        title = type.title
+        type_name = type.type_name
+      elsif type_result = /(\w+)\['?(\w+)'?\]/.match(type.to_s)
+        # not all types have a type_name and title so we
+        # output to a string and parse the results
+        title = type_result[2]
+        type_name = type_result[1]
+      else
+        return type
+      end
+      res = scope.catalog.resource(type_name, title)
+      if res
+        return res.to_ral
+      end
+      # don't return anything or returns nil if item is not in the catalog
+    end
+
+    # ruturns a formatted array
+    def expand_resource_type(types)
+      output = [types].flatten.map do |t|
+        if t.class.to_s =~ /Puppet::Pops::Types/
+          to_resource_declaration(t)
+        else
+          t
+        end
+      end
+      output
+    end
+
+    def normalize_output(result)
+      if result.instance_of?(Array)
+        output = expand_resource_type(result)
+        if output.count == 1
+          return output.first
+        end
+        return output
+      elsif result.class.to_s =~ /Puppet::Pops::Types/
+        return to_resource_declaration(result)
+      end
+      result
+    end
+
+    # this method handles all input and expects a string of text.
+    #
+    def handle_input(input)
+        raise ArgumentError unless input.instance_of?(String)
+        begin
+          output = ''
+          case input
+          when /^play|^classification|^whereami|^facterdb_filter|^facts|^vars|^functions|^classes|^resources|^krt|^environment|^reset|^help/
+            args = input.split(' ')
+            command = args.shift.to_sym
+            if self.respond_to?(command)
+              output = self.send(command, args)
+            end
+            return out_buffer.puts output
+          when /exit/
+            exit 0
+          when /^:set/
+            output = handle_set(input)
+          when '_'
+            output = " => #{@last_item}"
+          else
+            result = puppet_eval(input)
+            @last_item = result
+            output = normalize_output(result)
+            if output.nil?
+              output = ""
+            else
+              output = output.ai
+            end
+          end
+        rescue LoadError => e
+          output = e.message.fatal
+        rescue Errno::ETIMEDOUT => e
+          output = e.message.fatal
+        rescue ArgumentError => e
+          output = e.message.fatal
+        rescue Puppet::ResourceError => e
+          output = e.message.fatal
+        rescue Puppet::Error => e
+          output = e.message.fatal
+        rescue Puppet::ParseErrorWithIssue => e
+          output = e.message.fatal
+        rescue PuppetDebugger::Exception::FatalError => e
+          output = e.message.fatal
+          out_buffer.puts output
+          exit 1 # this can sometimes causes tests to fail
+        rescue PuppetDebugger::Exception::Error => e
+          output = e.message.fatal
+        end
+        unless output.empty?
+          out_buffer.print " => "
+          out_buffer.puts output unless output.empty?
+        end
+    end
+
+    def self.print_repl_desc
+      output = <<-EOT
+Ruby Version: #{RUBY_VERSION}
+Puppet Version: #{Puppet.version}
+Puppet Debugger Version: #{PuppetDebugger::VERSION}
+Created by: NWOps <corey@nwops.io>
+Type "exit", "functions", "vars", "krt", "whereami", "facts", "resources", "classes",
+     "play", "classification", "reset", or "help" for more information.
+
+      EOT
+      output
+    end
+
+    # tries to determine if the input is going to be a multiline input
+    # by reading the parser error message
+    def multiline_input?(e)
+      case e.message
+      when /Syntax error at end of file/i
+        true
+      else
+        false
+      end
+    end
+
+    # reads input from stdin, since readline requires a tty
+    # we cannot read from other sources as readline requires a file object
+    # we parse the string after each input to determine if the input is a multiline_input
+    # entry.  If it is multiline we run through the loop again and concatenate the
+    # input
+    def read_loop
+      line_number = 1
+      full_buffer = ''
+      while buf = Readline.readline("#{line_number}:>> ", true)
+        begin
+          full_buffer += buf
+          # unless this is puppet code, otherwise skip repl keywords
+          unless keyword_expression.match(buf)
+            line_number = line_number.next
+            parser.parse_string(full_buffer)
+          end
+        rescue Puppet::ParseErrorWithIssue => e
+          if multiline_input?(e)
+            out_buffer.print '  '
+            full_buffer += "\n"
+            next
+          end
+        end
+        handle_input(full_buffer)
+        full_buffer = ''
+      end
+    end
+
+    # used to start a repl without attempting to read from stdin
+    # or
+    # @param [Hash] must contain at least the puppet scope object
+    def self.start_without_stdin(options={:scope => nil})
+      puts print_repl_desc unless options[:quiet]
+      repl_obj = PuppetDebugger::Cli.new(options)
+      repl_obj.remote_node_name = options[:node_name] if options[:node_name]
+      repl_obj.initialize_from_scope(options[:scope])
+      puts repl_obj.whereami if options[:source_file] and options[:source_line]
+      if options[:play]
+        repl_obj.play_back(options)
+      elsif ! options[:run_once]
+        repl_obj.read_loop
+      end
+    end
+
+    # start reads from stdin or from a file
+    # if from stdin, the repl will process the input and exit
+    # if from a file, the repl will process the file and continue to prompt
+    # @param [Hash] puppet scope object
+    def self.start(options={:scope => nil})
+      opts = Trollop::options do
+        opt :play, "Url or file to load from", :required => false, :type => String
+        opt :run_once, "Evaluate and quit", :required => false, :default => false
+        opt :node_name, "Remote Node to grab facts from", :required => false, :type => String
+        opt :quiet, "Do not display banner", :required => false, :default => false
+      end
+      options = opts.merge(options)
+      puts print_repl_desc unless options[:quiet]
+      repl_obj = PuppetDebugger::Cli.new(options)
+      repl_obj.remote_node_name = opts[:node_name] if opts[:node_name]
+      repl_obj.initialize_from_scope(options[:scope])
+      if options[:play]
+        repl_obj.play_back(opts)
+      # when the user supplied a file name without using the args (stdin)
+      elsif ARGF.filename != "-"
+        path = File.expand_path(ARGF.filename)
+        repl_obj.play_back(:play => path)
+      # when the user supplied a file content using stdin, aka. cat,pipe,echo or redirection
+      elsif ARGF.filename == "-" and (not STDIN.tty? and not STDIN.closed?)
+        input = ARGF.read
+        repl_obj.handle_input(input)
+      end
+      # helper code to make tests exit the loop
+      unless options[:run_once]
+        repl_obj.read_loop
+      end
+    end
+  end
+end

data/lib/puppet-debugger/code/code_file.rb

@@ -0,0 +1,98 @@
+
+class CodeFile
+  class SourceNotFound < Exception
+  end
+
+    DEFAULT_EXT = '.pp'
+
+    # List of all supported languages.
+    # @return [Hash]
+    EXTENSIONS = {
+      %w(.py)        => :python,
+      %w(.js)        => :javascript,
+      %w(.pp)        => :puppet,
+      %w(.css)       => :css,
+      %w(.xml)       => :xml,
+      %w(.php)       => :php,
+      %w(.html)      => :html,
+      %w(.diff)      => :diff,
+      %w(.java)      => :java,
+      %w(.json)      => :json,
+      %w(.c .h)      => :c,
+      %w(.rhtml)     => :rhtml,
+      %w(.yaml .yml) => :yaml,
+      %w(.cpp .hpp .cc .h cxx) => :cpp,
+      %w(.rb .ru .irbrc .gemspec .pryrc) => :ruby,
+    }
+
+    # @return [Symbol] The type of code stored in this wrapper.
+    attr_reader :code_type
+
+    # @param [String] filename The name of a file with code to be detected
+    # @param [Symbol] code_type The type of code the `filename` contains
+    def initialize(filename, code_type = type_from_filename(filename))
+      @filename = filename
+      @code_type = code_type
+    end
+
+    # @return [String] The code contained in the current `@filename`.
+    def code
+      path = abs_path
+      @code_type = type_from_filename(path)
+      File.read(path)
+    end
+
+    private
+
+    # @raise [MethodSource::SourceNotFoundError] if the `filename` is not
+    #   readable for some reason.
+    # @return [String] absolute path for the given `filename`.
+    def abs_path
+      code_path.detect { |path| readable?(path) } or
+        raise SourceNotFound,
+              "Cannot open #{ @filename.inspect } for reading."
+    end
+
+    # @param [String] path
+    # @return [Boolean] if the path, with or without the default ext,
+    #   is a readable file then `true`, otherwise `false`.
+    def readable?(path)
+      File.readable?(path) && !File.directory?(path) or
+        File.readable?(path << DEFAULT_EXT)
+    end
+
+    # @return [Array] All the paths that contain code that Pry can use for its
+    #   API's. Skips directories.
+    def code_path
+      [from_pwd, from_pry_init_pwd, *from_load_path]
+    end
+
+    # @param [String] filename
+    # @param [Symbol] default (:unknown) the file type to assume if none could be
+    #   detected.
+    # @return [Symbol, nil] The CodeRay type of a file from its extension, or
+    #   `nil` if `:unknown`.
+    def type_from_filename(filename, default = :unknown)
+      _, @code_type = EXTENSIONS.find do |k, _|
+        k.any? { |ext| ext == File.extname(filename) }
+      end
+
+      code_type || default
+    end
+
+    # @return [String]
+    def from_pwd
+      File.expand_path(@filename, Dir.pwd)
+    end
+
+    # @return [String]
+    def from_pry_init_pwd
+      File.expand_path(@filename, Dir.pwd)
+    end
+
+    # @return [String]
+    def from_load_path
+      $LOAD_PATH.map { |path| File.expand_path(@filename, path) }
+    end
+
+  end

data/lib/puppet-debugger/code/code_range.rb

@@ -0,0 +1,69 @@
+  class DebuggerCode
+
+    # Represents a range of lines in a code listing.
+    #
+    # @api private
+    class CodeRange
+
+      # @param [Integer] start_line
+      # @param [Integer?] end_line
+      def initialize(start_line, end_line = nil)
+        @start_line = start_line
+        @end_line   = end_line
+        force_set_end_line
+      end
+
+      # @param [Array<LOC>] lines
+      # @return [Range]
+      def indices_range(lines)
+        Range.new(*indices(lines))
+      end
+
+      private
+
+      def start_line; @start_line; end
+      def end_line; @end_line; end
+
+      # If `end_line` is equal to `nil`, then calculate it from the first
+      # parameter, `start_line`. Otherwise, leave it as it is.
+      # @return [void]
+      def force_set_end_line
+        if start_line.is_a?(Range)
+          set_end_line_from_range
+        else
+          @end_line ||= start_line
+        end
+      end
+
+      # Finds indices of `start_line` and `end_line` in the given Array of
+      # +lines+.
+      #
+      # @param [Array<LOC>] lines
+      # @return [Array<Integer>]
+      def indices(lines)
+        [find_start_index(lines), find_end_index(lines)]
+      end
+
+      # @return [Integer]
+      def find_start_index(lines)
+        return start_line if start_line < 0
+        lines.index { |loc| loc.lineno >= start_line } || lines.length
+      end
+
+      # @return [Integer]
+      def find_end_index(lines)
+        return end_line if end_line < 0
+        (lines.index { |loc| loc.lineno > end_line } || 0) - 1
+      end
+
+      # For example, if the range is 4..10, then `start_line` would be equal to
+      # 4 and `end_line` to 10.
+      # @return [void]
+      def set_end_line_from_range
+        @end_line = start_line.last
+        @end_line -= 1 if start_line.exclude_end?
+        @start_line = start_line.first
+      end
+    end
+
+  end

data/lib/puppet-debugger/code/loc.rb

@@ -0,0 +1,80 @@
+  class DebuggerCode
+
+    # Represents a line of code. A line of code is a tuple, which consists of a
+    # line and a line number. A `LOC` object's state (namely, the line
+    # parameter) can be changed via instance methods. `Pry::Code` heavily uses
+    # this class.
+    #
+    # @api private
+    # @example
+    #   loc = LOC.new("def example\n  :example\nend", 1)
+    #   puts loc.line
+    #   def example
+    #     :example
+    #   end
+    #   #=> nil
+    #
+    #   loc.indent(3)
+    #   loc.line #=> "   def example\n  :example\nend"
+    class LOC
+
+      # @return [Array<String, Integer>]
+      attr_reader :tuple
+
+      # @param [String] line The line of code.
+      # @param [Integer] lineno The position of the +line+.
+      def initialize(line, lineno)
+        @tuple = [line.chomp, lineno.to_i]
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        other.tuple == tuple
+      end
+
+      def dup
+        self.class.new(line, lineno)
+      end
+
+      # @return [String]
+      def line
+        tuple.first
+      end
+
+      # @return [Integer]
+      def lineno
+        tuple.last
+      end
+
+      #Prepends the line number `lineno` to the `line`.
+      # @param [Integer] max_width
+      # @return [void]
+      def add_line_number(max_width = 0)
+        padded = lineno.to_s.rjust(max_width)
+        tuple[0] = "#{ padded }: #{ line }"
+      end
+
+      # Prepends a marker "=>" or an empty marker to the +line+.
+      #
+      # @param [Integer] marker_lineno If it is equal to the `lineno`, then
+      #   prepend a hashrocket. Otherwise, an empty marker.
+      # @return [void]
+      def add_marker(marker_lineno)
+        tuple[0] =
+          if lineno == marker_lineno
+            " => #{ line }".cyan
+          else
+            "    #{ line }"
+          end
+      end
+
+      # Indents the `line` with +distance+ spaces.
+      #
+      # @param [Integer] distance
+      # @return [void]
+      def indent(distance)
+        tuple[0] = "#{ ' ' * distance }#{ line }"
+      end
+    end
+
+  end