rider-server 0.1.0 → 0.1.2

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

data/lib/rider_server/session_operations/set_namespace.rb

@@ -0,0 +1,82 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "set-namespace"
+    documentation "Set the namespace to the given location."
+
+    argument :id, :string, "The request id", required: true
+    argument :location, :array, "The location to set the namespace to", required: true
+
+    def handle(session, operation)
+      response = Response.new(operation)
+      location = operation["location"]
+
+      value = traverse_location(location, nil, session)
+      session.workspace.set_namespace(value)
+      response.set("ns", session.workspace.namespace_name)
+      response.set("location", location)
+      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"
+        ctx.__rider_bindings_stack[identifier.to_i]
+      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(value, ctx, session)
+      session.get_result(value)
+    end
+
+    def rider_exception(id, ctx, session)
+      session.get_exception(id)["exception"]
+    end
+  end
+end

data/lib/rider_server/session_operations/set_namespace_variable.rb

@@ -0,0 +1,81 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "set-namespace-variable"
+    documentation "Set a variable in the current REPL binding."
+
+    argument :id, :string, "The request id", required: true
+    argument :name, :string, "The name of the local variable to set", required: true
+    argument :location, :array, "The location to set the namespace to", required: true
+
+    def handle(session, operation)
+      response = Response.new(operation)
+      name operation["name"]
+      raise "Name must be a valid Ruby identifier" unless /\A[a-zA-Z_]\w*\z/.match?(name)
+      location = operation["location"]
+
+      value = traverse_location(location, nil, session)
+      session.workspace.binding_local_variable_set(name, 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"
+        ctx.__rider_bindings_stack[identifier.to_i]
+      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(value, ctx, session)
+      session.get_result(value)
+    end
+
+    def rider_exception(id, ctx, session)
+      session.get_exception(id)["exception"]
+    end
+  end
+end

data/lib/rider_server/session_operations/stdin.rb

@@ -0,0 +1,19 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "stdin"
+    documentation "List all exceptions that have occurred in the session."
+
+    argument :id, :string, "The request id", required: true
+    argument :stdin, :string, "The input to write to the stdin of the process", required: true
+
+    def handle(session, operation)
+      session.stdin.write(operation["stdin"])
+      response = Response.new(operation)
+      response.status("done")
+      response
+    end
+  end
+end

data/lib/rider_server/utils.rb

@@ -30,19 +30,19 @@ module RiderServer
     end
     module_function :create_listeners
 
-    def rider_inspect(obj)
-      if obj.respond_to?(:rider_inspect)
-        obj.rider_inspect
+    def rider_display(obj)
+      if obj.respond_to?(:rider_display)
+        obj.rider_display
       else
         obj.inspect
       end
     end
-    module_function :rider_inspect
+    module_function :rider_display
 
     class FixedArray < Array
-      def initialize(*args)
-        @max_size = args[0] || 10
-        super
+      def initialize(*args, max_size: 10)
+        @max_size = max_size
+        super(*args)
       end
 
       def <<(element)

data/lib/rider_server/validate/array.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+#
+# array.rb -- Simple validation of arrays
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/validate/base"
+
+module RiderServer
+  module Validate
+    class Array < Base
+      def initialize(element_validator)
+        @element_validator = element_validator
+      end
+
+      def validate(data, loc = "")
+        fail(data, loc, "be an array") unless data.is_a?(::Array)
+
+        data.map.with_index do |element, index|
+          @element_validator.validate(element, "#{loc}[#{index}]")
+        end
+      end
+    end
+
+    def self.array(element_validator)
+      Array.new(element_validator)
+    end
+  end
+end

data/lib/rider_server/validate/base.rb

@@ -0,0 +1,28 @@
+require "rider_server/validate/predicates"
+
+module RiderServer
+  module Validate
+    class ValidationError < StandardError
+    end
+
+    class Base
+      include PredicateLogic
+
+      def self.validate(data)
+        new.validate(data)
+      end
+
+      def validate(data)
+        raise NotImplementedError
+      end
+
+      def fail(value, loc, reason)
+        if loc == ""
+          raise ValidationError, "#{value.inspect}, #{reason}"
+        else
+          raise ValidationError, "#{value.inspect}, found at #{loc} #{reason}"
+        end
+      end
+    end
+  end
+end

data/lib/rider_server/validate/boolean.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+#
+# boolean.rb -- Simple validation of booleans
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/validate/base"
+
+module RiderServer
+  module Validate
+    class Boolean < Base
+      TRUE_STRINGS = ["yes", "true", "on"]
+
+      def default(value)
+        @default = value
+        self
+      end
+
+      def validate(data, loc = "")
+        if data.nil? && @default
+          data = @default
+        elsif data.nil?
+          fail(data, loc, "no default value set")
+        end
+
+        case data
+
+        when ::TrueClass, ::FalseClass
+          data
+        when ::String
+          TRUE_STRINGS.member? data.downcase
+        when ::Integer
+          data > 0
+        else
+          fail(data, loc, "can't convert to a boolean")
+        end
+      end
+    end
+
+    def self.bool
+      Boolean.new
+    end
+  end
+end

data/lib/rider_server/validate/hash.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+#
+# hash.rb -- Simple validation of hashes
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/validate/base"
+
+module RiderServer
+  module Validate
+    class Hash < Base
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def validate(data, loc = "")
+        @schema.map do |key, validator|
+          if data.key? key
+            [key, validator.validate(data[key], "#{loc}[#{key}]")]
+          end
+        end.to_h
+      end
+    end
+
+    def self.hash(schema)
+      Hash.new(schema)
+    end
+  end
+end

data/lib/rider_server/validate/integer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+#
+# integer.rb -- Simple validation of integers
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/validate/base"
+
+module RiderServer
+  module Validate
+    class Integer < Base
+      def default(value)
+        @default = value
+        self
+      end
+
+      def greater_than(value)
+        add_predicate { |data| [data > value, "must be greater than #{value}"] }
+        self
+      end
+
+      def less_than(value)
+        add_predicate { |data| [data < value, "must be less than #{value}"] }
+        self
+      end
+
+      def validate(data, loc = "")
+        if data.nil? && @default
+          data = @default
+        elsif data.nil?
+          fail(data, loc, "no default value set")
+        end
+
+        begin
+          data = data.to_i
+        rescue
+          fail(data, loc, "can't convert to an integer")
+        end
+
+        result, reason = check_predicates(data)
+        unless result
+          fail(data, loc, reason)
+        end
+
+        data
+      end
+    end
+
+    def self.integer
+      Integer.new
+    end
+  end
+end

data/lib/rider_server/validate/predicates.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+#
+# predicates.rb -- Predicates for values
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+module RiderServer
+  module Validate
+    module PredicateLogic
+      def add_predicate(&block)
+        @predicates ||= []
+        @predicates << block
+      end
+
+      def check_predicates(data)
+        return [true, ""] if @predicates.nil?
+        @predicates.each do |predicate|
+          result, reason = predicate.call(data)
+          unless result
+            return [result, reason]
+          end
+        end
+        [true, ""]
+      end
+    end
+  end
+end

data/lib/rider_server/validate/string.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+#
+# string.rb -- Simple validation of strings
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/validate/base"
+
+module RiderServer
+  module Validate
+    class String < Base
+      def default(value)
+        @default = value
+        self
+      end
+
+      def empty
+        add_predicate do |data|
+          [data.empty?, "must be empty"]
+        end
+        self
+      end
+
+      def not_empty
+        add_predicate do |data|
+          [!data.empty?, "must not be empty"]
+        end
+        self
+      end
+
+      def validate(data, loc = "")
+        if data.nil? && @default
+          data = @default
+        elsif data.nil?
+          fail(data, loc, "no default value set")
+        end
+
+        begin
+          data = data.to_s
+        rescue
+          fail(data, loc, "can't convert to a string")
+        end
+
+        result, reason = check_predicates(data)
+        unless result
+          fail(data, loc, reason)
+        end
+
+        data
+      end
+    end
+
+    def self.string
+      Validate::String.new
+    end
+  end
+end

data/lib/rider_server/validate/symbol.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+#
+# symbol.rb -- Simple validation of symbols
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/validate/base"
+
+module RiderServer
+  module Validate
+    class Symbol < Base
+      def default(value)
+        @default = value
+        self
+      end
+
+      # Require that the input be one of the +values+.
+      def one_of(*values)
+        raise ArgumentError, "one_of requires at least one value" if values.empty?
+        values.each do |value|
+          raise ArgumentError, "one_of requires all values to be symbols but #{value.inspect} is not" \
+            unless value.is_a?(::Symbol)
+        end
+
+        add_predicate do |data|
+          [values.member?(data), "must one of #{values.inspect}"]
+        end
+        self
+      end
+
+      # Require that the input be empty.
+      def empty
+        add_predicate do |data|
+          [data.empty?, "must be empty"]
+        end
+        self
+      end
+
+      # Require that the input be not empty.
+      def not_empty
+        add_predicate do |data|
+          [!data.empty?, "must not be empty"]
+        end
+        self
+      end
+
+      # Convert the input to an upcase version if possible.
+      def upcase
+        @upcase = true
+        self
+      end
+
+      def validate(data, loc = "")
+        if data.nil? && @default
+          data = @default
+        elsif data.nil?
+          fail(data, loc, "no default value set")
+        end
+
+        if data.respond_to?(:upcase)
+          begin
+            data = data.upcase if @upcase
+          rescue
+            fail(data, loc, "can't upcase symbol")
+          end
+        end
+
+        begin
+          data = data.to_sym
+        rescue
+          fail(data, loc, "can't convert to a symbol")
+        end
+
+        result, reason = check_predicates(data)
+        unless result
+          fail(data, loc, reason)
+        end
+
+        data
+      end
+    end
+
+    def self.symbol
+      Symbol.new
+    end
+  end
+end

data/lib/rider_server/validate.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+#
+# validate.rb -- Simple validation library
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/validate/array"
+require "rider_server/validate/boolean"
+require "rider_server/validate/hash"
+require "rider_server/validate/integer"
+require "rider_server/validate/string"
+require "rider_server/validate/symbol"

data/lib/rider_server/version.rb

@@ -8,5 +8,5 @@
 # SPDX-License-Identifier: MIT
 
 module RiderServer
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/rider_server/workspace.rb

@@ -90,7 +90,7 @@ module RiderServer
 
     def create_binding(obj)
       if obj.is_a?(Binding)
-        [obj, obj.inspect]
+        [obj, obj.to_s]
       elsif obj.is_a?(Class)
         [obj.class_eval("binding", __FILE__, __LINE__), obj.name]
       elsif obj.is_a?(Module)

data/lib/rider_server.rb

@@ -2,4 +2,6 @@
 # Copyright (c) 2024 Russell Sim
 # SPDX-License-Identifier: MIT
 
-require_relative "rider_server/version"
+require "rider_server/version"
+require "rider_server/config"
+require "rider_server/server"