ruby-test-ide 0.1.0

data/lib/ruby_test_ide/runner.rb

@@ -0,0 +1,532 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# RubyTestIDE runtime-introspection worker.
+#
+# Reads ONE JSON request on stdin, evaluates the user's code in a clean
+# top-level binding (exactly the way `irb` / a debugger would), then
+# interrogates the resulting *live* objects for completions, hover info or
+# per-line variable state. Writes ONE JSON response on stdout.
+#
+# It is spawned per-request by server.rb and hard-killed if it exceeds the
+# time budget, so user code that loops forever cannot take the IDE down.
+#
+# NOTE: this executes the code being edited (that is the whole point of the
+# runtime-reflection approach). Treat it like running `ruby yourfile.rb`.
+
+require 'json'
+require 'stringio'
+require 'pathname'
+require 'timeout'
+
+module RubyTestIDE
+  SANDBOX_PATH = '(ruby-ide)'
+  MAX_TRACE_EVENTS = 50_000
+  MAX_ITEMS = 300
+  RECEIVER_TIMEOUT = 2 # seconds for evaluating the completion receiver
+  OBS_REL = File.join('.ruby-ide', 'observations.json')
+
+  KEYWORDS = %w[
+    BEGIN END alias and begin break case class def defined? do else elsif end
+    ensure false for if in module next nil not or redo rescue retry return
+    self super then true undef unless until when while yield
+    require require_relative attr_accessor attr_reader attr_writer
+  ].freeze
+
+  class << self
+    def main
+      # Results go out on fd 3 when the server provides it, so user code
+      # printing to stdout can never corrupt the JSON protocol. Fallback to
+      # stdout (with capture) when run by hand: `echo '{...}' | ruby runner.rb`
+      channel = begin
+        IO.new(3, 'w')
+      rescue StandardError
+        nil
+      end
+      request = JSON.parse($stdin.read)
+      captured = nil
+      unless channel
+        real_stdout = $stdout
+        $stdout = StringIO.new
+      end
+      response =
+        begin
+          handle(request)
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          { 'error' => "#{e.class}: #{e.message}"[0, 1000] }
+        end
+      response['bundler_error'] = @bundler_error if @bundler_error
+      unless channel
+        captured = $stdout.string
+        $stdout = real_stdout
+      end
+      response['stdout'] = truncate(captured, 20_000) if captured && !captured.empty?
+      out = channel || $stdout
+      out.puts JSON.generate(response)
+      out.flush
+      # exit! skips at_exit hooks — minitest/autorun must not re-run the
+      # suite after the response has been written.
+      Process.exit!(0)
+    end
+
+    def handle(req)
+      enter_workspace(req)
+      case req['op']
+      when 'complete' then complete(req)
+      when 'hover'    then hover(req)
+      when 'run'      then run(req)
+      else { 'error' => "unknown op #{req['op'].inspect}" }
+      end
+    end
+
+    # Evaluate "in place": chdir to the file's directory and use its real
+    # path as the eval filename, so require_relative / __FILE__ / __dir__
+    # behave as they would when running the file with `ruby`. The buffer
+    # content still comes from the request (unsaved edits included).
+    def enter_workspace(req)
+      @sandbox_path = req['path'].to_s.empty? ? SANDBOX_PATH : req['path']
+      @workspace_root = req['root'].to_s
+      dir = req['dir'].to_s
+      if !dir.empty? && File.directory?(dir)
+        Dir.chdir(dir)
+        $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
+      end
+      @bundler_error = activate_bundler(dir.empty? ? Dir.pwd : dir)
+      shim_require_relative(dir.empty? ? Dir.pwd : dir)
+    end
+
+    # If the workspace has a Gemfile (in the file's directory or above it),
+    # activate it so `require 'some-gem'` resolves exactly as it would under
+    # `bundle exec ruby file.rb`. Returns an error description (surfaced to
+    # the editor) when the bundle isn't installed, nil otherwise.
+    def activate_bundler(dir)
+      # Walk up from the file's directory, but never above the workspace
+      # root — a stray Gemfile in the user's home must not leak in.
+      root = File.expand_path(@workspace_root.to_s.empty? ? dir : @workspace_root)
+      gemfile = nil
+      Pathname.new(File.expand_path(dir)).ascend do |p|
+        candidate = p.join('Gemfile')
+        if candidate.file?
+          gemfile = candidate.to_s
+          break
+        end
+        break if p.to_s == root || !p.to_s.start_with?(root)
+      end
+      return nil unless gemfile
+
+      ENV['BUNDLE_GEMFILE'] = gemfile
+      # Pin the already-loaded bundler: without this, a lockfile BUNDLED WITH
+      # an older installed bundler makes bundler/setup RE-EXEC this process,
+      # and the restarted runner finds stdin already consumed (empty request).
+      require 'bundler/version'
+      ENV['BUNDLER_VERSION'] ||= Bundler::VERSION
+      require 'bundler/setup'
+      nil
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      { 'class' => e.class.to_s,
+        'message' => truncate("#{e.message} — try `bundle install` in #{File.dirname(gemfile)}", 400) }
+    end
+
+    # require_relative raises "cannot infer basepath" inside eval'd code.
+    # Resolve against the calling file's real directory when there is one
+    # (files loaded via require keep normal semantics), otherwise against
+    # the buffer's directory.
+    def shim_require_relative(base)
+      Object.__send__(:define_method, :require_relative) do |rel|
+        from = caller_locations(1, 1)&.first&.absolute_path
+        require(File.expand_path(rel.to_s, from ? File.dirname(from) : base))
+      end
+      Object.__send__(:private, :require_relative)
+    end
+
+    def sandbox_path
+      @sandbox_path || SANDBOX_PATH
+    end
+
+    # ---------------------------------------------------------------- context
+
+    # A binding that behaves like the top of a plain ruby script:
+    # self is `main`, and — unlike TOPLEVEL_BINDING — a method-body binding
+    # cannot leak the runner's own local variables into completions.
+    def fresh_binding
+      TOPLEVEL_BINDING.receiver.__send__(:__ruby_ide_sandbox__)
+    end
+
+    # Evaluate everything before the cursor. If it doesn't parse (the user is
+    # mid-edit inside a def/do block), fall back to the largest prefix of
+    # lines that does parse — partial context beats no context.
+    def eval_context(code)
+      bind = fresh_binding
+      error = nil
+      code = largest_valid_prefix(code)
+      unless code.strip.empty?
+        begin
+          bind.eval(code, sandbox_path)
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          error = describe_error(e) # keep partial state assigned before raise
+        end
+      end
+      [bind, error]
+    end
+
+    def largest_valid_prefix(code)
+      lines = code.to_s.lines
+      until lines.empty?
+        candidate = lines.join
+        return candidate if valid_syntax?(candidate)
+
+        lines.pop
+      end
+      ''
+    end
+
+    def valid_syntax?(code)
+      stderr, $stderr = $stderr, StringIO.new
+      RubyVM::AbstractSyntaxTree.parse(code)
+      true
+    rescue SyntaxError
+      false
+    ensure
+      $stderr = stderr
+    end
+
+    def describe_error(e)
+      line = e.backtrace_locations&.find { |l| l.path == sandbox_path }&.lineno
+      line ||= e.message[/#{Regexp.escape(sandbox_path)}:(\d+)/, 1]&.to_i
+      { 'class' => e.class.to_s, 'message' => truncate(e.message, 500), 'line' => line }
+    end
+
+    # ------------------------------------------------------------- completion
+
+    def complete(req)
+      bind, error = eval_context(req['code_before'])
+      receiver = req['receiver'].to_s
+      prefix = req['prefix'].to_s
+
+      if receiver.strip.empty?
+        { 'items' => bare_items(bind, prefix), 'context_error' => error }.compact
+      else
+        obj =
+          begin
+            Timeout.timeout(RECEIVER_TIMEOUT) { bind.eval(receiver, sandbox_path) }
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            oracle = oracle_complete(bind, receiver, prefix)
+            return oracle.merge('context_error' => error).compact if oracle
+
+            return { 'items' => [], 'context_error' => error,
+                     'receiver_error' => truncate("#{e.class}: #{e.message}", 200) }.compact
+          end
+        { 'items' => receiver_items(obj, prefix),
+          'receiver_class' => class_of(obj).to_s,
+          'context_error' => error }.compact
+      end
+    end
+
+    def receiver_items(obj, prefix)
+      klass = class_of(obj)
+      ancestors = klass.ancestors
+      names = obj.methods.map(&:to_s).uniq
+      names.select! { |n| n.start_with?(prefix) } unless prefix.empty?
+      names.sort.first(MAX_ITEMS).map do |n|
+        item = { 'name' => n, 'kind' => 'method' }
+        if (m = safe_method(obj, n))
+          item['signature'] = signature(n, m)
+          item['arity'] = m.arity
+          item['owner'] = m.owner.to_s
+          item['sort'] = ancestors.index(m.owner) || 98
+        end
+        item
+      end
+    end
+
+    def bare_items(bind, prefix)
+      items = []
+      main = bind.receiver
+
+      bind.local_variables.each do |v|
+        val = bind.local_variable_get(v)
+        items << { 'name' => v.to_s, 'kind' => 'variable', 'class' => class_of(val).to_s,
+                   'value' => safe_inspect(val), 'sort' => 0 }
+      end
+      bind.eval('instance_variables').each do |v|
+        items << { 'name' => v.to_s, 'kind' => 'variable', 'sort' => 1 }
+      end
+      if prefix.start_with?('$')
+        global_variables.each { |v| items << { 'name' => v.to_s, 'kind' => 'variable', 'sort' => 3 } }
+      end
+      (main.methods + main.private_methods).map(&:to_s).uniq.each do |n|
+        next if n.start_with?('_')
+
+        item = { 'name' => n, 'kind' => 'method', 'sort' => 4 }
+        if (m = safe_method(main, n))
+          item['signature'] = signature(n, m)
+          item['owner'] = m.owner.to_s
+        end
+        items << item
+      end
+      Object.constants.map(&:to_s).each do |c|
+        items << { 'name' => c, 'kind' => 'constant', 'sort' => 2 }
+      end
+      KEYWORDS.each { |k| items << { 'name' => k, 'kind' => 'keyword', 'sort' => 5 } }
+
+      items.select! { |i| i['name'].start_with?(prefix) } unless prefix.empty?
+      items.uniq { |i| i['name'] }.sort_by { |i| [i['sort'], i['name']] }.first(MAX_ITEMS)
+    end
+
+    # ------------------------------------------------------------------ hover
+
+    def hover(req)
+      bind, error = eval_context(req['code_before'])
+      receiver = req['receiver'].to_s
+      name = req['name'].to_s
+      res = hover_info(bind, receiver, name)
+      observed = observed_for(name)
+      if res
+        res['observed'] = observed if observed && res['kind'] == 'method'
+      elsif observed
+        # Not resolvable from live objects (unreached path) — build the hover
+        # entirely from what the tests saw.
+        o = observed.first
+        args = (o['args'] || {}).map { |n, classes| "#{n}: #{classes.keys.join(' | ')}" }.join(', ')
+        res = { 'kind' => 'method', 'name' => name,
+                'signature' => "#{name}(#{args})",
+                'owner' => o['owner'],
+                'source' => "#{o['file']}:#{o['line']}",
+                'observed' => observed }
+      end
+      res ||= {}
+      res['context_error'] = error if error
+      res.empty? ? {} : res
+    end
+
+    def hover_info(bind, receiver, name)
+      if receiver.strip.empty?
+        if bind.local_variables.map(&:to_s).include?(name)
+          val = bind.local_variable_get(name)
+          return { 'kind' => 'variable', 'name' => name, 'class' => class_of(val).to_s,
+                   'value' => safe_inspect(val) }
+        end
+        if name.match?(/\A[A-Z]/) && bind.eval("defined?(#{name})") == 'constant'
+          val = bind.eval(name, sandbox_path)
+          return { 'kind' => val.is_a?(Module) ? 'class' : 'constant', 'name' => name,
+                   'class' => class_of(val).to_s, 'value' => safe_inspect(val),
+                   'ancestors' => (val.is_a?(Module) ? val.ancestors.first(8).map(&:to_s) : nil) }.compact
+        end
+      end
+
+      target =
+        begin
+          if receiver.strip.empty?
+            bind.receiver
+          else
+            Timeout.timeout(RECEIVER_TIMEOUT) { bind.eval(receiver, sandbox_path) }
+          end
+        rescue Exception # rubocop:disable Lint/RescueException
+          # Receiver unreachable live (network edge, slow call) — fall back
+          # to the return class the tests observed for its trailing method.
+          klass, via = observed_receiver_class(bind, receiver)
+          m = begin
+            klass&.instance_method(name)
+          rescue StandardError
+            nil
+          end
+          return nil unless m
+
+          return { 'kind' => 'method', 'name' => name,
+                   'signature' => signature(name, m),
+                   'arity' => m.arity,
+                   'owner' => m.owner.to_s,
+                   'receiver_class' => klass.to_s,
+                   'via' => via,
+                   'source' => m.source_location&.join(':') }.compact
+        end
+      m = safe_method(target, name)
+      return nil unless m
+
+      { 'kind' => 'method', 'name' => name,
+        'signature' => signature(name, m),
+        'arity' => m.arity,
+        'owner' => m.owner.to_s,
+        'receiver_class' => class_of(target).to_s,
+        'source' => m.source_location&.join(':'),
+        'doc' => nil }.compact
+    end
+
+    # Observations persisted by the server after the last learn run.
+    def observations
+      return @observations if defined?(@observations)
+
+      file = @workspace_root.to_s.empty? ? nil : File.join(@workspace_root, OBS_REL)
+      @observations = file && File.file?(file) ? JSON.parse(File.read(file)) : nil
+    rescue StandardError
+      @observations = nil
+    end
+
+    def observed_for(name)
+      return nil unless observations
+
+      list = observations.values.select { |o| o['method'] == name.to_s }
+      list.empty? ? nil : list.first(5)
+    end
+
+    # "w.summary('London')" -> "summary"; "fetch(1)" -> "fetch"
+    def trailing_call_name(expr)
+      expr[/(?:\.|\A)\s*([a-zA-Z_]\w*[?!]?)\s*(?:\([^()]*\))?\s*\z/, 1]
+    end
+
+    # The class tests observed the receiver's trailing method returning,
+    # or nil. [Class, "Weather#summary → String (observed in unit tests)"]
+    def observed_receiver_class(bind, receiver)
+      name = trailing_call_name(receiver)
+      entries = name && observed_for(name)
+      return nil unless entries
+
+      ret = entries.flat_map { |o| o['returns'].keys }.tally.max_by { |_, count| count }&.first
+      klass = begin
+        ret && bind.eval(ret)
+      rescue Exception # rubocop:disable Lint/RescueException
+        nil
+      end
+      return nil unless klass.is_a?(Module)
+
+      [klass, "#{entries.first['owner']}##{name} → #{ret} (observed in unit tests)"]
+    end
+
+    # Completion fallback when the receiver can't be evaluated (mocked
+    # network, unreached code path): if tests observed the trailing method
+    # of the receiver expression, complete on its most-seen return class.
+    def oracle_complete(bind, receiver, prefix)
+      klass, via = observed_receiver_class(bind, receiver)
+      return nil unless klass
+
+      ancestors = klass.ancestors
+      names = klass.instance_methods.map(&:to_s)
+      names.select! { |n| n.start_with?(prefix) } unless prefix.empty?
+      items = names.sort.first(MAX_ITEMS).map do |n|
+        item = { 'name' => n, 'kind' => 'method' }
+        m = begin
+          klass.instance_method(n)
+        rescue StandardError
+          nil
+        end
+        if m
+          item['signature'] = signature(n, m)
+          item['owner'] = m.owner.to_s
+          item['sort'] = ancestors.index(m.owner) || 98
+        end
+        item
+      end
+      { 'items' => items, 'receiver_class' => klass.to_s, 'oracle' => true,
+        'oracle_source' => via }
+    end
+
+    # -------------------------------------------------------------------- run
+
+    # Execute the whole buffer under a TracePoint, capturing local-variable
+    # state per line — the "as if you were sitting in a debugger" view.
+    def run(req)
+      code = req['code'].to_s
+      bind = fresh_binding
+      line_states = {}
+      prev_line = nil
+      events = 0
+
+      tp = TracePoint.new(:line) do |t|
+        next unless t.path == sandbox_path
+
+        events += 1
+        next if events > MAX_TRACE_EVENTS
+
+        # A :line event fires *before* its line runs, so its state describes
+        # the world *after* the previously-seen line.
+        line_states[prev_line] = capture_locals(t.binding) if prev_line
+        prev_line = t.lineno
+      end
+
+      error = nil
+      begin
+        tp.enable { bind.eval(code, sandbox_path) }
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        error = describe_error(e)
+      ensure
+        tp.disable
+      end
+      line_states[prev_line] = capture_locals(bind) if prev_line
+
+      { 'line_states' => line_states,
+        'final_locals' => capture_locals(bind),
+        'error' => error,
+        'truncated' => events > MAX_TRACE_EVENTS || nil }.compact
+    end
+
+    def capture_locals(b)
+      b.local_variables.each_with_object({}) do |v, h|
+        val = b.local_variable_get(v)
+        h[v.to_s] = { 'class' => class_of(val).to_s, 'value' => safe_inspect(val) }
+      end
+    rescue Exception # rubocop:disable Lint/RescueException
+      {}
+    end
+
+    # ---------------------------------------------------------------- helpers
+
+    def safe_method(obj, name)
+      obj.method(name)
+    rescue Exception # rubocop:disable Lint/RescueException
+      begin
+        class_of(obj).instance_method(name)
+      rescue Exception # rubocop:disable Lint/RescueException
+        nil
+      end
+    end
+
+    def class_of(obj)
+      ::Kernel.instance_method(:class).bind_call(obj)
+    end
+
+    # "gsub(pattern, replacement = …, &block)" from Method#parameters.
+    # C-implemented methods often report anonymous params — synthesise names.
+    def signature(name, method)
+      params = method.parameters
+      counter = 0
+      parts = params.map do |type, pname|
+        counter += 1
+        n = pname || "arg#{counter}"
+        case type
+        when :req    then n.to_s
+        when :opt    then "#{n} = …"
+        when :rest   then "*#{pname || 'args'}"
+        when :keyreq then "#{n}:"
+        when :key    then "#{n}: …"
+        when :keyrest then "**#{pname || 'opts'}"
+        when :block  then "&#{pname || 'block'}"
+        when :nokey  then '**nil'
+        end
+      end.compact
+      if parts.empty? && method.arity != 0
+        n = method.arity.abs - (method.arity.negative? ? 1 : 0)
+        parts = (1..n).map { |i| "arg#{i}" }
+        parts << '*args' if method.arity.negative?
+      end
+      parts.empty? ? name.to_s : "#{name}(#{parts.join(', ')})"
+    end
+
+    def safe_inspect(val)
+      truncate(val.inspect, 140)
+    rescue Exception # rubocop:disable Lint/RescueException
+      "#<#{class_of(val)} (uninspectable)>"
+    end
+
+    def truncate(s, len)
+      s = s.to_s
+      s.length > len ? "#{s[0, len - 1]}…" : s
+    end
+  end
+end
+
+# Top-level def so `self` inside the sandbox is `main`, exactly like a script.
+def __ruby_ide_sandbox__
+  binding
+end
+
+RubyTestIDE.main