rider-server 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 302928be71e4f0608534e86f87c555a0f3507004c93c058947b74d480cfde558
+  data.tar.gz: 80707ddff979bb2a92f7f696dcbc44ac68830d56dffa11cfc021aa5eec06d743
+SHA512:
+  metadata.gz: f9fcc56b8cbceaa6df781155af166873e66c0bfe1261041b6667759dfc5eb56c3c9dfd6943b45e1e7f302cb0737e21da048ba399f837dec4a77416cb7af037bf
+  data.tar.gz: 74527b4e988b97b6ed527530bbdef94cc6b48776c74fef12930dbf70a59c648209f3afa615ebb835861acba0b0eba70884107268b65e7aa12da0adb7b63040f8

data/.build.yml

@@ -0,0 +1,23 @@
+image: debian/stable
+sources:
+  - https://git.sr.ht/~rsl/rider
+packages:
+  - bundler
+  - curl
+  - git-extras
+  - ruby-full
+  - ruby-dev
+  - zlib1g-dev
+tasks:
+  - lint: |
+      cd rider
+      bundle install --path="../.gems"
+      bundle exec rake standard
+  - test: |
+      cd rider
+      bundle install --path="../.gems"
+      bundle exec rake test
+triggers:
+  - action: email
+    condition: failure
+    to: "Russell Sim <rsl@simopolis.xyz>"

data/.ruby-version

@@ -0,0 +1 @@
+3.1.6

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.0

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-07-27
+
+- Initial release

data/README.md

@@ -0,0 +1,44 @@
+# RIDER -- RIDER Interactive Development Environment for Ruby
+
+RIDER Server is the server component of the RIDER development
+environment.
+
+## Installation
+
+TODO: Replace
+`UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG`
+with your gem name right after releasing it to RubyGems.org. Please do
+not do it earlier due to security reasons. Alternatively, replace this
+section with instructions to install your gem from git if you don't
+plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add rider-server
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install rider-server
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install
+dependencies. Then, run `rake test` to run the tests. You can also run
+`bin/console` for an interactive prompt that will allow you to
+experiment.
+
+To install this gem onto your local machine, run `bundle exec rake
+install`. To release a new version, update the version number in
+`version.rb`, and then run `bundle exec rake release`, which will
+create a git tag for the version, push git commits and the created
+tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports https://todo.sr.ht/~rsl/rider
+
+Support or discussion https://lists.sr.ht/~rsl/rider-devel

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+require "bump/tasks"
+
+Bump.tag_by_default = true
+Minitest::TestTask.create
+
+require "standard/rake"
+
+task default: %i[test standard]

data/exe/rider-server

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require "rider_server/server"
+
+server = RiderServer::Server.new
+server.run

data/lib/rider_server/core_ext/array.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+#
+# array.rb -- Array extensions
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+class Array
+  def rider_inspect
+    max_length = 50
+    sample = +""
+
+    dup.slice(0, 3).each do |item|
+      str = item.inspect
+      remaining = max_length - (sample.length + str.length)
+
+      # Truncate the string, and preserve any terminators
+      if sample.length >= max_length
+        # Ignore item
+      elsif remaining < 0
+        terminator = ["]", '"', "'", ">"].member?(str[-1]) ? str[-1] : ""
+        sample << (str.dup[0, max_length] + "..." + terminator)
+      else
+        sample << str.dup
+        sample << ", "
+      end
+    end
+    "#<#{self.class}: [#{sample}] size: #{length}>"
+  end
+end

data/lib/rider_server/core_ext/hash.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+#
+# hash.rb -- Hash extensions
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+class Hash
+  def rider_inspect
+    "#<#{self.class}: #{length} items}>"
+  end
+end

data/lib/rider_server/core_ext/object.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+#
+# object.rb -- Object class extensions
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+class Object
+  def rider_inspect
+    if defined?(inspect) && method(:inspect).owner != Object && method(:inspect).owner != Kernel
+      inspect
+    else
+      "#<#{self.class} #{object_id}>"
+    end
+  end
+end

data/lib/rider_server/core_ext/string.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+#
+# string.rb -- String extensions
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+class String
+  def rider_inspect
+    if length <= 50
+      "#<String #{inspect}>"
+    else
+      "#<String \"#{self[0, 50]}...\" #{length - 50} more characters>"
+    end
+  end
+end

data/lib/rider_server/core_ext/symbol.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+#
+# symbol.rb -- Symbol class extensions
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+class Symbol
+  def rider_inspect
+    ":#{self}"
+  end
+end

data/lib/rider_server/errors.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+#
+# errors.rb -- Errors
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+module RiderServer
+  class Error < StandardError; end
+
+  class EvalInterrupt < Error; end
+
+  class ModuleLookupError < Error; end
+end

data/lib/rider_server/exception_extension.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+#
+# exception_extension.rb -- Add stackframes to exceptions
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "binding_of_caller"
+
+module RiderServer
+  module ExceptionExtension
+    INPUT_FORMAT = %r{^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$}
+
+    def set_backtrace(...)
+      if caller.none? { |loc| loc.match(INPUT_FORMAT) && Regexp.last_match(1) == __FILE__ }
+        @__rider_bindings_stack = ::Kernel.binding.callers.drop(1)
+      end
+
+      super
+    end
+
+    def __rider_bindings_stack
+      @__rider_bindings_stack || []
+    end
+  end
+end
+
+unless ::Exception.included_modules.include?(RiderServer::ExceptionExtension)
+  class ::Exception
+    prepend RiderServer::ExceptionExtension
+  end
+end

data/lib/rider_server/inspect.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+#
+# inspect.rb -- Methods to help inspect objects
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/utils"
+
+module RiderServer
+  module Inspect
+
+    def self.safely_eval(string, file, line)
+      code = <<~HEREDOC
+      begin
+        #{string}
+      rescue StandardError => e
+        e
+      end
+      HEREDOC
+      eval(code, TOPLEVEL_BINDING, file, line) # rubocop:disable Security/Eval
+    end
+
+    def self.class(obj)
+      klass = obj.class
+      {
+        "name" => klass.to_s,
+        "value" => Utils.rider_inspect(safely_eval("Object.const_get('#{klass}')", __FILE__, __LINE__)),
+        "inspect-location" => "toplevel_const_get:#{klass.inspect}",
+        "source-location" => safely_eval("Object.const_source_location('#{klass}')", __FILE__, __LINE__) || []
+      }
+    end
+
+    def self.ancestors(obj)
+      # Look for instance ancestors on the class.
+      obj = obj.class if !obj.respond_to?(:ancestors) && obj.class.respond_to?(:ancestors)
+
+      if obj.class.respond_to?(:ancestors)
+        obj.class.ancestors.map do |item|
+          {
+            "name" => item.to_s,
+            "value" => Utils.rider_inspect(item),
+            "inspect-location" => "ancestor_find:#{item}",
+            "source-location" => safely_eval("Object.const_source_location('#{item}')", __FILE__, __LINE__) || []
+          }
+        end
+      else
+        []
+      end
+    end
+
+    def self.constants(obj)
+      if obj.respond_to?(:constants)
+        constants = safely_eval("#{obj.inspect}.constants", __FILE__, __LINE__)
+        return [] if constants.nil?  # Eigen classes have no constants
+        constants.map do |item|
+          {
+            "name" => item.to_s,
+            "value" => Utils.rider_inspect(safely_eval("#{obj.inspect}.const_get('#{item}')", __FILE__, __LINE__)),
+            "inspect-location" => "const_get:#{obj.inspect}::#{item}",
+            "source-location" => safely_eval("#{obj.inspect}.const_source_location('#{item}')", __FILE__, __LINE__) || []
+          }
+        end.sort_by { |hash| hash["name"] }
+      else
+        []
+      end
+    end
+
+    def self.describe_method(method)
+      {
+        "name" => method.name.to_s,
+        "value" => Utils.rider_inspect(method),
+        "visibility" => if method.private?
+                          ":private"
+                        elsif method.protected?
+                          ":protected"
+                        elsif method.public?
+                          ":public"
+                        else
+                          ":unknown"
+                        end,
+        "owner" => method.owner.inspect,
+        "source-location" => method.source_location || [],
+        "parameters" => method.parameters.map { |subarray| subarray.map(&:to_s) }
+      }
+    end
+
+    def self.methods(obj)
+      if obj.respond_to?(:methods)
+        obj.methods.map do |name|
+          describe_method(obj.method(name))
+        end
+      else
+        []
+      end
+    end
+
+    def self.instance_methods(obj)
+      if obj.respond_to?(:instance_methods)
+        obj.instance_methods.map do |item|
+          describe_method(obj.instance_method(item))
+        end
+      else
+        []
+      end
+    end
+
+    def self.instance_variables(obj)
+      if obj.respond_to?(:instance_variables)
+        obj.instance_variables.map do |item|
+          [
+            {
+              "name" => item.to_s
+            },
+            {
+              "name" => obj.instance_variable_get(item).to_s,
+              "value" => Utils.rider_inspect(obj.instance_variable_get(item)),
+              "inspect-location" => "instance_variable_get:#{item}"
+            }
+          ]
+        end
+      else
+        []
+      end
+    end
+
+    def self.class_variables(obj)
+      if obj.respond_to?(:class_variables)
+        obj.class_variables.map do |item|
+          [
+            {
+              "name" => item.to_s
+            },
+            {
+              "name" => obj.class_variable_get(item).to_s,
+              "value" => Utils.rider_inspect(obj.class_variable_get(item)),
+              "inspect-location" => "class_variable_get:#{item}"
+            }
+          ]
+        end
+      else
+        []
+      end
+    end
+  end
+end

data/lib/rider_server/logger.rb

@@ -0,0 +1,13 @@
+require "logger"
+
+module RiderServer
+  module Logger
+    def log
+      @logger ||= begin
+        log_level = (ENV["LOG_LEVEL"] || "INFO").upcase.to_sym
+
+        ::Logger.new(STDERR, level: log_level) # rubocop:disable Style/GlobalStdStream
+      end
+    end
+  end
+end

data/lib/rider_server/operation.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+#
+# operation.rb -- Base class for operations
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/logger"
+
+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
+    end
+
+    def self.documentation(desc)
+      @documentation = desc
+    end
+
+    def self.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 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?
+    end
+
+    def create_response(operation)
+      Utils.create_response(operation)
+    end
+
+    def send_response(response)
+      controller.send_response(response)
+    end
+
+    def validate_request!(request)
+      @arguments.each do |arg|
+        # Skip optional arguments
+        next if !arg[:required] && !request.key?(arg[:name])
+
+        name = arg[:name].to_s
+
+        if arg[:type] == :integer
+          request[name] = Integer(request[name])
+        elsif arg[:type] == :string
+          request[name] = String(request[name])
+        elsif arg[:type] == :array && request[name].is_a?(Array)
+          # pass, the type is correct
+        else
+          raise ArgumentError, "Invalid argument type #{arg[:type]}"
+        end
+      end
+    end
+  end
+end

data/lib/rider_server/operations.rb

@@ -0,0 +1,136 @@
+# 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 "rider_server/logger"
+require "rider_server/session"
+require "rider_server/errors"
+require "rider_server/response"
+require "rider_server/core_ext/array"
+require "rider_server/core_ext/hash"
+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"
+
+module RiderServer
+  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)
+      @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))
+      else
+        log.warn("Unknown operation '#{op}' requested")
+        response = Response.new(operation)
+        response.status "unknown-op", "done"
+        send_response(response)
+      end
+    rescue ScriptError, StandardError => e
+      response = Response.new(operation)
+      response.set("ex", e.inspect)
+      response.set("out", e.full_message)
+      response.status("eval-error", "done")
+      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)
+      end
+      send_response(response)
+    end
+
+    def new_session
+      Session.new(@response_queue)
+    end
+
+    def get_session(id)
+      return nil unless id
+      @sessions[id]
+    end
+
+    def add_session(session)
+      @sessions[session.id] = session
+    end
+
+    def delete_session(session_id)
+      @sessions.delete(session_id)
+    end
+  end
+end

data/lib/rider_server/ops/clone.rb

@@ -0,0 +1,32 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  module Ops
+    class Clone < Operation
+      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)
+        response = Response.new(operation)
+
+        # Clone a specific session if specified
+        storage_session = operation["session"]
+        new_session = if storage_session
+          controller.get_session(storage_session).clone
+        else
+          controller.new_session
+        end
+
+        controller.add_session(new_session)
+
+        response.set("new-session", new_session.id)
+        response.status("done")
+        response
+      end
+    end
+  end
+end