break 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb3884c4c9ee2235449260f2ee2395c356ab4c1db2fb7b4b052617df40d1f03a
-  data.tar.gz: 46bbb28dadb0c3fc3beffa6af4bd12481a3c9c409d5bd409804347bf05923ef7
+  metadata.gz: e14cd966917b91b925d085e986916164b42e5a3dd1986818b0e45e291e8177d5
+  data.tar.gz: 596fc1d57d319b23303ec89832c3e93cfbc62a6d040406f5ce9cad4dc8103735
 SHA512:
-  metadata.gz: 5109915a60c4f32575eceb3a2fc25e8ea58164e0fab643876ff61ce76943d497df197168d0e9c7c6b1bf2b3339801883a000637ccfbfa9d31f3405db2cf19cfe
-  data.tar.gz: 37aeec66fe323a44be5b7a2cbd957c163458752f2352d7c146dcde4cc06eecd363bf573cfb662857b1b36b585d804fa93baf67936221dc87676fdceca1e4cde1
+  metadata.gz: 8c9bf9ea4a4ddb23c69c27f536e1f54b87dd785346dd70e7f13c5dcc6fe51248ec3987f87e35f4dd6dd03016de4360e94a744d5218b5c33c48ce96d1e443e78a
+  data.tar.gz: 5f4f020f420ed3adb3db0db53960fa68c0b2824802dd3a718923ae151d71ae46eabeb037414ac3753131f329eccd46305b04429e1c77705eff4b7e61e5d4a718

data/lib/break.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "break/version"
+require_relative "break/session"
+require_relative "break/context"
+require_relative "break/command"
+require_relative "break/commands"
+require_relative "break/filter"
+require_relative "break/binding_ext"
+
+require_relative "break/irb"
+require_relative "break/pry" if defined?(Pry)
+
+Break::Filter.register_internal __dir__

data/lib/break/binding_ext.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Binding
+  unless method_defined?(:source_location)
+    def source_location
+      eval "[__FILE__, __LINE__.to_i]"
+    end
+  end
+end

data/lib/break/command.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Break
+  class Command
+    extend Forwardable
+
+    def initialize(session)
+      @session = session
+    end
+
+    def execute
+      raise NotImplementedError
+    end
+
+    private
+
+    attr_reader :session
+    def_delegators :session, :context, :context!, :frontend
+  end
+end

data/lib/break/commands.rb

@@ -0,0 +1,8 @@
+require_relative "commands/tracepoint_command"
+require_relative "commands/continue_command"
+require_relative "commands/list_command"
+require_relative "commands/next_command"
+require_relative "commands/step_command"
+require_relative "commands/up_command"
+require_relative "commands/down_command"
+

data/lib/break/commands/continue_command.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Break
+  class ContinueCommand < Command
+    def execute(*)
+      session.leave
+    end
+  end
+end

data/lib/break/commands/down_command.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Break
+  class DownCommand < TracePointCommand
+    def execute(*)
+      if context.depth >= 0
+        frontend.notify("Cannot go further down the stack")
+      else
+        super
+      end
+    end
+
+    def execute_trace(trace, *)
+      trace.disable
+
+      context!(*context.bindings, depth: context.depth + 1)
+    end
+  end
+end

data/lib/break/commands/list_command.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Break
+  class ListCommand < Command
+    def execute(*)
+      frontend.where
+    end
+  end
+end

data/lib/break/commands/next_command.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Break
+  class NextCommand < TracePointCommand
+    trace :line, :call, :return, :class, :end, :b_call, :b_return
+
+    def execute_trace(trace, *)
+      case trace.event
+      when :call, :class, :b_call
+        context.bindings << trace.binding
+        context.depth += 1
+      when :return, :end, :b_return
+        context.bindings.pop
+        context.depth -= 1
+      when :line
+        return if context.depth.positive?
+
+        trace.disable
+
+        context!(*context.bindings[0...-1], trace.binding)
+      end
+    end
+  end
+end

data/lib/break/commands/step_command.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Break
+  class StepCommand < TracePointCommand
+    trace :line, :call, :return, :class, :end, :b_call, :b_return
+
+    def execute_trace(trace, *)
+      case trace.event
+      when :call, :class, :b_call
+        trace.disable
+
+        context!(*context.bindings, trace.binding)
+      when :return, :end, :b_return
+        context.bindings.pop
+        context.depth -= 1
+      when :line
+        return if context.depth.positive?
+
+        trace.disable
+
+        context!(*context.bindings[0...-1], trace.binding)
+      end
+    end
+  end
+end

data/lib/break/commands/tracepoint_command.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Break
+  class TracePointCommand < Command
+    class << self
+      attr_reader :trace_events
+
+      def trace(*events)
+        @trace_events = events
+      end
+    end
+
+    def execute(*args)
+      TracePoint.trace(*trace_events) do |trace|
+        next if Filter.internal?(trace.path)
+
+        execute_trace(trace, *args)
+      end
+
+      session.leave
+    end
+
+    def execute_trace
+      raise NotImplementedError
+    end
+
+    private
+
+    def trace_events
+      self.class.trace_events
+    end
+  end
+end

data/lib/break/commands/up_command.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Break
+  class UpCommand < TracePointCommand
+    def execute(*)
+      if context.bindings[context.depth - 2]
+        super
+      else
+        frontend.notify("Cannot go further up the stack")
+      end
+    end
+
+    def execute_trace(trace, *)
+      trace.disable
+
+      context!(*context.bindings, depth: context.depth - 1)
+    end
+  end
+end

data/lib/break/context.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Break
+  class Context
+    attr_accessor :bindings
+    attr_accessor :depth
+
+    def initialize(*bindings, depth: 0)
+      @bindings = bindings
+      @depth = depth
+    end
+
+    def binding
+      @bindings[@depth - 1]
+    end
+
+    def inspect
+      "#{path}:#{lineno}"
+    end
+  end
+end

data/lib/break/filter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Break
+  module Filter
+    extend self
+
+    attr_reader :internal
+
+    def register_internal(*paths)
+      (@internal ||= []).concat(paths)
+    end
+
+    def internal?(path)
+      @internal.any? { |location| path.include?(location) }
+    end
+  end
+end

data/lib/break/irb.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "irb/frontend"
+require_relative "irb/commands"
+require_relative "irb/overrides"
+
+Break::Filter.register_internal IRB.method(:start).source_location.first.chomp(".rb")
+Break::Filter.register_internal "(irb)"
+
+Binding.prepend Break::IRB::Overrides

data/lib/break/irb/commands.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Break::IRB
+  class Commands < Module
+    def initialize(session)
+      define_command session, :next,     Break::NextCommand
+      define_command session, :step,     Break::StepCommand
+      define_command session, :up,       Break::UpCommand
+      define_command session, :down,     Break::DownCommand
+      define_command session, :continue, Break::ContinueCommand, preserve: false
+    end
+
+    private
+
+    def define_command(session, name, cls, preserve: true)
+      define_method(name) do |*args|
+        cls.new(session).execute(*args)
+      ensure
+        # We don't have a clear guideline of when an IRB session starts and
+        # when it ends. If we're excuting commands, we have to quit the IRB
+        # session which naturally marks it as stopped. If we're executing a
+        # `break` command though we actually want to keep marking it as started
+        # so we don't step over `binding.irb` calls.
+        Break::Session.start! if preserve
+      end
+    end
+  end
+end

data/lib/break/irb/frontend.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "irb"
+
+module Break::IRB
+  class Frontend
+    def initialize
+      IRB.setup caller_locations.first.path, argv: []
+    end
+
+    def attach(session)
+      @workspace = IRB::WorkSpace.new(session.context.binding)
+
+      begin
+        @irb = IRB::Irb.new(@workspace)
+        @irb.context.main.extend Commands.new(session)
+      rescue TypeError
+        return
+      end
+
+      where
+
+      @irb.suspend_context special_case_next_eval(@irb.context) do
+        @irb.run(IRB.conf)
+      end
+    end
+
+    def detach
+      @irb&.context&.exit
+    end
+
+    def where
+      puts @workspace.code_around_binding if @workspace
+    end
+
+    def notify(message)
+      puts message
+    end
+
+    private
+
+    # Evaling `next` is a `SyntaxError` in Ruby. Since IRB does not have
+    # commands support in the lexer level, we need to call the `next` command
+    # in syntactically correct way.
+    def special_case_next_eval(irb_context)
+      def irb_context.evaluate(line, line_no, exception: nil)
+        line = "self.next\n" if line == "next\n"
+        super(line, line_no, exception: exception)
+      end
+
+      irb_context
+    end
+  end
+end

data/lib/break/irb/overrides.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Break::IRB
+  module Overrides
+    def irb
+      return if Break::Session.active?
+
+      Break::Session.start!
+
+      begin
+        session = Break::Session.new(self, frontend: Frontend.new)
+        session.enter
+      ensure
+        Break::Session.stop!
+      end
+    end
+  end
+end

data/lib/break/pry.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "pry"
+require "break"
+
+require_relative "pry/frontend"
+require_relative "pry/commands"
+require_relative "pry/overrides"
+
+Break::Filter.register_internal MethodSource.method(:source_helper).source_location.first.chomp(".rb")
+Break::Filter.register_internal CodeRay.method(:scan).source_location.first.chomp(".rb")
+Break::Filter.register_internal Pry.method(:start).source_location.first.chomp("/pry_class.rb")
+Break::Filter.register_internal "(pry)"
+Break::Filter.register_internal __dir__
+
+Object.prepend Break::Pry::Overrides
+
+Pry.config.commands.import Break::Pry::Commands

data/lib/break/pry/commands.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Break::Pry
+  Commands = Pry::CommandSet.new do
+    create_command "next", "Go to the next line." do
+      group "Break"
+
+      banner <<-BANNER
+        Usage: next
+
+        Step over within the same frame.
+
+        Examples:
+          next #=> Move a line forward.
+      BANNER
+
+      def process
+        session = Break::Session.new(_pry_.binding_stack.first, frontend: Frontend.new(_pry_))
+
+        command = Break::NextCommand.new(session)
+        command.execute
+      ensure
+        Break::Session.start!
+      end
+    end
+
+    create_command "step", "Step into the current line invocation." do
+      group "Break"
+
+      banner <<-BANNER
+        Usage: step
+
+        Step into a method call.
+
+        Examples:
+          step #=> Step into the method invocation.
+      BANNER
+
+      def process
+        session = Break::Session.new(_pry_.binding_stack.first, frontend: Frontend.new(_pry_))
+
+        command = Break::StepCommand.new(session)
+        command.execute
+      ensure
+        Break::Session.start!
+      end
+    end
+
+    create_command "up", "Go up a frame." do
+      group "Break"
+
+      banner <<-BANNER
+        Usage: up
+
+        Go to the frame that called the current one. Can be used only if the
+        command `step` was issued before.
+
+        Examples:
+          up #=> Step into the method invocation.
+      BANNER
+
+      def process
+        session = Break::Session.new(_pry_.binding_stack.first, frontend: Frontend.new(_pry_))
+
+        command = Break::UpCommand.new(session)
+        command.execute
+      ensure
+        Break::Session.start!
+      end
+    end
+
+    create_command "down", "Go down a frame." do
+      group "Break"
+
+      banner <<-BANNER
+        Usage: down
+
+        Go to the frame called from the current one. Can be used only if the
+        command `step` was issued before.
+
+        Examples:
+          down #=> Step to the previous frame.
+      BANNER
+
+      def process
+        session = Break::Session.new(_pry_.binding_stack.first, frontend: Frontend.new(_pry_))
+
+        command = Break::DownCommand.new(session)
+        command.execute
+      ensure
+        Break::Session.start!
+      end
+    end
+  end
+end

data/lib/break/pry/frontend.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Break::Pry
+  class Frontend
+    def initialize(pry)
+      @pry = pry
+    end
+
+    def attach(session)
+      @pry = Pry.start(session.context.binding)
+      where
+    end
+
+    def detach
+      throw :breakout
+    end
+
+    def where
+      @pry&.run_command "whereami".dup
+    rescue MethodSource::SourceNotFoundError
+      puts "Cannot find method code."
+    end
+
+    def notify(message)
+      puts message
+    end
+  end
+end

data/lib/break/pry/overrides.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Break::Pry
+  # Overrides is a module that is supposed to be prepended into ::Object's
+  # ancestor chain and hook into the #pry method and prevent double break
+  # sessions.
+  module Overrides
+    def pry(*)
+      return if Break::Session.active?
+
+      Break::Session.start!
+
+      begin
+        super
+      ensure
+        Break::Session.stop!
+      end
+    end
+  end
+end

data/lib/break/session.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Break
+  class Session
+    class << self
+      def start!
+        Thread.current[:__break_active_session__] = true
+      end
+
+      def stop!
+        Thread.current[:__break_active_session__] = nil
+      end
+
+      def active?
+        Thread.current[:__break_active_session__]
+      end
+    end
+
+    attr_reader :contexts
+    attr_reader :frontend
+
+    def initialize(binding, frontend:)
+      @contexts = [Context.new(binding)]
+      @frontend = frontend
+    end
+
+    def enter
+      frontend.attach(self)
+    end
+
+    def leave
+      frontend.detach
+    end
+
+    def context
+      contexts.last
+    end
+
+    def context!(*bindings, depth: 0)
+      contexts << Context.new(*bindings, depth: depth)
+      enter
+    end
+  end
+end

data/lib/break/testing.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "minitest"
+
+module Break
+  class TestingFrontend
+    class << self
+      def build(&block)
+        Class.new(self, &block)
+      end
+
+      def stack
+        @stack ||= []
+      end
+
+      def [](index)
+        stack[index]
+      end
+
+      def last
+        stack.last
+      end
+
+      def clear
+        stack.clear
+      end
+    end
+
+    attr_reader :session
+
+    def initialize
+      self.class.stack << self
+    end
+
+    def attach(session)
+      @session = session
+    end
+
+    def detach; end
+
+    def where; end
+
+    def notify(_message); end
+  end
+
+  class Test < Minitest::Test
+    def self.test(name, &block)
+      define_method("test_#{name}", &block)
+    end
+
+    def pass
+      Kernel.binding.tap do |binding|
+        yield binding if block_given?
+      end
+    end
+  end
+end

data/lib/break/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Break
+  VERSION = "0.8.0"
+end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: break
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Genadi Samokovarov
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2019-09-18 00:00:00.000000000 Z
+date: 2019-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '5.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '5.11'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -58,7 +58,31 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- lib/break.rb
+- lib/break/binding_ext.rb
+- lib/break/command.rb
+- lib/break/commands.rb
+- lib/break/commands/continue_command.rb
+- lib/break/commands/down_command.rb
+- lib/break/commands/list_command.rb
+- lib/break/commands/next_command.rb
+- lib/break/commands/step_command.rb
+- lib/break/commands/tracepoint_command.rb
+- lib/break/commands/up_command.rb
+- lib/break/context.rb
+- lib/break/filter.rb
+- lib/break/irb.rb
+- lib/break/irb/commands.rb
+- lib/break/irb/frontend.rb
+- lib/break/irb/overrides.rb
+- lib/break/pry.rb
+- lib/break/pry/commands.rb
+- lib/break/pry/frontend.rb
+- lib/break/pry/overrides.rb
+- lib/break/session.rb
+- lib/break/testing.rb
+- lib/break/version.rb
 homepage: https://github.com/gsamokovarov/break
 licenses:
 - MIT