katakata_irb 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d3d6ff924cd8fa8f05b097253525517a988c377d59e63ed1e5c6e5867cfde88
-  data.tar.gz: af6afd4a833e2b9bfd08a05877db80e45faadcac845be5148b53e3266d5539d8
+  metadata.gz: 6e13d1b43d98e8be7595125b4e1e27533d83da1ee4d87df0dfb613d8fb8adee4
+  data.tar.gz: ae508bc65cd1049100fe4811b1d2b27036b30131cab13821d52b637e91e2ed41
 SHA512:
-  metadata.gz: 35b76a766b99913226c5888b00efcc1c88c35ecb1bbb38338cf69a47772153caecb204bf5cad0a4f7affb475a179b0bd084ecd673c793260165731eef88a258b
-  data.tar.gz: e2dc520f4d5fe10a95795d5cbcdb784289e674c415a8eddea2c06883262f02847a5fd5b4fb7dc83d219e8a2add95e5fb5ed7c3d7000b4c83ea539825d50c5f20
+  metadata.gz: be9ed49c8de27772f7ec154df136134e9d5319a851fe392656a67d3c49069ed040a41b2af8deb6e81577c0c59c6d5bc0918a8165e09ccab2bce15fd6f09abba8
+  data.tar.gz: 8d9554e6532488742e156d39e7ee63c3c2461900db42badfd0d49990e35769b1e0f34a8cd746d5aab57839d3f31e894a081ec42389cd2383dafab5043d3fa578

data/Gemfile.lock

@@ -1,15 +1,21 @@
 PATH
   remote: .
   specs:
-    katakata_irb (0.1.2)
+    katakata_irb (0.1.4)
+      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
@@ -57,6 +59,44 @@ 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
+            "#{type.module_or_class.name}.#{name}"
+          elsif type in KatakataIrb::Types::InstanceType
+            "#{type.klass.name}##{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 : "#{type.module_or_class.name}::#{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
+    }
   end
 
   def self.analyze(code, binding = Kernel.binding)
@@ -65,8 +105,8 @@ module KatakataIrb::Completor
     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/
@@ -89,7 +129,6 @@ module KatakataIrb::Completor
       end
     end
 
-    return if code =~ /[!?]\z/
     case tokens.last
     in { event: :on_ignored_by_ripper, tok: '.' }
       suffix = 'method'

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
@@ -31,81 +30,102 @@ module KatakataIrb::TRex
     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].include?(t.event)
+        unless %i[on_sp on_ignored_nl on_comment on_embdoc_beg on_embdoc on_embdoc_end].include?(t.event)
           next_args = []
           body = nil
-          if args.include? :receiver
+          if args.include?(:receiver)
             case t.event
             when :on_lparen, :on_ivar, :on_gvar, :on_cvar
+              # def (receiver). | def @ivar. | def $gvar. | def @@cvar.
               next_args << :dot
             when :on_kw
-              if t.tok in 'self' | 'true' | 'false' | 'nil'
-                next_args.push :arg, :dot
+              case t.tok
+              when 'self', 'true', 'false', 'nil'
+                # def self(arg) | def self.
+                next_args.push(:arg, :dot)
               else
+                # def if(arg)
                 skip = true
                 next_args << :arg
               end
-            when :on_op
+            when :on_op, :on_backtick
+              # def +(arg)
               skip = true
               next_args << :arg
             when :on_ident, :on_const
-              next_args.push :arg, :dot
+              # def a(arg) | def a.
+              next_args.push(:arg, :dot)
             end
           end
-          if args.include? :dot
+          if args.include?(:dot)
+            # def receiver.name
             next_args << :name if t.event == :on_period || (t.event == :on_op && t.tok == '::')
           end
-          if args.include? :name
-            if %i[on_ident on_const on_op on_kw].include? t.event
+          if args.include?(:name)
+            if %i[on_ident on_const on_op on_kw on_backtick].include?(t.event)
+              # def name(arg) | def receiver.name(arg)
               next_args << :arg
               skip = true
             end
           end
-          if args.include? :arg
+          if args.include?(:arg)
             case t.event
-            when :on_op
-              body = :oneliner if t.tok == '='
             when :on_nl, :on_semicolon
+              # def recever.f;
               body = :normal
             when :on_lparen
+              # def recever.f()
               next_args << :eq
             else
-              next_args << :arg_without_paren
+              if t.event == :on_op && t.tok == '='
+                # def receiver.f =
+                body = :oneliner
+              else
+                # def recever.f arg
+                next_args << :arg_without_paren
+              end
             end
           end
-          if args.include? :eq
+          if args.include?(:eq)
             if t.event == :on_op && t.tok == '='
               body = :oneliner
-            elsif t.event != :on_embdoc_beg
+            else
               body = :normal
             end
           end
-          if args.include? :args_without_paren
-            body = :normal if %i[on_semicolon on_nl].include? t.event
+          if args.include?(:arg_without_paren)
+            if %i[on_semicolon on_nl].include?(t.event)
+              # def f a;
+              body = :normal
+            else
+              # def f a, b
+              next_args << :arg_without_paren
+            end
           end
           if body == :oneliner
             opens.pop
           elsif body
-            opens.pop
-            opens << [last_tok, nil]
+            opens[-1] = [last_tok, nil]
           else
-            opens.pop
-            opens << [last_tok, :in_method_head, next_args]
+            opens[-1] = [last_tok, :in_method_head, next_args]
           end
         end
       when :in_for_while_until_condition
         if t.event == :on_semicolon || t.event == :on_nl || (t.event == :on_kw && t.tok == 'do')
           skip = true if t.event == :on_kw && t.tok == 'do'
-          opens.pop
-          opens << [last_tok, nil]
+          opens[-1] = [last_tok, nil]
         end
       end
 
@@ -143,6 +163,8 @@ module KatakataIrb::TRex
               opens << [t, nil]
             end
           end
+        when :on_tlambda
+          opens << [t, :in_lambda_head]
         when :on_lparen, :on_lbracket, :on_lbrace, :on_tlambeg, :on_embexpr_beg, :on_embdoc_beg
           opens << [t, nil]
         when :on_rparen, :on_rbracket, :on_rbrace, :on_embexpr_end, :on_embdoc_end
@@ -171,10 +193,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
@@ -184,10 +206,10 @@ module KatakataIrb::TRex
     prev_opens = []
     min_depth = 0
     output = []
-    last_opens = KatakataIrb::TRex.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"
+      if t.tok.include?("\n")
         t.tok.each_line do |line|
           line_tokens << [t, line]
           next if line[-1] != "\n"

data/lib/katakata_irb/type_simulator.rb

@@ -31,13 +31,13 @@ class KatakataIrb::TypeSimulator
         fallback = KatakataIrb::Types::NIL
         case BaseScope.type_by_name name
         when :cvar
-          KatakataIrb::TypeSimulator.type_of(fallback:) { @self_object.class_variable_get name }
+          KatakataIrb::TypeSimulator.type_of(fallback: fallback) { @self_object.class_variable_get name }
         when :ivar
-          KatakataIrb::TypeSimulator.type_of(fallback:) { @self_object.instance_variable_get name }
+          KatakataIrb::TypeSimulator.type_of(fallback: fallback) { @self_object.instance_variable_get name }
         when :lvar
-          KatakataIrb::TypeSimulator.type_of(fallback:) { @binding.local_variable_get(name) }
+          KatakataIrb::TypeSimulator.type_of(fallback: fallback) { @binding.local_variable_get(name) }
         when :const
-          KatakataIrb::TypeSimulator.type_of(fallback:) { @binding.eval name }
+          KatakataIrb::TypeSimulator.type_of(fallback: fallback) { @binding.eval name }
         end
       )
     end
@@ -85,7 +85,7 @@ class KatakataIrb::TypeSimulator
   class Scope
     attr_reader :parent, :jump_branches
 
-    def self.from_binding(binding) = new BaseScope.new(binding, binding.eval('self'))
+    def self.from_binding(binding) = new(BaseScope.new(binding, binding.eval('self')))
 
     def initialize(parent, table = {}, trace_cvar: true, trace_ivar: true, trace_lvar: true, passthrough: false)
       @tables = [table]
@@ -243,8 +243,8 @@ class KatakataIrb::TypeSimulator
     refine Ripper::Lexer::Elem do
       def deconstruct_keys(_keys)
         {
-          tok:,
-          event:,
+          tok: tok,
+          event: event,
           label: state.allbits?(Ripper::EXPR_LABEL),
           beg: state.allbits?(Ripper::EXPR_BEG),
           dot: state.allbits?(Ripper::EXPR_DOT)
@@ -280,7 +280,7 @@ class KatakataIrb::TypeSimulator
   end
 
   def simulate_evaluate(sexp, scope, case_target: nil)
-    result = simulate_evaluate_inner(sexp, scope, case_target:)
+    result = simulate_evaluate_inner(sexp, scope, case_target: case_target)
     @dig_targets.resolve result, scope if @dig_targets.target?(sexp)
     result
   end
@@ -293,7 +293,7 @@ class KatakataIrb::TypeSimulator
       sexp in [:def, _method_name_exp, params, body_stmt]
       sexp in [:defs, receiver_exp, _dot_exp, _method_name_exp, params, body_stmt]
       if receiver_exp
-        receiver_exp in  [:paren, receiver_exp]
+        receiver_exp in [:paren, receiver_exp]
         self_type = simulate_evaluate receiver_exp, scope
       else
         current_self_types = scope.self_type.types
@@ -407,6 +407,9 @@ class KatakataIrb::TypeSimulator
       KatakataIrb::Types::InstanceType.new Hash, K: KatakataIrb::Types::UnionType[*keys], V: KatakataIrb::Types::UnionType[*values]
     in [:hash, nil]
       KatakataIrb::Types::InstanceType.new Hash
+    in [:paren, [Symbol,] | false => statement]
+      # workaround for `p ()` and `p (foo)`
+      simulate_evaluate statement, scope if statement
     in [:paren | :ensure | :else, statements]
       statements.map { simulate_evaluate _1, scope }.last
     in [:const_path_ref, receiver, [:@const, name,]]
@@ -574,6 +577,7 @@ class KatakataIrb::TypeSimulator
       simulate_evaluate target, scope
       simulate_evaluate value, scope
     in [:massign, targets, value]
+      targets in [:mlhs, *targets] # (a,b) = value
       rhs = simulate_evaluate value, scope
       evaluate_massign targets, rhs, scope
       rhs
@@ -631,6 +635,8 @@ class KatakataIrb::TypeSimulator
       KatakataIrb::Types::OBJECT
     in [:redo | :retry]
       scope.terminate
+    in [:zsuper]
+      KatakataIrb::Types::OBJECT
     in [:super, args]
       args, kwargs, _block = retrieve_method_args args
       args.each do |arg|
@@ -717,7 +723,7 @@ class KatakataIrb::TypeSimulator
       end
       else_branch = lambda do
         pattern.each { simulate_evaluate _1, scope }
-        simulate_evaluate(else_statement, scope, case_target:)
+        simulate_evaluate(else_statement, scope, case_target: case_target)
       end
       if if_statements && else_statement
         KatakataIrb::Types::UnionType[*scope.run_branches(if_branch, else_branch)]
@@ -737,7 +743,7 @@ class KatakataIrb::TypeSimulator
         },
         -> {
           pattern_scope.merge_jumps
-          else_statement ? simulate_evaluate(else_statement, scope, case_target:) : KatakataIrb::Types::NIL
+          else_statement ? simulate_evaluate(else_statement, scope, case_target: case_target) : KatakataIrb::Types::NIL
         }
       )
       KatakataIrb::Types::UnionType[*results]
@@ -1037,6 +1043,14 @@ class KatakataIrb::TypeSimulator
     types = type_breaks.map(&:first)
     breaks = type_breaks.map(&:last).compact
     types << OBJECT_METHODS[method_name.to_sym] if name_match && OBJECT_METHODS.has_key?(method_name.to_sym)
+
+    if method_name.to_sym == :new
+      receiver.types.each do |type|
+        if (type in KatakataIrb::Types::SingletonType) && type.module_or_class.is_a?(Class)
+          types << KatakataIrb::Types::InstanceType.new(type.module_or_class)
+        end
+      end
+    end
     KatakataIrb::Types::UnionType[*types, *breaks]
   end
 

data/lib/katakata_irb/types.rb

@@ -85,23 +85,26 @@ module KatakataIrb::Types
 
   def self.type_from_object(object, max_level: 4)
     max_level -= 1
+    sample_size = 1000
     case object
     when Array
+      values = object.size > sample_size ? object.sample(sample_size) : object
       if max_level > 0
-        values = object.map { type_from_object(_1, max_level:) }
-        InstanceType.new Array, { Elem: UnionType[*values] }
+        InstanceType.new Array, { Elem: UnionType[*values.map { type_from_object(_1, max_level: max_level) }] }
       else
-        InstanceType.new Array, { Elem: UnionType[*object.map(&:class).uniq.map { InstanceType.new _1 }] }
+        InstanceType.new Array, { Elem: UnionType[*values.map(&:class).uniq.map { InstanceType.new _1 }] }
       end
     when Hash
+      keys = object.size > sample_size ? object.keys.sample(sample_size) : object.keys
+      values = object.size > sample_size ? object.values.sample(sample_size) : object.values
       if max_level > 0
-        keys = object.keys.map { type_from_object(_1, max_level:) }
-        values = object.values.map { type_from_object(_1, max_level:) }
-        InstanceType.new Hash, { K: UnionType[*keys], V: UnionType[*values] }
+        key_types = keys.map { type_from_object(_1, max_level: max_level) }
+        value_types = values.map { type_from_object(_1, max_level: max_level) }
+        InstanceType.new Hash, { K: UnionType[*key_types], V: UnionType[*value_types] }
       else
-        keys = object.keys.map(&:class).uniq.map { InstanceType.new _1 }
-        values = object.values.map(&:class).uniq.map { InstanceType.new _1 }
-        InstanceType.new Hash, { K: UnionType[*keys], V: UnionType[*values] }
+        key_types = keys.map(&:class).uniq.map { InstanceType.new _1 }
+        value_types = values.map(&:class).uniq.map { InstanceType.new _1 }
+        InstanceType.new Hash, { K: UnionType[*key_types], V: UnionType[*value_types] }
       end
     when Module
       SingletonType.new object
@@ -117,7 +120,7 @@ module KatakataIrb::Types
     end
     def transform() = yield(self)
     def methods() = @module_or_class.methods
-    def all_methods() = methods
+    def all_methods() = methods | Kernel.methods
     def constants() = @module_or_class.constants
     def types() = [self]
   end
@@ -294,19 +297,13 @@ module KatakataIrb::Types
       # unimplemented
       OBJECT
     when RBS::Types::ClassInstance
-      classes = self_type.types.filter_map do |type|
-        type.module_or_class if (type in SingletonType) && type.module_or_class.is_a?(Class)
-      end
-      if classes.empty?
-        klass = return_type.name.to_namespace.path.reduce(Object) { _1.const_get _2 }
-        classes << klass if klass in Class
-      end
+      klass = return_type.name.to_namespace.path.reduce(Object) { _1.const_get _2 }
       if return_type.args
         args = return_type.args.map { from_rbs_type _1, self_type, extra_vars }
         names = rbs_builder.build_singleton(return_type.name).type_params
         params = names.map.with_index { [_1, args[_2] || OBJECT] }.to_h
       end
-      UnionType[*classes.map { InstanceType.new _1, params || {} }]
+      InstanceType.new klass, params || {}
     end
   end
 

data/lib/katakata_irb/version.rb

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

data/lib/katakata_irb.rb

@@ -1,11 +1,7 @@
-require 'io/console'
-module KatakataIrb
-  def self.repl
-    require 'katakata_irb/completor'
-    KatakataIrb::Completor.setup
-    IRB.start(__FILE__)
-  end
+require 'katakata_irb/version'
+require 'katakata_irb/completor'
 
+module KatakataIrb
   def self.log_output=(output)
     @log_output = output
   end
@@ -14,3 +10,5 @@ module KatakataIrb
     STDOUT.cooked { @log_output&.puts(...) }
   end
 end
+
+KatakataIrb::Completor.setup

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: katakata_irb
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - tompng
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-20 00:00:00.000000000 Z
+date: 2023-01-26 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.0
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement
@@ -27,8 +41,7 @@ dependencies:
 description: IRB with Typed Completion
 email:
 - tomoyapenguin@gmail.com
-executables:
-- kirb
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -39,19 +52,10 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- exe/kirb
 - katakata_irb.gemspec
 - lib/katakata_irb.rb
 - lib/katakata_irb/completor.rb
-- lib/katakata_irb/reline_patch.rb
-- lib/katakata_irb/reline_patches/escapeseq.patch
-- lib/katakata_irb/reline_patches/fullwidth.patch
-- lib/katakata_irb/reline_patches/indent.patch
-- lib/katakata_irb/reline_patches/raw.patch
-- lib/katakata_irb/reline_patches/scrollbar.patch
-- lib/katakata_irb/reline_patches/wholelines.patch
-- lib/katakata_irb/ruby_lex_patch.rb
-- lib/katakata_irb/trex.rb
+- lib/katakata_irb/nesting_parser.rb
 - lib/katakata_irb/type_simulator.rb
 - lib/katakata_irb/types.rb
 - lib/katakata_irb/version.rb
@@ -70,14 +74,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.5
 signing_key:
 specification_version: 4
 summary: IRB with Typed Completion