rider-server 0.1.0

data/lib/rider_server/ops/close.rb

@@ -0,0 +1,25 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class Close < Operation
+      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)
+        response = Response.new(operation)
+
+        session_id = operation["session"]
+
+        controller.delete_session(session_id)
+
+        response.status("done")
+        response
+      end
+    end
+  end
+end

data/lib/rider_server/ops/completions.rb

@@ -0,0 +1,100 @@
+require "rider_server/operation"
+require "rider_server/response"
+require "rider_server/inspect"
+
+module RiderServer
+  module Ops
+    class Completions < Operation
+      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 :ns, :string, "The namespace to search for completions"
+
+      def initialize(*args)
+        @workspace = Workspace.new
+        super
+      end
+
+      def handle(session, operation)
+        response = Response.new(operation)
+
+        prefix = operation["prefix"]
+        log.info "prefix: #{prefix}"
+        ns = operation["ns"]
+        # options = operation["options"]
+
+        log.info "prefix: #{prefix}"
+        ns_object = @workspace.lookup_module(ns)
+        log.info "ns_object: #{ns_object}"
+
+        response.set("completions", lookup_module(prefix, ns_object))
+        log.info "completions: #{response["completions"]}"
+
+        response.status("done")
+        response
+      rescue ScriptError, StandardError => e
+        log.error "Error in completions: #{e}"
+        log.error e.backtrace.join("\n")
+        raise e
+      end
+
+      private
+
+      def lookup_module(module_name, klass = ::Object)
+        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) + all_methods(ns, prefix)
+        when :send
+          ns = lookup_module_ast(node.children.first, klass)
+          prefix = node.children.last
+          all_methods(ns, prefix)
+        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)
+        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 all_constants(ns_object, prefix)
+        ns_object.constants.grep(/^#{prefix}/).map do |constant|
+          {
+            "candidate" => constant.to_s,
+            "type" => "constant"
+          }
+        end
+      end
+
+      def all_methods(ns_object, prefix)
+        ns_object.methods.grep(/^#{prefix}/).map do |method|
+          {
+            "candidate" => method.to_s,
+            "type" => "method"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rider_server/ops/eval.rb

@@ -0,0 +1,62 @@
+require "rider_server/operation"
+require "rider_server/response"
+require "rider_server/utils"
+
+module RiderServer
+  module Ops
+    class Eval < Operation
+      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_inspect(value))
+            response.set("ns", session.workspace.evaluate("inspect"))
+            response.status("done")
+            session.add_result(operation["id"], value)
+            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_id = session.add_exception(operation["id"], e)
+            response.set("rider/exception-id", exception_id)
+            send_response(response)
+          end
+
+          session.remove_evaluation(operation["id"])
+        end
+
+        session.add_evaluation(operation["id"], eval_thread)
+        nil
+      end
+    end
+  end
+end

data/lib/rider_server/ops/inspect.rb

@@ -0,0 +1,121 @@
+require "rider_server/inspect"
+require "rider_server/operation"
+require "rider_server/response"
+require "rider_server/utils"
+
+module RiderServer
+  module Ops
+    class Inspect < Operation
+      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_inspect(value))
+
+        if value.is_a?(Array)
+          value = value.map.with_index do |item, index|
+            {
+              "name" => item.to_s,
+              "value" => Utils.rider_inspect(item),
+              "inspect-location" => "rider_array_item:#{index}"
+            }
+          end
+          response.set("value-array", value)
+        elsif value.is_a?(Hash)
+          value = value.map do |key, value|
+            [
+              {
+                "name" => key.to_s,
+                "value" => Utils.rider_inspect(key),
+                "inspect-location" => "rider_hash_key:#{key.hash}"
+              },
+              {
+                "name" => value.to_s,
+                "value" => Utils.rider_inspect(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.class(value))
+        response.set("ancestors", RiderServer::Inspect.ancestors(value))
+        response.set("constants", RiderServer::Inspect.constants(value))
+        response.set("methods", RiderServer::Inspect.methods(value))
+        response.set("instance-variables", RiderServer::Inspect.instance_variables(value))
+        response.set("instance-methods", RiderServer::Inspect.instance_methods(value))
+        response.set("class-variables", RiderServer::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 "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
+end

data/lib/rider_server/ops/inspect_exception.rb

@@ -0,0 +1,47 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class InspectException < Operation
+      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_inspect(frame.local_variable_get(var)),
+                "inspect-location" => ["rider_exception:#{exception_id}", "rider_stackframe_variable:#{frame_id}:#{var}"]
+              }
+            end
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rider_server/ops/interrupt.rb

@@ -0,0 +1,30 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class Interrupt < Operation
+      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
+end

data/lib/rider_server/ops/load_path.rb

@@ -0,0 +1,20 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class LoadPath < Operation
+      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
+end

data/lib/rider_server/ops/lookup.rb

@@ -0,0 +1,83 @@
+require "rider_server/operation"
+require "rider_server/response"
+require "rider_server/inspect"
+
+module RiderServer
+  module Ops
+    class Lookup < Operation
+      documentation "Get completions for a given string"
+
+      argument :id, :string, "The request id", required: true
+      argument :sym, :string, "The symbol to lookup", required: true
+      argument :ns, :string, "The namespace to search for completions"
+
+      def initialize(*args)
+        @workspace = Workspace.new
+        super
+      end
+
+      def handle(session, operation)
+        response = Response.new(operation)
+        ns = operation["ns"]
+        sym = operation["sym"]
+
+        ns_object = @workspace.lookup_module(ns)
+
+        method_type = nil
+        if sym.include?("#")
+          sym, method = sym.split("#")
+          method_type = :instance
+          method = method.to_sym
+        elsif sym.start_with?("self.class")
+          method = sym.split(".").last
+          method_type = :class
+          method = method.to_sym
+        elsif sym.include?(".")
+          sym, method = sym.split(".")
+          method_type = :class
+          method = method.to_sym
+        end
+
+        if sym.include?("::")
+          ns_object = lookup_ns(sym.split("::"), ns_object)
+        end
+        constant = ns_object
+
+        info = if sym.start_with?("@")
+          constant = ns_object.instance_variable_get(sym)
+        elsif method_type == :instance
+          RiderServer::Inspect.describe_method(constant.instance_method(method))
+        elsif method_type == :class
+          RiderServer::Inspect.describe_method(constant.method(method))
+        elsif constant.respond_to?(:instance_methods) && constant.instance_methods.include?(sym.to_sym)
+          RiderServer::Inspect.describe_method(constant.instance_method(sym))
+        elsif constant.respond_to?(:methods) && constant.methods.include?(sym.to_sym)
+          RiderServer::Inspect.describe_method(constant.method(sym))
+        else
+          {}
+        end
+
+        response.set("info", info)
+        response.status("done")
+        response
+      end
+
+      private
+
+      def lookup_ns(module_name, klass = Object)
+        if module_name.start_with?("::")
+          klass = Module
+          module_name = module_name.delete_prefix("::")
+        end
+
+        path = module_name.split("::")
+
+        path.inject(klass) do |acc, elem|
+          acc.const_get(elem)
+        end
+      rescue NameError
+        nil
+      end
+    end
+  end
+end

data/lib/rider_server/ops/ls_exceptions.rb

@@ -0,0 +1,29 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class LsExceptions < Operation
+      documentation "List all exceptions that have occurred in the session."
+
+      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
+end

data/lib/rider_server/ops/ls_services.rb

@@ -0,0 +1,19 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class LsServices < Operation
+      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
+end

data/lib/rider_server/ops/ls_sessions.rb

@@ -0,0 +1,52 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class LsSessions < Operation
+      documentation "List all sessions"
+
+      argument :id, :string, "The request id", required: true
+
+      def handle(session, 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
+end

data/lib/rider_server/ops/service.rb

@@ -0,0 +1,43 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class Service < Operation
+      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
+end