puppet-debugger 0.6.1 → 0.7.0

data/lib/plugins/puppet-debugger/input_responders/reset.rb

@@ -0,0 +1,21 @@
+require 'puppet-debugger/input_responder_plugin'
+module PuppetDebugger
+  module InputResponders
+    class Reset < InputResponderPlugin
+      COMMAND_WORDS = %w(reset)
+      SUMMARY = 'Reset the debugger to a clean state.'
+      COMMAND_GROUP = :context
+
+      def run(args = [])
+        debugger.set_scope(nil)
+        debugger.set_remote_node_name(nil)
+        debugger.set_node(nil)
+        debugger.set_facts(nil)
+        debugger.set_environment(nil)
+        debugger.set_compiler(nil)
+        #debugger.handle_input(":set loglevel #{debugger.log_level}")
+        nil
+      end
+    end
+  end
+end

data/lib/plugins/puppet-debugger/input_responders/resources.rb

@@ -0,0 +1,22 @@
+require 'puppet-debugger/input_responder_plugin'
+module PuppetDebugger
+  module InputResponders
+    class Resources < InputResponderPlugin
+      COMMAND_WORDS = %w(resources)
+      SUMMARY = 'List all the resources current in the catalog.'
+      COMMAND_GROUP = :scope
+
+      def run(args = [])
+        res = debugger.scope.compiler.catalog.resources.map do |res|
+          res.to_s.gsub(/\[/, "['").gsub(/\]/, "']") # ensure the title has quotes
+        end
+        if !args.first.nil?
+          res[args.first.to_i].ai
+        else
+          output = "Resources not shown in any specific order\n".warning
+          output += res.ai
+        end
+      end
+    end
+  end
+end

data/lib/plugins/puppet-debugger/input_responders/set.rb

@@ -0,0 +1,55 @@
+require 'puppet-debugger/input_responder_plugin'
+module PuppetDebugger
+  module InputResponders
+    class Set < InputResponderPlugin
+      COMMAND_WORDS = %w(set :set)
+      SUMMARY = 'Set the a puppet debugger config'
+      COMMAND_GROUP = :scope
+
+      def run(args = [])
+        handle_set(args)
+      end
+
+      private
+
+      def handle_set(input)
+        output = ''
+        # args = input.split(' ')
+        # args.shift # throw away the set
+        case input.shift
+          when /node/
+            if name = input.shift
+              output = "Resetting to use node #{name}"
+              debugger.set_scope(nil)
+              debugger.set_node(nil)
+              debugger.set_facts(nil)
+              debugger.set_environment(nil)
+              debugger.set_compiler(nil)
+              set_log_level(debugger.log_level)
+              debugger.set_remote_node_name(name)
+            else
+              debugger.out_buffer.puts 'Must supply a valid node name'
+            end
+          when /loglevel/
+            if level = input.shift
+              set_log_level(level)
+              output = "loglevel #{Puppet::Util::Log.level} is set"
+            end
+        end
+        output
+      end
+
+      def set_log_level(level)
+        debugger.log_level = level
+        Puppet::Util::Log.level = level.to_sym
+        buffer_log = Puppet::Util::Log.newdestination(:buffer)
+        if buffer_log
+          # if this is already set the buffer_log is nil
+          buffer_log.out_buffer = debugger.out_buffer
+          buffer_log.err_buffer = debugger.out_buffer
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/plugins/puppet-debugger/input_responders/types.rb

@@ -0,0 +1,35 @@
+require 'puppet-debugger/input_responder_plugin'
+module PuppetDebugger
+  module InputResponders
+    class Types < InputResponderPlugin
+      COMMAND_WORDS = %w(types)
+      SUMMARY = 'List all the types available in the environment.'
+      COMMAND_GROUP = :environment
+
+      # @return - returns a list of types available to the environment
+      # if a error occurs we we run the types function again
+      def run(args = [])
+        types
+      end
+
+      def types
+        loaded_types = []
+        begin
+          # this loads all the types, if already loaded the file is skipped
+          Puppet::Type.loadall
+          Puppet::Type.eachtype do |t|
+            next if t.name == :component
+            loaded_types << t.name.to_s
+          end
+          loaded_types.ai
+        rescue Puppet::Error => e
+          puts e.message.red
+          Puppet.info(e.message)
+          # prevent more than two calls and recursive loop
+          return if caller_locations(1, 10).find_all { |f| f.label == 'types' }.count > 2
+          types
+        end
+      end
+    end
+  end
+end

data/lib/plugins/puppet-debugger/input_responders/vars.rb

@@ -0,0 +1,18 @@
+require 'puppet-debugger/input_responder_plugin'
+module PuppetDebugger
+  module InputResponders
+    class Vars < InputResponderPlugin
+      COMMAND_WORDS = %w(vars ls)
+      SUMMARY = 'List all the variables in the current scopes.'
+      COMMAND_GROUP = :scope
+
+      def run(args = [])
+        # remove duplicate variables that are also in the facts hash
+        variables = debugger.scope.to_hash.delete_if { |key, _value| debugger.node.facts.values.key?(key) }
+        variables['facts'] = 'removed by the puppet-debugger' if variables.key?('facts')
+        output = 'Facts were removed for easier viewing'.ai + "\n"
+        output += variables.ai(sort_keys: true, indent: -1)
+      end
+    end
+  end
+end

data/lib/plugins/puppet-debugger/input_responders/whereami.rb

@@ -0,0 +1,29 @@
+require 'puppet-debugger/input_responder_plugin'
+module PuppetDebugger
+  module InputResponders
+    class Whereami < InputResponderPlugin
+      COMMAND_WORDS = %w(whereami)
+      SUMMARY = 'Show code surrounding the current context.'
+      COMMAND_GROUP = :context
+
+      # source_file and source_line_num instance variables must be set for this
+      # method to show the surrounding code
+      # @return [String] - string output of the code surrounded by the breakpoint or nil if file
+      # or line_num do not exist
+      def run(args = [])
+        file = debugger.source_file
+        line_num = debugger.source_line_num
+        if file && line_num
+          if file == :code
+            source_code = Puppet[:code]
+            code = DebuggerCode.from_string(source_code, :puppet)
+          else
+            code = DebuggerCode.from_file(file, :puppet)
+          end
+          return code.with_marker(line_num).around(line_num, 5)
+                     .with_line_numbers.with_indentation(5).with_file_reference.to_s
+        end
+      end
+    end
+  end
+end

data/lib/puppet-debugger.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'puppet-debugger/cli'
 require_relative 'version'
 require 'awesome_print'
@@ -6,14 +7,24 @@ require_relative 'awesome_print/ext/awesome_puppet'
 require_relative 'trollop'
 require 'puppet/util/log'
 require_relative 'puppet-debugger/debugger_code'
-
 require_relative 'puppet-debugger/support/errors'
+require 'plugins/puppet-debugger/input_responders/commands'
+
+
 # monkey patch in some color effects string methods
 class String
   def red
     "\033[31m#{self}\033[0m"
   end
 
+  def bold
+    "\033[1m#{self}\033[22m"
+  end
+
+  def black
+    "\033[30m#{self}\033[0m"
+  end
+
   def green
     "\033[32m#{self}\033[0m"
   end

data/lib/puppet-debugger/cli.rb

@@ -1,14 +1,20 @@
 # frozen_string_literal: true
+
 require 'puppet'
 require 'readline'
 require 'json'
 require_relative 'support'
+require 'pluginator'
+require 'puppet-debugger/hooks'
+require 'forwardable'
 
 module PuppetDebugger
   class Cli
     include PuppetDebugger::Support
-
-    attr_accessor :settings, :log_level, :in_buffer, :out_buffer, :html_mode
+    extend Forwardable
+    attr_accessor :settings, :log_level, :in_buffer, :out_buffer, :html_mode, :extra_prompt, :bench
+    attr_reader :source_file, :source_line_num, :hooks
+    def_delegators :hooks, :exec_hook, :add_hook, :delete_hook
 
     def initialize(options = {})
       do_initialize if Puppet[:codedir].nil?
@@ -36,6 +42,10 @@ module PuppetDebugger
       }
     end
 
+    def hooks
+      @hooks ||= PuppetDebugger::Hooks.new
+    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
@@ -90,23 +100,23 @@ module PuppetDebugger
       result
     end
 
+    def responder_list
+      plugins = Pluginator.find(PuppetDebugger)
+    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|^datatypes|^types|^vars|^functions|^classes|^resources|^krt|^environment|^benchmark|^reset|^help/
+        case input.strip
+        when PuppetDebugger::InputResponders::Commands.command_list_regex
           args = input.split(' ')
-          command = args.shift.to_sym
-          output = send(command, args) if respond_to?(command)
-          @bencmark = false
+          command = args.shift
+          plugin = PuppetDebugger::InputResponders::Commands.plugin_from_command(command)
+          output = plugin.execute(args, self)
           return out_buffer.puts output
-        when /exit/
-          exit 0
-        when /^:set/
-          output = handle_set(input)
         when '_'
           output = " => #{@last_item}"
         else
@@ -115,6 +125,8 @@ module PuppetDebugger
           output = normalize_output(result)
           output = output.nil? ? '' : output.ai
         end
+      rescue PuppetDebugger::Exception::InvalidCommand => e
+        output = e.message.fatal
       rescue LoadError => e
         output = e.message.fatal
       rescue Errno::ETIMEDOUT => e
@@ -137,6 +149,7 @@ module PuppetDebugger
       unless output.empty?
         out_buffer.print ' => '
         out_buffer.puts output unless output.empty?
+        exec_hook :after_output, out_buffer, self, self
       end
     end
 
@@ -146,9 +159,9 @@ 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", "types", "datatypes", "benchmark",
-     "reset", or "help" for more information.
+Type "commands" for a list of debugger commands
+or "help" to show the help screen.
+
 
       EOT
       output
@@ -173,11 +186,11 @@ Type "exit", "functions", "vars", "krt", "whereami", "facts", "resources", "clas
     def read_loop
       line_number = 1
       full_buffer = ''
-      while buf = Readline.readline("#{line_number}:#{$extra_prompt}>> ", true)
+      while buf = Readline.readline("#{line_number}:#{extra_prompt}>> ", true)
         begin
           full_buffer += buf
           # unless this is puppet code, otherwise skip repl keywords
-          unless keyword_expression.match(buf)
+          unless PuppetDebugger::InputResponders::Commands.command_list_regex.match(buf)
             line_number = line_number.next
             parser.parse_string(full_buffer)
           end
@@ -197,12 +210,14 @@ Type "exit", "functions", "vars", "krt", "whereami", "facts", "resources", "clas
     # or
     # this is primarily used by the debug::break() module function and the puppet debugger face
     # @param [Hash] must contain at least the puppet scope object
+    # @option play - must be a path string
     def self.start_without_stdin(options = { scope: nil })
       puts print_repl_desc unless options[:quiet]
       repl_obj = PuppetDebugger::Cli.new(options)
+      options[:play] = options[:play].path if options[:play].respond_to?(:path)
       # TODO: make the output optional so we can have different output destinations
-      puts repl_obj.whereami if options[:source_file] && options[:source_line]
-      repl_obj.play_back(options) if options[:play]
+      repl_obj.handle_input('whereami') if options[:source_file] && options[:source_line]
+      repl_obj.handle_input("play #{options[:play]}") if options[:play]
       repl_obj.read_loop unless options[:run_once]
     end
 
@@ -219,15 +234,16 @@ Type "exit", "functions", "vars", "krt", "whereami", "facts", "resources", "clas
       end
       options = opts.merge(options)
       puts print_repl_desc unless options[:quiet]
+      options[:play] = options[:play].path if options[:play].respond_to?(:path)
       repl_obj = PuppetDebugger::Cli.new(options)
       if options[:play]
-        repl_obj.play_back(opts)
-      # when the user supplied a file name without using the args (stdin)
+        repl_obj.handle_input("play #{options[:play]}")
       elsif ARGF.filename != '-'
+        # when the user supplied a file name without using the args (stdin)
         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
+        repl_obj.handle_input("play #{path}")
       elsif (ARGF.filename == '-') && (!STDIN.tty? && !STDIN.closed?)
+        # when the user supplied a file content using stdin, aka. cat,pipe,echo or redirection
         input = ARGF.read
         repl_obj.handle_input(input)
       end

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

@@ -1,5 +1,6 @@
 
 # frozen_string_literal: true
+
 class CodeFile
   class SourceNotFound < RuntimeError
   end
@@ -9,21 +10,21 @@ class CodeFile
   # 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
+    %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
   }.freeze
 
   # @return [Symbol] The type of code stored in this wrapper.

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class DebuggerCode
   # Represents a range of lines in a code listing.
   #

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 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

data/lib/puppet-debugger/debugger_code.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'code/loc'
 require_relative 'code/code_range'
 require_relative 'code/code_file'

data/lib/puppet-debugger/hooks.rb

@@ -0,0 +1,174 @@
+require 'puppet-debugger/support/errors'
+
+module PuppetDebugger
+  # This code was borrowed from Pry hooks file
+  # Implements a hooks system for Puppet Debugger. A hook is a callable that is associated
+  # with an event. A number of events are currently provided by Pry, these
+  # include: `:when_started`, `:before_session`, `:after_session`.  A hook must
+  # have a name, and is connected with an event by the `PuppetDebugger::Hooks#add_hook`
+  # method.
+  #
+  # @example Adding a hook for the `:before_session` event.
+  #   debugger.hooks.add_hook(:before_session, :say_hi) do
+  #     puts "hello"
+  #   end
+  class Hooks
+    def initialize
+      @hooks = Hash.new { |h, k| h[k] = [] }
+    end
+
+    # Ensure that duplicates have their @hooks object.
+    def initialize_copy(orig)
+      hooks_dup = @hooks.dup
+      @hooks.each do |k, v|
+        hooks_dup[k] = v.dup
+      end
+
+      @hooks = hooks_dup
+    end
+
+    def errors
+      @errors ||= []
+    end
+
+    # Destructively merge the contents of two `PuppetDebugger::Hooks` instances.
+    #
+    # @param [PuppetDebugger::Hooks] other The `PuppetDebugger::Hooks` instance to merge
+    # @return [PuppetDebugger::Hooks] The receiver.
+    # @see {#merge}
+    def merge!(other)
+      @hooks.merge!(other.dup.hooks) do |key, array, other_array|
+        temp_hash, output = {}, []
+
+        (array + other_array).reverse_each do |pair|
+          temp_hash[pair.first] ||= output.unshift(pair)
+        end
+
+        output
+      end
+
+      self
+    end
+
+    # @example
+    #   hooks = PuppetDebugger::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }
+    #   PuppetDebugger::Hooks.new.merge(hooks)
+    # @param [PuppetDebugger::Hooks] other The `PuppetDebugger::Hooks` instance to merge
+    # @return [PuppetDebugger::Hooks] a new `PuppetDebugger::Hooks` instance containing a merge of the
+    #   contents of two `PuppetDebugger::Hooks` instances.
+    def merge(other)
+      self.dup.tap do |v|
+        v.merge!(other)
+      end
+    end
+
+    # Add a new hook to be executed for the `event_name` event.
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] hook_name The name of the hook.
+    # @param [#call] callable The callable.
+    # @yield The block to use as the callable (if no `callable` provided).
+    # @return [PuppetDebugger::Hooks] The receiver.
+    def add_hook(event_name, hook_name, callable=nil, &block)
+      event_name = event_name.to_s
+
+      # do not allow duplicates, but allow multiple `nil` hooks
+      # (anonymous hooks)
+      if hook_exists?(event_name, hook_name) && !hook_name.nil?
+        raise ArgumentError, "Hook with name '#{hook_name}' already defined!"
+      end
+
+      if !block && !callable
+        raise ArgumentError, "Must provide a block or callable."
+      end
+
+      # ensure we only have one anonymous hook
+      @hooks[event_name].delete_if { |h, k| h.nil? } if hook_name.nil?
+
+      if block
+        @hooks[event_name] << [hook_name, block]
+      elsif callable
+        @hooks[event_name] << [hook_name, callable]
+      end
+
+      self
+    end
+
+    # Execute the list of hooks for the `event_name` event.
+    # @param [Symbol] event_name The name of the event.
+    # @param [Array] args The arguments to pass to each hook function.
+    # @return [Object] The return value of the last executed hook.
+    def exec_hook(event_name, *args, &block)
+      @hooks[event_name.to_s].map do |hook_name, callable|
+        begin
+          callable.call(*args, &block)
+        rescue PuppetDebugger::Exception::Error, ::RuntimeError => e
+          errors << e
+          e
+        end
+      end.last
+    end
+
+    # @param [Symbol] event_name The name of the event.
+    # @return [Fixnum] The number of hook functions for `event_name`.
+    def hook_count(event_name)
+      @hooks[event_name.to_s].size
+    end
+
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] hook_name The name of the hook
+    # @return [#call] a specific hook for a given event.
+    def get_hook(event_name, hook_name)
+      hook = @hooks[event_name.to_s].find do |current_hook_name, callable|
+        current_hook_name == hook_name
+      end
+      hook.last if hook
+    end
+
+    # @param [Symbol] event_name The name of the event.
+    # @return [Hash] The hash of hook names / hook functions.
+    # @note Modifying the returned hash does not alter the hooks, use
+    # `add_hook`/`delete_hook` for that.
+    def get_hooks(event_name)
+      Hash[@hooks[event_name.to_s]]
+    end
+
+    # @param [Symbol] event_name The name of the event.
+    # @param [Symbol] hook_name The name of the hook.
+    #   to delete.
+    # @return [#call] The deleted hook.
+    def delete_hook(event_name, hook_name)
+      deleted_callable = nil
+
+      @hooks[event_name.to_s].delete_if do |current_hook_name, callable|
+        if current_hook_name == hook_name
+          deleted_callable = callable
+          true
+        else
+          false
+        end
+      end
+      deleted_callable
+    end
+
+    # Clear all hooks functions for a given event.
+    #
+    # @param [String] event_name The name of the event.
+    # @return [void]
+    def clear_event_hooks(event_name)
+      @hooks[event_name.to_s] = []
+    end
+
+    # @param [Symbol] event_name Name of the event.
+    # @param [Symbol] hook_name Name of the hook.
+    # @return [Boolean] Whether the hook by the name `hook_name`.
+    def hook_exists?(event_name, hook_name)
+      @hooks[event_name.to_s].map(&:first).include?(hook_name)
+    end
+
+    protected
+
+    def hooks
+      @hooks
+    end
+  end
+end