dopairb 0.1.0

data/lib/dopairb/probe.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Dopairb
+  # Cheap, side-effect free facts about results and exceptions. Never calls
+  # the user's #inspect / #to_s: those may be slow, raise, or print.
+  module Probe
+    KERNEL_CLASS = Kernel.instance_method(:class)
+    MODULE_NAME = Module.instance_method(:name)
+    STR_LENGTH = String.instance_method(:length)
+    STR_SLICE = String.instance_method(:[])
+    ARY_SIZE = Array.instance_method(:size)
+    HASH_SIZE = Hash.instance_method(:size)
+    SYM_NAME = Symbol.instance_method(:name)
+    INT_BITS = Integer.instance_method(:bit_length)
+    INT_TO_S = Integer.instance_method(:to_s)
+    EXC_MESSAGE = Exception.instance_method(:message)
+
+    HUGE_BITS = 4000
+
+    module_function
+
+    def value(v, code = "")
+      info = classify(v)
+      if (m = code.match(/\A\s*def\s+(?:self\.)?([^\s(=;]+)/)) && info[:type] == :symbol
+        return { type: :definition, what: :method, name: m[1] }
+      end
+      if (m = code.match(/\A\s*(class|module)\s+(?!<<)([A-Z][\w:]*)/))
+        return { type: :definition, what: m[1].to_sym, name: m[2] }
+      end
+      info
+    rescue StandardError
+      { type: :object, class_name: "?" }
+    end
+
+    def classify(v)
+      if NilClass === v then { type: :nil }
+      elsif TrueClass === v then { type: :true }
+      elsif FalseClass === v then { type: :false }
+      elsif Integer === v
+        bits = INT_BITS.bind_call(v)
+        if bits > HUGE_BITS
+          { type: :huge, digits: (bits * 0.30103).floor + 1 }
+        else
+          { type: :integer, value: v }
+        end
+      elsif Float === v then { type: :float, value: v }
+      elsif String === v
+        len = STR_LENGTH.bind_call(v)
+        { type: :string, length: len, head: sanitize(STR_SLICE.bind_call(v, 0, 160) || "") }
+      elsif Array === v then { type: :array, size: ARY_SIZE.bind_call(v) }
+      elsif Hash === v then { type: :hash, size: HASH_SIZE.bind_call(v) }
+      elsif Symbol === v then { type: :symbol, name: SYM_NAME.bind_call(v) }
+      else { type: :object, class_name: class_name(v) }
+      end
+    end
+
+    def class_name(v)
+      MODULE_NAME.bind_call(KERNEL_CLASS.bind_call(v)) || "(anonymous)"
+    rescue TypeError
+      "BasicObject"
+    end
+
+    def sanitize(s)
+      s = s.dup.force_encoding(Encoding::UTF_8)
+      s = s.scrub("?")
+      s.gsub(/[\p{Cc}\p{Cf}]/) { |c| c == "\n" ? " " : "." }
+    rescue StandardError
+      "?"
+    end
+
+    def message(exc)
+      sanitize(EXC_MESSAGE.bind_call(exc).to_s.lines.first.to_s.chomp)
+    rescue Exception # rubocop:disable Lint/RescueException
+      ""
+    end
+
+    def exception(exc, code = "")
+      klass = MODULE_NAME.bind_call(KERNEL_CLASS.bind_call(exc)) || "Exception"
+      msg = message(exc)
+      info = { class_name: klass, message: msg }
+      case exc
+      when SyntaxError
+        info[:type] = :syntax
+        info.merge!(syntax_location(code))
+      when NoMethodError
+        info[:type] = :nomethod
+        info[:name] = safe_name(exc)
+        info[:receiver] = receiver_name(exc, msg)
+      when NameError
+        info[:type] = :name
+        info[:name] = safe_name(exc)
+      when TypeError
+        info[:type] = :type
+        info[:sides] = type_sides(msg)
+      when ArgumentError
+        info[:type] = :argument
+        info[:sides] = argument_sides(msg)
+      else
+        info[:type] = interrupt?(exc) ? :interrupt : :other
+      end
+      info
+    rescue StandardError
+      { type: :other, class_name: "Exception", message: "" }
+    end
+
+    def interrupt?(exc)
+      Interrupt === exc || (defined?(IRB::Abort) && IRB::Abort === exc)
+    end
+
+    def safe_name(exc)
+      n = NameError.instance_method(:name).bind_call(exc)
+      Symbol === n ? SYM_NAME.bind_call(n) : nil
+    rescue StandardError
+      nil
+    end
+
+    def receiver_name(exc, msg)
+      if (m = msg.match(/for (?:an instance of |)([A-Z][\w:]*|nil|true|false)/))
+        return m[1]
+      end
+      r = NameError.instance_method(:receiver).bind_call(exc)
+      Module === r ? MODULE_NAME.bind_call(r).to_s : class_name(r)
+    rescue StandardError
+      "?"
+    end
+
+    def syntax_location(code)
+      return {} unless defined?(Prism)
+      err = Prism.parse(code).errors.first
+      return {} unless err
+      loc = err.location
+      { line: loc.start_line, column: loc.start_column, detail: sanitize(err.message) }
+    rescue StandardError
+      {}
+    end
+
+    def type_sides(msg)
+      if (m = msg.match(/(?:no implicit conversion of|conversion of) (\S+) into (\S+)/))
+        [m[1], m[2]]
+      elsif (m = msg.match(/(\S+) can't be coerced into (\S+)/))
+        [m[1], m[2]]
+      elsif (m = msg.match(/wrong argument type (\S+) \(expected (\S+)\)/))
+        [m[1], m[2]]
+      else
+        %w[TYPE TYPE]
+      end
+    end
+
+    def argument_sides(msg)
+      if (m = msg.match(/given (\d+), expected ([\d.+\-]+)/))
+        ["given #{m[1]}", "expected #{m[2]}"]
+      elsif (m = msg.match(/(missing|unknown) keywords?: (.+)/))
+        [m[1], m[2][0, 20]]
+      else
+        %w[ARG ARG]
+      end
+    end
+  end
+end

data/lib/dopairb/reline_adapter.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module Dopairb
+  # Every dependency on Reline internals lives in this file.
+  #
+  # Tested with Reline 0.6.x. Public hooks used: add_dialog_proc,
+  # output_modifier_proc. Internal ones (prepended): LineEditor#input_key,
+  # #handle_signal (called every 10ms while Reline waits for a key -- our
+  # animation tick), #render, #render_finished, Core#readmultiline.
+  module RelineAdapter
+    SUPPORTED = Gem::Requirement.new(">= 0.5.0", "< 0.8")
+    DIALOGS = %i[dopa_strip dopa_trail dopa_hud].freeze
+    TICK = 1 / 30.0
+
+    class << self
+      attr_reader :fx, :editor
+
+      def supported?
+        defined?(Reline::VERSION) && SUPPORTED.satisfied_by?(Gem::Version.new(Reline::VERSION))
+      end
+
+      def install(fx)
+        @fx = fx
+        return false unless supported?
+        return true if @installed
+        Reline::LineEditor.prepend(LineEditorHook)
+        Reline::Core.prepend(CoreHook)
+        DIALOGS.each do |name|
+          kind = name.to_s.delete_prefix("dopa_").to_sym
+          Reline.add_dialog_proc(name, ->() { Dopairb::RelineAdapter.dialog(kind, self) }, nil)
+        end
+        @installed = true
+      end
+
+      def active?
+        @installed && Dopairb.active? && !@broken
+      end
+
+      def keys? = active? && Dopairb.config.keys
+
+      # Something went wrong inside our hooks: stop decorating, keep the REPL.
+      def broken!(e)
+        Dopairb.debug(e)
+        @broken = true
+      end
+
+      def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      # ---- called from hooks ------------------------------------------------
+
+      def before_read(core)
+        wrap_output_modifier(core)
+        @editor = core.line_editor
+        return unless keys?
+        @fx.reset_line
+        # Keep a lane of blank rows under the prompt for the effect strip.
+        n = InputFx::STRIP_ROWS
+        Term.write("\eD" * n + "\e[#{n}A")
+      end
+
+      def wrap_output_modifier(core)
+        orig = core.output_modifier_proc
+        return if orig&.instance_variable_get(:@dopairb)
+        memo = [nil, nil, nil]
+        wrapper = proc do |input, complete:|
+          # highlights re-render the same text many times; colorize it once
+          if memo[0] == input && memo[1] == complete
+            colored = memo[2]
+          else
+            colored = orig ? orig.call(input, complete: complete) : nil
+            memo.replace([input.dup, complete, colored])
+          end
+          if complete || !RelineAdapter.keys?
+            colored
+          else
+            begin
+              RelineAdapter.fx.apply(colored || Reline::Unicode.escape_for_print(input), input)
+            rescue StandardError => e
+              RelineAdapter.broken!(e)
+              colored
+            end
+          end
+        end
+        wrapper.instance_variable_set(:@dopairb, true)
+        core.output_modifier_proc = wrapper
+      end
+
+      def after_key(le, key, before, prev_x, pasting)
+        @editor = le
+        return if le.finished?
+        after = [le.whole_lines, le.instance_variable_get(:@line_index), le.instance_variable_get(:@byte_pointer)]
+        cur_x, = le.wrapped_cursor_position
+        @fx.on_key(key.method_symbol, before, after, prev_x: prev_x, cur_x: cur_x, pasting: pasting)
+      end
+
+      def layout(le)
+        key = [le.whole_lines, le.instance_variable_get(:@byte_pointer), le.instance_variable_get(:@line_index), le.screen_width, le.screen_scroll_top]
+        return @layout[1] if @layout && @layout[0] == key
+        lay = compute_layout(le)
+        @layout = [key.map { |k| k.frozen? ? k : k.dup }, lay]
+        lay
+      end
+
+      def compute_layout(le)
+        x, y = le.wrapped_cursor_position
+        top = le.screen_scroll_top
+        rows = le.wrapped_prompt_and_input_lines.flatten(1)
+        prompt, line = rows[y] || ["", ""]
+        InputFx::Layout.new(cursor_x: x, cursor_row: y - top,
+                            row_end_x: Term.str_width(prompt.to_s) + Term.str_width(line.to_s),
+                            last_row: rows.size - 1 - top, screen_width: le.screen_width,
+                            room_below: le.rest_height(y))
+      end
+
+      def dialog(kind, scope)
+        return nil unless keys? && @editor
+        lay = layout(@editor)
+        info = case kind
+               when :hud
+                 r = @fx.hud_render(lay)
+                 r && Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(r[0], -1), contents: r[1], height: 1)
+               when :trail
+                 r = @fx.trail_render(lay)
+                 r && Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(r[0], -1), contents: r[1], height: 1)
+               when :strip
+                 return nil if scope.completion_journey_data
+                 dy = lay.last_row - lay.cursor_row
+                 return nil if lay.room_below - dy < InputFx::STRIP_ROWS
+                 lines = @fx.strip_render(lay)
+                 lines && Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(0, dy), contents: lines,
+                                                       width: lay.screen_width - 1, height: InputFx::STRIP_ROWS)
+               end
+        info
+      rescue StandardError => e
+        broken!(e)
+        nil
+      end
+
+      def tick(le)
+        return unless keys?
+        t = now
+        return if @last_tick && t - @last_tick < TICK
+        @last_tick = t
+        @editor = le
+        return unless @fx.animating?(t)
+        le.__send__(:dopairb_refresh)
+      rescue StandardError => e
+        broken!(e)
+      end
+
+      def hl_dirty? = keys? && @fx.hl_dirty?
+
+      # Snapshot what render_finished is about to print.
+      def capture(le, rows, lines)
+        @last_input = InputShot.new(rows: rows, lines: lines, code: le.whole_buffer, screen_width: le.screen_width)
+      rescue StandardError => e
+        Dopairb.debug(e)
+        @last_input = nil
+      end
+
+      # The shot of the input that produced `code`, if it is still on screen.
+      def take_input(code)
+        shot = @last_input
+        @last_input = nil
+        return nil unless shot
+        return nil unless shot.code.chomp == code.chomp
+        return nil if shot.rows.size > Term.rows - 3
+        shot
+      end
+    end
+
+    module LineEditorHook
+      def input_key(key)
+        return super unless RelineAdapter.keys?
+        if @in_pasting
+          # keep pastes cheap: no layout work, just count
+          RelineAdapter.fx.on_key(nil, nil, nil, prev_x: nil, cur_x: nil, pasting: true) unless key.char.nil?
+          return super
+        end
+        before = nil
+        prev_x = nil
+        pasting = false
+        begin
+          before = [whole_lines.map(&:dup), @line_index, @byte_pointer]
+          prev_x, = wrapped_cursor_position
+        rescue StandardError => e
+          RelineAdapter.broken!(e)
+        end
+        result = super
+        if before
+          begin
+            RelineAdapter.after_key(self, key, before, prev_x, pasting)
+          rescue StandardError => e
+            RelineAdapter.broken!(e)
+          end
+        end
+        result
+      end
+
+      def handle_signal
+        super
+        RelineAdapter.tick(self) unless @in_pasting || finished?
+      end
+
+      def render
+        @cache.delete(:modified_lines) if RelineAdapter.hl_dirty?
+        super
+      end
+
+      def render_finished
+        if RelineAdapter.active?
+          begin
+            lines = []
+            rows = @buffer_of_lines.size.times.flat_map do |i|
+              prompt = Reline::Unicode.strip_non_printing_start_end(prompt_list[i])
+              line = prompt + modified_lines[i]
+              lines << [Term.str_width(prompt), whole_lines[i]]
+              wrapped = split_line_by_width(line, screen_width)
+              wrapped.last.empty? ? split_line_by_width("#{line} ", screen_width) : wrapped
+            end
+            RelineAdapter.capture(self, rows, lines)
+          rescue StandardError => e
+            Dopairb.debug(e)
+          end
+        end
+        super
+      end
+
+      private
+
+      def dopairb_refresh
+        x, y = wrapped_cursor_position
+        @dialogs.each do |d|
+          update_each_dialog(d, x, y - screen_scroll_top) if RelineAdapter::DIALOGS.include?(d.name)
+        end
+        render
+      end
+    end
+
+    module CoreHook
+      def readmultiline(prompt = "", add_hist = false, &block)
+        RelineAdapter.before_read(self) if RelineAdapter.active?
+        super
+      end
+    end
+  end
+end

data/lib/dopairb/scene.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Dopairb
+  # Snapshot of the submitted input as it sits on screen right above the cursor.
+  class InputShot
+    attr_reader :rows, :plain, :code, :prompt_widths, :lines, :screen_width
+
+    # rows: physical rows (with SGR) exactly as Reline printed them
+    # lines: [[prompt_width, code_line], ...] per logical line
+    def initialize(rows:, lines:, code:, screen_width:)
+      @rows = rows
+      @plain = rows.map { |r| r.gsub(/\e\[[\d;?]*[A-Za-z]/, "").gsub(/[\x01\x02]/, "") }
+      @lines = lines
+      @code = code
+      @screen_width = screen_width
+    end
+
+    def size = @rows.size
+
+    # [row, x] on screen of (logical line index, byte column)
+    def locate(line_idx, byte_col)
+      row = 0
+      @lines.each_with_index do |(pw, text), i|
+        if i == line_idx
+          prefix = text.byteslice(0, byte_col).to_s.scrub("?")
+          x = pw + Term.str_width(prefix)
+          return [row + x / @screen_width, x % @screen_width]
+        end
+        row += (pw + Term.str_width(text)) / @screen_width + 1
+      end
+      nil
+    end
+
+    # [[row, x, width], ...] for each word-bounded occurrence of name
+    def find(name)
+      return [] if name.nil? || name.empty?
+      hits = []
+      re = /(?<![\w@$])#{Regexp.escape(name)}(?![\w?!])/
+      @lines.each_with_index do |(_, text), i|
+        text.to_enum(:scan, re).each do
+          b = Regexp.last_match.byteoffset(0)[0]
+          pos = locate(i, b)
+          hits << [pos[0], pos[1], Term.str_width(name)] if pos
+        end
+      end
+      hits
+    end
+  end
+
+  # Everything a scene needs to know about where it is drawing.
+  Ctx = Struct.new(:w, :rows, :depth, :config, :rng, :input, :pre, :compact, keyword_init: true)
+
+  class Scene
+    attr_reader :ctx, :event
+
+    def initialize(ctx, event = nil)
+      @ctx = ctx
+      @event = event
+      @rng = ctx.rng
+      @w = ctx.w
+      setup
+    end
+
+    def setup; end
+
+    def height = 1
+    def length = 0.4
+    def top? = false
+    def big? = false
+    def mega? = false
+    def bell? = mega?
+    def trail = nil
+    def shake(_t) = 0
+    def flash_at = nil
+
+    # Wind-up before the main animation (input row glow); 0 when not wanted.
+    def pre = top? ? ctx.pre.to_f : 0.0
+    def total_length = pre + length
+
+    # Top rows (the input) as canvas, or nil to leave them untouched.
+    def draw_top(c, t)
+      return nil unless t < pre
+      glow_input(c, t / pre)
+      true
+    end
+
+    def draw(_c, _t); end
+
+    def w = @w
+    def depth = ctx.depth
+
+    def paint(text, col, bold: false)
+      return text if depth == :none && !bold
+      "#{Color.sgr(col, nil, bold, depth)}#{text}\e[0m"
+    end
+
+    def sub_bits(extra = [])
+      bits = extra.dup
+      return bits unless event
+      bits << "+#{Fx.number_with_commas(event.gain)}" if event.gain.to_i > 0
+      bits << "COMBO #{event.combo}" if event.combo.to_i > 1
+      bits << "NEW RECORD" if event.flag?(:new_record) && !bits.include?("NEW RECORD")
+      bits << "FIRST HIT" if event.flag?(:first_hit)
+      bits << "RECOVERED after #{event.streak} error#{'s' if event.streak > 1}" if event.flag?(:comeback)
+      bits
+    end
+
+    def sub_line(extra = [])
+      sub_bits(extra).join("   ")
+    end
+
+    protected
+
+    def plain_input(c, color = [150, 150, 160])
+      ctx.input.plain.each_with_index { |r, y| c.put(0, y, r, color) }
+    end
+
+    # A hot band sweeping across the submitted code: "EXECUTE".
+    def glow_input(c, p)
+      band = p * (@w + 16) - 8
+      ctx.input.plain.each_with_index do |r, y|
+        x = 0
+        r.each_char do |ch|
+          d = (x - band - y * 2).abs
+          col = d < 6 ? Color.mix([255, 255, 255], [255, 170, 40], d / 6.0) : [200, 200, 215]
+          bg = d < 3 ? Color.mix([255, 120, 0], [60, 20, 0], d / 3.0) : nil
+          c.put(x, y, ch, col, bg: bg, bold: d < 3)
+          x += ch.ord < 0x80 ? 1 : Term.char_width(ch)
+        end
+      end
+    end
+
+    def combo_palette(combo = event&.combo.to_i)
+      case combo
+      when 0..2 then Color::ICE
+      when 3..5 then Color::TOXIC
+      when 6..9 then Color::GOLD
+      when 10..19 then Color::FIRE
+      else Color::NEON
+      end
+    end
+
+    def combo_color(t = 0, combo = event&.combo.to_i)
+      return Color.rainbow(t * 1.5) if combo >= 20
+      Color.ramp(combo_palette(combo), 0.25)
+    end
+
+    def ease(t) = Fx.ease_out(t)
+
+    def best_scale(text)
+      ctx.compact ? nil : Fx.best_scale(text, @w)
+    end
+  end
+end