byebug 3.5.1 → 4.0.0

data/lib/byebug/interface.rb

@@ -1,4 +1,5 @@
 require 'byebug/history'
+require 'byebug/helper'
 
 #
 # Namespace for all of byebug's code
@@ -11,30 +12,109 @@ module Byebug
   #
   class Interface
     attr_accessor :command_queue, :history
+    attr_reader :input, :output, :error
 
     def initialize
       @command_queue, @history = [], History.new
     end
 
     #
-    # Common routine for reporting byebug error messages.
-    # Derived classes may want to override this to capture output.
+    # Pops a command from the input stream.
+    #
+    def read_command(prompt)
+      return command_queue.shift unless command_queue.empty?
+
+      cmds = read_input(prompt)
+      return unless cmds
+
+      command_queue.concat(cmds)
+      command_queue.shift
+    end
+
+    include FileFunctions
+    #
+    # Pushes lines in +filename+ to the command queue.
+    #
+    def read_file(filename)
+      command_queue.concat(get_lines(filename))
+    end
+
+    #
+    # Reads a new line from the interface's input stream.
+    #
+    def read_input(prompt, save_hist = true)
+      line = readline(prompt)
+      return unless line
+
+      history.push(line) if save_hist
+
+      split_commands(line)
+    end
+
+    #
+    # Prints an error message to the error stream.
     #
     def errmsg(message)
-      print("*** #{message}\n")
+      error.print("*** #{message}\n")
+    end
+
+    #
+    # Prints an output message to the output stream.
+    #
+    def puts(message)
+      output.puts(message)
     end
 
-    protected
+    def print(message)
+      output.print(message)
+    end
 
     #
-    # Stores <cmd> in commands history.
+    # Confirms user introduced an affirmative response to the input stream.
     #
-    def save_history(cmd)
-      @history.push(cmd) unless @history.ignore?(cmd)
+    def confirm(prompt)
+      readline(prompt) == 'y'
     end
-  end
 
-  require 'byebug/interfaces/local_interface'
-  require 'byebug/interfaces/script_interface'
-  require 'byebug/interfaces/remote_interface'
+    def close
+    end
+
+    #
+    # Saves or clears history according to +autosave+ setting.
+    #
+    def autosave
+      Setting[:autosave] ? history.save : history.clear
+    end
+
+    #
+    # Restores history according to +autosave+ setting.
+    #
+    def autorestore
+      history.restore if Setting[:autosave]
+    end
+
+    private
+
+    #
+    # Splits a command line of the form "cmd1 ; cmd2 ; ... ; cmdN" into an
+    # array of commands: [cmd1, cmd2, ..., cmdN]
+    #
+    def split_commands(cmd_line)
+      return [''] if cmd_line.empty?
+
+      cmd_line.split(/;/).each_with_object([]) do |v, m|
+        if m.empty? || m.last[-1] != '\\'
+          m << v
+          next
+        end
+
+        m.last[-1, 1] = ''
+        m.last << ';' << v
+      end
+    end
+  end
 end
+
+require 'byebug/interfaces/local_interface'
+require 'byebug/interfaces/script_interface'
+require 'byebug/interfaces/remote_interface'

data/lib/byebug/interfaces/local_interface.rb

@@ -3,30 +3,23 @@ module Byebug
   # Interface class for standard byebug use.
   #
   class LocalInterface < Interface
-    def read_command(prompt)
-      readline(prompt, true)
+    def initialize
+      super()
+      @input, @output, @error = STDIN, STDOUT, STDERR
     end
 
-    def confirm(prompt)
-      readline(prompt, false)
-    end
-
-    def puts(*args)
-      STDOUT.puts(*args)
-    end
-
-    def close
-    end
-
-    private
-
-    def readline(prompt, hist)
-      line = Readline.readline(prompt, false)
+    #
+    # Reads a single line of input using Readline. If Ctrl-C is pressed in the
+    # middle of input, the line is reset to only the prompt and we ask for input
+    # again.
+    #
+    # @param prompt Prompt to be displayed.
+    #
+    def readline(prompt)
+      Readline.readline(prompt, false)
     rescue Interrupt
       puts('^C')
       retry
-    ensure
-      save_history(line) if hist
     end
   end
 end

data/lib/byebug/interfaces/remote_interface.rb

@@ -7,32 +7,29 @@ module Byebug
   class RemoteInterface < Interface
     def initialize(socket)
       super()
-      @socket = socket
+      @input, @output, @error = socket, socket, socket
     end
 
-    def close
-      @socket.close
-    rescue IOError
+    def read_command(prompt)
+      super("PROMPT #{prompt}")
     end
 
     def confirm(prompt)
-      send_command "CONFIRM #{prompt}"
+      super("CONFIRM #{prompt}")
     end
 
-    def read_command(prompt)
-      send_command "PROMPT #{prompt}"
-    end
-
-    def puts(message)
-      @socket.puts(message)
+    def close
+      output.close
+    rescue IOError
+      errmsg('Error closing the interface...')
     end
 
-    private
+    def readline(prompt)
+      output.puts(prompt)
 
-    def send_command(msg)
-      @socket.puts msg
-      result = @socket.gets
+      result = input.gets
       fail IOError unless result
+
       result.chomp
     end
   end

data/lib/byebug/interfaces/script_interface.rb

@@ -3,31 +3,27 @@ module Byebug
   # Interface class for command execution from script files.
   #
   class ScriptInterface < Interface
-    def initialize(file, out, verbose = false)
+    def initialize(file, verbose = false)
       super()
-      @file = file.respond_to?(:gets) ? file : open(file)
-      @out, @verbose = out, verbose
+      @input = File.open(file)
+      @output = verbose ? STDOUT : StringIO.new
+      @error = verbose ? STDERR : StringIO.new
     end
 
-    def read_command(_prompt)
-      while (result = @file.gets)
-        puts "# #{result}" if @verbose
-        next if result =~ /^\s*#/
-        next if result.strip.empty?
-        return result.chomp
-      end
-    end
-
-    def confirm(_prompt)
-      'y'
+    def read_command(prompt)
+      readline(prompt, false)
     end
 
-    def puts(message)
-      @out.printf(message)
+    def close
+      input.close
     end
 
-    def close
-      @file.close
+    def readline(*)
+      while (result = input.gets)
+        output.puts "+ #{result}"
+        next if result =~ /^\s*#/
+        return result.chomp
+      end
     end
   end
 end

data/lib/byebug/interfaces/test_interface.rb

@@ -0,0 +1,54 @@
+module Byebug
+  #
+  # Custom interface for easier assertions
+  #
+  class TestInterface < Interface
+    attr_accessor :test_block
+
+    def initialize
+      super()
+      @input, @output, @error = [], [], []
+    end
+
+    def errmsg(message)
+      error.concat(message.to_s.split("\n"))
+    end
+
+    def print(message)
+      output.concat(message.to_s.split("\n"))
+    end
+
+    def puts(message)
+      output.concat(message.to_s.split("\n"))
+    end
+
+    def read_command(prompt)
+      cmd = super(prompt)
+
+      return cmd unless cmd.nil? && test_block
+
+      test_block.call
+      self.test_block = nil
+    end
+
+    def clear
+      @input, @output, @error = [], [], []
+      history.clear
+    end
+
+    def inspect
+      [
+        'Input:', input.join("\n"),
+        'Output:', output.join("\n"),
+        'Error:', error.join("\n")
+      ].join("\n")
+    end
+
+    def readline(prompt)
+      puts(prompt)
+
+      cmd = input.shift
+      cmd.is_a?(Proc) ? cmd.call : cmd
+    end
+  end
+end

data/lib/byebug/printers/base.rb

@@ -0,0 +1,64 @@
+require 'yaml'
+
+module Byebug
+  module Printers
+    class Base
+      class MissedPath < StandardError; end
+      class MissedArgument < StandardError; end
+
+      SEPARATOR = '.'
+
+      def type
+        self.class.name.split('::').last.downcase
+      end
+
+      private
+
+      def locate(path)
+        result = nil
+        contents.each do |_, contents|
+          result = parts(path).reduce(contents) do |r, part|
+            r && r.key?(part) ? r[part] : nil
+          end
+          break if result
+        end
+        fail MissedPath, "Can't find part path '#{path}'" unless result
+        result
+      end
+
+      def translate(string, args = {})
+        # they may contain #{} string interpolation
+        string.gsub(/\|\w+$/, '').gsub(/([^#]?){([^}]*)}/) do
+          key = Regexp.last_match[2].to_s
+          unless args.key?(key.to_sym)
+            fail MissedArgument, "Missed argument #{key} for '#{string}'"
+          end
+
+          "#{Regexp.last_match[1]}#{args[key.to_sym]}"
+        end
+      end
+
+      def parts(path)
+        path.split(SEPARATOR)
+      end
+
+      def contents
+        @contents ||= contents_files.each_with_object({}) do |filename, hash|
+          hash[filename] = YAML.load_file(filename) || {}
+        end
+      end
+
+      def array_of_args(collection, &block)
+        collection_with_index = collection.each.with_index
+        collection_with_index.each_with_object([]) do |(item, index), array|
+          args = block.call(item, index)
+          array << args if args
+        end
+      end
+
+      def contents_files
+        [File.expand_path(File.join('..', 'texts', 'base.yml'), __FILE__)]
+      end
+    end
+  end
+end

data/lib/byebug/printers/plain.rb

@@ -0,0 +1,53 @@
+require 'byebug/printers/base'
+
+module Byebug
+  module Printers
+    class Plain < Base
+      include Columnize
+
+      def print(path, args = {})
+        message = translate(locate(path), args)
+        tail = parts(path).include?('confirmations') ? ' (y/n) ' : "\n"
+        message << tail
+      end
+
+      def print_collection(path, collection, &block)
+        modifier = get_modifier(path)
+        lines = array_of_args(collection, &block).map do |args|
+          print(path, args)
+        end
+
+        if modifier == 'c'
+          columnize(lines.map { |l| l.gsub(/\n$/, '') }, Setting[:width])
+        else
+          lines.join('')
+        end
+      end
+
+      def print_variables(variables)
+        print_collection('variable.variable', variables) do |(key, value), _|
+          value = value.nil? ? 'nil' : value.to_s
+          if "#{key} = #{value}".size > Setting[:width]
+            key_size = "#{key} = ".size
+            value = value[0..Setting[:width] - key_size - 4] + '...'
+          end
+
+          { key: key, value: value }
+        end
+      end
+
+      private
+
+      def get_modifier(path)
+        modifier_regexp = /\|(\w+)$/
+        modifier_match = locate(path).match(modifier_regexp)
+        modifier_match && modifier_match[1]
+      end
+
+      def contents_files
+        [File.expand_path(File.join('..', 'texts', 'plain.yml'), __FILE__)] +
+          super
+      end
+    end
+  end
+end

data/lib/byebug/processor.rb

@@ -16,9 +16,28 @@ module Byebug
     rescue
       nil
     end
+
+    def self.load_commands
+      Dir.glob(File.expand_path('../commands/*.rb', __FILE__)).each do |file|
+        require file
+      end
+    end
+
+    def self.load_settings
+      Dir.glob(File.expand_path('../settings/*.rb', __FILE__)).each do |file|
+        require file
+      end
+
+      Byebug.constants.grep(/[a-z]Setting/).map do |name|
+        setting = Byebug.const_get(name).new
+        Byebug::Setting.settings[setting.to_sym] = setting
+      end
+    end
   end
+
+  Processor.load_commands
+  Processor.load_settings
 end
 
-require 'byebug/command'
 require 'byebug/processors/command_processor'
 require 'byebug/processors/control_command_processor'