debugger-xml 0.3.3 → 0.4.0

data/lib/byebug/printers/xml.rb

@@ -0,0 +1,197 @@
+require 'byebug/printers/base'
+require 'builder'
+
+module Byebug
+  module Printers
+    class Xml < Byebug::Printers::Base
+
+      def print(path, args = {})
+        case parts(path)[1]
+        when "errors"
+          print_error(path, args)
+        when "confirmations"
+          print_confirmation(path, args)
+        when "debug"
+          print_debug(path, args)
+        when "messages"
+          print_message(path, args)
+        else
+          print_general(path, args)
+        end
+      end
+
+      def print_collection(path, collection, &block)
+        settings = locate(path)
+        xml = ::Builder::XmlMarkup.new
+        tag = translate(settings["tag"])
+        xml.tag!("#{tag}s") do |xml|
+          array_of_args(collection, &block).each do |args|
+            xml.tag!(tag, translated_attributes(settings["attributes"], args))
+          end
+        end
+      end
+
+      def print_variables(variables, global_kind)
+        print_collection("variable.variable", variables) do |(key, value, kind), index|
+          Variable.new(key, value, kind || global_kind).to_hash
+        end
+      end
+
+      def print_instance_variables(object)
+        variables = if object.is_a?(Array)
+          object.each.with_index.map { |item, index| ["[#{index}]", item, 'instance'] }
+        elsif object.is_a?(Hash)
+          object.map { |key, value| [key.is_a?(String) ? "'#{key}'" : key.to_s, value, 'instance'] }
+        else
+          AllVariables.new(object).variables
+        end
+        print_variables(variables, nil)
+      end
+
+      private
+
+        def print_general(path, args)
+          settings = locate(path)
+          xml = ::Builder::XmlMarkup.new
+          tag = translate(settings["tag"], args)
+          attributes = translated_attributes(settings["attributes"], args)
+          xml.tag!(tag, attributes)
+        end
+
+        def print_debug(path, args)
+          translate(locate(path), args)
+        end
+
+        def print_error(path, args)
+          xml = ::Builder::XmlMarkup.new
+          xml.error { print_content(xml, path, args) }
+        end
+
+        def print_confirmation(path, args)
+          xml = ::Builder::XmlMarkup.new
+          xml.confirmation { print_content(xml, path, args) }
+        end
+
+        def print_message(path, args)
+          xml = ::Builder::XmlMarkup.new
+          xml.message { print_content(xml, path, args) }
+        end
+
+        def print_content(xml, path, args)
+          xml.text!(translate(locate(path), args))
+        end
+
+        def translated_attributes(attributes, args)
+          attributes.inject({}) do |hash, (key, value)|
+            hash[key] = translate(value, args)
+            hash
+          end
+        end
+
+        def contents_files
+          [File.expand_path(File.join("..", "texts", "xml.yml"), __FILE__)] + super
+        end
+
+      class Variable
+        attr_reader :name, :kind
+        def initialize(name, value, kind = nil)
+          @name = name.to_s
+          @value = value
+          @kind = kind
+        end
+
+        def has_children?
+          if @value.is_a?(Array) || @value.is_a?(Hash)
+            !@value.empty?
+          else
+            !@value.instance_variables.empty? || !@value.class.class_variables.empty?
+          end
+        rescue
+          false
+        end
+
+        def value
+          if @value.is_a?(Array) || @value.is_a?(Hash)
+            if has_children?
+              "#{@value.class} (#{@value.size} element(s))"
+            else
+              "Empty #{@value.class}"
+            end
+          else
+            value_str = @value.nil? ? 'nil' : @value.to_s
+            if !value_str.is_a?(String)
+              "ERROR: #{@value.class}.to_s method returns #{value_str.class}. Should return String."
+            elsif binary_data?(value_str)
+              "[Binary Data]"
+            else
+              value_str.gsub(/^(")(.*)(")$/, '\2')
+            end
+          end
+        rescue => e
+          "<raised exception: #{e}>"
+        end
+
+        def id
+          @value.respond_to?(:object_id) ? "%#+x" % @value.object_id : nil
+        rescue
+          nil
+        end
+
+        def type
+          @value.class
+        rescue
+          "Undefined"
+        end
+
+        def to_hash
+          {name: @name, kind: @kind, value: value, type: type, has_children: has_children?, id: id}
+        end
+
+        private
+
+          def binary_data?(string)
+            string.count("\x00-\x7F", "^ -~\t\r\n").fdiv(string.size) > 0.3 || string.index("\x00") unless string.empty?
+          end
+      end
+
+      class AllVariables
+        def initialize(object)
+          @object = object
+          @instance_binding = object.instance_eval{binding()}
+          @class_binding = object.class.class_eval('binding()')
+
+          @instance_variable_names = object.instance_variables
+          @self_variable_name = @instance_variable_names.delete('self')
+          @class_variable_names = object.class.class_variables
+        end
+
+        def variables
+          self_variables + instance_variables + class_variables
+        end
+
+        private
+
+          def instance_variables
+            @instance_variable_names.map do |var|
+              [var.to_s, (eval(var.to_s, @instance_binding) rescue "<raised exception>"), 'instance']
+            end
+          end
+
+          def self_variables
+            if @self_variable_name
+              [@self_variable_name, (eval(@self_variable_name, @instance_binding)), 'instance']
+            else
+              []
+            end
+          end
+
+          def class_variables
+            @class_variable_names.map do |var|
+              [var.to_s, (eval(var.to_s, @class_binding) rescue "<raised exception>"), 'class']
+            end
+          end
+      end
+
+    end
+  end
+end

data/lib/debugger/{xml/extensions/commands → commands}/frame.rb

@@ -13,4 +13,3 @@ module Debugger
 
   end
 end
-

data/lib/debugger/commands/start.rb

@@ -0,0 +1,25 @@
+module Debugger
+  class StartCommand < Command # :nodoc:
+    self.allow_in_control = true
+
+    def regexp
+      /^\s*(start)\s*$/ix
+    end
+
+    def execute
+      DebuggerXml.proceed
+    end
+
+    class << self
+      def help_command
+        'start'
+      end
+
+      def help(cmd)
+        %{
+          run prog script
+        }
+      end
+    end
+  end
+end

data/lib/debugger/{xml/extensions/commands → commands}/variables.rb

@@ -20,4 +20,18 @@ module Debugger
     alias_method :execute, :execute_with_xml
 
   end
+
+  class VarIdeCommand < Command
+    def regexp
+      /^\s*v(?:ar)?\s+ide\s*$/
+    end
+
+    def execute
+      locals = []
+      _self = @state.context.frame_self(@state.frame_pos)
+      locals << ['self', _self] unless _self.to_s == "main"
+      locals += @state.context.frame_locals(@state.frame_pos).sort.map { |key, value| [key, value] }
+      print prv(locals, 'instance')
+    end
+  end
 end

data/lib/debugger_xml.rb

@@ -0,0 +1,91 @@
+Dir.glob(File.expand_path("../debugger_xml/**/*.rb", __FILE__)).each { |f| require f }
+if DEBUGGER_TYPE == :debugger
+  Dir.glob(File.expand_path("../debugger/**/*.rb", __FILE__)).each { |f| require f }
+else
+  Dir.glob(File.expand_path("../byebug/**/*.rb", __FILE__)).each { |f| require f }
+end
+
+module DebuggerXml
+  class << self
+    attr_accessor :logger, :wait_for_start, :control_thread, :handler, :queue
+
+    def start_remote_ide(proxy, host, port)
+      return if @control_thread
+      @mutex = Mutex.new
+      @proceed = ConditionVariable.new
+      @queue = Queue.new
+      proxy.start
+      @control_thread = proxy.debug_thread_class.new do
+        server = TCPServer.new(host, port)
+        $stderr.printf "Fast Debugger (debugger-xml #{VERSION}) listens on #{host}:#{port}\n"
+        while (session = server.accept)
+          dispatcher = ENV['IDE_PROCESS_DISPATCHER']
+          if dispatcher && !dispatcher.include?(":")
+            ENV['IDE_PROCESS_DISPATCHER'] = "#{session.peeraddr[2]}:#{dispatcher}"
+          end
+          interface = DebuggerXml::Ide::Interface.new(session)
+          processor = DebuggerXml::Ide::ControlCommandProcessor.new(interface, proxy)
+          debugger_class.handler = DebuggerXml::Ide::Processor.new(interface, proxy)
+          processor.process_commands
+        end
+      end
+      @mutex.synchronize { @proceed.wait(@mutex) } if wait_for_start
+    end
+
+    def start_for_vim(proxy, options)
+      return if @control_thread
+      logger.puts("Going to daemonize")
+      daemonize!
+      logger.puts("Successfully daemonized")
+      $stdout.reopen(options.output_file, 'w')
+      $stdout.sync
+      $stderr.reopen($stdout)
+      logger.puts("Redirected stderr")
+      @mutex = Mutex.new
+      @proceed = ConditionVariable.new
+      @queue = Queue.new
+      proxy.start
+      logger.puts("Started debugger")
+      File.unlink(options.socket) if File.exist?(options.socket)
+      server = UNIXServer.new(options.socket)
+      Vim::Notification.new("establish_connection", options).send
+      logger.puts("Sent 'established_connection' command")
+      @control_thread = proxy.debug_thread_class.new do
+        begin
+          while (session = server.accept)
+            logger.puts("Accepted connection");
+            interface = Vim::Interface.new(session, options)
+            processor = Vim::ControlCommandProcessor.new(interface, proxy)
+            proxy.handler = Vim::Processor.new(processor, interface, proxy)
+            logger.puts("Going to process commands");
+            processor.process_commands
+          end
+        rescue Exception => e
+          logger.puts("INTERNAL ERROR!!! #{$!}") rescue nil
+          logger.puts($!.backtrace.map { |l| "\t#{l}" }.join("\n")) rescue nil
+          raise e
+        ensure
+          logger.puts("Closing server");
+          server.close
+        end
+      end
+      @mutex.synchronize { @proceed.wait(@mutex) } if wait_for_start
+    end
+
+    def proceed
+      return unless @mutex
+      @mutex.synchronize { @proceed.signal }
+    end
+
+    private
+
+      def daemonize!
+        pid = Process.fork
+        if pid
+          print pid
+          exit
+        end
+      end
+
+  end
+end

data/lib/debugger_xml/byebug_proxy.rb

@@ -0,0 +1,108 @@
+module DebuggerXml
+  class ByebugProxy
+    def start
+      ::Byebug.start
+    end
+
+    def handler
+      ::Byebug.handler
+    end
+
+    def handler=(value)
+      ::Byebug.handler = value
+    end
+
+    def control_commands(interface)
+      control_command_classes = commands.select(&:allow_in_control)
+      state = ::Byebug::ControlCommandProcessor::State.new(interface, control_command_classes)
+      control_command_classes.map { |cmd| cmd.new(state) }
+    end
+
+    def build_command_processor_state(interface)
+      ::Byebug::CommandProcessor::State.new(commands, handler.context, [], handler.file, interface, handler.line)
+    end
+
+    def commands
+      ::Byebug::Command.commands
+    end
+
+    def event_commands(state)
+      event_command_classes.map { |cls| cls.new(state) }
+    end
+
+    def print(*args)
+      printer.print(*args)
+    end
+
+    def canonic_file(file)
+      ::Byebug::CommandProcessor.canonic_file(file)
+    end
+
+    def line_at(file, line)
+    end
+
+    def breakpoints
+      ::Byebug.breakpoints
+    end
+
+    def debug_thread?(context)
+      context && context.thread.is_a?(debug_thread_class)
+    end
+
+    def debug_thread_class
+      ::Byebug::DebugThread
+    end
+
+    def current_context
+      ::Byebug.current_context
+    end
+
+    def set_rdebug_script(file)
+      ::Byebug.const_set("RDEBUG_SCRIPT", file)
+    end
+
+    def set_prog_script(file)
+      ::Byebug.const_set("PROG_SCRIPT", file)
+    end
+
+    def set_argv(argv)
+      ::Byebug.const_set("ARGV", argv)
+    end
+
+    def interrupt_last
+      ::Byebug.interrupt_last
+    end
+
+    def tracing=(value)
+      ::Byebug.tracing = value
+    end
+
+    def wait_connection=(value)
+      ::Byebug.wait_connection = value
+    end
+
+    def printer=(value)
+      ::Byebug.printer = value
+    end
+
+    def debug_load
+      ::Byebug.debug_load(::Byebug::PROG_SCRIPT, false)
+    end
+
+    def inspect_command_class
+      ::Byebug::InspectCommand
+    end
+
+    private
+
+    def event_command_classes
+      commands
+    end
+
+    def printer
+      ::Byebug.printer
+    end
+
+  end
+end
+