rider-server 0.1.0

data/lib/rider_server/ops/set_namespace.rb

@@ -0,0 +1,79 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class SetNamespace < Operation
+      documentation "Set the namespace to the given location."
+
+      argument :id, :string, "The request id", required: true
+      argument :location, :array, "The location to set the namespace to", required: true
+
+      def handle(session, operation)
+        response = Response.new(operation)
+        location = operation["location"]
+
+        value = traverse_location(location, nil, session)
+        session.workspace.set_namespace(value)
+        response.set("ns", session.workspace.namespace_name)
+        response.set("location", location)
+        response.status("done")
+        response
+      end
+
+      def traverse_location(location, ctx, session)
+        loc = location.first
+        locs = location.drop(1)
+
+        if locs.empty?
+          lookup_object(loc, ctx, session)
+        else
+          traverse_location(locs, lookup_object(loc, ctx, session), session)
+        end
+      end
+
+      def lookup_object(loc, ctx, session)
+        lookup, identifier = loc.split(":", 2)
+
+        case lookup
+        when "rider_main"
+          "main"
+        when "rider_history"
+          rider_history(identifier, nil, session)
+        when "rider_exception"
+          rider_exception(identifier, nil, session)
+        when "rider_stackframe"
+          ctx.__rider_bindings_stack[identifier.to_i]
+        when "rider_stackframe_variable"
+          frame_id, local_var = identifier.split(":", 2)
+          ctx.__rider_bindings_stack[frame_id.to_i].local_variable_get(local_var)
+        when "rider_hash_key"
+          hash = identifier.to_i
+          ctx.keys.find { |key| key.hash == hash }
+        when "rider_hash_value"
+          hash = identifier.to_i
+          key = ctx.keys.find { |key| key.hash == hash }
+          ctx.fetch(key)
+        when "toplevel_const_get"
+          Object.const_get(identifier)
+        when "instance_variable_get"
+          ctx.instance_variable_get(identifier)
+        when "const_get"
+          ctx.const_get(identifier)
+        when "ancestor_find"
+          ctx.class.ancestors.find { |item| item.to_s == identifier }
+        else
+          raise "Unknown inspect function: #{lookup}"
+        end
+      end
+
+      def rider_history(value, ctx, session)
+        session.get_result(value)
+      end
+
+      def rider_exception(id, ctx, session)
+        session.get_exception(id)["exception"]
+      end
+    end
+  end
+end

data/lib/rider_server/ops/set_namespace_variable.rb

@@ -0,0 +1,80 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class SetNamespaceVariable < Operation
+      documentation "Set a variable in the current REPL binding."
+
+      argument :id, :string, "The request id", required: true
+      argument :name, :string, "The name of the local variable to set", required: true
+      argument :location, :array, "The location to set the namespace to", required: true
+
+      def handle(session, operation)
+        response = Response.new(operation)
+        name = operation["name"]
+        raise "Name must be a valid Ruby identifier" unless name =~ /\A[a-zA-Z_]\w*\z/
+        location = operation["location"]
+
+        value = traverse_location(location, nil, session)
+        session.workspace.binding_local_variable_set(name, value)
+        response.status("done")
+        response
+      end
+
+      def traverse_location(location, ctx, session)
+        loc = location.first
+        locs = location.drop(1)
+
+        if locs.empty?
+          lookup_object(loc, ctx, session)
+        else
+          traverse_location(locs, lookup_object(loc, ctx, session), session)
+        end
+      end
+
+      def lookup_object(loc, ctx, session)
+        lookup, identifier = loc.split(":", 2)
+
+        case lookup
+        when "rider_main"
+          "main"
+        when "rider_history"
+          rider_history(identifier, nil, session)
+        when "rider_exception"
+          rider_exception(identifier, nil, session)
+        when "rider_stackframe"
+          ctx.__rider_bindings_stack[identifier.to_i]
+        when "rider_stackframe_variable"
+          frame_id, local_var = identifier.split(":", 2)
+          ctx.__rider_bindings_stack[frame_id.to_i].local_variable_get(local_var)
+        when "rider_hash_key"
+          hash = identifier.to_i
+          ctx.keys.find { |key| key.hash == hash }
+        when "rider_hash_value"
+          hash = identifier.to_i
+          key = ctx.keys.find { |key| key.hash == hash }
+          ctx.fetch(key)
+        when "toplevel_const_get"
+          Object.const_get(identifier)
+        when "instance_variable_get"
+          ctx.instance_variable_get(identifier)
+        when "const_get"
+          ctx.const_get(identifier)
+        when "ancestor_find"
+          ctx.class.ancestors.find { |item| item.to_s == identifier }
+        else
+          raise "Unknown inspect function: #{lookup}"
+        end
+      end
+
+      def rider_history(value, ctx, session)
+        session.get_result(value)
+      end
+
+      def rider_exception(id, ctx, session)
+        session.get_exception(id)["exception"]
+      end
+    end
+  end
+end

data/lib/rider_server/ops/stdin.rb

@@ -0,0 +1,20 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class Stdin < Operation
+      documentation "List all exceptions that have occurred in the session."
+
+      argument :id, :string, "The request id", required: true
+      argument :stdin, :string, "The input to write to the stdin of the process", required: true
+
+      def handle(session, operation)
+        controller.stdin.write(operation["stdin"])
+        response = Response.new(operation)
+        response.status("done")
+        response
+      end
+    end
+  end
+end

data/lib/rider_server/ops/toggle_catch_all_exceptions.rb

@@ -0,0 +1,27 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class ToggleCatchAllExceptions < Operation
+      documentation "Enable catching all exceptions. Not just the ones with a session."
+
+      argument :id, :string, "The request id", required: true
+
+      def handle(session, operation)
+        if @controller.sessions_catching_exceptions.member?(session.id)
+          @controller.sessions_catching_exceptions.delete(session.id)
+          value = "disabled"
+        else
+          @controller.sessions_catching_exceptions.push(session.id)
+          value = "enabled"
+        end
+
+        response = Response.new(operation)
+        response.status("done")
+        response.set("value", value)
+        response
+      end
+    end
+  end
+end

data/lib/rider_server/response.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+#
+# operations.rb -- Handle all the nRepl op codes
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "bencode"
+
+module RiderServer
+  class Response
+    def initialize(operation)
+      raise "Operation ID cannot be nil" if operation["id"].nil?
+      @op = operation["op"]
+
+      @data = {
+        "id" => operation["id"],
+        "timestamp" => Time.now.strftime("%Y-%m-%d %H:%M:%S"),
+        "status" => []
+      }
+
+      if operation["session"]
+        @data["session"] = operation["session"]
+      end
+    end
+
+    def id
+      @data["id"]
+    end
+
+    def session
+      @data["session"]
+    end
+
+    def set(key, value)
+      @data[key] = value
+    end
+
+    def fetch(*args)
+      @data.fetch(*args)
+    end
+
+    def [](item)
+      @data[item]
+    end
+
+    def status(*value)
+      @data["status"].concat(value)
+    end
+
+    def done?
+      @data["status"].include?("done")
+    end
+
+    def bencode
+      @data.bencode
+    end
+
+    def inspect
+      "#<RiderServer::Response:#{object_id} id=#{id} session=#{session} op=#{@op} status=#{@data["status"]}>"
+    end
+
+    def to_h
+      @data
+    end
+  end
+end

data/lib/rider_server/server.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+#
+# server.rb -- Server Class
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/exception_extension"
+require "rider_server/operations"
+require "rider_server/utils"
+require "rider_server/logger"
+require "bencode"
+
+module RiderServer
+  class Server
+    include RiderServer::Logger
+
+    attr_reader :status
+    attr_reader :listeners
+
+    def initialize
+      @status = :stopped
+      @shutdown_pipe = nil
+    end
+
+    def listen(address, port)
+      Utils.create_listeners(address, port)
+    end
+
+    def setup_shutdown_pipe
+      @shutdown_pipe ||= IO.pipe
+    end
+
+    def run
+      socket = listen("127.0.0.1", 7888)
+      request_count = 0
+
+      responses = Thread::Queue.new
+      operations = Operations.new(responses)
+
+      loop do
+        client = socket[0].accept
+
+        request_count += 1
+
+        threads = []
+        threads << Thread.new {
+          log.debug "Starting response thread"
+          loop do
+            response = responses.pop
+
+            if response == :shutdown
+              break
+            end
+
+            begin
+              output = response.bencode
+            rescue StandardError => e
+              log.error "Error encoding response: #{e}"
+              response = Response.new(response.to_h)
+              response.set("ex", e.inspect)
+              response.set("out", e.full_message)
+              response.status("eval-error")
+              output = response.bencode
+            end
+
+            if log.debug?
+              log.debug "sending response #{response.to_h}"
+            else
+              log.info "sending response #{response.inspect}"
+            end
+            client.write(output)
+            # Try to allow time for the client to read the response
+            sleep 0.01
+          end
+        }
+
+        threads << Thread.new {
+          parser = BEncode::Parser.new(client)
+          loop do
+            # Peek at the next character, and exit if it is nil
+            c = client.getc
+            if c.nil?
+              responses.push :shutdown
+              log.debug("Connection closed, closing")
+              break
+            end
+            client.ungetc(c)
+
+            operation = parser.parse!
+
+            log.debug(operation.inspect)
+            operations.handle(operation)
+          end
+        }
+        threads.each { |thr| thr.join }
+
+        client.close
+      end
+    end
+  end
+end

data/lib/rider_server/service.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+#
+# service.rb -- Base class for services
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+module RiderServer
+  class Service
+    def self.service_name
+      name.split("::").last.gsub(/(.)([A-Z])/, '\1_\2').downcase
+    end
+
+    def initialize(session)
+      @session = session
+    end
+  end
+end

data/lib/rider_server/services/capture_exceptions.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+#
+# capture_exception.rb -- Capture exceptions and send them to the session
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/service"
+
+module RiderServer
+  module Services
+    class CaptureExceptions < Service
+      @sessions = []
+
+      def self.sessions
+        @sessions
+      end
+
+      # Take an exception object created by the session and create a
+      # response to send back to the client
+      def self.create_response(id, exception)
+        {
+          "id" => id,
+          "rider/exception-id" => exception.id,
+          "time-stamp" => Time.now.strftime("%Y-%m-%d %H:%M:%S")
+        }
+      end
+
+      def self.handle_exception(exception, metadata = {})
+        @sessions.each do |session, stream_id|
+          ex = session.add_exception(stream_id, exception, metadata)
+          session.response_queue.push(create_response(stream_id, ex))
+        end
+      end
+
+      def initialize(session)
+        @session = session
+      end
+
+      def start(stream_id)
+        @stream_id = stream_id
+        self.class.sessions.push([@session, @stream_id])
+        :running
+      end
+
+      def stop
+        self.class.sessions.delete_if { |s| s[0] == @session }
+        :stopped
+      end
+
+      def status
+        if self.class.sessions.find { |s| s[0] == @session }
+          :running
+        else
+          :stopped
+        end
+      end
+    end
+  end
+end