readapt 1.4.0 → 1.4.1

data/lib/readapt/message/step_out.rb

@@ -1,11 +1,11 @@
-# frozen_string_literal: true
-
-module Readapt
-  module Message
-    class StepOut < Base
-      def run
-        debugger.thread(arguments['threadId']).control = :step_out
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Readapt
+  module Message
+    class StepOut < Base
+      def run
+        debugger.thread(arguments['threadId']).control = :step_out
+      end
+    end
+  end
+end

data/lib/readapt/message/threads.rb

@@ -1,18 +1,18 @@
-# frozen_string_literal: true
-
-module Readapt
-  module Message
-    class Threads < Base
-      def run
-        set_body({
-          threads: debugger.threads.map do |thr|
-            {
-              id: thr.id,
-              name: thr.name
-            }
-          end
-        })
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Readapt
+  module Message
+    class Threads < Base
+      def run
+        set_body({
+          threads: debugger.threads.map do |thr|
+            {
+              id: thr.id,
+              name: thr.name
+            }
+          end
+        })
+      end
+    end
+  end
+end

data/lib/readapt/message/variables.rb

@@ -1,53 +1,53 @@
-# frozen_string_literal: true
-
-module Readapt
-  module Message
-    class Variables < Base
-      def run
-        ref = arguments['variablesReference']
-        frame = debugger.frame(ref)
-        # @todo 1 is a magic number representing the toplevel binding (see
-        #   Message::Scopes)
-        vars = if ref == 1
-          global_variables.map do |gv|
-            Variable.new(gv, eval(gv.to_s))
-          end
-        else
-          if frame != Frame::NULL_FRAME && !frame.nil?
-            frame.locals
-          else
-            obj = References.get(ref)
-            result = []
-            if obj.is_a?(Array)
-              obj.each_with_index do |itm, idx|
-                result.push Variable.new("[#{idx}]", itm)
-              end
-            elsif obj.is_a?(Hash)
-              obj.each_pair do |idx, itm|
-                result.push Variable.new("[#{idx}]", itm)
-              end
-            else
-              obj.instance_variables.sort.each do |iv|
-                result.push Variable.new(iv, obj.instance_variable_get(iv))
-              end
-              obj.class.class_variables.sort.each do |cv|
-                result.push Variable.new(cv, obj.class.class_variable_get(cv))
-              end
-            end
-            result
-          end
-        end
-        set_body({
-          variables: vars.map do |var|
-            {
-              name: var.name,
-              value: var.value,
-              type: var.type,
-              variablesReference: var.reference
-            }
-          end
-        })
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Readapt
+  module Message
+    class Variables < Base
+      def run
+        ref = arguments['variablesReference']
+        frame = debugger.frame(ref)
+        # @todo 1 is a magic number representing the toplevel binding (see
+        #   Message::Scopes)
+        vars = if ref == 1
+          global_variables.map do |gv|
+            Variable.new(gv, eval(gv.to_s))
+          end
+        else
+          if frame != Frame::NULL_FRAME && !frame.nil?
+            frame.locals
+          else
+            obj = References.get(ref)
+            result = []
+            if obj.is_a?(Array)
+              obj.each_with_index do |itm, idx|
+                result.push Variable.new("[#{idx}]", itm)
+              end
+            elsif obj.is_a?(Hash)
+              obj.each_pair do |idx, itm|
+                result.push Variable.new("[#{idx}]", itm)
+              end
+            else
+              obj.instance_variables.sort.each do |iv|
+                result.push Variable.new(iv, obj.instance_variable_get(iv))
+              end
+              obj.class.class_variables.sort.each do |cv|
+                result.push Variable.new(cv, obj.class.class_variable_get(cv))
+              end
+            end
+            result
+          end
+        end
+        set_body({
+          variables: vars.map do |var|
+            {
+              name: var.name,
+              value: var.value,
+              type: var.type,
+              variablesReference: var.reference
+            }
+          end
+        })
+      end
+    end
+  end
+end

data/lib/readapt/output.rb

@@ -1,25 +1,25 @@
-module Readapt
-  module Output
-    class << self
-      attr_accessor :adapter
-    end
-
-    def receiving data
-      send_event('output', {
-        output: data.force_encoding('utf-8'),
-        category: 'stdout'
-      })
-    end
-
-    def send_event event, data
-      obj = {
-        type: 'event',
-        event: event
-      }
-      obj[:body] = data unless data.nil?
-      json = obj.to_json
-      envelope = "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
-      Output.adapter.write envelope
-    end
-  end
-end
+module Readapt
+  module Output
+    class << self
+      attr_accessor :adapter
+    end
+
+    def receiving data
+      send_event('output', {
+        output: data.force_encoding('utf-8'),
+        category: 'stdout'
+      })
+    end
+
+    def send_event event, data
+      obj = {
+        type: 'event',
+        event: event
+      }
+      obj[:body] = data unless data.nil?
+      json = obj.to_json
+      envelope = "Content-Length: #{json.bytesize}\r\n\r\n#{json}"
+      Output.adapter.write envelope
+    end
+  end
+end

data/lib/readapt/references.rb

@@ -1,27 +1,27 @@
-module Readapt
-  module References
-    module_function
-
-    @variable_reference_map = {}
-    @reference_variable_map = {}
-    @reference_id = 1000
-
-    def clear
-      @variable_reference_map.clear
-      @reference_variable_map.clear
-      @reference_id = 1000
-    end
-
-    def identify object
-      return @variable_reference_map[object] if @variable_reference_map.has_key?(object)
-      @reference_id += 1
-      @variable_reference_map[object] = @reference_id
-      @reference_variable_map[@reference_id] = object
-      @reference_id
-    end
-
-    def get id
-      @reference_variable_map[id]
-    end
-  end
-end
+module Readapt
+  module References
+    module_function
+
+    @variable_reference_map = {}
+    @reference_variable_map = {}
+    @reference_id = 1000
+
+    def clear
+      @variable_reference_map.clear
+      @reference_variable_map.clear
+      @reference_id = 1000
+    end
+
+    def identify object
+      return @variable_reference_map[object] if @variable_reference_map.has_key?(object)
+      @reference_id += 1
+      @variable_reference_map[object] = @reference_id
+      @reference_variable_map[@reference_id] = object
+      @reference_id
+    end
+
+    def get id
+      @reference_variable_map[id]
+    end
+  end
+end

data/lib/readapt/server.rb

@@ -1,22 +1,22 @@
-require 'securerandom'
-require 'stringio'
-
-module Readapt
-  module Server
-    class << self
-      attr_accessor :target_in
-      attr_accessor :target_pid
-    end
-
-    def opening
-      Error.adapter = self
-      Output.adapter = self
-    end
-
-    def receiving data
-      Server.target_in.syswrite data
-    rescue Errno::EPIPE, IOError
-      close
-    end
-  end
-end
+require 'securerandom'
+require 'stringio'
+
+module Readapt
+  module Server
+    class << self
+      attr_accessor :target_in
+      attr_accessor :target_pid
+    end
+
+    def opening
+      Error.adapter = self
+      Output.adapter = self
+    end
+
+    def receiving data
+      Server.target_in.syswrite data
+    rescue Errno::EPIPE, IOError
+      close
+    end
+  end
+end

data/lib/readapt/shell.rb

@@ -1,104 +1,104 @@
-require 'thor'
-require 'backport'
-require 'open3'
-require 'securerandom'
-require 'socket'
-
-module Readapt
-  class Shell < Thor
-    map %w[--version -v] => :version
-
-    desc "--version, -v", "Print the version"
-    def version
-      puts Readapt::VERSION
-    end
-
-    desc 'socket', 'Run a DAP server over TCP'
-    option :host, type: :string, aliases: :h, description: 'The server host', default: '127.0.0.1'
-    option :port, type: :numeric, aliases: :p, description: 'The server port', default: 1234
-    def socket
-      machine = Backport::Machine.new
-      machine.run do
-        prepare_machine machine
-        server = Backport::Server::Tcpip.new(host: options[:host], port: options[:port], adapter: Readapt::Server)
-        machine.prepare server
-        STDERR.puts "Readapt Debugger #{Readapt::VERSION} is listening HOST=#{options[:host]} PORT=#{options[:port]} PID=#{Process.pid}"
-      end
-    end
-    map serve: :socket
-
-    desc 'stdio', 'Run a DAP server over STDIO'
-    def stdio
-      machine = Backport::Machine.new
-      machine.run do
-        prepare_machine machine
-        server = Backport::Server::Stdio.new(adapter: Readapt::Server)
-        machine.prepare server
-      end
-    end
-
-    desc 'target [PROCID]', 'Run a target process'
-    def target procid = nil
-      STDIN.binmode
-      STDOUT.binmode
-      STDERR.binmode
-      STDOUT.sync = true
-      STDERR.sync = true
-      Readapt::Adapter.procid = procid
-      machine = Backport::Machine.new
-      Signal.trap("INT") do
-        graceful_shutdown machine
-      end
-      Signal.trap("TERM") do
-        graceful_shutdown machine
-      end
-      machine.run do
-        debugger = Readapt::Debugger.new
-        Readapt::Adapter.host debugger
-        machine.prepare Backport::Server::Stdio.new(input: STDIN, output: STDERR, adapter: Readapt::Adapter)
-      end
-    end
-
-    private
-
-    # @param machine [Backport::Machine]
-    # @return [void]
-    def prepare_machine machine
-      STDOUT.sync = true
-      STDERR.sync = true
-      Signal.trap("INT") do
-        graceful_shutdown machine
-      end
-      Signal.trap("TERM") do
-        graceful_shutdown machine
-      end
-      procid = SecureRandom.hex(8)
-      Readapt::Error.procid = procid
-      stdin, stdout, stderr, thr = Open3.popen3('ruby', $0, 'target', procid)
-      stdin.sync = true
-      stdout.sync = true
-      stderr.sync = true
-      stdin.binmode
-      Readapt::Server.target_in = stdin
-      Readapt::Server.target_pid = thr[:pid]
-      output = Backport::Server::Stdio.new(input: stdout, output: stdin, adapter: Readapt::Output)
-      error = Backport::Server::Stdio.new(input: stderr, output: stdin, adapter: Readapt::Error)
-      machine.prepare output
-      machine.prepare error
-      at_exit do
-        begin
-          Process.kill 'KILL', thr[:pid]
-        rescue Errno::ESRCH
-          # Ignore
-        end
-      end
-    end
-
-    # @param machine [Backport::Machine]
-    # @return [void]
-    def graceful_shutdown machine
-      machine.stop
-      exit
-    end
-  end
-end
+require 'thor'
+require 'backport'
+require 'open3'
+require 'securerandom'
+require 'socket'
+
+module Readapt
+  class Shell < Thor
+    map %w[--version -v] => :version
+
+    desc "--version, -v", "Print the version"
+    def version
+      puts Readapt::VERSION
+    end
+
+    desc 'socket', 'Run a DAP server over TCP'
+    option :host, type: :string, aliases: :h, description: 'The server host', default: '127.0.0.1'
+    option :port, type: :numeric, aliases: :p, description: 'The server port', default: 1234
+    def socket
+      machine = Backport::Machine.new
+      machine.run do
+        prepare_machine machine
+        server = Backport::Server::Tcpip.new(host: options[:host], port: options[:port], adapter: Readapt::Server)
+        machine.prepare server
+        STDERR.puts "Readapt Debugger #{Readapt::VERSION} is listening HOST=#{options[:host]} PORT=#{options[:port]} PID=#{Process.pid}"
+      end
+    end
+    map serve: :socket
+
+    desc 'stdio', 'Run a DAP server over STDIO'
+    def stdio
+      machine = Backport::Machine.new
+      machine.run do
+        prepare_machine machine
+        server = Backport::Server::Stdio.new(adapter: Readapt::Server)
+        machine.prepare server
+      end
+    end
+
+    desc 'target [PROCID]', 'Run a target process'
+    def target procid = nil
+      STDIN.binmode
+      STDOUT.binmode
+      STDERR.binmode
+      STDOUT.sync = true
+      STDERR.sync = true
+      Readapt::Adapter.procid = procid
+      machine = Backport::Machine.new
+      Signal.trap("INT") do
+        graceful_shutdown machine
+      end
+      Signal.trap("TERM") do
+        graceful_shutdown machine
+      end
+      machine.run do
+        debugger = Readapt::Debugger.new
+        Readapt::Adapter.host debugger
+        machine.prepare Backport::Server::Stdio.new(input: STDIN, output: STDERR, adapter: Readapt::Adapter)
+      end
+    end
+
+    private
+
+    # @param machine [Backport::Machine]
+    # @return [void]
+    def prepare_machine machine
+      STDOUT.sync = true
+      STDERR.sync = true
+      Signal.trap("INT") do
+        graceful_shutdown machine
+      end
+      Signal.trap("TERM") do
+        graceful_shutdown machine
+      end
+      procid = SecureRandom.hex(8)
+      Readapt::Error.procid = procid
+      stdin, stdout, stderr, thr = Open3.popen3('ruby', $0, 'target', procid)
+      stdin.sync = true
+      stdout.sync = true
+      stderr.sync = true
+      stdin.binmode
+      Readapt::Server.target_in = stdin
+      Readapt::Server.target_pid = thr[:pid]
+      output = Backport::Server::Stdio.new(input: stdout, output: stdin, adapter: Readapt::Output)
+      error = Backport::Server::Stdio.new(input: stderr, output: stdin, adapter: Readapt::Error)
+      machine.prepare output
+      machine.prepare error
+      at_exit do
+        begin
+          Process.kill 'KILL', thr[:pid]
+        rescue Errno::ESRCH
+          # Ignore
+        end
+      end
+    end
+
+    # @param machine [Backport::Machine]
+    # @return [void]
+    def graceful_shutdown machine
+      machine.stop
+      exit
+    end
+  end
+end