nrepl-lazuli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 01bda1a2be06171508f3a03d476dd5d108939b703af0b039fd4e050a07622c1f
+  data.tar.gz: f85343da3cce42d114abbb1141705fa46aee8dcebe4b18198ef983a127cc2455
+SHA512:
+  metadata.gz: 153895cd6a45830613cf7ebb0b7fa4fb61e45e8ee4d588e5d60b02669c12f5d3469a520e4fa80b0f9690785337e15d6db80ec2084c3330e8c609beb39ca268cb
+  data.tar.gz: b5a887a6b2fe214476828fbdd600d4d3be16846074e7e01e371d5a85f72253730e3e8ee3046effa7897a9e115f3a7d02cfa79e4917f5f04901caa963f87ae3c6

data/lib/nrepl/connection.rb

@@ -0,0 +1,222 @@
+module NREPL
+  class Connection
+    @@debug_counter = 0
+
+    def initialize(input, debug: false, out: input, watches: NREPL.class_variable_get(:@@watches))
+      @debug = debug
+      @in = input
+      @out = out
+      @pending_evals = {}
+      @watches = watches
+      @counter = 0
+    end
+
+    def treat_messages!
+      bencode = BEncode::Parser.new(@in)
+      loop do
+        break if @in.eof?
+        msg = bencode.parse!
+        debug "Received", msg
+        next unless msg
+        treat_msg(msg)
+      end
+      @pending_evals.each { |(i, _)| clear_eval!(i) }
+    end
+
+    def treat_msg(msg)
+      case msg['op']
+      when 'clone'
+        register_session(msg)
+      when 'describe'
+        describe_msg(msg)
+      when 'eval'
+        eval_op(msg, false)
+      when 'eval_pause'
+        eval_op(msg, true)
+      when 'eval_resume'
+        msg['id'] ||= "eval_#{@counter += 1}"
+        stop_id = msg['stop_id']
+        clear_eval!(stop_id)
+
+        send_msg(response_for(msg, {
+          'status' => ['done'],
+          'op' => msg['op']
+        }))
+      when 'unwatch'
+        msg['id'] ||= "eval_#{@counter += 1}"
+        watch_id = msg['watch_id']
+        @watches.delete(watch_id)
+
+        send_msg(response_for(msg, {
+          'status' => ['done'],
+          'op' => msg['op']
+        }))
+      when 'interrupt'
+        id = if(msg['interrupt-id'])
+          msg['interrupt-id']
+        else
+          @pending_evals.keys.first
+        end
+        pending = @pending_evals[id] || {}
+        thread = pending[:thread]
+        msg['id'] ||= (id || 'unknown')
+
+        if(thread)
+          thread.kill
+          clear_eval!(id)
+          send_msg(response_for(msg, {
+            'status' => ['done', 'interrupted'],
+            'op' => msg['op']
+          }))
+
+        else
+          send_msg(response_for(msg, {
+            'status' => ['done'],
+            'op' => msg['op']
+          }))
+        end
+
+      else
+        send_msg(response_for(msg, {
+          'op' => msg['op'],
+          'status' => ['done', 'error'],
+          'error' => "unknown operation: #{msg['op'].inspect}"
+        }))
+      end
+    end
+
+    private def eval_op(msg, stop)
+      msg['id'] ||= "eval_#{@counter += 1}"
+      id = msg['id']
+      @pending_evals[id] = msg
+      @pending_evals[id][:thread] = Thread.new do
+        Thread.current[:eval_id] = msg['id']
+
+        begin
+          eval_msg(msg, stop)
+        rescue Exception => e
+          send_exception(msg, e)
+        ensure
+          @pending_evals.delete(id) unless stop
+        end
+      end
+    end
+
+    private def clear_eval!(id)
+      function_name = @pending_evals.fetch(id, {})[:stop_function_name]
+      if function_name
+        NREPL.singleton_class.send(:undef_method, "stop_#{function_name}")
+      end
+
+      input = @pending_evals.fetch(id, {})[:in]
+      input.close if input
+
+      @pending_evals.delete(id)
+    end
+
+    private def response_for(old_msg, msg)
+      msg.merge('session' => old_msg.fetch('session', 'none'), 'id' => old_msg.fetch('id', 'unknown'))
+    end
+
+    private def eval_msg(msg, stop)
+      str   = msg['code']
+      code  = str == 'nil' ? nil : str
+      pending_eval = @pending_evals[msg['id']]
+      value = unless code.nil?
+        if stop
+          @@debug_counter += 1
+          method_name = "_#{@@debug_counter}_#{rand(9999999999).to_s(32)}"
+          pending_eval[:stop_function_name] = method_name
+          code = code.gsub(/^NREPL\.stop!$/, "NREPL.stop_#{method_name}(binding)")
+          define_stop_function!(msg, method_name)
+        end
+
+        original_bind = if msg['stop_id']
+          @pending_evals.fetch(msg['stop_id'], {})[:binding]
+        elsif msg['watch_id']
+          @watches.fetch(msg['watch_id'], {})[:binding]
+        end
+        evaluate_code(code, msg['file'], msg['line'], original_bind)
+      end
+
+      unless pending_eval[:stopped?]
+        send_msg(response_for(msg, {'value' => value.to_s, 'status' => ['done']}))
+      end
+    end
+
+    private def define_stop_function!(msg, method_name)
+      out, inp = IO.pipe
+      send_stopped = proc do |ctx_binding, original_msg, caller|
+        stop_msg = @pending_evals[msg['id']]
+        if stop_msg
+          stop_msg.update(
+            in: inp,
+            binding: ctx_binding
+          )
+        end
+        @pending_evals[original_msg['id']].update(stopped?: true)
+        (file, row) = caller[0].split(/:/)
+        send_msg(response_for(original_msg, {
+          'file' => file,
+          'line' => row.to_i,
+          'status' => ['done', 'paused']
+        }))
+      end
+
+      will_pause = proc do
+        eval_id = while(thread = Thread.current)
+          break thread[:eval_id] if thread[:eval_id]
+        end
+        original_msg = @pending_evals[eval_id] || {}
+        stop_id = original_msg['stop_id']
+        original_msg if stop_id == msg['id']
+      end
+      NREPL.singleton_class.send(:define_method, "stop_#{method_name}") do |ctx_binding|
+        original_msg = will_pause.call
+        if original_msg
+          send_stopped.call(ctx_binding, original_msg, caller)
+        end
+      end
+    end
+
+    private def register_session(msg)
+      debug "Register session", msg
+
+      id = rand(4294967087).to_s(16)
+      send_msg(response_for(msg, { 'new_session' => id, 'status' => ['done'] }))
+    end
+
+    private def debug(text, msg)
+      STDOUT.write("#{text}: #{msg.inspect}\n") if @debug
+    end
+
+    private def describe_msg(msg)
+      versions = {
+        ruby: RUBY_VERSION,
+        nrepl: NREPL::VERSION,
+      }
+
+      send_msg(response_for(msg, { 'versions' => versions }))
+    end
+
+    # @param [TCPSocket] client
+    # @param [Hash] msg
+    # @param [Exception] e
+    def send_exception(msg, e)
+      send_msg(response_for(msg, { 'ex' => e.message, 'status' => ['done', 'error'] }))
+    end
+
+    def send_msg(msg)
+      debug "Sending", msg
+      @out.write(msg.bencode)
+      @out.flush
+    end
+  end
+end
+
+# To avoid locally binding with the NREPL::Connection module
+b = binding
+define_method(:evaluate_code) do |code, file, line, bind|
+  bind ||= b
+  eval(code, bind, file || "EVAL", line || 0).inspect
+end

data/lib/nrepl/fake_stdout.rb

@@ -0,0 +1,18 @@
+module NREPL
+  class FakeStdout
+    def initialize(connections, kind)
+      @connections = connections
+      @kind = kind
+    end
+
+    def write(text)
+      STDOUT.write "#{@connections}\n"
+      STDOUT.write(text)
+      @connections.each do |conn|
+        conn.send_msg(
+          @kind => text
+        )
+      end
+    end
+  end
+end

data/lib/nrepl/server.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+#
+# A Ruby port of ogion https://gitlab.com/technomancy/ogion &
+# https://github.com/borkdude/nrepl-server/blob/master/src/borkdude/nrepl_server.clj
+
+require 'bencode'
+require 'socket'
+require_relative 'connection'
+require_relative 'fake_stdout'
+
+module NREPL
+  class Server
+    attr_reader :debug, :port, :host
+    alias debug? debug
+
+    def self.start(**kwargs)
+      new(**kwargs).start
+    end
+
+    def initialize(port: DEFAULT_PORT, host: DEFAULT_HOST, debug: false)
+      @port  = port
+      @host  = host
+      @debug = debug
+      @connections = Set.new
+      NREPL.class_variable_set(:@@connections, @connections)
+    end
+
+    private def record_port
+      File.open(PORT_FILENAME, 'w+') do |f|
+        f.write(port)
+      end
+    end
+
+    def start
+      puts "nREPL server started on port #{port} on host #{host} - nrepl://#{host}:#{port}"
+      puts "Running in debug mode" if debug?
+      record_port
+
+      $stdout = FakeStdout.new(@connections, "out")
+      $stderr = FakeStdout.new(@connections, "err")
+
+      Signal.trap("INT") { stop }
+      Signal.trap("TERM") { stop }
+
+      s = TCPServer.new(host, port)
+      loop do
+        Thread.start(s.accept) do |client|
+          connection = Connection.new(client, debug: debug?)
+          @connections << connection
+          connection.treat_messages!
+          @connections.delete(connection)
+        end
+      end
+    ensure
+      File.unlink(PORT_FILENAME)
+    end
+
+    def stop
+      Thread.exit
+      exit(0)
+    end
+  end
+end
+
+# Sorry, no other way...
+module ThreadPatch
+  def initialize(*args, &b)
+    @parent = Thread.current
+    super
+  end
+
+  def parent
+    @parent
+  end
+end
+
+Thread.prepend(ThreadPatch)

data/lib/nrepl.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module NREPL
+  VERSION = '0.1.0'
+  DEFAULT_PORT  = 7888
+  DEFAULT_HOST  = '127.0.0.1'
+  PORT_FILENAME = '.nrepl-port'
+
+  require_relative 'nrepl/server'
+  @@watches = {}
+  @@connections = Set.new
+
+  def self.watch!(binding, id=nil)
+    (file, row) = caller[0].split(/:/)
+    id ||= "#{file}:#{row}"
+    row = row.to_i
+
+    @@watches[id] = {binding: binding}
+    @@connections.each do |connection|
+      connection.send_msg(
+        'op' => 'hit_watch',
+        'id' => id,
+        'file' => file,
+        'line' => row,
+        'status' => ['done']
+      )
+    end
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: nrepl-lazuli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Maurício Szabo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bencode
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+description: A Ruby nREPL server, made to be used with Lazuli plug-in (but can be
+  used with any nREPL client too)
+email: mauricio@szabo.link
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/nrepl.rb
+- lib/nrepl/connection.rb
+- lib/nrepl/fake_stdout.rb
+- lib/nrepl/server.rb
+homepage: https://rubygems.org/gems/nrepl-lazuli
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: A Ruby nREPL server
+test_files: []