byebug 0.0.1

data/test/support/breakpoint.rb

@@ -0,0 +1,13 @@
+module Byebug
+
+  class Breakpoint
+
+    def inspect
+      values = %w{id pos source expr hit_condition hit_count hit_value enabled?}.map do |field|
+        "#{field}: #{send(field)}"
+      end.join(", ")
+      "#<Byebug::Breakpoint #{values}>"
+    end
+
+  end
+end

data/test/support/context.rb

@@ -0,0 +1,14 @@
+module Byebug
+  class Context
+
+    def inspect
+      values = %w{
+        thread thnum stop_reason tracing ignored? stack_size dead? frame_line frame_file frame_self
+      }.map do |field|
+        "#{field}: #{send(field)}"
+      end.join(", ")
+      "#<Byebug::Context #{values}>"
+    end
+
+  end
+end

data/test/support/matchers.rb

@@ -0,0 +1,67 @@
+module MiniTest::Assertions
+
+  # This matcher checks that given collection is included into the original collection,
+  # and in correct order. It accepts both strings and regexps.
+  #
+  # Examples:
+  #
+  #   assert_includes_in_order(%w{1 2 3 4 5}, %w{1 3 5})            # => pass
+  #   assert_includes_in_order(%w{1 2 3 4 5}, %w{1 5 3})            # => fail
+  #   assert_includes_in_order(w{1 2 3 4 5}, ["1", /\d+/, "5"])     # => pass
+  #   assert_includes_in_order(w{1 2 3 4 5}, ["1", /\[a-z]+/, "5"]) # => fail
+  #
+  def assert_includes_in_order(given_collection, original_collection, msg = nil)
+    msg = message(msg) do
+      "Expected #{mu_pp(original_collection)} to include #{mu_pp(given_collection)} in order"
+    end
+    assert includes_in_order_result(original_collection, given_collection), msg
+  end
+
+  def refute_includes_in_order(given_collection, original_collection, msg = nil)
+    msg = message(msg) do
+      "Expected #{mu_pp(original_collection)} to not include #{mu_pp(given_collection)} in order"
+    end
+    refute includes_in_order_result(original_collection, given_collection), msg
+  end
+
+
+  private
+
+    def includes_in_order_result(original_collection, given_collection)
+      result = true
+      given_collection.each do |given_item|
+        result &&= case given_item
+          when String
+            index = original_collection.index(given_item)
+            if index
+              original_collection = original_collection[(index + 1)..-1]
+              true
+            else
+              false
+            end
+          when Regexp
+            index = nil
+            original_collection.each_with_index do |original_item, i|
+              if original_item =~ given_item
+                index = i
+                break
+              end
+            end
+            if index
+              original_collection = original_collection[(index + 1)..-1]
+              true
+            else
+              false
+            end
+          else
+            false
+          end
+      end
+      result
+    end
+end
+
+module MiniTest::Expectations
+  infect_an_assertion :assert_includes_in_order, :must_include_in_order
+  infect_an_assertion :refute_includes_in_order, :wont_include_in_order
+end

data/test/support/mocha_extensions.rb

@@ -0,0 +1,72 @@
+module Mocha
+
+  class Expectation
+
+    # Allows to specify a block to execute when expectation will be matched.
+    # This way, we can specify dynamic values to return or just make some side effects
+    #
+    # Example:
+    #
+    #   foo.expects(:bar).with('bla').calls { 2 + 3 }
+    #   foo.bar('bla') # => 5
+    #
+    def calls(&block)
+      @calls ||= Call.new
+      @calls += Call.new(block)
+      self
+    end
+
+    def invoke_with_calls(arguments, &block)
+      invoke_without_calls(&block) || (@calls.next(arguments, &block) if @calls)
+    end
+    alias_method :invoke_without_calls, :invoke
+    alias_method :invoke, :invoke_with_calls
+
+  end
+
+  class Mock
+
+    # We monkey-patch that method to be able to pass arguments to Expectation#invoke method
+    def method_missing(symbol, *arguments, &block)
+      if @responder and not @responder.respond_to?(symbol)
+        raise NoMethodError, "undefined method `#{symbol}' for #{self.mocha_inspect} which responds like #{@responder.mocha_inspect}"
+      end
+      if matching_expectation_allowing_invocation = @expectations.match_allowing_invocation(symbol, *arguments)
+        # We change this line - added arguments
+        matching_expectation_allowing_invocation.invoke(arguments, &block)
+      else
+        if (matching_expectation = @expectations.match(symbol, *arguments)) || (!matching_expectation && !@everything_stubbed)
+          # We change this line - added arguments
+          matching_expectation.invoke(arguments, &block) if matching_expectation
+          message = UnexpectedInvocation.new(self, symbol, *arguments).to_s
+          require 'mocha/mockery'
+          message << Mockery.instance.mocha_inspect
+          raise ExpectationError.new(message, caller)
+        end
+      end
+    end
+
+  end
+
+  class Call
+
+    attr_reader :blocks
+
+    def initialize(*blocks)
+      @blocks = [ *blocks ]
+    end
+
+    def next(arguments, &block)
+      case @blocks.length
+        when 0 then nil
+        when 1 then @blocks.first.call(*arguments, &block)
+        else @blocks.shift.call(*arguments, &block)
+      end
+    end
+
+    def +(other)
+      self.class.new(*(@blocks + other.blocks))
+    end
+
+  end
+end

data/test/support/processor.rb

@@ -0,0 +1,7 @@
+class Byebug::Processor
+  class << self
+    def print(message)
+      Byebug.handler.interface.print_queue << message
+    end
+  end
+end

data/test/support/test_dsl.rb

@@ -0,0 +1,206 @@
+module TestDsl
+
+  module Shared
+    def fullpath(filename)
+      (Pathname.new(__FILE__) + "../../examples/#{filename}.rb").cleanpath.to_s
+    end
+  end
+
+  include Shared
+
+  def self.included(base)
+    base.class_eval do
+      extend ClassMethods
+      before do
+        Byebug.interface = TestInterface.new
+        Byebug.handler.display.clear
+      end
+      after do
+        Byebug.handler.display.clear
+      end
+    end
+  end
+
+  # Adds commands to the input queue, so they will be later retrieved by
+  # Processor, i.e. it emulates user's input.
+  #
+  # If a command is a Proc object, it will be executed before retrieving by
+  # Processor. May be handy when you need build a command depending on the
+  # current context/state.
+  #
+  # Usage:
+  #   enter 'b 12'
+  #   enter 'b 12', 'cont'
+  #   enter ['b 12', 'cont']
+  #   enter 'b 12', ->{"disable #{breakpoint.id}"}, 'cont'
+  #
+  def enter(*messages)
+    messages = messages.first.is_a?(Array) ? messages.first : messages
+    interface.input_queue.concat(messages)
+  end
+
+  # Runs a byebug with the provided basename for a file. The file should be
+  # placed in the test/examples dir.
+  #
+  # You also can specify a block, which will be executed when Processor extracts
+  # all the commands from the input queue. You can use it e.g. for making
+  # asserts for the current test. If you specified the block, and it never was
+  # executed, the test will fail.
+  #
+  # Usage:
+  #   debug "ex1" # ex1 should be placed in test/examples/ex1.rb
+  #
+  #   enter 'b 4', 'cont'
+  #   debug("ex1") { state.line.must_equal 4 }
+  #
+  def debug_file(filename, &block)
+    is_test_block_called = false
+    debug_completed = false
+    exception = nil
+    Byebug.stubs(:run_init_script)
+    if block
+      interface.test_block= lambda do
+        is_test_block_called = true
+        # We need to store exception and reraise it after completing debugging,
+        # because Byebug will swallow any exceptions, so e.g. our failed
+        # assertions will be ignored
+        begin
+          block.call
+        rescue Exception => e
+          exception = e
+          raise e
+        end
+      end
+    end
+    Byebug.start do
+      load fullpath(filename)
+      debug_completed = true
+    end
+    flunk "Debug block was not completed" unless debug_completed
+    flunk "Test block was provided, but not called" if block && !is_test_block_called
+    raise exception if exception
+  end
+
+  #
+  # Checks the output of byebug. By default it checks output queue of the current
+  # interface, but you can check again any queue by providing it as a second
+  # argument.
+  #
+  # Usage:
+  #   enter 'break 4', 'cont'
+  #   debug("ex1")
+  #   check_output "Breakpoint 1 at #{fullpath('ex1')}:4"
+  #
+  def check_output(check_method, *args)
+    queue = args.last.is_a?(String) || args.last.is_a?(Regexp) ? interface.output_queue : args.pop
+    queue_messages = queue.map(&:strip)
+    messages = Array(args).map { |msg| msg.is_a?(String) ? msg.strip : msg }
+    queue_messages.send(check_method, messages)
+  end
+
+  def check_output_includes(*args)
+    check_output :must_include_in_order, *args
+  end
+
+  def check_output_doesnt_include(*args)
+    check_output :wont_include_in_order, *args
+  end
+
+  def interface
+    Byebug.handler.interface
+  end
+
+  def state
+    $rdebug_state
+  end
+
+  def context
+    state.context
+  end
+
+  def breakpoint
+    Byebug.breakpoints.first
+  end
+
+  def force_set_const(klass, const, value)
+    klass.send(:remove_const, const) if klass.const_defined?(const)
+    klass.const_set(const, value)
+  end
+
+  def change_line_in_file(file, line, new_line_content)
+    old_content = File.read(file)
+    new_content = old_content.split("\n").tap { |c| c[line - 1] = new_line_content }.join("\n")
+    File.open(file, 'w') { |f| f.write(new_content) }
+  end
+
+  def temporary_change_method_value(item, method, value)
+    old = item.send(method)
+    item.send("#{method}=", value)
+    yield
+  ensure
+    item.send("#{method}=", old)
+  end
+
+  def temporary_change_hash_value(item, key, value)
+    old_value = item[key]
+    item[key] = value
+    yield
+  ensure
+    item[key] = old_value
+  end
+
+  def temporary_set_const(klass, const, value)
+    old_value = klass.const_defined?(const) ? klass.const_get(const) : :__undefined__
+    force_set_const(klass, const, value)
+    yield
+  ensure
+    if old_value == :__undefined__
+      klass.send(:remove_const, const)
+    else
+     force_set_const(klass, const, old_value)
+    end
+  end
+
+  module ClassMethods
+
+    include Shared
+
+    def temporary_change_method_value(item, method, value)
+      old_value = nil
+      before do
+        old_value = item.send(method)
+        item.send("#{method}=", value)
+      end
+      after do
+        item.send("#{method}=", old_value)
+      end
+    end
+
+    def temporary_change_hash_value(item, key, value)
+      old_value = nil
+      before do
+        old_value = item[key]
+        item[key] = value
+      end
+      after do
+        item[key] = old_value
+      end
+    end
+
+    def temporary_set_const(klass, const, value)
+      old_value = nil
+      before do
+        old_value = klass.const_defined?(const) ? klass.const_get(const) : :__undefined__
+        force_set_const(klass, const, value)
+      end
+      after do
+        if old_value == :__undefined__
+          klass.send(:remove_const, const)
+        else
+          force_set_const(klass, const, old_value)
+        end
+      end
+    end
+  end
+
+end

data/test/support/test_interface.rb

@@ -0,0 +1,68 @@
+class TestInterface < Byebug::Interface
+  attr_reader :input_queue, :output_queue, :error_queue, :confirm_queue
+
+  attr_accessor :command_queue, :histfile, :history_length, :history_save
+  attr_accessor :print_queue, :readline_support, :restart_file, :test_block
+
+  def initialize
+    @input_queue = []
+    @output_queue = []
+    @error_queue = []
+    @confirm_queue = []
+    @command_queue = []
+    @print_queue = []
+    @readline_support = false
+  end
+
+  def errmsg(*args)
+    @error_queue << format(args)
+  end
+
+  def read_command(*args)
+    if @input_queue.empty? && test_block
+      test_block.call
+      self.test_block = nil
+    end
+    result = @input_queue.shift
+    result.is_a?(Proc) ? result.call : result
+  end
+
+  def print(*args)
+    @output_queue << format(args)
+  end
+
+  def confirm(message)
+    @confirm_queue << message
+    read_command message
+  end
+
+  def readline_support?
+    @readline_support
+  end
+
+  def finalize
+  end
+
+  def close
+  end
+
+  def inspect
+    [
+      "input_queue: #{input_queue.inspect}",
+      "output_queue: #{output_queue.inspect}",
+      "error_queue: #{error_queue.inspect}",
+      "confirm_queue: #{confirm_queue.inspect}",
+      "print_queue: #{print_queue.inspect}"
+    ].join("\n")
+  end
+
+  private
+
+    def format(args)
+      if args.size > 1
+        args.first % args[1..-1]
+      else
+        args.first
+      end
+    end
+end