rstfilter 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acaf57f79e7bee11c42958205a4970e6c85a2de855f82513076e40eba42a5d4d
-  data.tar.gz: 540a4a20d663769298947079626f5ec8d4ff1d10d72d724d126d5a7a2f9400bd
+  metadata.gz: 493aaf26c129bbac2f2e56a62a59575e0805be44d4c48e2707da454cd51d2972
+  data.tar.gz: 164cbf3204c18b09c8dca6cb78c9059f13e49cd255c77fa793721479b337237a
 SHA512:
-  metadata.gz: a3371ad347e2797e051a9c9ac0621eca32022aae6b41ef859c961928e3b1159235e64e75e307901ca8dc17dba27e9e9e56d8646af02683b1eddc8eb2b68184a1
-  data.tar.gz: 7abd528a4b660261a2be171609191c16ee848348ad0e6adf7d7c5421ba3aabf4757be69657f3fb6c6b4195083c4c9102d85964a10d086189a843924a923684d2
+  metadata.gz: 0ff94c098b3f781a767c0887b30b8b24ebb58e909930ee70865d666f920d1ff50e9de7ed47a0072bd667d39da285682ef83591d81078c6f1d5cca63cc2b07a5c
+  data.tar.gz: 62b140c8dfde2082e39a132403f34d81b89a34c4993e814a3e847fed949ff5bf78e64125e3e7770268c4ee1d47d326252dbe25a9469a46cbb5a667bc360362e9

data/.github/workflows/ruby.yml

@@ -0,0 +1,38 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.7', '3.0', '3.1', 'head', 'debug']
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@2b019609e2b0f1ea1a2bc8ca11cb82ab46ada124
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake

data/README.md

@@ -1,3 +1,5 @@
+[![GH Actions](https://github.com/ko1/rstfilter/actions/workflows/ruby.yml/badge.svg)](https://github.com/ko1/rstfilter/actions/workflows/ruby.yml)
+
 # Rstfilter
 
 This tool prints a Ruby script with execution results.
@@ -9,7 +11,7 @@ b = 2
 c = a + b
 puts "Hello" * c
 
-$ rstfilter sample.rb -a
+$ rstfilter sample.rb -o
 a = 1                                              #=> 1
 b = 2                                              #=> 2
 c = a + b                                          #=> 3
@@ -41,12 +43,51 @@ Usage: rstfilter [options] SCRIPT
     -o, --output                     Show output results
     -d, --decl                       Show results on declaration
         --no-exception               Do not show exception
-    -a, --all                        Show all results/output
         --pp                         Use pp to represent objects
+    -n, --nextline                   Put comments on next line
         --comment-indent=NUM         Specify comment indent size (default: 50)
+        --comment-pattern=PAT        Specify comment pattern of -c (default: '#=>')
+        --coment-label=LABEL         Specify comment label (default: "")
+    -e, --command=COMMAND            Execute Ruby script with given command
+        --no-filename                Execute -e command without filename
+    -j, --json                       Print records in JSON format
+        --ignore-pragma              Ignore pragma specifiers
         --verbose                    Verbose mode
 ```
 
+Note that you can specify multiple `-e` options like that:
+
+```
+$ rstfilter -o sample.rb -eruby27:/home/ko1/.rbenv/versions/2.7.6/bin/ruby -e ruby30:/home/ko1/.rbenv/versions/3.0.4/bin/ruby
+a = 1
+#=> ruby27: 1
+#=> ruby30: 1
+b = 2
+#=> ruby27: 2
+#=> ruby30: 2
+c = a + b
+#=> ruby27: 3
+#=> ruby30: 3
+puts "Hello" * c
+#=> ruby27: nil
+#=> ruby30: nil
+#ruby27:out: HelloHelloHello
+#ruby30:out: HelloHelloHello
+```
+
+On this case, you can check results on multiple Ruby interpreters.
+
+## Advanced demo
+
+https://user-images.githubusercontent.com/9558/170426066-e0c19185-10e9-4932-a1ce-3088a4189b34.mp4
+
+This video shows advanced usage to show the results with modified script immediately.
+
+* [kv](https://rubygems.org/gems/kv) is another pager.
+* `kv -w SCRIPT` monitors SCRIPT file modification and reload it immediately.
+* `kv --filter-process=cmd SCRIPT` shows the result of `cmd FILE` as a filter.
+* Combination: `kv -w --filter-command='rstfilter -a' SCRIPT` shows modified script with execution results.
+
 ## Implementation
 
 With parser gem, rstfilter translates the given script and run it.
@@ -70,3 +111,8 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/ko1/rs
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Aside
+
+* My motivation of this tool is to make it easy to annotate the script with execution results. For example, Ruby developer's meeting generates many code like: https://github.com/ruby/dev-meeting-log/blob/master/DevMeeting-2022-05-19.md
+* The name "Rst" stands for "Result". This tool is inspired from [xmpfilter](https://github.com/rcodetools/rcodetools/blob/master/lib/rcodetools/xmpfilter.rb) and original author Gotoken-san told me that "xmp" is stand for "Example" (he had wanted to make a support tool for lectures). Respect to the "xmp" mysterious word, I choosed "Rst".

data/exe/rstfilter-lsp

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/rstfilter/lsp/handler'
+
+RstFilter::LSP.new.start

data/lib/rstfilter/exec.rb

@@ -0,0 +1,330 @@
+require 'optparse'
+require 'shellwords'
+
+module RstFilter
+  class Exec
+    def update_opt opt = {}
+      opt = @opt.to_h.merge(opt)
+      @opt = ConfigOption.new(**opt)
+    end
+
+    attr_reader :output
+
+    def initialize opt = {}
+      @output = ''
+      @opt = ConfigOption.new(**DEFAULT_SETTING)
+      update_opt opt
+    end
+
+    DEFAULT_SETTING = {
+      # rewrite options
+      show_all_results: true,
+      show_exceptions: true,
+      show_output: false,
+      show_decl: false,
+      show_specific_line: nil,
+
+      use_pp: false,
+      comment_nextline: false,
+      comment_indent: 50,
+      comment_pattern: '#=>',
+      comment_label: nil,
+
+      # execute options
+      exec_command: false, # false: simply load file
+                           # String value: launch given string as a command
+      exec_with_filename: true,
+
+      # dump
+      dump: nil, # :json
+
+      # general
+      verbose: false,
+      ignore_pragma: false,
+    }
+
+    ConfigOption = Struct.new(*DEFAULT_SETTING.keys, keyword_init: true)
+    Command = Struct.new(:label, :command)
+
+    def optparse! argv
+      opt = {}
+      o = OptionParser.new
+      o.on('-c', '--comment', 'Show result only on comment'){
+        opt[:show_all_results] = false
+      }
+      o.on('-o', '--output', 'Show output results'){
+        opt[:show_output] = true
+      }
+      o.on('-d', '--decl', 'Show results on declaration'){
+        opt[:show_decl] = true
+      }
+      o.on('--no-exception', 'Do not show exception'){
+        opt[:show_exception] = false
+      }
+      o.on('--pp', 'Use pp to represent objects'){
+        opt[:use_pp] = true
+      }
+      o.on('-n', '--nextline', 'Put comments on next line'){
+        opt[:comment_nextline] = true
+      }
+      o.on('--comment-indent=NUM', "Specify comment indent size (default: #{DEFAULT_SETTING[:comment_indent]})"){|n|
+        opt[:comment_indent] = n.to_i
+      }
+      o.on('--comment-pattern=PAT', "Specify comment pattern of -c (default: '#=>')"){|pat|
+        opt[:comment_pattern] = pat
+      }
+      o.on('--coment-label=LABEL', 'Specify comment label (default: "")'){|label|
+        opt[:comment_label] = label
+      }
+      o.on('--verbose', 'Verbose mode'){
+        opt[:verbose] = true
+      }
+      o.on('-e', '--command=COMMAND', 'Execute Ruby script with given command'){|cmdstr|
+        opt[:exec_command] ||= []
+
+        if /\A(.+):(.+)\z/ =~ cmdstr
+          cmd = Command.new($1, $2)
+        else
+          cmd = Command.new("e#{(opt[:exec_command]&.size || 0) + 1}", cmdstr)
+        end
+
+        opt[:exec_command] << cmd
+      }
+      o.on('--no-filename', 'Execute -e command without filename'){
+        opt[:exec_with_filename] = false
+      }
+      o.on('-j', '--json', 'Print records in JSON format'){
+        opt[:dump] = :json
+      }
+      o.on('--ignore-pragma', 'Ignore pragma specifiers'){
+        opt[:ignore_pragma] = true
+      }
+      o.on('--verbose', 'Verbose mode'){
+        opt[:verbose] = true
+      }
+      o.parse!(argv)
+      update_opt opt
+    end
+
+    def err msg
+      msg.each_line{|line|
+        STDERR.puts "[RstFilter] #{line}"
+      }
+    end
+
+    def comment_label
+      if l = @opt.comment_label
+        "#{l}: "
+      end
+    end
+
+    def puts_result prefix, results, line = nil
+      prefix = prefix.chomp
+
+      if results.size == 1
+        r = results.first
+        result_lines = r.lines
+        indent = ''
+
+        if @opt.comment_nextline
+          puts prefix
+          if prefix.match(/\A(\s+)/)
+            prefix = ' ' * $1.size
+          else
+            prefix = ''
+          end
+          puts "#{prefix}" + "#{@opt.comment_pattern}#{comment_label}#{result_lines.shift}"
+        else
+          if line
+            puts line.sub(/#{@opt.comment_pattern}.*$/, "#{@opt.comment_pattern} #{comment_label}#{result_lines.shift.chomp}")
+          else
+            indent = ' ' * [0, @opt.comment_indent - prefix.size].max
+            puts "#{prefix}#{indent} #=> #{comment_label}#{result_lines.shift}"
+          end
+        end
+
+        cont_comment = ' #' + ' ' * @opt.comment_pattern.size + ' '
+
+        result_lines.each{|result_line|
+          puts ' ' * prefix.size + indent + "#{cont_comment}#{result_line}"
+        }
+      else
+        puts prefix
+
+        if prefix.match(/\A(\s+)/)
+          prefix = ' ' * $1.size
+        else
+          prefix = ''
+        end
+
+        results.each.with_index{|r, i|
+          result_lines = r.lines
+          puts "#{prefix}#{@opt.comment_pattern} #{@opt.exec_command[i].label}: #{result_lines.first}"
+        }
+      end
+    end
+
+    def exec_mod_src mod_src
+      # execute modified src
+      ENV['RSTFILTER_SHOW_OUTPUT'] = @opt.show_output ? '1' : nil
+      ENV['RSTFILTER_SHOW_EXCEPTIONS'] = @opt.show_exceptions ? '1' : nil
+      ENV['RSTFILTER_FILENAME'] = @filename
+      ENV['RSTFILTER_PP'] = @opt.use_pp ? '1' : nil
+
+      case cs = @opt.exec_command
+      when Array
+        @output = String.new
+
+        cs.map do |c|
+          require 'tempfile'
+          recf = Tempfile.new('rstfilter-rec')
+          ENV['RSTFILTER_RECORD_PATH'] = recf.path
+          recf.close
+
+          modf = Tempfile.new('rstfilter-modsrc')
+          modf.write mod_src
+          modf.close
+          ENV['RSTFILTER_MOD_SRC_PATH'] = modf.path
+
+          ENV['RUBYOPT'] = "-r#{File.join(__dir__, 'exec_setup')} #{ENV['RUBYOPT']}"
+
+          cmd = c.command
+          cmd << ' ' + @filename if @opt.exec_with_filename
+          p exec:cmd if @opt.verbose
+
+          io = IO.popen(cmd, err: [:child, :out])
+          begin
+            Process.waitpid(io.pid)
+          ensure
+            begin
+              Process.kill(:KILL, io.pid)
+            rescue Errno::ESRCH
+            end
+          end
+
+          @output << io.read
+          open(recf.path){|f| Marshal.load f}
+        end
+      else
+        begin
+          begin
+            require_relative 'exec_setup'
+            ::RSTFILTER__.clear
+            ::TOPLEVEL_BINDING.eval(mod_src, @filename)
+            [::RSTFILTER__.records]
+          ensure
+            $stdout = $__rst_filter_prev_out if $__rst_filter_prev_out
+            $stderr = $__rst_filter_prev_err if $__rst_filter_prev_err
+          end
+        rescue Exception => e
+          if @opt.verbose
+            err e.inspect
+            err e.backtrace.join("\n")
+          else
+            err "exit with #{e.inspect}"
+          end
+          [::RSTFILTER__.records]
+        end
+      end
+    end
+
+    def modified_src src, filename = nil
+      rewriter = Rewriter.new @opt
+      rewriter.rewrite(src, filename)
+    end
+
+    def record_records filename
+      @filename = filename
+      src = File.read(filename)
+      src, mod_src, comments = modified_src(src, filename)
+
+      comments.each{|c|
+        case c.text
+        when /\A\#rstfilter\s(.+)/
+          optparse! Shellwords.split($1)
+        end
+      } unless @opt.ignore_pragma
+
+      return exec_mod_src(mod_src), src, comments
+    end
+
+    def make_line_records rs
+      lrs = {}
+      rs.each{|(_bl, _bc, el, _ec), result|
+        lrs[el] = result
+      }
+      lrs
+    end
+
+    def process filename
+      records, src, comments = record_records filename
+      pp records: records if @opt.verbose
+      line_records = records.map{|r|
+        make_line_records r
+      }
+
+      case @opt.dump
+      when :json
+        require 'json'
+        puts JSON.dump(records)
+      else
+        replace_comments = comments.filter_map{|c|
+          next unless c.text.start_with? @opt.comment_pattern
+          e = c.loc.expression
+          [e.begin.line, true]
+        }.to_h
+
+        src.each_line.with_index{|line, i|
+          lineno = i+1
+          line_results = line_records.map{|r| r[lineno]&.first}.compact
+
+          if line_results.empty?
+            puts line
+          else
+            if replace_comments[lineno]
+              line.match(/(.+)#{@opt.comment_pattern}.*$/) || raise("unreachable")
+              puts_result $1, line_results, line
+            elsif @opt.show_all_results
+              puts_result line, line_results
+            end
+          end
+
+          if @opt.show_output && !line_results.empty?
+            if m = line.match(/^\s+/)
+              indent = ' ' * m[0].size
+            else
+              indent = ''
+            end
+
+            line_outputs = line_records.map{|r| r[lineno]}.compact
+            line_outputs.each.with_index{|r, i|
+              out, err = *r[1..2]
+              label = @opt.exec_command && @opt.exec_command[i].label
+              label += ':' if label
+
+              {out: out, err: err}.each{|k, o|
+                o.strip!
+                o.each_line{|ol|
+                  puts "#{indent}\##{label ? label : nil}#{k}: #{ol}"
+                } unless o.empty?
+              }
+            }
+          end
+        }
+
+        if !@opt.show_output && !@output.empty?
+          puts "# output"
+          puts output
+        end
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  require_relative 'rewriter'
+  filter = RstFilter::Exec.new
+  filter.optparse! ['-v']
+  file = ARGV.shift || File.expand_path(__dir__ + '/../../sample.rb')
+  filter.process File.expand_path(file)
+end

data/lib/rstfilter/exec_setup.rb

@@ -0,0 +1,95 @@
+require 'stringio'
+
+if defined?(RSTFILTER__)
+  Object.remove_const :RSTFILTER__
+end
+
+class RSTFILTER__
+  SHOW_EXCEPTION = ENV['RSTFILTER_SHOW_EXCEPTIONS']
+
+  if ::ENV['RSTFILTER_PP']
+    require 'pp'
+    def self.__rst_inspect_body__ val
+      ::PP.pp(val, '')
+    end
+  else
+    def self.__rst_inspect_body__ val
+      val.inspect
+    end
+  end
+
+  def self.__rst_inspect__ val
+    begin
+      __rst_inspect_body__ val
+    rescue Exception => e
+      "!! __rst_inspect__ failed: #{e}"
+    end
+  end
+
+  @@records = {}
+
+  def self.records
+    @@records
+  end
+
+  def self.clear
+    @@records.clear
+  end
+
+  def self.write begin_line, begin_col, end_line, end_col, val, prefix
+    # p [begin_line, begin_col, end_line, end_col]
+    out, err = *[$__rst_filter_captured_out, $__rst_filter_captured_err].map{|o|
+      str = o.string
+      o.string = ''
+      str
+    } if $__rst_filter_captured_out
+
+    @@records[[begin_line, begin_col, end_line, end_col]] = ["#{prefix}#{__rst_inspect__(val)}", out, err]
+  end
+
+  def self.record begin_line, begin_col, end_line, end_col
+    r = yield
+    write begin_line, begin_col, end_line, end_col, r, nil
+    r
+  rescue Exception => e
+    write begin_line, begin_col, end_line, end_col, e, 'raised '
+    raise
+  end
+end
+
+if ENV['RSTFILTER_SHOW_OUTPUT']
+  $__rst_filter_prev_out = $stdout
+  $__rst_filter_prev_err = $stderr
+
+  $__rst_filter_captured_out = $stdout = StringIO.new
+  if false # debug
+    $__rst_filter_captured_err = $captured_out
+  else
+    $__rst_filter_captured_err = $stderr = StringIO.new
+  end
+else
+  $__rst_filter_prev_out = $__rst_filter_prev_err = nil
+  $__rst_filter_captured_out = $__rst_filter_captured_err = nil
+end
+
+if path = ENV['RSTFILTER_RECORD_PATH']
+  # inter-process communication
+
+  END{
+    open(path, 'wb'){|f|
+      f.write Marshal.dump(::RSTFILTER__.records)
+    }
+  }
+
+  class RubyVM::InstructionSequence
+    RST_FILENAME = ENV['RSTFILTER_FILENAME']
+    RST_MOD_SRC = File.read(ENV['RSTFILTER_MOD_SRC_PATH'])
+    @found = false
+    def self.translate iseq
+      if !@found && iseq.path == RST_FILENAME && iseq.label == "<main>"
+        @found = true
+        RubyVM::InstructionSequence.compile RST_MOD_SRC, RST_FILENAME
+      end
+    end
+  end
+end

data/lib/rstfilter/lsp/handler.rb

@@ -0,0 +1,291 @@
+require 'json'
+require_relative '../version'
+require_relative '../rewriter'
+require_relative '../exec'
+
+module RstFilter
+  class LSP
+    def initialize input: $stdin, output: $stdout, err: $stderr, indent: 50
+      @input   = input
+      @output  = output
+      @err     = err
+      @indent  = indent
+      @records = {} # {filename => [record, line_record, src]}
+      @server_request_id = 0
+      @exit_status = 1
+      @running = {} # id for cancel
+    end
+
+    def self.reload
+      ::RstFilter.send(:remove_const, :LSP)
+      $".delete_if{|e| /lsp\/handler\.rb$/ =~ e}
+      require __FILE__
+    end
+
+    def start
+      # for reload
+      trap(:USR1){
+        Thread.main.raise "reload"
+      }
+
+      lsp = self
+      begin
+        lsp.event_loop
+      rescue Exception => e
+        log e
+        log e.backtrace
+
+        # reload
+        lsp.class.reload
+        lsp = RstFilter::LSP.new
+        retry
+      end
+    end
+
+    def event_loop
+      while req = recv_message
+        if req[:id]
+          handle_request req
+        else
+          handle_notification req
+        end
+      end
+    end
+
+    def log msg
+      @err.puts msg
+    end
+
+    def recv_message
+      log "wait from #{@input.inspect}"
+      line = @input.gets 
+      line.match(/Content-Length: (\d+)/) || raise("irregular json-rpc: #{line}")
+      @input.gets
+      msg = JSON.parse(@input.read($1.to_i), symbolize_names: true)
+      log "[recv] #{msg.inspect}"
+      msg
+    end
+
+    def send_message type, msg_text
+      log "[#{type}] #{msg_text}"
+
+      text = "Content-Length: #{msg_text.size}\r\n" \
+          "\r\n" \
+          "#{msg_text}"
+      @output.write text
+      @output.flush
+      if true
+        log '----'
+        log text
+        log '----'
+      end
+    end
+
+    def send_response req, kw
+      res_text = JSON.dump({
+        jsonrpc: "2.0",
+        id: req[:id],
+        result: kw,
+      })
+
+      send_message 'response', res_text
+    end
+
+    def send_request method, kw = {}
+      msg_text = JSON.dump({
+        jsonrpc: "2.0",
+        method: method,
+        id: (@server_request_id+=1),
+        params: {
+          **kw
+        }
+      })
+
+      send_message 'request', msg_text
+    end
+
+    def send_notice method, kw = {}
+      msg_text = JSON.dump({
+        jsonrpc: "2.0",
+        method: method,
+        params: {
+          **kw
+        }
+      })
+      send_message "notice", msg_text
+    end
+
+    def handle_request req
+      if req[:error]
+        log "error: #{req.inspect}"
+        return
+      end
+
+      case req[:method]
+      when 'initialize'
+        send_response req, {
+          capabilities: {
+            textDocumentSync: {
+              openClose: true,
+              change: 2, # Incremental
+              save: true,
+            },
+
+            inlineValueProvider: true,
+
+            hoverProvider: true,
+
+            inlayHintProvider: {
+              resolveProvider: true,
+            },
+
+          },
+          serverInfo: {
+            name: "rstfilter-lsp-server",
+            version: '0.0.1',
+          }
+        }
+      when 'textDocument/hover'
+        filename = uri2filename req.dig(:params, :textDocument, :uri)
+        line = req.dig(:params, :position, :line)
+        char = req.dig(:params, :position, :character)
+        if (record, _line_record, src = @records[filename])
+          line += 1
+          rs = record.find_all{|(bl, bc, el, ec), _v| cover?(line, char, bl, bc, el, ec)}
+          if rs.empty?
+            send_response req, nil
+            else
+              r = rs.min_by{|(_bl, _bc, _el, ec), _v| ec}
+              v = r[1][0].strip
+              pos = r[0]
+              send_response req, contents: {
+                kind: 'markdown',
+                value: "```\n#{v}```",
+              }, range: {
+                start: {line: pos[0]-1, character: pos[1],},
+                end:   {line: pos[2]-1, character: pos[3],},
+              }
+            end
+        else
+          send_response req, nil
+        end
+      when 'textDocument/codeLens'
+        filename = uri2filename req.dig(:params, :textDocument, :uri)
+        send_response req, codelens(filename)
+      when 'textDocument/inlayHint'
+        filename = uri2filename req.dig(:params, :textDocument, :uri)
+        send_response req, inlayhints(filename)
+      when 'inlayHint/resolve'
+        hint = req.dig(:params)
+        send_response req, {
+          position: hint[:position],
+
+          label: [{
+            tooltip: {
+              kind: 'markdown',
+              value: hint[:label] + "\n 1. *foo* `bar` _baz_",
+              tooltip: hint[:label] + "\n 1. *foo* `bar` _baz_",
+            }
+          },
+          {
+            kind: 'markdown',
+            value: hint[:label] + "\n# 2. FOO\n*foo* `bar` _baz_",
+          }],
+        }
+      when 'shutdown'
+        @exit_status = 0
+        send_response req, nil
+      when nil
+        # reply
+      else
+        raise "unknown request: #{req.inspect}"
+      end
+    end
+
+    def cover? line, char, bl, bc, el, ec
+      return false if bl > line
+      return false if bl == line && char < bc
+      return false if el < line
+      return false if el == line && char >= ec
+      true
+    end
+
+    def inlayhints filename
+      if (_record, line_record, src = @records[filename])
+        src_lines = src.lines.to_a
+
+        line_record.sort_by{|k, v| k}.map do |lineno, r|
+          line = src_lines[lineno - 1]
+          next unless line
+
+          {
+            position: {
+              line: lineno - 1, # 0 origin
+              character: line.length,
+            },
+            label: ' ' * [@indent - line.size, 3].max + "#=> #{r.first.strip}",
+            # tooltip: "tooltip of #{lineno}",
+            paddingLeft: true,
+            kind: 1,
+          }
+        end.compact
+      else
+        nil
+      end
+    end
+
+    def take_record filename
+      send_notice 'rstfilter/start', {
+        uri: filename,
+      }
+      Thread.new do
+        filter = RstFilter::Exec.new
+        filter.optparse! ['--pp', '-eruby']
+        records, src, _comments = filter.record_records(filename)
+        records = records.first # only 1 process results
+        @records[filename] = [records, filter.make_line_records(records), src]
+        send_notice 'rstfilter/done'
+        unless filter.output.empty?
+          send_notice 'rstfilter/output', output: "# Output for #{filename}\n\n#{filter.output}"
+        end
+        send_request 'workspace/inlayHint/refresh'
+      end
+    end
+
+    def clear_record filename
+      @records[filename] = nil
+    end
+
+    def uri2filename uri
+      case uri
+      when /^file:\/\/(.+)/
+        $1
+      else
+        raise "unknown uri: #{uri}"
+      end
+    end
+
+    def handle_notification req
+      case req[:method]
+      when 'initialized'
+        send_notice 'rstfilter/version', {
+          version: "#{::RstFilter::VERSION} on #{RUBY_DESCRIPTION}",
+        }
+      when 'textDocument/didOpen',
+           'textDocument/didSave'
+        filename = uri2filename req.dig(:params, :textDocument, :uri)
+        take_record filename
+      when 'textDocument/didClose',
+           'textDocument/didChange'
+        filename = uri2filename req.dig(:params, :textDocument, :uri)
+        clear_record filename
+      when '$/cancelRequest'
+        # TODO: cancel
+      when 'exit'
+        exit(@exit_code)
+      else
+        raise
+      end
+    end
+  end
+end

data/lib/rstfilter/rewriter.rb

@@ -0,0 +1,182 @@
+
+require 'parser/current'
+require 'pp'
+
+module RstFilter
+  class RecordAll < Parser::TreeRewriter
+    def initialize opt
+      @decl = opt.show_decl || (opt.show_all_results == false)
+
+      super()
+    end
+
+    def add_record node
+      if le = node&.location&.expression
+        pos = [le.begin.line, le.begin.column, le.end.line, le.end.column].join(',')
+        insert_before(le.begin, "::RSTFILTER__.record(#{pos}){")
+        insert_after(le.end, "}")
+      end
+    end
+
+    def add_paren node
+      if le = node&.location&.expression
+        insert_before(le.begin, '(')
+        insert_after(le.end, ")")
+      end
+    end
+
+    def process node
+      return unless node
+
+      super
+
+      case node.type
+      when :begin,
+           :resbody, :rescue,
+           :ensure,
+           :return,
+           :next,
+           :redo,
+           :retry,
+           :splat,
+           :block_pass,
+           :lvasgn,
+           :when
+        # skip
+      when :def, :class
+        add_record node if @decl
+      when :if
+        unless node.loc.expression.source.start_with? 'elsif'
+          add_record node
+        end
+      else
+        add_record node
+      end
+    end
+
+    def on_dstr node
+    end
+
+    def on_regexp node
+    end
+
+    def on_const node
+    end
+
+    def on_masgn node
+      _mlhs, rhs = node.children
+      if rhs.type == :array
+        rhs.children.each{|r| process r}
+      end
+    end
+
+    def on_class node
+      _name, sup, body = node.children
+      process sup
+      process body
+    end
+
+    def on_module node
+      _name, body = node.children
+      process body
+    end
+
+    def process_args args
+      args.children.each{|arg|
+        case arg.type
+        when :optarg
+          _name, opexpr = arg.children
+          process opexpr
+        when :kwoptarg
+          _name, kwexpr = arg.children
+          process kwexpr
+        end
+      }
+    end
+
+    def on_def node
+      _name, args, body = node.children
+      process_args args
+      process body
+    end
+
+    def on_defs node
+      recv, _name, args, body = node.children
+      process recv
+      add_paren recv
+      process_args args
+      process body
+    end
+
+    def process_pairs pairs
+      pairs.each{|pair|
+        key, val = pair.children
+        if key.type != :sym
+          process key
+        end
+        process val
+      }
+    end
+
+    def on_hash node
+      process_pairs node.children
+    end
+
+    def on_send node
+      recv, _name, *args = *node.children
+      process recv if recv
+
+      args.each{|arg|
+        if arg.type == :hash
+          process_pairs arg.children
+        else
+          process arg
+        end
+      }
+    end
+
+    def on_block node
+      _send, _args, block = *node.children
+      process block
+    end
+
+    def on_numblock node
+      on_block node
+    end
+  end
+
+  class Rewriter
+    def initialize opt
+      @opt = opt
+    end
+
+    def rewrite src, filename
+      begin
+        prev_v, $VERBOSE = $VERBOSE, false
+        ast = RubyVM::AbstractSyntaxTree.parse(src)
+        $VERBOSE = prev_v
+        last_lineno = ast.last_lineno
+      rescue SyntaxError => e
+        err e.inspect
+        exit 1
+      end
+
+      # rewrite
+      src           = src.lines[0..last_lineno].join # remove __END__ and later
+      ast, comments = Parser::CurrentRuby.parse_with_comments(src)
+      buffer        = Parser::Source::Buffer.new('(example)')
+      buffer.source = src
+      rewriter      = RecordAll.new @opt
+      mod_src       = rewriter.rewrite(buffer, ast)
+
+      if @opt.verbose
+        pp ast
+        puts "     #{(0...80).map{|i| i%10}.join}"
+        puts mod_src.lines.map.with_index{|line, i| '%4d:%s' % [i+1, line] }
+      end
+
+      return src, mod_src, comments
+    end
+  end
+end
+

data/lib/rstfilter/version.rb

@@ -1,3 +1,3 @@
-module Rstfilter
-  VERSION = "0.1.0"
+module RstFilter
+  VERSION = "0.2.0"
 end

data/lib/rstfilter.rb

@@ -1,287 +1,11 @@
 # require "rstfilter/version"
 
-require 'parser/current'
-require 'stringio'
-require 'optparse'
-require 'ostruct'
-require 'pp'
-
-module RstFilter
-  class RecordAll < Parser::TreeRewriter
-    def initialize opt
-      @decl = opt.show_decl || (opt.show_all_results == false)
-
-      super()
-    end
-
-    def add_record node
-      if le = node&.location&.expression
-        insert_before(le.begin, '(')
-        insert_after(le.end, ").__rst_record__(#{le.end.line}, #{le.end.column})")
-      end
-    end
-
-    def process node
-      return unless node
-      case node.type
-      when :resbody, :rescue, :begin
-        # skip
-      when :def, :class
-        add_record node if @decl
-      else
-        add_record node
-      end
-
-      super
-    end
-
-    def on_class node
-      _name, sup, body = node.children
-      process sup
-      process body
-    end
-
-    def on_def node
-      _name, args, body = node.children
-      args.children.each{|arg|
-        case arg.type
-        when :optarg
-          _name, opexpr = arg.children
-          process opexpr
-        when :kwoptarg
-          _name, kwexpr = arg.children
-          process kwexpr
-        end
-      }
-      process body
-    end
-
-    def on_send node
-    end
-  end
-
-  class Exec
-    DEFAULT_SETTING = {
-      # default setting
-      show_all_results: true,
-      show_exceptions: true,
-      show_output: false,
-      show_decl: false,
-      show_specific_line: nil,
-
-      use_pp: false,
-      comment_indent: 50,
-      comment_pattern: '#=>',
-      verbose: false,
-    }
-
-    ConfigOption = Struct.new(*DEFAULT_SETTING.keys, keyword_init: true)
-
-    def update_opt opt = {}
-      opt = @opt.to_h.merge(opt)
-      @opt = ConfigOption.new(**opt)
-    end
-    
-    def initialize
-      @opt = ConfigOption.new(**DEFAULT_SETTING)
-    end
-
-    def optparse! argv
-      opt = {}
-      o = OptionParser.new
-      o.on('-c', '--comment', 'Show result only on comment'){
-        opt[:show_all_results] = false
-      }
-      o.on('-o', '--output', 'Show output results'){
-        opt[:show_output] = true
-      }
-      o.on('-d', '--decl', 'Show results on declaration'){
-        opt[:show_decl] = true
-      }
-      o.on('--no-exception', 'Do not show exception'){
-        opt[:show_exception] = false
-      }
-      o.on('-a', '--all', 'Show all results/output'){
-        opt[:show_output]      = true
-        opt[:show_all_results] = true
-        opt[:show_exceptions]  = true
-      }
-      o.on('--pp', 'Use pp to represent objects'){
-        opt[:use_pp] = true
-      }
-      o.on('--comment-indent=NUM', "Specify comment indent size (default: #{DEFAULT_SETTING[:comment_indent]})"){|n|
-        opt[:comment_indent] = n.to_i
-      }
-      o.on('--verbose', 'Verbose mode'){
-        opt[:verbose] = true
-      }
-      o.parse!(argv)
-      update_opt opt
-    end
-
-    def capture_out
-      return yield unless @opt.show_output
-
-      begin
-        prev_out = $stdout
-        prev_err = $stderr
-
-        $captured_out = $stdout = StringIO.new
-        if false # debug
-          $captured_err = $captured_out
-        else
-          $captured_err = $stderr = StringIO.new
-        end
-
-        yield
-      ensure
-        $stdout = prev_out
-        $stderr = prev_err
-      end
-    end
-
-    def record_rescue
-      if @opt.show_exceptions
-        TracePoint.new(:raise) do |tp|
-          caller_locations.each{|loc|
-            if loc.path == @filename
-              $__rst_record[loc.lineno][0] = [tp.raised_exception, '', '']
-              break
-            end
-          }
-        end.enable do
-          yield
-        end
-      else
-        yield
-      end
-    end
-
-    class ::BasicObject
-      def __rst_record__ line, col
-        out, err = *[$captured_out, $captured_err].map{|o|
-          str = o.string
-          o.string = ''
-          str
-        } if $captured_out
-
-        # ::STDERR.puts [line, col, self, out, err].inspect
-        $__rst_record[line][col] = [self, out, err]
-
-        self
-      end
-    end
-
-    $__rst_record = Hash.new{|h, k| h[k] = []}
-
-    def process filename
-      @filename = filename
-
-      code = File.read(filename)
-
-      begin
-        ast, comments = Parser::CurrentRuby.parse_with_comments(code)
-      rescue Parser::SyntaxError => e
-        puts e
-        exit 1
-      end
-
-      end_line = ast.loc.expression.end.line
-      code = code.lines[0..end_line].join # remove __END__ and later
-
-      buffer        = Parser::Source::Buffer.new('(example)')
-      buffer.source = code
-      rewriter      = RecordAll.new @opt
-
-      mod_src = rewriter.rewrite(buffer, ast)
-      puts mod_src.lines.map.with_index{|line, i| '%4d: %s' % [i+1, line] } if @opt.verbose
-
-      begin
-        capture_out do
-          record_rescue do
-            ::TOPLEVEL_BINDING.eval(mod_src, filename)
-          end
-        end
-      rescue Exception => e
-        if @opt.verbose
-          STDERR.puts e
-          STDERR.puts e.backtrace
-        else
-          STDERR.puts "RstFilter: exit with #{e.inspect}"
-        end
-      end
-
-      replace_comments = {}
-
-      comments.each{|c|
-        next unless c.text.start_with? @opt.comment_pattern
-        e = c.loc.expression
-        line, _col = e.begin.line, e.begin.column
-        if $__rst_record.has_key? line
-          result = $__rst_record[line].last
-          replace_comments[line] = result
-        end
-      }
-
-      pp $__rst_record if @opt.verbose
-
-      code.each_line.with_index{|line, i|
-        line_result = $__rst_record[i+1]&.last
-
-        if line_result && line.match(/(.+)#{@opt.comment_pattern}.*$/)
-          prefix = $1
-          r = line_result.first
-          if @opt.use_pp
-            result_lines = PP.pp(r, '').lines
-          else
-            result_lines = r.inspect.lines
-          end
-          puts line.sub(/#{@opt.comment_pattern}.*$/, "#{@opt.comment_pattern} #{result_lines.shift.chomp}")
-          cont_comment = '#' + ' ' * @opt.comment_pattern.size
-          result_lines.each{|result_line|
-            puts ' ' * prefix.size + "#{cont_comment}#{result_line}"
-          }
-        elsif @opt.show_all_results && line_result
-          r = line_result.first
-          indent = ' ' * [@opt.comment_indent - line.chomp.length, 0].max
-          if @opt.use_pp
-            result_lines = PP.pp(r, '').lines
-          else
-            result_lines = r.inspect.lines
-          end
-          prefix = line.chomp.concat "#{indent}"
-          puts "#{prefix} #=> #{result_lines.shift}"
-          cont_comment = '#' + ' ' * @opt.comment_pattern.size
-          result_lines.each{|result_line|
-            puts ' ' * prefix.size + " #{cont_comment}#{result_line}"
-          }
-        else
-          puts line
-        end
-
-        if @opt.show_output && line_result
-          out, err = *line_result[1..2]
-          if m = line.match(/^\s+/)
-            indent = ' ' * m[0].size
-          else
-            indent = ''
-          end
-
-          {out: out, err: err}.each{|k, o|
-            o.strip!
-            o.each_line{|ol|
-              puts "#{indent}##{k}: #{ol}"
-            } unless o.empty?
-          }
-        end
-      }
-    end
-  end
-end
+require_relative 'rstfilter/rewriter'
+require_relative 'rstfilter/exec'
 
 if __FILE__ == $0
   filter = RstFilter::Exec.new
-  filter.optparse ARGV
-  file = ARGV.shift
+  filter.optparse! ['-o', '-v']
+  file = ARGV.shift || File.expand_path(__dir__ + '/../sample.rb')
   filter.process File.expand_path(file)
 end

data/rstfilter.gemspec

@@ -2,7 +2,7 @@ require_relative 'lib/rstfilter/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "rstfilter"
-  spec.version       = Rstfilter::VERSION
+  spec.version       = RstFilter::VERSION
   spec.authors       = ["Koichi Sasada"]
   spec.email         = ["ko1@atdot.net"]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rstfilter
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Koichi Sasada
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-05-26 00:00:00.000000000 Z
+date: 2022-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -29,9 +29,11 @@ email:
 - ko1@atdot.net
 executables:
 - rstfilter
+- rstfilter-lsp
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".travis.yml"
 - Gemfile
@@ -41,7 +43,12 @@ files:
 - bin/console
 - bin/setup
 - exe/rstfilter
+- exe/rstfilter-lsp
 - lib/rstfilter.rb
+- lib/rstfilter/exec.rb
+- lib/rstfilter/exec_setup.rb
+- lib/rstfilter/lsp/handler.rb
+- lib/rstfilter/rewriter.rb
 - lib/rstfilter/version.rb
 - rstfilter.gemspec
 homepage: https://github.com/ko1/rstfilter
@@ -66,7 +73,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Show Ruby script with execution results.