rider-server 0.1.1 → 0.1.2

data/lib/rider_server/services/rails.rb

@@ -51,7 +51,7 @@ module RiderServer
             end
           end
         rescue => e
-          @session.push_exception(stream_id, e)
+          @session.add_exception(stream_id, e)
           nputs "Error starting Rails Server: #{e.message}"
         end
       end

data/lib/rider_server/session.rb

@@ -15,8 +15,28 @@ require "rider_server/services/rails"
 require "rider_server/services/capture_io"
 require "rider_server/services/capture_exceptions"
 require "rider_server/logger"
+require "rider_server/session_operations/eval"
+require "rider_server/session_operations/inspect"
+require "rider_server/session_operations/inspect_exception"
+require "rider_server/session_operations/interrupt"
+require "rider_server/session_operations/load_path"
+require "rider_server/session_operations/ls_exceptions"
+require "rider_server/session_operations/ls_services"
+require "rider_server/session_operations/service"
+require "rider_server/session_operations/set_namespace"
+require "rider_server/session_operations/set_namespace_variable"
 
 module RiderServer
+  def self.create_session(config, response_queue, history: [])
+    session = Session.new(config, response_queue, history: history)
+
+    ObjectSpace.each_object(Class).select { |klass| klass < ::RiderServer::Service }.map do |klass, h|
+      session.add_service klass
+    end
+
+    session
+  end
+
   class Session
     include RiderServer::Logger
 
@@ -27,24 +47,17 @@ module RiderServer
     attr_reader :response_queue
     attr_reader :history
 
-    SERVICES = [
-      Services::Rails,
-      Services::CaptureIO,
-      Services::CaptureExceptions
-    ]
-
-    def initialize(response_queue, history: [])
+    def initialize(config, response_queue, history: [])
       @id = SecureRandom.uuid
+      @config = config
       @history = history
       @workspace = Workspace.new
       @queue = Thread::Queue.new
-      @exceptions = Utils::FixedArray.new
+      @exceptions = Utils::FixedArray.new(max_size: config.exception_history_size)
       @response_queue = response_queue
       @exception_queue = Thread::Queue.new
       @evaluations = {}
-      @services = SERVICES.each_with_object({}) do |klass, h|
-        h[klass.service_name] = klass.new(self)
-      end
+      @services = {}
 
       # XXX Side effects in initializer, :()
       start_exception_processing
@@ -56,34 +69,40 @@ module RiderServer
       end
     end
 
+    def stdin
+      ::STDIN  # rubocop:disable Style/GlobalStdStream
+    end
+
     def clone
-      Session.new(@responses_queue, history: @history.clone)
+      RiderServer.create_session(@responses_queue, history: @history.clone)
     end
 
     #
     # Input History
     #
 
+    # Push an event onto the history stack.
     def push_history(event)
       @history.push(event)
     end
 
-    def last_history
-      @history.last
-    end
-
     #
     # Historical Results
     #
 
+    # Return a Hash containing all historical evaluations.
     def result_history
       @result_history ||= {}
     end
 
+    # Add an execution result to the history. The +evaluation_id+ is
+    # the operation id of the evaluation and the +value+ is the result
+    # of the evaluation.
     def add_result(evaluation_id, value)
       result_history[evaluation_id] = value
     end
 
+    # Return a historical result of an evaluation by +evaluation_id+.
     def get_result(evaluation_id)
       raise "Missing history item #{evaluation_id}." unless result_history.key?(evaluation_id)
       result_history[evaluation_id]
@@ -93,41 +112,33 @@ module RiderServer
     # Historical Exceptions
     #
 
-    def wrap_exception(operation_id, exception, metadata = {})
-      id = SecureRandom.uuid
-      {
-        "id" => id,
-        "operation_id" => operation_id,
-        "created_at" => DateTime.now,
-        "exception" => exception,
-        "metadata" => metadata
-      }
+    # Add an exception to the exception history. +operation_id+ is the
+    # id of the request. +exception+ is the exception
+    # object. +metadata+ is a Hash containing additional information
+    # about the exception.
+    def add_exception(operation_id, exception, metadata = {})
+      ex = wrap_exception(operation_id, exception, metadata)
+      @exception_queue.push(ex)
+      ex
     end
 
-    def add_exception(operation_id, exception, metadata = {})
-      id = SecureRandom.uuid
-      @exceptions << wrap_exception(operation_id, exception, metadata)
-      id
+    # Add an exception that has already been wrapped in metadata.
+    # +wrapped_exception+ should be a hash, that has the keys "id",
+    # "created_at", "exception", and "metadata"
+    def add_wrapped_exception(wrapped_exception)
+      @exception_queue.push(wrapped_exception)
+      exception
     end
 
+    # Return an exception by +exception_id+. Raises an exception if
+    # the exception doesn't exist.
     def get_exception(exception_id)
       exception = @exceptions.find { |item| item["id"] == exception_id }
       raise "Missing exception #{exception_id}." unless exception
       exception
     end
 
-    # A threadsafe way to add exceptions
-    def push_exception(operation_id, exception, metadata = {})
-      ex = wrap_exception(operation_id, exception, metadata)
-      @exception_queue.push(ex)
-      ex
-    end
-
-    def push_anonymous_exception(exception)
-      @exception_queue.push(exception)
-      exception
-    end
-
+    # Start a thread to process exceptions from the exception queue.
     def start_exception_processing
       return if @exception_processing_thread
 
@@ -138,6 +149,7 @@ module RiderServer
       end
     end
 
+    # Stop the exception processing thread.
     def stop_exception_processing
       @exception_processing_thread.exit
       @exception_processing_thread = nil
@@ -168,11 +180,17 @@ module RiderServer
     #
     # Service control
     #
+
+    def add_service(service_class)
+      cls = service_class.new(self)
+      @services[service_class.service_name] = cls
+    end
+
     def list_services
-      SERVICES.map do |klass|
+      @services.map do |name, _|
         {
-          "name" => klass.service_name,
-          "state" => service_state(klass.service_name).to_s
+          "name" => name,
+          "state" => service_state(name).to_s
         }
       end
     end
@@ -198,5 +216,18 @@ module RiderServer
         :stopped
       end
     end
+
+    private
+
+    def wrap_exception(operation_id, exception, metadata = {})
+      id = SecureRandom.uuid
+      {
+        "id" => id,
+        "operation_id" => operation_id,
+        "created_at" => DateTime.now,
+        "exception" => exception,
+        "metadata" => metadata
+      }
+    end
   end
 end

data/lib/rider_server/session_operation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+#
+# session_operation.rb -- Base class for operations
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/operation"
+
+module RiderServer
+  class SessionOperation < Operation
+    # Operations registry
+    @operations = {}
+  end
+end

data/lib/rider_server/session_operations/eval.rb

@@ -0,0 +1,61 @@
+require "rider_server/session_operation"
+require "rider_server/response"
+require "rider_server/utils"
+
+module RiderServer
+  SessionOperation.define do
+    name "eval"
+    documentation "Evaluate a string of code"
+
+    argument :id, :string, "The request id", required: true
+    argument :code, :string, "The code to evaluate"
+    argument :ns, :string, "The namespace to evaluate the code in"
+    argument :file, :string, "The file the code is from"
+    argument :line, :integer, "The line number the code is from"
+
+    def handle(session, operation)
+      # TODO should do something if the session is nil
+
+      response = Response.new(operation)
+
+      # Abort if there is an evaluation with the same id
+      if session.running_evaluation?(operation["id"])
+        msg = "Evaluation already in progress for #{operation["id"]}"
+        log.warn(msg)
+        response.set("value", msg)
+        response.status("eval-error", "done")
+        send_response(response)
+        return
+      end
+
+      session.push_history(operation)
+      code = operation["code"]
+      ns = operation["ns"]
+      file = operation["file"] || ""
+      line = operation["line"] || 0
+
+      eval_thread = Thread.new do
+        begin
+          value = session.workspace.evaluate(code, ns, file, line)
+          response.set("value", Utils.rider_display(value))
+          response.set("ns", session.workspace.evaluate("inspect"))
+          response.status("done")
+          session.add_result(operation["id"], value)
+          session.send_response(response)
+        rescue EvalInterrupt, ScriptError, StandardError => e
+          response.set("ex", e.inspect)
+          response.set("ns", session.workspace.evaluate("inspect"))
+          response.status("eval-error", "done")
+          exception = session.add_exception(operation["id"], e)
+          response.set("rider/exception-id", exception["id"])
+          session.send_response(response)
+        end
+
+        session.remove_evaluation(operation["id"])
+      end
+
+      session.add_evaluation(operation["id"], eval_thread)
+      nil
+    end
+  end
+end

data/lib/rider_server/session_operations/inspect.rb

@@ -0,0 +1,123 @@
+require "rider_server/inspect"
+require "rider_server/operation"
+require "rider_server/response"
+require "rider_server/utils"
+
+module RiderServer
+  SessionOperation.define do
+    name "inspect"
+    documentation "Inspect an object"
+
+    argument :id, :string, "The request id", required: true
+    argument :location, :array, "The location of the object to inspect"
+
+    def handle(session, operation)
+      response = Response.new(operation)
+      location = operation["location"]
+      raise "Location is required" if location.nil? || location.empty?
+
+      value = traverse_location(location, nil, session)
+      response.set("name", Utils.rider_display(value))
+
+      if value.is_a?(Array)
+        value = value.map.with_index do |item, index|
+          {
+            "name" => item.to_s,
+            "value" => Utils.rider_display(item),
+            "inspect-location" => "rider_array_item:#{index}"
+          }
+        end
+        response.set("value-array", value)
+      elsif value.is_a?(Hash) || value.eql?(::ENV)
+        value = value.map do |key, value|
+          [
+            {
+              "name" => key.to_s,
+              "value" => Utils.rider_display(key),
+              "inspect-location" => "rider_hash_key:#{key.hash}"
+            },
+            {
+              "name" => value.to_s,
+              "value" => Utils.rider_display(value),
+              "inspect-location" => "rider_hash_value:#{key.hash}"
+            }
+          ]
+        end
+        response.set("value-hash", value)
+      elsif value.is_a?(String)
+        response.set("value", value.inspect)
+      elsif value.is_a?(Numeric)
+        response.set("value", value.to_s)
+      end
+
+      response.set("inspect-location", location)
+
+      response.set("class", RiderServer::Inspect.inspect_class(value))
+      response.set("singleton-class", RiderServer::Inspect.inspect_singleton_class(value))
+      response.set("ancestors", RiderServer::Inspect.inspect_ancestors(value))
+      response.set("constants", RiderServer::Inspect.inspect_constants(value))
+      response.set("methods", RiderServer::Inspect.inspect_methods(value))
+      response.set("instance-variables", RiderServer::Inspect.inspect_instance_variables(value))
+      response.set("instance-methods", RiderServer::Inspect.inspect_instance_methods(value))
+      response.set("class-variables", RiderServer::Inspect.inspect_class_variables(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_variable"
+        frame_id, local_var = identifier.split(":", 2)
+        ctx.__rider_bindings_stack[frame_id.to_i].local_variable_get(local_var)
+      when "rider_array_item"
+        ctx[identifier.to_i]
+      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 "singleton_class"
+        ctx.singleton_class
+      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(id, ctx, session)
+      session.get_result(id)
+    end
+
+    def rider_exception(id, ctx, session)
+      session.get_exception(id)["exception"]
+    end
+  end
+end

data/lib/rider_server/session_operations/inspect_exception.rb

@@ -0,0 +1,46 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "inspect-exception"
+    documentation "Inspect an exception."
+
+    argument :id, :string, "The request id", required: true
+    argument :"exception-id", :string, "The exception id"
+
+    def handle(session, operation)
+      response = Response.new(operation)
+      exception_id = operation["exception-id"]
+
+      value = session.get_exception(exception_id)
+      response.set("inspect-location", value["id"])
+      response.set("exception-id", value["id"])
+      response.set("source-operation-id", value["operation_id"])
+      response.set("created-at", value["created_at"].to_s)
+
+      exception = value["exception"]
+      response.set("value", exception.inspect)
+      response.set("stacktrace", encode_stacktrace(exception, exception_id))
+
+      response.status("done")
+      response
+    end
+
+    def encode_stacktrace(exception, exception_id)
+      exception.backtrace.zip(exception.__rider_bindings_stack).map.with_index do |(line, frame), frame_id|
+        {
+          "line" => line,
+          "inspect-location" => ["rider_exception:#{exception_id}", "rider_stackframe:#{frame_id}"],
+          "frame" => (frame&.local_variables || []).map do |var|
+                       {
+                         "name" => var.to_s,
+                         "value" => Utils.rider_display(frame.local_variable_get(var)),
+                         "inspect-location" => ["rider_exception:#{exception_id}", "rider_stackframe_variable:#{frame_id}:#{var}"]
+                       }
+                     end
+        }
+      end
+    end
+  end
+end

data/lib/rider_server/session_operations/interrupt.rb

@@ -0,0 +1,29 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "interrupt"
+    documentation "Interrupts the evaluation of a session."
+
+    argument :id, :string, "The request id", required: true
+    argument :"interrupt-id", :string, "The ID of the evaluation to interrupt.", required: true
+
+    def handle(session, operation)
+      # TODO should do something if the session is nil
+
+      if operation["interrupt-id"].nil? || operation["interrupt-id"].empty?
+        if session.evaluations.empty?
+          raise ArgumentError, "No evaluations to interrupt"
+        end
+        session.interrupt_evaluation(session.evaluations.keys.max)
+      else
+        session.interrupt_evaluation(operation["interrupt-id"])
+      end
+
+      response = Response.new(operation)
+      response.status("interrupted", "done")
+      response
+    end
+  end
+end

data/lib/rider_server/session_operations/load_path.rb

@@ -0,0 +1,19 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "load-path"
+    documentation "Return the current load path."
+
+    argument :id, :string, "The request id", required: true
+
+    def handle(session, operation)
+      response = Response.new(operation)
+      load_path = session.workspace.evaluate("$LOAD_PATH", "main")
+      response.set("load-path", load_path)
+      response.status("done")
+      response
+    end
+  end
+end

data/lib/rider_server/session_operations/ls_exceptions.rb

@@ -0,0 +1,28 @@
+require "rider_server/session_operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "ls-exceptions"
+    documentation "List all exceptions that exist in the sessions cache."
+
+    argument :id, :string, "The request id", required: true
+
+    def handle(session, operation)
+      response = Response.new(operation)
+
+      exceptions = session.exceptions.map do |item|
+        {
+          "id" => item["id"],
+          "operation-id" => item["operation_id"],
+          "created-at" => item["created_at"].iso8601,
+          "exception" => item["exception"].inspect
+        }
+      end
+
+      response.set("exceptions", exceptions)
+      response.status("done")
+      response
+    end
+  end
+end

data/lib/rider_server/session_operations/ls_services.rb

@@ -0,0 +1,18 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "ls-services"
+    documentation "List all services."
+
+    argument :id, :string, "The request id", required: true
+
+    def handle(session, operation)
+      response = Response.new(operation)
+      response.set("services", session.list_services)
+      response.status("done")
+      response
+    end
+  end
+end

data/lib/rider_server/session_operations/service.rb

@@ -0,0 +1,42 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "service"
+    documentation "Control a Ruby service integration"
+
+    argument :id, :string, "The request id", required: true
+    argument :service, :string, "The name of the Ruby service to control", required: true
+    argument :state, :string, "The desired state of the service", required: true
+
+    def handle(session, operation)
+      response = Response.new(operation)
+
+      service = operation["service"]
+      state = operation["state"]
+
+      current_state = session.service_state(service)
+
+      case state
+      when "start"
+        raise "Service already running" if current_state == "running"
+        session.start_service(service, response.id)
+        response.set("rider/stream", "true")
+      when "stop"
+        raise "Can't stop service #{service}.  It's not running." if current_state == "stopped"
+        session.stop_service(service)
+        response.status("done")
+      else
+        # TODO: throwing this exception will caues a "done" response
+        # to be sent, which will implicitly close the stream.  It
+        # might make sense to handle this more gracefully here.
+        raise "Unknown state #{state}"
+      end
+
+      response.set("service", service)
+      response.set("state", session.service_state(service).to_s)
+      response
+    end
+  end
+end