katakata_irb 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb7e44af7218463a13dd4e072748d5880924a3b5678f8c30200f3e5bfde391cd
-  data.tar.gz: c0a6c33286b4a8197ad594f16baa87892448ea487e2faa153cac4d8f48d4208f
+  metadata.gz: 882c0834b6d52916911b26b82083e1100491dd24cafdb1c948c4c1795fe03d7e
+  data.tar.gz: 2250eaec5d0b1cabc236f238249e132206b62e70ada1c16429567b680ace2093
 SHA512:
-  metadata.gz: c79ea66192ad0c3f671a8cbaa9cf2d497b6b662482615a6f497e9a86ad6f797cc4d7b8d228bd44afd4c0968736a1ea83630311d2056b3bd4ae4befc1d2c94609
-  data.tar.gz: d3cde5bdd7a966ecf6a06e82bdd9f276664e513999902e37e3abd1a0870452e4eb8265c43949ce8c7f110e6786980a79e4b07abaf0dd7880c37dee39a27865c3
+  metadata.gz: 60f3c4de13636f2948e740b3a57b6091c1f193ae7fa259d665c69a404833ef413b90aca3da7360f97be2d7a669e9a0d5fc101ff172890c4f0714c9eb63db8dd4
+  data.tar.gz: eb496c54819de4f1e035e261a6afffcc13d2809b316428602567614dbc5671df5ead97fb4a0696afbb34a7ade9ce8a2b3e9579ebad4ddd006d9a32b120b3e05d

data/Gemfile.lock

@@ -1,15 +1,21 @@
 PATH
   remote: .
   specs:
-    katakata_irb (0.1.3)
+    katakata_irb (0.1.5)
+      irb (>= 1.4.0)
       rbs
 
 GEM
   remote: https://rubygems.org/
   specs:
+    io-console (0.6.0)
+    irb (1.6.2)
+      reline (>= 0.3.0)
     minitest (5.16.3)
     rake (13.0.6)
     rbs (2.7.0)
+    reline (0.3.2)
+      io-console (~> 0.5)
 
 PLATFORMS
   x86_64-darwin-20
@@ -20,4 +26,4 @@ DEPENDENCIES
   rake (~> 13.0)
 
 BUNDLED WITH
-   2.4.0.dev
+   2.4.5

data/README.md

@@ -9,9 +9,15 @@ gem install katakata_irb
 ```
 ## Usage
 
+Just require katakata_irb or write it to your `.irbrc` file.
+```ruby
+require 'katakata_irb'
+```
+
 ```
-% kirb
-irb(main):001:0> [1,'a'].sample.a█
+irb(main):001:0> require 'katakata_irb'
+=> true
+irb(main):002:0> [1,'a'].sample.a█
                 |[1,'a'].sample.abs        |
                 |[1,'a'].sample.abs2       |
                 |[1,'a'].sample.allbits?   |
@@ -22,30 +28,14 @@ irb(main):001:0> [1,'a'].sample.a█
 ```
 
 ```
-% kirb
-irb(main):001:0> a = 10
+irb(main):001:0> require 'katakata_irb'
+=> true
+irb(main):002:0> a = 10
 => 10
-irb(main):002:1* if true
-irb(main):003:2*   b = a.times.map do
-irb(main):004:2*     _1.to_s
-irb(main):005:1*   end
-irb(main):006:1*   b[0].a█
+irb(main):003:1* if true
+irb(main):004:2*   b = a.times.map do
+irb(main):005:2*     _1.to_s
+irb(main):006:1*   end
+irb(main):007:1*   b[0].a█
                   |b[0].ascii_only?|
 ```
-
-```ruby
-require 'katakata_irb/completor'
-KatakataIrb::Completor.setup
-10.times do |i|
-  binding.irb
-end
-```
-
-## Options
-
-### `kirb --debug-output`
-Show debug output if it meets unimplemented syntax or something
-
-### `kirb --without-patch`
-`kirb` will apply some patches to reline and irb/ruby-lex.rb by default. This option will disable it.
-See `lib/katakata_irb/ruby_lex_patch.rb` and `lib/katakata_irb/reline_patches/*.patch`

data/bin/console

@@ -1,10 +1,5 @@
 #!/usr/bin/env ruby
-require_relative '../lib/katakata_irb'
-require_relative '../lib/katakata_irb/reline_patch'
-KatakataIrb.log_output = STDERR
-KatakataIrb::RelinePatch.require_patched_reline
 require 'bundler/setup'
 require 'katakata_irb'
-require 'katakata_irb/ruby_lex_patch'
-KatakataIrb::RubyLexPatch.patch_to_ruby_lex
-KatakataIrb.repl
+KatakataIrb.log_output = STDERR
+IRB.start(__FILE__)

data/katakata_irb.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description = "IRB with Typed Completion"
   spec.homepage = "http://github.com/tompng/katakata_irb"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.1.0"
+  spec.required_ruby_version = ">= 3.0.0" # recommend >= 3.1.0
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "http://github.com/tompng/katakata_irb"
@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Uncomment to register a new dependency of your gem
+  spec.add_dependency 'irb', '>= 1.4.0'
   spec.add_dependency 'rbs'
 
   # For more information and examples about making a new gem, check out our

data/lib/katakata_irb/completor.rb

@@ -1,4 +1,4 @@
-require_relative 'trex'
+require_relative 'nesting_parser'
 require_relative 'type_simulator'
 require 'rbs'
 require 'rbs/cli'
@@ -6,15 +6,17 @@ require 'irb'
 
 module KatakataIrb::Completor
   using KatakataIrb::TypeSimulator::LexerElemMatcher
-
   HIDDEN_METHODS = %w[Namespace TypeName] # defined by rbs, should be hidden
+  singleton_class.attr_accessor :prev_analyze_result
 
   def self.setup
     completion_proc = ->(target, preposing = nil, postposing = nil) do
       code = "#{preposing}#{target}"
       irb_context = IRB.conf[:MAIN_CONTEXT]
       binding = irb_context.workspace.binding
-      candidates = case analyze code, binding
+      result = analyze code, binding
+      KatakataIrb::Completor.prev_analyze_result = result
+      candidates = case result
       in [:require | :require_relative => method, name]
         if method == :require
           IRB::InputCompletor.retrieve_files_to_require_from_load_path
@@ -25,18 +27,18 @@ module KatakataIrb::Completor
         ((self_call ? type.all_methods: type.methods).map(&:to_s) - HIDDEN_METHODS) | type.constants
       in [:const, type, name]
         type.constants
-      in [:ivar, name, _scope]
+      in [:ivar, name, *_scope]
         # TODO: scope
         ivars = binding.eval('self').instance_variables rescue []
         cvars = (binding.eval('self').class_variables rescue nil) if name == '@'
         ivars | (cvars || [])
-      in [:cvar, name, _scope]
+      in [:cvar, name, *_scope]
         # TODO: scope
         binding.eval('self').class_variables rescue []
       in [:gvar, name]
         global_variables
       in [:symbol, name]
-        Symbol.all_symbols
+        Symbol.all_symbols.map { _1.inspect[1..] }
       in [:call, type, name, self_call]
         (self_call ? type.all_methods : type.methods).map(&:to_s) - HIDDEN_METHODS
       in [:lvar_or_method, name, scope]
@@ -57,16 +59,95 @@ module KatakataIrb::Completor
       KatakataIrb.log_puts "#{e.inspect} stored to $error"
       KatakataIrb.log_puts
     end
+
+    IRB::InputCompletor.singleton_class.prepend Module.new{
+      def retrieve_completion_data(input, _bind: IRB.conf[:MAIN_CONTEXT].workspace.binding, doc_namespace: false)
+        return super unless doc_namespace
+        name = input[/[a-zA-Z_0-9]+[!?=]?\z/]
+        method_doc = -> type do
+          type = type.types.find { _1.all_methods.include? name.to_sym }
+          if type in KatakataIrb::Types::SingletonType
+            "#{KatakataIrb::Types.class_name_of(type.module_or_class)}.#{name}"
+          elsif type in KatakataIrb::Types::InstanceType
+            "#{KatakataIrb::Types.class_name_of(type.klass)}##{name}"
+          end
+        end
+        call_or_const_doc = -> type do
+          if name =~ /\A[A-Z]/
+            type = type.types.grep(KatakataIrb::Types::SingletonType).find { _1.module_or_class.const_defined?(name) }
+            type.module_or_class == Object ? name : "#{KatakataIrb::Types.class_name_of(type.module_or_class)}::#{name}" if type
+          else
+            method_doc.call(type)
+          end
+        end
+
+        case KatakataIrb::Completor.prev_analyze_result
+        in [:call_or_const, type, _name, _self_call]
+          call_or_const_doc.call type
+        in [:const, type, _name]
+          # when prev_analyze_result is const, current analyze result might be call
+          call_or_const_doc.call type
+        in [:gvar, _name]
+          name
+        in [:call, type, _name, _self_call]
+          method_doc.call type
+        in [:lvar_or_method, _name, scope]
+          method_doc.call scope.self_type unless scope.local_variables.include?(name)
+        else
+        end
+      end
+    }
+    setup_type_dialog
+  end
+
+  def self.setup_type_dialog
+    type_dialog_proc = -> {
+      return if just_cursor_moving && completion_journey_data
+      cursor_pos_to_render, _result, pointer, autocomplete_dialog = context.last(4)
+      return unless cursor_pos_to_render && autocomplete_dialog&.width && pointer.nil?
+      receiver_type = (
+        case KatakataIrb::Completor.prev_analyze_result
+        in [:call_or_const, type, name, _self_call] if name.empty?
+          type
+        in [:call, type, name, _self_call] if name.empty?
+          type
+        else
+          return
+        end
+      )
+      return unless receiver_type
+      types = type.types
+      contents = types.filter_map do |type|
+        case type
+        when KatakataIrb::Types::InstanceType
+          KatakataIrb::Types.class_name_of type.klass
+        when KatakataIrb::Types::SingletonType
+          module_name = KatakataIrb::Types.class_name_of type.module_or_class
+          "#{module_name}.itself" if module_name
+        end
+      end.uniq
+      return if contents.empty?
+
+      width = contents.map { Reline::Unicode.calculate_width _1 }.max
+      x = cursor_pos_to_render.x + autocomplete_dialog.width
+      y = cursor_pos_to_render.y
+      Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(x, y), contents: contents, width: width, bg_color: 44, fg_color: 37)
+    }
+    Reline.add_dialog_proc(:show_type, type_dialog_proc, Reline::DEFAULT_DIALOG_CONTEXT)
+  end
+
+  def self.empty_binding()
+    Kernel.binding
   end
 
-  def self.analyze(code, binding = Kernel.binding)
+  def self.analyze(code, binding = empty_binding)
     lvars_code = binding.local_variables.map do |name|
       "#{name}="
     end.join + "nil;\n"
     code = lvars_code + code
     tokens = RubyLex.ripper_lex_without_warning code
-    tokens = KatakataIrb::TRex.interpolate_ripper_ignored_tokens code, tokens
-    last_opens = KatakataIrb::TRex.parse(tokens)
+    tokens = KatakataIrb::NestingParser.interpolate_ripper_ignored_tokens code, tokens
+    last_opens = KatakataIrb::NestingParser.parse(tokens)
     closings = last_opens.map do |t|
       case t.tok
       when /\A%.[<>]\z/
@@ -84,12 +165,21 @@ module KatakataIrb::Completor
         t.tok
       when /\A<<[~-]?(?:"(?<s>.+)"|'(?<s>.+)'|(?<s>.+))/
         $/ + ($1 || $2 || $3) + $/
+      when ':"', ":'", ':'
+        t.tok[1]
+      when '?'
+        # ternary operator
+        ' : value'
+      when '|'
+        # block args
+        '|'
       else
         $/ + 'end'
       end
     end
+    # remove error tokens
+    tokens.pop while tokens&.last&.tok&.empty?
 
-    return if code =~ /[!?]\z/
     case tokens.last
     in { event: :on_ignored_by_ripper, tok: '.' }
       suffix = 'method'
@@ -97,6 +187,9 @@ module KatakataIrb::Completor
     in { dot: true }
       suffix = 'method'
       name = ''
+    in { event: :on_symbeg }
+      suffix = 'symbol'
+      name = ''
     in { event: :on_ident | :on_kw, tok: }
       return unless code.delete_suffix! tok
       suffix = 'method'
@@ -109,10 +202,21 @@ module KatakataIrb::Completor
       return unless code.delete_suffix! tok
       suffix = 'string'
       name = tok.rstrip
+    in { event: :on_gvar, tok: }
+      return unless code.delete_suffix! tok
+      suffix = '$gvar'
+      name = tok
+    in { event: :on_ivar, tok: }
+      return unless code.delete_suffix! tok
+      suffix = '@ivar'
+      name = tok
+    in { event: :on_cvar, tok: }
+      return unless code.delete_suffix! tok
+      suffix = '@@cvar'
+      name = tok
     else
       return
     end
-
     sexp = Ripper.sexp code + suffix + closings.reverse.join
     lines = code.lines
     line_no = lines.size
@@ -136,16 +240,26 @@ module KatakataIrb::Completor
       return [:cvar, name] if icvar_available
     end
     return unless expression
+    calculate_scope = -> { KatakataIrb::TypeSimulator.calculate_binding_scope binding, parents, expression }
+    calculate_receiver = -> receiver { KatakataIrb::TypeSimulator.calculate_receiver binding, parents, receiver }
+
     if (target in [:@tstring_content,]) && (parents[-4] in [:command, [:@ident, 'require' | 'require_relative' => require_method,],])
+      # `require 'target'`
       return [require_method.to_sym, name.rstrip]
     end
-    calculate_scope = -> { KatakataIrb::TypeSimulator.calculate_binding_scope binding, parents, expression }
-    calculate_receiver = -> receiver { KatakataIrb::TypeSimulator.calculate_receiver binding, parents, receiver }
+    if (target in [:@ident,]) && (expression in [:symbol,]) && (parents[-2] in [:args_add_block, Array => args, [:symbol_literal, ^expression]])
+      # `method(&:target)`
+      receiver_ref = [:var_ref, [:@ident, '_1', [0, 0]]]
+      block_statements = [receiver_ref]
+      parents[-1] = parents[-2][-1] = [:brace_block, nil, block_statements]
+      parents << block_statements
+      return [:call, calculate_receiver.call(receiver_ref), name, false]
+    end
     case expression
     in [:vcall | :var_ref, [:@ident,]]
       [:lvar_or_method, name, calculate_scope.call]
     in [:symbol, [:@ident | :@const | :@op | :@kw,]]
-      [:symbol, name]
+      [:symbol, name] unless name.empty?
     in [:var_ref | :const_ref, [:@const,]]
       # TODO
       [:const, KatakataIrb::Types::SingletonType.new(Object), name]

data/lib/katakata_irb/{trex.rb → nesting_parser.rb}

@@ -1,5 +1,4 @@
-module KatakataIrb; end
-module KatakataIrb::TRex
+module KatakataIrb::NestingParser
   def self.interpolate_ripper_ignored_tokens(code, tokens)
     line_positions = code.lines.reduce([0]) { _1 << _1.last + _2.bytesize }
     prev_byte_pos = 0
@@ -27,19 +26,25 @@ module KatakataIrb::TRex
     interpolated
   end
 
+  IGNOREABLE_TOKENS = %i[on_sp on_ignored_nl on_comment on_embdoc_beg on_embdoc on_embdoc_end]
+
   def self.parse(tokens)
     opens = []
     pending_heredocs = []
     first_token_on_line = true
-    tokens.each_with_index do |t, index|
+    tokens.each do |t|
       skip = false
       last_tok, state, args = opens.last
       case state
       when :in_unquoted_symbol
-        opens.pop
-        skip = true if %i[on_ident on_const on_op on_cvar on_ivar on_gvar on_kw on_int on_backtick].include?(t.event)
+        unless t.event == :on_sp
+          opens.pop
+          skip = true
+        end
+      when :in_lambda_head
+        opens.pop if t.event == :on_tlambeg || (t.event == :on_kw && t.tok == 'do')
       when :in_method_head
-        unless %i[on_sp on_ignored_nl on_comment on_embdoc_beg on_embdoc on_embdoc_end].include?(t.event)
+        unless IGNOREABLE_TOKENS.include?(t.event)
           next_args = []
           body = nil
           if args.include?(:receiver)
@@ -124,13 +129,27 @@ module KatakataIrb::TRex
           skip = true if t.event == :on_kw && t.tok == 'do'
           opens[-1] = [last_tok, nil]
         end
+      when :in_block_head
+        if t.event == :on_op && t.tok == '|'
+          opens[-1] = [last_tok, nil]
+          opens << [t, :in_block_args]
+        elsif !IGNOREABLE_TOKENS.include?(t.event)
+          opens[-1] = [last_tok, nil]
+        end
+      when :in_block_args
+        if t.event == :on_op && t.tok == '|' && t.state.allbits?(Ripper::EXPR_BEG)
+          opens.pop
+          skip = true
+        end
       end
 
       unless skip
         case t.event
         when :on_kw
           case t.tok
-          when 'begin', 'class', 'module', 'do', 'case'
+          when 'do'
+            opens << [t, :in_block_head]
+          when 'begin', 'class', 'module', 'case'
             opens << [t, nil]
           when 'end'
             opens.pop
@@ -160,7 +179,15 @@ module KatakataIrb::TRex
               opens << [t, nil]
             end
           end
-        when :on_lparen, :on_lbracket, :on_lbrace, :on_tlambeg, :on_embexpr_beg, :on_embdoc_beg
+        when :on_lbrace
+          if t.state.allbits?(Ripper::EXPR_LABEL)
+            opens << [t, nil]
+          else
+            opens << [t, :in_block_head]
+          end
+        when :on_tlambda
+          opens << [t, :in_lambda_head]
+        when :on_lparen, :on_lbracket, :on_tlambeg, :on_embexpr_beg, :on_embdoc_beg
           opens << [t, nil]
         when :on_rparen, :on_rbracket, :on_rbrace, :on_embexpr_end, :on_embdoc_end
           opens.pop
@@ -174,6 +201,15 @@ module KatakataIrb::TRex
           opens << [t, nil]
         when :on_tstring_end, :on_regexp_end, :on_label_end
           opens.pop
+        when :on_op
+          case t.tok
+          when '?'
+            # opening of `cond ? value : value``
+            opens << [t, nil]
+          when ':'
+            # closing of `cond ? value : value``
+            opens.pop
+          end
         when :on_symbeg
           if t.tok == ':'
             opens << [t, :in_unquoted_symbol]
@@ -188,10 +224,10 @@ module KatakataIrb::TRex
         first_token_on_line = false
       end
       if pending_heredocs.any? && t.tok.include?("\n")
-        pending_heredocs.reverse_each { opens << [_1, nil] }
+        pending_heredocs.reverse_each { |t| opens << [t, nil] }
         pending_heredocs = []
       end
-      yield t, index, opens if block_given?
+      yield t, opens if block_given?
     end
     opens.map(&:first) + pending_heredocs.reverse
   end
@@ -201,7 +237,7 @@ module KatakataIrb::TRex
     prev_opens = []
     min_depth = 0
     output = []
-    last_opens = parse(tokens) do |t, _index, opens|
+    last_opens = parse(tokens) do |t, opens|
       depth = t == opens.last&.first ? opens.size - 1 : opens.size
       min_depth = depth if depth < min_depth
       if t.tok.include?("\n")