rider-server 0.1.1 → 0.1.2

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 = session.push_exception(operation["id"], e)
-        response.set("rider/exception-id", exception["id"])
-      end
-      @sessions_catching_exceptions.each do |session_id|
-        session = @sessions[session_id]
-        next if session.nil?
-        exception = session.push_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)

data/lib/rider_server/server.rb

@@ -9,6 +9,7 @@
 
 require "rider_server/exception_extension"
 require "rider_server/operations"
+require "rider_server/request"
 require "rider_server/utils"
 require "rider_server/logger"
 require "bencode"
@@ -17,30 +18,28 @@ module RiderServer
   class Server
     include RiderServer::Logger
 
+    # The status of the server, either +:running+ or +:stopped+
     attr_reader :status
-    attr_reader :listeners
 
-    def initialize
+    def initialize(config)
+      @config = config
       @status = :stopped
-      @shutdown_pipe = nil
-    end
 
-    def listen(address, port)
-      Utils.create_listeners(address, port)
-    end
-
-    def setup_shutdown_pipe
-      @shutdown_pipe ||= IO.pipe
+      RiderServer::Logger.configure_logger(level: @config.log_level)
     end
 
+    # Start the servers main event loop.  This will bind to the
+    # configured host and port, and create threads for sending and
+    # recieving requests.
     def run
-      socket = listen("127.0.0.1", 7888)
+      socket = listen(@config.host, @config.port)
       request_count = 0
 
       responses = Thread::Queue.new
-      operations = Operations.new(responses)
+      operations = RiderServer.create_operation_handler(@config, responses)
 
       loop do
+        @status = :running
         client = socket[0].accept
 
         request_count += 1
@@ -58,7 +57,7 @@ module RiderServer
             begin
               output = response.bencode
             rescue => e
-              log.error "Error encoding response: #{e}"
+              log.error "Error encoding response: #{e}\n #{e.backtrace.join("\n")}"
               response = Response.new(response.to_h)
               response.set("ex", e.inspect)
               response.set("out", e.full_message)
@@ -67,9 +66,9 @@ module RiderServer
             end
 
             if log.debug?
-              log.debug "sending response #{response.to_h}"
+              log.debug "Sending response #{response.to_h}"
             else
-              log.info "sending response #{response.inspect}"
+              log.info "Sending response #{response.inspect}"
             end
             client.write(output)
             # Try to allow time for the client to read the response
@@ -92,13 +91,26 @@ module RiderServer
             operation = parser.parse!
 
             log.debug(operation.inspect)
-            operations.handle(operation)
+
+            begin
+              operations.handle(::RiderServer::Request.new(operation))
+            rescue => e
+              log.error "Error handling request: #{e}\n #{e.backtrace}"
+            end
           end
         }
         threads.each { |thr| thr.join }
 
         client.close
+        @status = :stopped
       end
     end
+
+    private
+
+    # Open a TCP server listening on an +address+ and +port+.
+    def listen(address, port)
+      Utils.create_listeners(address, port)
+    end
   end
 end

data/lib/rider_server/services/capture_exceptions.rb

@@ -44,7 +44,7 @@ module RiderServer
         # This needs to use push exception
 
         @sessions.each do |session, stream_id|
-          ex = session.push_anonymous_exception(wrapped_ex)
+          ex = session.add_wrapped_exception(wrapped_ex)
           session.response_queue.push(create_response(stream_id, ex))
         end