rdb 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cb10186874a82b79627e85bc76509e03947a5795
+  data.tar.gz: 7b062cebaa8ed960fa418c144e531e9e15f6e0f7
+SHA512:
+  metadata.gz: 1bdadde43fb3ea668a1e6af471b7fdd699d7d08ab4c83db4b98357f3abd31ba357dd29d0bd00fe7745acaae02ace51ceeb29224d16bb96f2102399fcc3952a33
+  data.tar.gz: 068a505eec8b57c3440586b5be63696df678affa9a510178125162f09e7add3cf8ae68ae6ab098b4ebadf26c8e1cc3003d2b6d6858c5a2175c5b8e6fbf45c52b

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+gem/
+.bundle/

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Chris Schmich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,9 @@
+#  rdb
+
+Shh, it's a secret (for now).
+
+## License
+
+Copyright © 2014 Chris Schmich
+<br />
+MIT License, See [LICENSE](LICENSE) for details.

data/Rakefile

@@ -0,0 +1,93 @@
+require 'rake/testtask'
+require 'fileutils'
+
+class GemInfo
+  def initialize
+    @gemspec_filename = Dir['*.gemspec'][0]
+  end
+   
+  def spec
+    @spec ||= eval(File.read(@gemspec_filename))
+  end
+
+  def name
+    @name ||= spec.name
+  end
+
+  def version
+    @version ||= spec.version.to_s
+  end
+
+  def gem_filename
+    "#{name}-#{version}.gem"
+  end
+
+  def gemspec_filename
+    @gemspec_filename
+  end
+end
+
+$gem = GemInfo.new
+
+desc "Start irb #{$gem.name} session"
+task :console do
+  sh "irb -rubygems -I./lib -r ./lib/#{$gem.name}.rb"
+end
+
+desc "Install #{$gem.name} gem"
+task :install => :build do
+  gemfile = "gem/#{$gem.gem_filename}"
+  if !gemfile.nil?
+    sh "gem install --no-ri --no-rdoc #{gemfile}"
+  else
+    puts 'Could not find gem.'
+  end
+end
+
+desc "Uninstall #{$gem.name} gem"
+task :uninstall do
+  sh "gem uninstall #{$gem.name} -x"
+end
+
+desc "Build #{$gem.name} gem"
+task :build do
+  FileUtils.mkdir_p('gem')
+  sh "gem build #{$gem.gemspec_filename}"
+  FileUtils.mv $gem.gem_filename, 'gem'
+end
+
+desc "Release #{$gem.name} v#{$gem.version} and tag in git"
+task :release => :build do
+  if (`git` rescue nil).nil?
+    puts 'Could not run git command.'
+    exit!
+  end
+
+  if (`gem` rescue nil).nil?
+    puts 'Could not run gem command.'
+    exit!
+  end
+
+  unless (`git branch --no-color`.strip rescue '') =~ /\A*\s+master\z/
+    puts 'You must release from the master branch.'
+    exit!
+  end
+
+  print "Do you want to release #{$gem.name} v#{$gem.version} and tag it in git (y/n)? "
+  response = $stdin.gets.strip
+  unless response =~ /\Ay/
+    puts 'Aborting.'
+    exit!
+  end
+
+  version = $gem.version
+  puts "Releasing version #{version}."
+
+  sh "git commit --allow-empty -a -m \"Release #{version}.\""
+  sh "git tag v#{version}"
+  sh 'git push origin master'
+  sh "git push origin v#{version}"
+  sh "gem push gem/#{$gem.gem_filename}"
+
+  puts 'Fin.'
+end

data/TODO.txt

@@ -0,0 +1,44 @@
+- File selector at top of source editor
+  - Populate with every file seen so far
+- Locals window
+- Params window (with locals?)
+- Watch window
+  - Custom user expressions
+- Object explorer
+  - Tree view
+  - Show class names
+  - Show circular references like node
+- Breakpoint setting
+- Breakpoints window
+- Tracepoints
+  - Like VS Debugger
+- stdout/stderr viewer ("Console" window)
+- Exception reporter
+- Have target launch webserver itself
+- Auto-open browser
+- Gemify library
+- Preserve settings
+  - Breakpoints
+  - Watches
+- Expression tooltips
+  - Hovering over expressions in source editor shows evaluated value
+- Show graphs while running
+  - Mem usage
+  - CPU usage
+  - Network/disk usage
+- Expose ARGV/ARGC, env, and config somewhere (from GET /process)
+- Cover usage scenarios
+  - Launch
+  - Attach/dettach/re-attach
+  - Rails/Sinatra/Padrino
+  - Thin/WEBRick/Puma/Unicorn
+  - User-invoked
+- Command history for expression evaluator
+  - e.g. up/down arrow to recall previous commands
+  - Escape to clear current command
+- Autocomplete for evaluation
+  - Discover from target
+  - Tab to complete
+- Use RUBYOPT/RUBYLIB to autoload debugger
+  - RUBYLIB=/path/to/rdb/lib
+  - RUBYOPT=-rrdb

data/bin/rdb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'web'
+
+server = Rdb::DebugServer
+server.set(:bind, 'localhost')
+server.set(:port, 4567)
+server.run!

data/lib/rdb.rb

@@ -0,0 +1,5 @@
+require 'rdb/inspector'
+require 'rdb/messaging'
+require 'rdb/debugger'
+require 'rdb/attach'
+require 'rdb/version'

data/lib/rdb/attach.rb

@@ -0,0 +1,10 @@
+module Kernel
+  def rdb
+    Byebug.handler = RemoteCommandProcessor.new
+    Byebug.start
+    Byebug.run_init_script(StringIO.new)
+    Byebug.current_context.step_out(1, true)
+  end
+
+  alias_method :debugger, :rdb
+end

data/lib/rdb/debugger.rb

@@ -0,0 +1,297 @@
+require 'byebug'
+require 'thread'
+
+class CommandServer < Messaging::Server
+  def initialize
+    super
+
+    @debug_thread_group = nil
+
+    @access = Mutex.new
+
+    @waiting = false
+    @mutex = Mutex.new
+    @resource = ConditionVariable.new
+
+    @command_queue = []
+  end
+
+  def start
+    @debug_thread_group = group = ThreadGroup.new
+
+    thread = Byebug::DebugThread.new do
+      listen('0.0.0.0', 4444)
+    end
+    
+    group.add(thread)
+    group.enclose
+  end
+
+  remote!
+  def threads
+    @access.synchronize {
+      # TODO: Better sync
+      while !@waiting
+      end
+
+      threads = []
+      Thread.list.each do |t|
+        next if ignored? t
+        
+        backtrace = []
+
+        context = Byebug.thread_context(t)
+        stack_size = context.calced_stack_size
+
+        (0...stack_size).each do |i|
+          path = File.expand_path(context.frame_file(i))
+          line = context.frame_line(i)
+          klass = context.frame_class(i).to_s
+          klass = nil if klass.empty?
+          method = context.frame_method(i)
+
+          backtrace << {
+            path: path,
+            line: line,
+            class: klass,
+            method: method,
+          }
+        end
+
+        threads << {
+          id: context.thnum,
+          main: t == Thread.main,
+          status: t.status,
+          alive: t.alive?,
+          priority: t.priority,
+          safe_level: t.safe_level,
+          backtrace: backtrace
+        }
+      end
+
+      threads
+    }
+  end
+
+  remote!
+  def process
+    @access.synchronize {
+      {
+        id: Process.pid,
+        argv: ARGV,
+        script: $0,
+        env: ENV.to_h,
+        config: RbConfig::CONFIG
+      }
+    }
+  end
+
+  remote!
+  def locals
+    @access.synchronize {
+      while !@waiting
+      end
+
+      vars = {}
+      context = Byebug.thread_context(Thread.main)
+      syms = context.frame_binding.eval('local_variables')
+      syms.each do |sym|
+        name = sym.to_s
+        vars[name] = context.frame_binding.eval(name).inspect
+      end
+
+      vars
+    }
+  end
+
+  remote!
+  def eval(expr: nil, frame: nil)
+    @access.synchronize {
+      while !@waiting
+      end
+
+      context = Byebug.thread_context(Thread.main)
+      begin
+        binding = context.frame_binding(frame)
+        value = Inspector.inspect(binding.eval(expr))
+        return { success: true, value: value }
+      rescue Exception => e
+        return { success: false, class: e.class.name, message: e.message }
+      end
+    }
+  end
+
+  remote!
+  def breakpoints
+    @access.synchronize {
+      Byebug.breakpoints.map do |bp|
+        {
+          id: bp.id,
+          line: bp.pos,
+          path: bp.source
+        }
+      end
+    }
+  end
+
+  remote!
+  def add_breakpoint(file: nil, line: nil)
+    @access.synchronize {
+      breakpoint = Byebug::Breakpoint.add(file, line)
+      broadcast.breakpoint_created
+      breakpoint.id
+    }
+  end
+
+  remote!
+  def remove_breakpoint(id: nil)
+    @access.synchronize {
+      breakpoint = Byebug::Breakpoint.remove(id)
+      broadcast.breakpoint_deleted
+      true
+    }
+  end
+
+  remote!
+  def pause
+    @access.synchronize {
+      context = Byebug.thread_context(Thread.main)
+      context.interrupt
+
+      false
+    }
+  end
+
+  remote!
+  def resume
+    @access.synchronize {
+      @command_queue << proc { |context|
+        true
+      }
+
+      @mutex.synchronize {
+        @resource.signal
+      }
+
+      true
+    }
+  end
+
+  remote!
+  def step_in
+    @access.synchronize {
+      @command_queue << proc { |context|
+        context.step_into(1)
+        true
+      }
+
+      @mutex.synchronize {
+        @resource.signal
+      }
+
+      true
+    }
+  end
+  
+  remote!
+  def step_over
+    @access.synchronize {
+      @command_queue << proc { |context|
+        context.step_over(1)
+        true
+      }
+
+      @mutex.synchronize {
+        @resource.signal
+      }
+
+      true
+    }
+  end
+
+  remote!
+  def step_out
+    @access.synchronize {
+      @command_queue << proc { |context|
+        context.step_out(1)
+        true
+      }
+
+      @mutex.synchronize {
+        @resource.signal
+      }
+
+      true
+    }
+  end
+
+  def next_command
+    if @command_queue.empty?
+      @mutex.synchronize {
+        @waiting = true
+        # TODO: Fix this synchronization. Using a condition variable here
+        # triggers Ruby's deadlock detection, so for now, we use a limited
+        # sleep with repeated checking.
+        while @command_queue.empty?
+          sleep 0.1
+        end
+        @waiting = false
+      }
+    end
+
+    return @command_queue.shift
+  end
+
+  remote!
+  def running?
+    @access.synchronize {
+      @running
+    }
+  end
+
+  def running=(running)
+    @running = running
+  end
+
+  private
+
+  def ignored?(thread)
+    thread.group == @debug_thread_group
+  end
+end
+
+class RemoteCommandProcessor < Byebug::Processor
+  def initialize(interface = Byebug::LocalInterface.new)
+    super(interface)
+
+    @server = CommandServer.new
+    @server.start
+  end
+  
+  def at_breakpoint(context, breakpoint)
+  end
+
+  def at_catchpoint(context, excpt)
+  end
+
+  def at_tracing(context, file, line)
+  end
+
+  def at_line(context, file, line)
+    @server.broadcast.break
+    process_commands(context, file, line)
+  end
+
+  def at_return(context, file, line)
+    process_commands(context, file, line)
+  end
+
+  def process_commands(context, file, line)
+    @server.running = false
+    loop do
+      command = @server.next_command
+      break if command.call(context)
+    end
+    @server.running = true
+  end
+end