katakata_irb 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce4d7b2e5ebfc546ddb501c43c13c62b166a55dc34a215a460d560b946ad4f02
-  data.tar.gz: f23396dc9804a798d109342d063943da759139fd849fd828f85d51f71089d5e7
+  metadata.gz: 810109ee76180f61c9b3672a8def67d0a32d53ca23b2436c65575457b586bf68
+  data.tar.gz: e17ff5c4e226d785031f2b433b35a8763a49e6a254420fcacf96507975dfa70b
 SHA512:
-  metadata.gz: 5e44f1dbab26c56949e89053a0309ad9f3195a8f545ea95b546a541c547b55b86a69afb3944bdbfeb5e498a62105cb2f54630e559b32188b2532cfa4625ee765
-  data.tar.gz: 9beaaf9996eba51111cabc5a1ba4082f94657ecdeb06b3cf1c0859c346822d772134673d190639b874caacf3f220c19d8ac8ad150c2c98f85129e658a58a2b95
+  metadata.gz: 47f0ea76bdf5a5599d219524346acca935b67d1ea73ed60d55887534bce442fffc8c483590b53cd84754c754b829551d837c38687282c497f2924c3ec616f0ff
+  data.tar.gz: f3aec83bbee8f2e889fdcf31eecc85627972511bf1673894d7f45f8a6834e6b52212ec4beb1814e0e8ddd705cf39eb9370ba78ff395d288caadcaa07008ebed8

data/lib/katakata_irb/completor.rb

@@ -10,7 +10,9 @@ 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
+      verbose, $VERBOSE = $VERBOSE, nil
       code = "#{preposing}#{target}"
       irb_context = IRB.conf[:MAIN_CONTEXT]
       binding = irb_context.workspace.binding
@@ -18,10 +20,17 @@ module KatakataIrb::Completor
       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
+        if IRB.const_defined? :InputCompletor # IRB::VERSION <= 1.8.1
+          path_completor = IRB::InputCompletor
+        elsif IRB.const_defined? :RegexpCompletor # IRB::VERSION >= 1.8.2
+          path_completor = IRB::RegexpCompletor.new
+        end
+        if !path_completor
+          []
+        elsif method == :require
+          path_completor.retrieve_files_to_require_from_load_path
         else
-          IRB::InputCompletor.retrieve_files_to_require_relative_from_current_dir
+          path_completor.retrieve_files_to_require_relative_from_current_dir
         end
       in [:call_or_const, type, name, self_call]
         ((self_call ? type.all_methods: type.methods).map(&:to_s) - HIDDEN_METHODS) | type.constants
@@ -50,82 +59,111 @@ module KatakataIrb::Completor
       candidates.map(&:to_s).select { !_1.match?(all_symbols_pattern) && _1.start_with?(name) }.uniq.sort.map do
         target + _1[name.size..]
       end
-    end
-    IRB::InputCompletor::CompletionProc.define_singleton_method :call do |*args|
-      completion_proc.call(*args)
     rescue => e
       KatakataIrb.last_completion_error = e
       KatakataIrb.log_puts
       KatakataIrb.log_puts "#{e.inspect} stored to KatakataIrb.last_completion_error"
       KatakataIrb.log_puts
+    ensure
+      $VERBOSE = verbose
     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
+    doc_namespace_proc = ->(input) do
+      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
-        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
+      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
+      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
+
+    if IRB.const_defined? :InputCompletor # IRB::VERSION <= 1.8.1
+      IRB::InputCompletor::CompletionProc.define_singleton_method :call do |*args|
+        completion_proc.call(*args)
+      end
+      IRB::InputCompletor.singleton_class.prepend(
+        Module.new do
+          define_method :retrieve_completion_data do |input, doc_namespace: false, **kwargs|
+            return super(input, doc_namespace: false, **kwargs) unless doc_namespace
+            doc_namespace_proc.call input
+          end
+        end
+      )
+    elsif IRB.const_defined? :RegexpCompletor # IRB::VERSION >= 1.8.2
+      IRB::RegexpCompletor.class_eval do
+        define_method :completion_candidates do |preposing, target, postposing, bind:|
+          completion_proc.call(target, preposing, postposing)
+        end
+        define_method :doc_namespace do |_preposing, matched, _postposing, bind:|
+          doc_namespace_proc.call matched
         end
       end
-    }
+    else
+      puts 'Cannot activate katakata_irb'
+    end
+
     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 +183,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 +308,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,21 @@
 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)
+    verbose, $VERBOSE = $VERBOSE, nil
+    tokens = Ripper::Lexer.new(code).scan.reject { ERROR_TOKENS.include? _1.event }
+    KatakataIrb::NestingParser.interpolate_ripper_ignored_tokens code, tokens
+  ensure
+    $VERBOSE = verbose
+  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 +43,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 +55,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 +151,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 +219,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 +234,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 +250,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.11"
 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.11
 platform: ruby
 authors:
 - tompng
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-19 00:00:00.000000000 Z
+date: 2023-10-12 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