puppet-debugger 0.17.0 → 1.2.0

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

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require 'puppet-debugger/input_responder_plugin'
 module PuppetDebugger
   module InputResponders
     class Types < InputResponderPlugin
-      COMMAND_WORDS = %w(types)
+      COMMAND_WORDS = %w[types].freeze
       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 = [])
+      def run(_args = [])
         types
       end
 
@@ -19,6 +21,7 @@ module PuppetDebugger
           Puppet::Type.loadall
           Puppet::Type.eachtype do |t|
             next if t.name == :component
+
             loaded_types << t.name.to_s
           end
           loaded_types.ai
@@ -27,6 +30,7 @@ module PuppetDebugger
           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

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

@@ -1,26 +1,28 @@
+# frozen_string_literal: true
+
 require 'puppet-debugger/input_responder_plugin'
 module PuppetDebugger
   module InputResponders
     class Vars < InputResponderPlugin
-      COMMAND_WORDS = %w(vars ls)
+      COMMAND_WORDS = %w[vars ls].freeze
       SUMMARY = 'List all the variables in the current scopes.'
       COMMAND_GROUP = :scope
 
       def run(args = [])
         filter = args
         unless filter.empty?
-          parameters = resource_parameters(debugger.scope.catalog.resources, filter)
+          parameters = resource_parameters(debugger.catalog.resources, filter)
           return parameters.ai(sort_keys: true, indent: -1)
         end
         # 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)
+        output + variables.ai(sort_keys: true, indent: -1)
       end
 
       def resource_parameters(resources, filter = [])
-        find_resources(resources, filter).each_with_object({}) do | resource, acc|
+        find_resources(resources, filter).each_with_object({}) do |resource, acc|
           name = "#{resource.type}[#{resource.name}]"
           acc[name] = parameters_to_h(resource)
           acc
@@ -28,9 +30,9 @@ module PuppetDebugger
       end
 
       def parameters_to_h(resource)
-        resource.parameters.each_with_object({}) do | param, params |
+        resource.parameters.each_with_object({}) do |param, params|
           name = param.first.to_s
-          params[name] = param.last.value
+          params[name] = param.last.respond_to?(:value) ? param.last.value : param.last
           params
         end
       end
@@ -41,7 +43,6 @@ module PuppetDebugger
           resource.name.to_s.downcase.include?(filter_string) || resource.type.to_s.downcase.include?(filter_string)
         end
       end
-
     end
   end
 end

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

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'puppet-debugger/input_responder_plugin'
 module PuppetDebugger
   module InputResponders
     class Whereami < InputResponderPlugin
-      COMMAND_WORDS = %w(whereami)
+      COMMAND_WORDS = %w[whereami].freeze
       SUMMARY = 'Show code surrounding the current context.'
       COMMAND_GROUP = :context
 
@@ -21,8 +23,8 @@ module PuppetDebugger
           else
             code = DebuggerCode.from_file(file, :puppet)
           end
-          return code.with_marker(line_num).around(line_num, num_lines)
-                     .with_line_numbers.with_indentation(5).with_file_reference.to_s
+          code.with_marker(line_num).around(line_num, num_lines)
+              .with_line_numbers.with_indentation(5).with_file_reference.to_s
         end
       end
 

data/lib/puppet-debugger/cli.rb

@@ -1,31 +1,32 @@
 # frozen_string_literal: true
 
-require "puppet"
-require "readline"
-require "json"
-require "puppet-debugger/support"
-require "pluginator"
-require "puppet-debugger/hooks"
-require "forwardable"
-require "plugins/puppet-debugger/input_responders/functions"
-require "plugins/puppet-debugger/input_responders/datatypes"
-
+require 'puppet'
+require 'readline'
+require 'json'
+require 'puppet-debugger/support'
+require 'pluginator'
+require 'puppet-debugger/hooks'
+require 'forwardable'
+require 'plugins/puppet-debugger/input_responders/functions'
+require 'plugins/puppet-debugger/input_responders/datatypes'
+require 'tty-pager'
 module PuppetDebugger
   class Cli
     include PuppetDebugger::Support
     extend Forwardable
     attr_accessor :settings, :log_level, :in_buffer, :out_buffer, :html_mode, :extra_prompt, :bench
-    attr_reader :source_file, :source_line_num, :hooks
+    attr_reader :source_file, :source_line_num, :hooks, :options
     def_delegators :hooks, :exec_hook, :add_hook, :delete_hook
-
+    OUT_SYMBOL = ' => '
     def initialize(options = {})
       do_initialize if Puppet[:codedir].nil?
       Puppet.settings[:name] = :debugger
-      Puppet.settings[:trusted_server_facts] = true unless Puppet.settings[:trusted_server_facts].nil?
+      @options = options
       Puppet[:static_catalogs] = false unless Puppet.settings[:static_catalogs].nil?
       set_remote_node_name(options[:node_name])
       initialize_from_scope(options[:scope])
-      @log_level = "notice"
+      set_catalog(options[:catalog])
+      @log_level = 'notice'
       @out_buffer = options[:out_buffer] || $stdout
       @html_mode = options[:html_mode] || false
       @source_file = options[:source_file] || nil
@@ -33,14 +34,23 @@ module PuppetDebugger
       @in_buffer = options[:in_buffer] || $stdin
       Readline.input = @in_buffer
       Readline.output = @out_buffer
-      Readline.completion_append_character = ""
-      Readline.basic_word_break_characters = " "
+      Readline.completion_append_character = ''
+      Readline.basic_word_break_characters = ' '
       Readline.completion_proc = command_completion
       AwesomePrint.defaults = {
         html: @html_mode,
         sort_keys: true,
-        indent: 2,
+        indent: 2
       }
+      # Catch control-c sequences
+      trap('SIGINT') do
+        # control-d
+        exit 0
+      end
+      trap('INT') do
+        # control-c
+        # handle_output('Type exit or use control-d')
+      end
     end
 
     # @return [Proc] the proc used in the command completion for readline
@@ -50,11 +60,12 @@ module PuppetDebugger
       proc do |input|
         words = Readline.line_buffer.split(Readline.basic_word_break_characters)
         next key_words.grep(/^#{Regexp.escape(input)}/) if words.empty?
+
         first_word = words.shift
         plugins = PuppetDebugger::InputResponders::Commands.plugins.find_all do |p|
           p::COMMAND_WORDS.find { |word| word.start_with?(first_word) }
         end
-        if plugins.count == 1 and /\A#{first_word}\s/.match(Readline.line_buffer)
+        if (plugins.count == 1) && /\A#{first_word}\s/.match(Readline.line_buffer)
           plugins.first.command_completion(words)
         else
           key_words.grep(/^#{Regexp.escape(input)}/)
@@ -76,7 +87,8 @@ module PuppetDebugger
       PuppetDebugger::InputResponders::Functions.instance.debugger = self
       funcs = PuppetDebugger::InputResponders::Functions.instance.func_list
       PuppetDebugger::InputResponders::Datatypes.instance.debugger = self
-      (scoped_vars + funcs + static_responder_list + PuppetDebugger::InputResponders::Datatypes.instance.all_data_types).uniq.sort
+      (scoped_vars + funcs + static_responder_list +
+        PuppetDebugger::InputResponders::Datatypes.instance.all_data_types).uniq.sort
     end
 
     # looks up the type in the catalog by using the type and title
@@ -116,87 +128,108 @@ module PuppetDebugger
         # if the only output is a resource then return it
         # otherwise it is multiple items or an actually array
         return output.first if output.count == 1
+
         return output
       end
       result
     end
 
     def responder_list
-      plugins = Pluginator.find(PuppetDebugger)
+      Pluginator.find(PuppetDebugger)
+    end
+
+    # @return [TTY::Pager] the pager object, disable if CI or testing is present
+    def pager
+      @pager ||= TTY::Pager.new(output: out_buffer, enabled: pager_enabled?)
+    end
+
+    def pager_enabled?
+      ENV['CI'].nil?
+    end
+
+    # @param output [String] - the content to output
+    # @summary outputs the output to the output buffer
+    #   uses the pager if the screen height is less than the height of the
+    #   output content
+    #   Disabled if CI or testing is being done
+    def handle_output(output)
+      return if output.nil?
+
+      if pager_enabled? && output.lines.count >= TTY::Screen.height
+        output << "\n"
+        pager.page(output)
+      else
+        out_buffer.puts(output) unless output.empty?
+      end
     end
 
     # this method handles all input and expects a string of text.
-    #
+    # @param input [String] - the input content to parse or run
     def handle_input(input)
       raise ArgumentError unless input.instance_of?(String)
-      begin
-        output = ""
-        case input.strip
-        when PuppetDebugger::InputResponders::Commands.command_list_regex
-          args = input.split(" ")
-          command = args.shift
-          plugin = PuppetDebugger::InputResponders::Commands.plugin_from_command(command)
-          output = plugin.execute(args, self)
-          return out_buffer.puts output
-        when "_"
-          output = " => #{@last_item}"
-        else
-          result = puppet_eval(input)
-          @last_item = result
-          output = normalize_output(result)
-          output = output.nil? ? "" : output.ai
+
+      output =
+        begin
+          case input.strip
+          when PuppetDebugger::InputResponders::Commands.command_list_regex
+            args = input.split(' ')
+            command = args.shift
+            plugin = PuppetDebugger::InputResponders::Commands.plugin_from_command(command)
+            plugin.execute(args, self) || ''
+          when '_'
+            " => #{@last_item}"
+          else
+            result = puppet_eval(input)
+            @last_item = result
+            o = normalize_output(result)
+            o.nil? ? '' : o.ai
+          end
+        rescue PuppetDebugger::Exception::InvalidCommand => e
+          e.message.fatal
+        rescue LoadError => e
+          e.message.fatal
+        rescue Errno::ETIMEDOUT => e
+          e.message.fatal
+        rescue ArgumentError => e
+          e.message.fatal
+        rescue Puppet::ResourceError => e
+          e.message.fatal
+        rescue Puppet::Error => e
+          e.message.fatal
+        rescue Puppet::ParseErrorWithIssue => e
+          e.message.fatal
+        rescue PuppetDebugger::Exception::FatalError => e
+          handle_output(e.message.fatal)
+          exit 1 # this can sometimes causes tests to fail
+        rescue PuppetDebugger::Exception::Error => e
+          e.message.fatal
+        rescue ::RuntimeError => e
+          handle_output(e.message.fatal)
+          exit 1
         end
-      rescue PuppetDebugger::Exception::InvalidCommand => e
-        output = e.message.fatal
-      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
-      rescue ::RuntimeError => e
-        output = e.message.fatal
-        out_buffer.puts output
-        exit 1
-      end
-      unless output.empty?
-        out_buffer.print " => "
-        out_buffer.puts output unless output.empty?
-        exec_hook :after_output, out_buffer, self, self
-      end
+      output = OUT_SYMBOL + output unless output.empty?
+      handle_output(output)
+      exec_hook :after_output, out_buffer, self, self
     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 "commands" for a list of debugger commands
-or "help" to show the help screen.
+      <<~OUT
+        Ruby Version: #{RUBY_VERSION}
+        Puppet Version: #{Puppet.version}
+        Puppet Debugger Version: #{PuppetDebugger::VERSION}
+        Created by: NWOps <corey@nwops.io>
+        Type "commands" for a list of debugger commands
+        or "help" to show the help screen.
 
 
-      EOT
-      output
+      OUT
     end
 
     # tries to determine if the input is going to be a multiline input
     # by reading the parser error message
     # @return [Boolean] - return true if this is a multiline input, false otherwise
-    def multiline_input?(e)
-      case e.message
+    def multiline_input?(data)
+      case data.message
       when /Syntax error at end of/i
         true
       else
@@ -211,7 +244,7 @@ or "help" to show the help screen.
     # input
     def read_loop
       line_number = 1
-      full_buffer = ""
+      full_buffer = ''
       while buf = Readline.readline("#{line_number}:#{extra_prompt}>> ", true)
         begin
           full_buffer += buf
@@ -222,14 +255,14 @@ or "help" to show the help screen.
               parser.parse_string(full_buffer)
             rescue Puppet::ParseErrorWithIssue => e
               if multiline_input?(e)
-                out_buffer.print "  "
+                out_buffer.print '  '
                 full_buffer += "\n"
                 next
               end
             end
           end
           handle_input(full_buffer)
-          full_buffer = ""
+          full_buffer = ''
         end
       end
     end
@@ -251,7 +284,7 @@ or "help" to show the help screen.
       repl_obj.out_buffer.puts print_repl_desc unless options[:quiet]
       repl_obj.handle_input(options[:content]) if options[:content]
       # TODO: make the output optional so we can have different output destinations
-      repl_obj.handle_input("whereami") if options[:source_file] && options[:source_line]
+      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
@@ -262,10 +295,15 @@ or "help" to show the help screen.
     # @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
+        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 :catalog, 'Import a catalog file to inspect', required: false, type: String
+        opt :quiet, 'Do not display banner', required: false, default: false
+      end
+      if !STDIN.tty? && !STDIN.closed?
+        options[:run_once] = true
+        options[:quiet] = true
       end
       options = opts.merge(options)
       options[:play] = options[:play].path if options[:play].respond_to?(:path)
@@ -273,14 +311,14 @@ or "help" to show the help screen.
       repl_obj.out_buffer.puts print_repl_desc unless options[:quiet]
       if options[:play]
         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.handle_input("play #{path}")
-      elsif (ARGF.filename == "-") && (!STDIN.tty? && !STDIN.closed?)
+      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)
+      elsif ARGF.filename != '-'
+        # when the user supplied a file name without using the args (stdin)
+        path = File.expand_path(ARGF.filename)
+        repl_obj.handle_input("play #{path}")
       end
       # helper code to make tests exit the loop
       repl_obj.read_loop unless options[:run_once]

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

@@ -1,4 +1,3 @@
-
 # frozen_string_literal: true
 
 class CodeFile
@@ -10,18 +9,18 @@ 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[.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
@@ -96,4 +95,4 @@ class CodeFile
   def from_load_path
     $LOAD_PATH.map { |path| File.expand_path(@filename, path) }
   end
-  end
+end