rider-server 0.1.0 → 0.1.2

data/lib/rider_server/operation.rb

@@ -13,38 +13,57 @@ module RiderServer
   class Operation
     include RiderServer::Logger
 
-    attr_reader :documentation, :arguments, :controller
-    def self.operation_name
-      name.split("::").last.gsub(/(.)([A-Z])/, '\1_\2').downcase
+    # Operations registry
+    @operations = {}
+    class << self
+      attr_reader :operations
     end
 
-    def self.documentation(desc)
-      @documentation = desc
+    def self.handles?(request)
+      @operations.key? request.op
     end
 
-    def self.argument(name, type, description, required: false)
-      @arguments ||= []
+    def self.handle(context, request)
+      operation = @operations[request.op]
+      operation.validate_request!(request)
+      operation.handle(context, request)
+    end
 
-      raise ArgumentError, "Invalid argument type #{type}" \
-        unless [:string, :integer, :array].include?(type)
+    def self.define(&block)
+      instance = new
+      instance.instance_eval(&block)
+      raise ArgumentError, "Operation #{self} must have a name" if instance.name.empty?
+      raise ArgumentError, "Operation #{self} must have a documentation string" if instance.documentation.empty?
+      raise ArgumentError, "Operation #{self} must have at least one argument" if instance.arguments.empty?
+      @operations[instance.name] = instance
+      instance
+    end
 
-      @arguments << {name: name, type: type, required: required, description: description}
+    attr_reader :arguments
+
+    def documentation(value = nil)
+      @documentation = value if value
+      @documentation
     end
 
-    def initialize(controller)
-      @controller = controller
-      @documentation = self.class.instance_variable_get(:@documentation) || ""
-      @arguments = self.class.instance_variable_get(:@arguments) || []
-      raise ArgumentError, "Operation must have a documentation string" if @documentation.empty?
-      raise ArgumentError, "Operation must have at least one argument" if @arguments.empty?
+    def name(value = nil)
+      @name = value if value
+      @name
     end
 
-    def create_response(operation)
-      Utils.create_response(operation)
+    def initialize
+      @name = ""
+      @arguments = []
+      @documentation = ""
     end
 
-    def send_response(response)
-      controller.send_response(response)
+    def argument(name, type, description, required: false)
+      @arguments ||= []
+
+      raise ArgumentError, "Invalid argument type #{type}" \
+        unless [:string, :integer, :array].include?(type)
+
+      @arguments << {name: name, type: type, required: required, description: description}
     end
 
     def validate_request!(request)

data/lib/rider_server/{ops → operations}/clone.rb

@@ -3,14 +3,15 @@ require "rider_server/response"
 
 module RiderServer
   module Ops
-    class Clone < Operation
+    Operation.define do
+      name "clone"
       documentation "Clone a session"
 
       argument :id, :string, "The request id", required: true
       argument :session, :string, "The session to clone"
 
       # Handle the clone operation, session will be nil
-      def handle(session, operation)
+      def handle(controller, operation)
         response = Response.new(operation)
 
         # Clone a specific session if specified

data/lib/rider_server/{ops → operations}/close.rb

@@ -3,14 +3,15 @@ require "rider_server/response"
 
 module RiderServer
   module Ops
-    class Close < Operation
+    Close = Operation.define do
+      name "close"
       documentation "Close a specific session."
 
       argument :id, :string, "The request id", required: true
       argument :session, :string, "The session to close", required: true
 
       # Handle the close operation, session will be nil
-      def handle(session, operation)
+      def handle(controller, operation)
         response = Response.new(operation)
 
         session_id = operation["session"]

data/lib/rider_server/operations/completions.rb

@@ -0,0 +1,146 @@
+require "rider_server/operation"
+require "rider_server/response"
+require "rider_server/inspect"
+require "rider_server/workspace"
+
+module RiderServer
+  Operation.define do
+    name "completions"
+    documentation "Get completions for a given prefix"
+
+    argument :id, :string, "The request id", required: true
+    argument :prefix, :string, "The prefix to complete", required: true
+    argument :complete_fn, :string, "What completion function to use, top-level, module, method or singleton-method"
+    argument :ns, :string, "The namespace to search for completions"
+
+    @workspace = Workspace.new
+
+    def handle(controller, operation)
+      response = Response.new(operation)
+
+      prefix = operation["prefix"]
+      ns = operation["ns"]
+      complete_fn = operation.fetch("complete-fn", "top-level")
+
+      if prefix.nil? || parse_string(prefix).nil?
+        response.set("completions", [])
+      else
+        ns_object = if ns.empty?
+          ::Object
+        else
+          @workspace.lookup_module(ns)
+        end
+
+        # If the prefix isn't parseable, return an empty list
+        response.set("completions", lookup_module(prefix, klass: ns_object, completion_fn: complete_fn))
+      end
+      response.status("done")
+      response
+    end
+
+    def lookup_module(module_name, klass: ::Object, completion_fn: "top-level")
+      node = parse_string(module_name)
+      case node.type
+      when :const
+        ns = lookup_module_ast(node.children.first, klass)
+        prefix = node.children.last
+        all_constants(ns, prefix)
+      when :send
+        ns = lookup_module_ast(node.children.first, klass)
+        prefix = node.children.last
+        if completion_fn == "method"
+          all_constants(ns, prefix) + encode_methods(class_instance_methods(ns, prefix) + class_singleton_methods(::Kernel, prefix))
+        else
+          all_constants(ns, prefix) + encode_methods(class_methods(ns, prefix) + class_singleton_methods(::Kernel, prefix))
+        end
+      else
+        []
+      end
+    end
+
+    def parse_string(string)
+      buffer = Parser::Source::Buffer.new("(string)")
+      buffer.source = string
+      Parser::CurrentRuby.new.parse(buffer)
+    end
+
+    def lookup_module_ast(node, klass = ::Object)
+      return klass if node.nil?
+
+      case node.type
+      when :cbase
+        ::Object
+      when :const
+        if node.children.first.nil?
+          klass.const_get(node.children.last)
+        else
+          lookup_module_ast(node.children.first, klass).const_get(node.children.last)
+        end
+      else
+        raise ModuleLookupError, "Unknown node type #{node.type}"
+      end
+    end
+
+    def parent_constant(ns_object)
+      ns_object_name = ns_object.to_s
+      parent_name, _ = ns_object_name.rpartition("::")
+      parent_name.empty? ? nil : ::Object.const_get(parent_name)
+    end
+
+    def all_constants(ns_object, prefix)
+      consts = []
+      ns_object.constants.grep(/^#{prefix}/).each do |constant|
+        consts << constant.to_s
+      end
+
+      # Search up the tree to find all the other constants
+      constant = ns_object
+      loop do
+        constant = parent_constant(constant)
+        break if constant.nil?
+
+        constant.constants.grep(/^#{prefix}/).each do |constant|
+          consts << constant.to_s
+        end
+      end
+
+      ::Object.constants.grep(/^#{prefix}/).each do |constant|
+        consts << constant.to_s
+      end
+
+      consts.map do |constant|
+        {
+          "candidate" => constant,
+          "type" => "constant"
+        }
+      end
+    end
+
+    ##
+    # Get all instance methods that match a +prefix+ for a given object +obj+
+    #
+    # This method should be called when in the context of an
+    # instance method, as all other instance methods will be
+    # acessable.
+    def class_instance_methods(obj, prefix)
+      Set.new(obj.instance_methods.grep(/^#{prefix}/))
+    end
+
+    def class_methods(obj, prefix)
+      Set.new(obj.methods.grep(/^#{prefix}/))
+    end
+
+    def class_singleton_methods(obj, prefix)
+      Set.new(obj.singleton_methods.grep(/^#{prefix}/))
+    end
+
+    def encode_methods(methods)
+      methods.map do |method|
+        {
+          "candidate" => method.to_s,
+          "type" => "method"
+        }
+      end
+    end
+  end
+end

data/lib/rider_server/operations/lookup.rb

@@ -0,0 +1,102 @@
+require "rider_server/operation"
+require "rider_server/response"
+require "rider_server/inspect"
+
+module RiderServer
+  Operation.define do
+    name "lookup"
+    documentation "Get info about a symbol."
+
+    argument :id, :string, "The request id", required: true
+    argument :sym, :string, "The symbol to lookup", required: true
+    argument :lookup_fn, :string, "What lookup function to use, top-level, module, method or singleton-method"
+    argument :ns, :string, "The namespace to search for completions"
+
+    def handle(controller, operation)
+      response = Response.new(operation)
+      ns = operation["ns"]
+      sym = operation["sym"]
+      lookup_fn = operation.fetch("lookup-fn", "top-level")
+
+      if sym.nil? || parse_string(sym).nil?
+        response.set("info", {})
+      else
+        ns_object = if ns.empty?
+          ::Object
+        else
+          workspace.lookup_module(ns)
+        end
+
+        # If the prefix isn't parseable, return an empty list
+        response.set("info", lookup_module(sym, klass: ns_object, lookup_fn: lookup_fn))
+      end
+      response.status("done")
+      response
+    end
+
+    def lookup_module(module_name, klass: ::Object, lookup_fn: "top-level")
+      node = parse_string(module_name)
+      case node.type
+      when :const
+        ns = lookup_module_ast(node.children.first, klass)
+        name node.children.last
+        encode_const(ns, name)
+      when :send
+        ns = lookup_module_ast(node.children.first, klass)
+        prefix = node.children.last
+        if lookup_fn == "method"
+          encode_method(ns.instance_method(prefix))
+        else
+          encode_method(ns.method(prefix))
+        end
+      else
+        []
+      end
+    end
+
+    def parse_string(string)
+      buffer = Parser::Source::Buffer.new("(string)")
+      buffer.source = string
+      Parser::CurrentRuby.new.parse(buffer)
+    end
+
+    def lookup_module_ast(node, klass = ::Object)
+      return klass if node.nil?
+
+      case node.type
+      when :cbase
+        ::Object
+      when :const
+        if node.children.first.nil?
+          klass.const_get(node.children.last)
+        else
+          lookup_module_ast(node.children.first, klass).const_get(node.children.last)
+        end
+      else
+        raise ModuleLookupError, "Unknown node type #{node.type}"
+      end
+    end
+
+    def encode_const(ns, const_name)
+      if ns.const_defined? const_name
+        {
+          "name" => "#{ns}::#{const_name}",
+          "source_location" => ns.const_source_location(const_name)
+        }
+      else
+        {}
+      end
+    end
+
+    def encode_method(thing)
+      {
+        "name" => thing.name.to_s,
+        "source_location" => thing.source_location
+      }
+    end
+
+    def workspace
+      @workspace ||= Workspace.new
+    end
+  end
+end

data/lib/rider_server/operations/ls_sessions.rb

@@ -0,0 +1,51 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  Operation.define do
+    name "ls-sessions"
+    documentation "List all sessions"
+
+    argument :id, :string, "The request id", required: true
+
+    def handle(controller, operation)
+      response = Response.new(operation)
+      response.set("sessions", controller.sessions.map { |k, v| k })
+      response.set("rider/session-headings",
+        [
+          {
+            "id" => "id",
+            "name" => "ID",
+            "length" => 36
+          },
+          {
+            "id" => "namespace_name",
+            "name" => "Namespace",
+            "length" => 25
+          },
+          {
+            "id" => "history_items",
+            "name" => "History Items",
+            "length" => 5
+          },
+          {
+            "id" => "exceptions",
+            "name" => "Exceptions",
+            "length" => 5
+          }
+        ])
+      response.set("rider/sessions", controller.sessions.map { |k, v| session_summary(v) })
+      response.status("done")
+      response
+    end
+
+    def session_summary(session)
+      {
+        "id" => session.id,
+        "namespace_name" => session.workspace.namespace_name,
+        "history_items" => session.history.length.to_s,
+        "exceptions" => session.exceptions.length.to_s
+      }
+    end
+  end
+end

data/lib/rider_server/operations/toggle_catch_all_exceptions.rb

@@ -0,0 +1,24 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  Operation.define do
+    name "toggle-catch-all-exceptions"
+    documentation "Enable catching all exceptions. Not just the ones with a session."
+
+    argument :id, :string, "The request id", required: true
+
+    def handle(controller, operation)
+      value = if controller.toggle_capture_exceptions
+        "enabled"
+      else
+        "disabled"
+      end
+
+      response = Response.new(operation)
+      response.status("done")
+      response.set("value", value)
+      response
+    end
+  end
+end

data/lib/rider_server/operations.rb

@@ -12,112 +12,78 @@ require "rider_server/session"
 require "rider_server/errors"
 require "rider_server/response"
 require "rider_server/core_ext/array"
+require "rider_server/core_ext/class"
+require "rider_server/core_ext/env"
 require "rider_server/core_ext/hash"
+require "rider_server/core_ext/kernel"
+require "rider_server/core_ext/module"
 require "rider_server/core_ext/object"
 require "rider_server/core_ext/string"
 require "rider_server/core_ext/symbol"
-require "rider_server/ops/clone"
-require "rider_server/ops/close"
-require "rider_server/ops/completions"
-require "rider_server/ops/eval"
-require "rider_server/ops/inspect"
-require "rider_server/ops/inspect_exception"
-require "rider_server/ops/interrupt"
-require "rider_server/ops/load_path"
-require "rider_server/ops/lookup"
-require "rider_server/ops/ls_exceptions"
-require "rider_server/ops/ls_services"
-require "rider_server/ops/ls_sessions"
-require "rider_server/ops/service"
-require "rider_server/ops/set_namespace"
-require "rider_server/ops/set_namespace_variable"
-require "rider_server/ops/toggle_catch_all_exceptions"
+require "rider_server/operations/clone"
+require "rider_server/operations/close"
+require "rider_server/operations/completions"
+require "rider_server/operations/lookup"
+require "rider_server/operations/ls_sessions"
+require "rider_server/operations/toggle_catch_all_exceptions"
 
 module RiderServer
+  def self.create_operation_handler(config, response_queue)
+    Operations.new(config, response_queue)
+  end
+
   class Operations
     include RiderServer::Logger
 
-    attr_reader :executing_requests
     attr_reader :sessions
-    attr_reader :stdin, :stdout, :stderr
     attr_reader :response_queue
-    attr_accessor :sessions_catching_exceptions
-
-    OPERATIONS = [
-      Ops::Clone,
-      Ops::Close,
-      Ops::Completions,
-      Ops::Eval,
-      Ops::Inspect,
-      Ops::InspectException,
-      Ops::Interrupt,
-      Ops::LoadPath,
-      Ops::Lookup,
-      Ops::LsExceptions,
-      Ops::LsServices,
-      Ops::LsSessions,
-      Ops::Service,
-      Ops::SetNamespace,
-      Ops::SetNamespaceVariable,
-      Ops::ToggleCatchAllExceptions
-    ]
 
-    def initialize(response_queue)
+    def initialize(config, response_queue)
+      @config = config
       @sessions = {}
       @response_queue = response_queue
-      @executing_requests = []
-      @operations = OPERATIONS.each_with_object({}) do |klass, h|
-        h[klass.operation_name] = klass.new(self)
-      end
-      @sessions_catching_exceptions = []
     end
 
     def send_response(response)
       if response
         @response_queue.push(response)
-        if response.done?
-          @executing_requests.delete(response.id)
-        end
       end
     end
 
-    def handle(operation)
-      session = nil
-
-      session_id = operation["session"]
-      op = operation["op"].tr("-", "_")
-      log.info("Handling operation '#{operation}'")
-      session = get_session(session_id)
-      @executing_requests << operation["id"]
-      if @operations.key? op
-        @operations[op].validate_request!(operation)
-        send_response(@operations[op].handle(session, operation))
+    def handle(request)
+      op = request.op
+      log.info("Handling operation '#{request.inspect}'")
+      session = get_session(request.session)
+      if Operation.handles?(request)
+        send_response(Operation.handle(self, request))
+      elsif !session.nil? && SessionOperation.handles?(request)
+        send_response(SessionOperation.handle(session, request))
       else
         log.warn("Unknown operation '#{op}' requested")
-        response = Response.new(operation)
+        response = Response.new(request)
         response.status "unknown-op", "done"
         send_response(response)
       end
     rescue ScriptError, StandardError => e
-      response = Response.new(operation)
+      response = Response.new(request)
       response.set("ex", e.inspect)
       response.set("out", e.full_message)
       response.status("eval-error", "done")
+      log.error "Error handling request: #{e}\n #{e.backtrace.join("\n")}"
       if session
-        exception_id = session.add_exception(operation["id"], e)
-        response.set("rider/exception-id", exception_id)
-      end
-
-      # Broadcast the exception to sessions that are listening
-      @sessions_catching_exceptions.each do |s|
-        next if session == s
-        @sessions[s]&.add_exception(operation["id"], e)
+        exception = session.add_exception(request.id, e)
+        response.set("rider/exception-id", exception["id"])
       end
+      RiderServer::Services::CaptureExceptions.handle_exception(e)
       send_response(response)
     end
 
+    #
+    # Sessions
+    #
+
     def new_session
-      Session.new(@response_queue)
+      RiderServer.create_session(@config, @response_queue)
     end
 
     def get_session(id)
@@ -132,5 +98,13 @@ module RiderServer
     def delete_session(session_id)
       @sessions.delete(session_id)
     end
+
+    #
+    # Exceptions
+    #
+
+    def toggle_capture_exceptions
+      @config.capture_exceptions(!@config.capture_exceptions)
+    end
   end
 end

data/lib/rider_server/request.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+#
+# request.rb -- A simple wrapper around a request
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "bencode"
+
+module RiderServer
+  class Request
+    def initialize(operation)
+      raise "Operation ID cannot be nil" if operation["id"].nil?
+      raise "Operation name cannot be nil" if operation["op"].nil?
+
+      @data = operation
+    end
+
+    def op
+      @data["op"]
+    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 key?(name)
+      @data.key? name
+    end
+
+    def [](name)
+      @data[name]
+    end
+
+    def []=(name, value)
+      @data[name] = value
+    end
+
+    def inspect
+      "#<RiderServer::Request:#{object_id} id=#{id} session=#{session} op=#{op}}>"
+    end
+
+    def to_h
+      @data
+    end
+  end
+end

data/lib/rider_server/response.rb

@@ -42,8 +42,16 @@ module RiderServer
       @data.fetch(*args)
     end
 
-    def [](item)
-      @data[item]
+    def key?(name)
+      @data.key? name
+    end
+
+    def [](name)
+      @data[name]
+    end
+
+    def []=(name, value)
+      @data[name] = value
     end
 
     def status(*value)