katakata_irb 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce4d7b2e5ebfc546ddb501c43c13c62b166a55dc34a215a460d560b946ad4f02
-  data.tar.gz: f23396dc9804a798d109342d063943da759139fd849fd828f85d51f71089d5e7
+  metadata.gz: 297457c829dac09ddee68c1cc5365acfcc2583e0282fb1070ebae8fa138523ba
+  data.tar.gz: a45663afa386d4093814a3ea2a49c98cb03e90004e2a42c0dc723f4686500a51
 SHA512:
-  metadata.gz: 5e44f1dbab26c56949e89053a0309ad9f3195a8f545ea95b546a541c547b55b86a69afb3944bdbfeb5e498a62105cb2f54630e559b32188b2532cfa4625ee765
-  data.tar.gz: 9beaaf9996eba51111cabc5a1ba4082f94657ecdeb06b3cf1c0859c346822d772134673d190639b874caacf3f220c19d8ac8ad150c2c98f85129e658a58a2b95
+  metadata.gz: e66cd04bba34272f585adb1a6dde686a49d064604a48b1c0d14093474857b30537f6b05dd965eaf7ae822b174e373122479c05a643cc951fe4ecea3009a625c6
+  data.tar.gz: 4cb475b48b8e73db73340a1a11c97b087f99d2d6159e235d93a8845e4a718e9b18deb4e693d86059ba98bdbecbf41f24c13cb70d969fdd6d18f9cb171c76478b

data/lib/katakata_irb/completor.rb

@@ -10,6 +10,7 @@ module KatakataIrb::Completor
   singleton_class.attr_accessor :prev_analyze_result
 
   def self.setup
+    KatakataIrb::Types.preload_in_thread
     completion_proc = ->(target, preposing = nil, postposing = nil) do
       code = "#{preposing}#{target}"
       irb_context = IRB.conf[:MAIN_CONTEXT]
@@ -61,7 +62,7 @@ module KatakataIrb::Completor
     end
 
     IRB::InputCompletor.singleton_class.prepend Module.new{
-      def retrieve_completion_data(input, _bind: IRB.conf[:MAIN_CONTEXT].workspace.binding, doc_namespace: false)
+      def retrieve_completion_data(input, doc_namespace: false, **)
         return super unless doc_namespace
         name = input[/[a-zA-Z_0-9]+[!?=]?\z/]
         method_doc = -> type do
@@ -100,32 +101,39 @@ module KatakataIrb::Completor
     setup_type_dialog
   end
 
+  def self.type_dialog_content
+    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
+    )
+    if KatakataIrb::Types.rbs_builder.nil? && !KatakataIrb::Types.rbs_load_error
+      return [' Loading ', ' RBS... ']
+    end
+    types = receiver_type.types
+    contents = types.filter_map do |type|
+      case type
+      when KatakataIrb::Types::InstanceType
+        type.inspect_without_params
+      else
+        type.inspect
+      end
+    end.uniq
+    contents if contents.any?
+  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
-          type.inspect_without_params
-        else
-          type.inspect
-        end
-      end.uniq
-      return if contents.empty?
+      contents = KatakataIrb::Completor.type_dialog_content
+      return unless contents&.any?
 
       width = contents.map { Reline::Unicode.calculate_width _1 }.max
       x = cursor_pos_to_render.x + autocomplete_dialog.width
@@ -145,12 +153,11 @@ module KatakataIrb::Completor
       "#{name}="
     end.join + "nil;\n"
     code = lvars_code + code
-    tokens = RubyLex.ripper_lex_without_warning code
-    tokens = KatakataIrb::NestingParser.interpolate_ripper_ignored_tokens code, tokens
-    last_opens = KatakataIrb::NestingParser.parse(tokens)
+    tokens = KatakataIrb::NestingParser.tokenize code
+    last_opens = KatakataIrb::NestingParser.open_tokens(tokens)
     closings = last_opens.map do |t|
       case t.tok
-      when /\A%.[<>]\z/
+      when /\A%.?[<>]\z/
         $/ + '>'
       when '{', '#{', /\A%.?[{}]\z/
         $/ + '}'
@@ -271,9 +278,15 @@ module KatakataIrb::Completor
       [:ivar, name, calculate_scope.call.self_type] if icvar_available
     in [:var_ref, [:@cvar,]]
       [:cvar, name, calculate_scope.call.self_type] if icvar_available
-    in [:call, receiver, [:@period,] | [:@op, '&.',] | :'::' => dot, [:@ident | :@const,]]
+    in [:call, receiver, [:@op, '::',] | :'::', [:@ident | :@const,]]
+      self_call = (receiver in [:var_ref, [:@kw, 'self',]])
+      [:call_or_const, calculate_receiver.call(receiver), name, self_call]
+    in [:call, receiver, [:@period,], [:@ident | :@const,]]
+      self_call = (receiver in [:var_ref, [:@kw, 'self',]])
+      [:call, calculate_receiver.call(receiver), name, self_call]
+    in [:call, receiver, [:@op, '&.',], [:@ident | :@const,]]
       self_call = (receiver in [:var_ref, [:@kw, 'self',]])
-      [dot == :'::' ? :call_or_const : :call, calculate_receiver.call(receiver), name, self_call]
+      [:call, calculate_receiver.call(receiver).nonnillable, name, self_call]
     in [:const_path_ref, receiver, [:@const,]]
       [:const, calculate_receiver.call(receiver), name]
     in [:top_const_ref, [:@const,]]

data/lib/katakata_irb/nesting_parser.rb

@@ -1,4 +1,18 @@
 module KatakataIrb::NestingParser
+  ERROR_TOKENS = %i[
+    on_parse_error
+    compile_error
+    on_assign_error
+    on_alias_error
+    on_class_name_error
+    on_param_error
+  ]
+
+  def self.tokenize(code)
+    tokens = Ripper::Lexer.new(code).scan.reject { ERROR_TOKENS.include? _1.event }
+    KatakataIrb::NestingParser.interpolate_ripper_ignored_tokens code, tokens
+  end
+
   def self.interpolate_ripper_ignored_tokens(code, tokens)
     line_positions = code.lines.reduce([0]) { _1 << _1.last + _2.bytesize }
     prev_byte_pos = 0
@@ -26,9 +40,10 @@ module KatakataIrb::NestingParser
     interpolated
   end
 
-  IGNOREABLE_TOKENS = %i[on_sp on_ignored_nl on_comment on_embdoc_beg on_embdoc on_embdoc_end]
+  IGNORE_TOKENS = %i[on_sp on_ignored_nl on_comment on_embdoc_beg on_embdoc on_embdoc_end]
 
-  def self.parse(tokens)
+  # Scan each token and call the given block with array of token and other information for parsing
+  def self.scan_opens(tokens)
     opens = []
     pending_heredocs = []
     first_token_on_line = true
@@ -37,14 +52,14 @@ module KatakataIrb::NestingParser
       last_tok, state, args = opens.last
       case state
       when :in_unquoted_symbol
-        unless t.event == :on_sp
+        unless IGNORE_TOKENS.include?(t.event)
           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 IGNOREABLE_TOKENS.include?(t.event)
+        unless IGNORE_TOKENS.include?(t.event)
           next_args = []
           body = nil
           if args.include?(:receiver)
@@ -133,7 +148,7 @@ module KatakataIrb::NestingParser
         if t.event == :on_op && t.tok == '|'
           opens[-1] = [last_tok, nil]
           opens << [t, :in_block_args]
-        elsif !IGNOREABLE_TOKENS.include?(t.event)
+        elsif !IGNORE_TOKENS.include?(t.event)
           opens[-1] = [last_tok, nil]
         end
       when :in_block_args
@@ -201,6 +216,12 @@ module KatakataIrb::NestingParser
           opens << [t, nil]
         when :on_tstring_end, :on_regexp_end, :on_label_end
           opens.pop
+        when :on_symbeg
+          if t.tok == ':'
+            opens << [t, :in_unquoted_symbol]
+          else
+            opens << [t, nil]
+          end
         when :on_op
           case t.tok
           when '?'
@@ -210,12 +231,6 @@ module KatakataIrb::NestingParser
             # closing of `cond ? value : value``
             opens.pop
           end
-        when :on_symbeg
-          if t.tok == ':'
-            opens << [t, :in_unquoted_symbol]
-          else
-            opens << [t, nil]
-          end
         end
       end
       if t.event == :on_nl || t.event == :on_semicolon
@@ -232,29 +247,8 @@ module KatakataIrb::NestingParser
     opens.map(&:first) + pending_heredocs.reverse
   end
 
-  def self.parse_line(tokens)
-    line_tokens = []
-    prev_opens = []
-    min_depth = 0
-    output = []
-    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")
-        t.tok.each_line do |line|
-          line_tokens << [t, line]
-          next if line[-1] != "\n"
-          next_opens = opens.map(&:first)
-          output << [line_tokens, prev_opens, next_opens, min_depth]
-          prev_opens = next_opens
-          min_depth = prev_opens.size
-          line_tokens = []
-        end
-      else
-        line_tokens << [t, t.tok]
-      end
-    end
-    output << [line_tokens, prev_opens, last_opens, min_depth] if line_tokens.any?
-    output
+  def self.open_tokens(tokens)
+    # scan_opens without block will return a list of open tokens at last token position
+    scan_opens(tokens)
   end
 end

data/lib/katakata_irb/type_simulator.rb

@@ -769,9 +769,9 @@ class KatakataIrb::TypeSimulator
     case sexp
     in [:fcall | :vcall, [:@ident | :@const | :@kw | :@op, method,]] # hoge
       [nil, method, [], [], nil, false]
-    in [:call, receiver, [:@period,] | [:@op, '&.',] | :'::' => dot, :call]
+    in [:call, receiver, [:@period,] | [:@op, '&.',] | [:@op, '::',] | :'::' => dot, :call]
       [receiver, :call, [], [], nil, optional[dot]]
-    in [:call, receiver, [:@period,] | [:@op, '&.',] | :'::' => dot, method]
+    in [:call, receiver, [:@period,] | [:@op, '&.',] | [:@op, '::',] | :'::' => dot, method]
       method => [:@ident | :@const | :@kw | :@op, method,] unless method == :call
       [receiver, method, [], [], nil, optional[dot]]
     in [:command, [:@ident | :@const | :@kw | :@op, method,], args] # hoge 1, 2

data/lib/katakata_irb/types.rb

@@ -3,8 +3,12 @@ require 'rbs/cli'
 
 module KatakataIrb; end
 module KatakataIrb::Types
-  def self.rbs_builder
-    @rbs_builder ||= load_rbs_builder
+  singleton_class.attr_reader :rbs_builder, :rbs_load_error
+
+  def self.preload_in_thread
+    @loader_thread ||= Thread.new do
+      @rbs_builder = load_rbs_builder
+    end
   end
 
   def self.load_rbs_builder
@@ -12,8 +16,10 @@ module KatakataIrb::Types
     loader.add path: Pathname('sig')
     RBS::DefinitionBuilder.new env: RBS::Environment.from_loader(loader).resolve_type_names
   rescue => e
-    puts "\r\nKatakataIRB failed to initialize RBS::DefinitionBuilder\r\n#{e}\r\n"
-    Object.new
+    @rbs_load_error = e
+    puts "\r\nKatakataIRB failed to initialize RBS::DefinitionBuilder: #{e.class}\r\n"
+    puts "See `KatakataIrb::Types.rbs_load_error` for more details.\r\n"
+    nil
   end
 
   Splat = Struct.new :item
@@ -59,6 +65,8 @@ module KatakataIrb::Types
   end
 
   def self.rbs_methods(type, method_name, args_types, kwargs_type, has_block)
+    return [] unless rbs_builder
+
     receivers = type.types.map do |t|
       case t
       in ProcType
@@ -397,8 +405,8 @@ module KatakataIrb::Types
 
   def self.match_free_variables(vars, types, values)
     accumulator = {}
-    types.zip(values).each do |t, v|
-      _match_free_variable(vars, t, v, accumulator)
+    types.zip values do |t, v|
+      _match_free_variable(vars, t, v, accumulator) if v
     end
     accumulator.transform_values { UnionType[*_1] }
   end

data/lib/katakata_irb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KatakataIrb
-  VERSION = "0.1.9"
+  VERSION = "0.1.10"
 end

data/lib/katakata_irb.rb

@@ -1,5 +1,6 @@
 require 'katakata_irb/version'
 require 'katakata_irb/completor'
+require 'katakata_irb/types'
 
 module KatakataIrb
   class << self

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katakata_irb
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - tompng
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-19 00:00:00.000000000 Z
+date: 2023-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: irb
@@ -95,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: IRB with Typed Completion