rbs_goose 0.1.1 → 0.2.0

data/examples/fix_errors/Steepfile

@@ -0,0 +1,6 @@
+target :lib do
+  signature "sig"
+  # signature "refined/sig"
+
+  check "lib"
+end

data/examples/fix_errors/error_messages.txt

@@ -0,0 +1,26 @@
+# Type checking files:
+
+..........................F.............................................F...............F
+
+sig/phone.rbs:8:22: [error] Instance variable cannot have different type with parents: ::Integer <=> ::String
+│ Diagnostic ID: RBS::InstanceVariableTypeError
+│
+└   attr_reader number: Integer
+                        ~~~~~~~
+
+sig/person.rbs:8:24: [error] Instance variable cannot have different type with parents: ::Array[::String] <=> ::Array[(::Email | ::Phone)]
+│ Diagnostic ID: RBS::InstanceVariableTypeError
+│
+└   attr_reader contacts: Array[String]
+                          ~~~~~~~~~~~~~
+
+lib/person.rb:15:6: [error] Cannot allow method body have type `(::String | nil)` because declared as type `::String`
+│   (::String | nil) <: ::String
+│     nil <: ::String
+│
+│ Diagnostic ID: Ruby::MethodBodyTypeMismatch
+│
+└   def guess_country()
+        ~~~~~~~~~~~~~
+
+Detected 3 problems from 3 files

data/{lib/rbs_goose/examples/rbs_samples → examples/fix_errors}/refined/sig/email.rbs

@@ -5,7 +5,7 @@ class Email
 
   def initialize: (address: String) -> void
 
-  def ==: (untyped other) -> bool
+  def ==: (Object other) -> bool
 
   def hash: () -> Integer
 end

data/{lib/rbs_goose/examples/rbs_samples → examples/fix_errors}/refined/sig/person.rbs

@@ -1,11 +1,11 @@
 class Person
   @name: String
 
-  @contacts: Array[Email | Phone]
+  @contacts: Array[(Email | Phone)]
 
   attr_reader name: String
 
-  attr_reader contacts: Array[Email | Phone]
+  attr_reader contacts: Array[(Email | Phone)]
 
   def initialize: (name: String) -> void
 

data/{lib/rbs_goose/examples/rbs_samples → examples/fix_errors}/refined/sig/phone.rbs

@@ -9,7 +9,7 @@ class Phone
 
   def initialize: (country: String, number: String) -> void
 
-  def ==: (untyped other) -> (bool | nil)
+  def ==: (Object other) -> (bool | nil)
 
   def hash: () -> Integer
 end

data/examples/fix_errors/sig/email.rbs

@@ -0,0 +1,11 @@
+class Email
+  @address: String
+
+  attr_reader address: String
+
+  def initialize: (address: String) -> void
+
+  def ==: (Object other) -> bool
+
+  def hash: () -> Integer
+end

data/examples/fix_errors/sig/person.rbs

@@ -0,0 +1,15 @@
+class Person
+  @name: String
+
+  @contacts: Array[Email | Phone]
+
+  attr_reader name: String
+
+  attr_reader contacts: Array[String]
+
+  def initialize: (name: Integer) -> void
+
+  def name=: (String name) -> void
+
+  def guess_country: () -> String
+end

data/examples/fix_errors/sig/phone.rbs

@@ -0,0 +1,15 @@
+class Phone
+  @country: String
+
+  @number: String
+
+  attr_reader country: String
+
+  attr_reader number: Integer
+
+  def initialize: (country: String, number: String) -> void
+
+  def ==: (Object other) -> (bool | nil)
+
+  def hash: () -> Integer
+end

data/examples/rbs_samples/lib/email.rb

@@ -0,0 +1,16 @@
+class Email
+  # @dynamic address
+  attr_reader :address
+
+  def initialize(address:)
+    @address = address
+  end
+
+  def ==(other)
+    other.is_a?(self.class) && other.address == address
+  end
+
+  def hash
+    self.class.hash ^ address.hash
+  end
+end

data/examples/rbs_samples/lib/person.rb

@@ -0,0 +1,23 @@
+class Person
+  # @dynamic name, contacts
+  attr_reader :name
+  attr_reader :contacts
+
+  def initialize(name:)
+    @name = name
+    @contacts = []
+  end
+
+  def name=(name)
+    @name = name
+  end
+
+  def guess_country()
+    contacts.map do |contact|
+      case contact
+      when Phone
+        contact.country
+      end
+    end.compact.first
+  end
+end

data/examples/rbs_samples/lib/phone.rb

@@ -0,0 +1,22 @@
+class Phone
+  # @dynamic country, number
+  attr_reader :country, :number
+
+  def initialize(country:, number:)
+    @country = country
+    @number = number
+  end
+
+  def ==(other)
+    if other.is_a?(Phone)
+      # @type var other: Phone
+      other.country == country && other.number == number
+    else
+      false
+    end
+  end
+
+  def hash
+    self.class.hash ^ country.hash ^ number.hash
+  end
+end

data/examples/rbs_samples/refined/sig/email.rbs

@@ -0,0 +1,11 @@
+class Email
+  @address: String
+
+  attr_reader address: String
+
+  def initialize: (address: String) -> void
+
+  def ==: (Object other) -> bool
+
+  def hash: () -> Integer
+end

data/examples/rbs_samples/refined/sig/person.rbs

@@ -0,0 +1,15 @@
+class Person
+  @name: String
+
+  @contacts: Array[(Email | Phone)]
+
+  attr_reader name: String
+
+  attr_reader contacts: Array[(Email | Phone)]
+
+  def initialize: (name: String) -> void
+
+  def name=: (String name) -> void
+
+  def guess_country: () -> (String | nil)
+end

data/examples/rbs_samples/refined/sig/phone.rbs

@@ -0,0 +1,15 @@
+class Phone
+  @country: String
+
+  @number: String
+
+  attr_reader country: String
+
+  attr_reader number: String
+
+  def initialize: (country: String, number: String) -> void
+
+  def ==: (Object other) -> (bool | nil)
+
+  def hash: () -> Integer
+end

data/examples/rbs_syntax/Steepfile

@@ -0,0 +1,6 @@
+target :lib do
+  # signature "sig"
+  signature "refined/sig"
+
+  check "lib"
+end

data/examples/rbs_syntax/lib/a.rb

@@ -0,0 +1,53 @@
+module M1
+  def m1(n)
+    "M1#{n}"
+  end
+end
+
+module M2
+  def m2(s)
+    s.to_i
+  end
+end
+
+class Base
+  attr_reader :a, :b
+
+  def initialize(a, b = nil)
+    @a = a
+    @b = b
+  end
+end
+
+class A < Base
+  include M1
+  extend M2
+  prepend Enumerable
+
+  attr_accessor :c
+  attr_reader :d, :f
+
+  def initialize(a, b = nil, c:, d:, f:)
+    super(a, b)
+    @c = c
+    @d = d
+    @f = f
+  end
+
+  def foo(foo)
+    n = foo[:i] || 0
+    s = "#{foo[:s]}#{n}"
+    r = @f.call(s)
+    FormattableString.new(r)
+  end
+
+  def self.bar
+    rand(2) == 0 ? "str" : 123
+  end
+
+  def each
+    yield 1
+    yield 2
+    yield 3
+  end
+end

data/examples/rbs_syntax/lib/list.rb

@@ -0,0 +1,9 @@
+module List
+  def self.cons(item, rest = nil)
+    [item, rest]
+  end
+
+  def self.sum(list)
+    list.nil? ? 0 : list[0] + sum(list[1])
+  end
+end

data/examples/rbs_syntax/lib/main.rb

@@ -0,0 +1,17 @@
+LITERAL_TYPES = [123, "str", :sym, true, false]
+
+$GLOBAL_PROC = proc { |subject| "formatted: #{subject}" }
+
+module Formattable
+  def format(formatter)
+    formatter.call(self.to_s)
+  end
+end
+
+class FormattableString < String
+  include Formattable
+
+  def format(formatter)
+    formatter.call(to_s)
+  end
+end

data/examples/rbs_syntax/refined/sig/a.rbs

@@ -0,0 +1,47 @@
+module M1
+  def m1: (Integer) -> String
+end
+
+module M2
+  def m2: (String) -> Integer
+end
+
+class Base
+  @a: String
+
+  @b: Integer?
+
+  attr_reader a: String
+
+  attr_reader b: Integer?
+
+  def initialize: (String a, ?Integer? b) -> void
+end
+
+class A < Base
+  @c: bool
+
+  @d: [String, Integer]
+
+  @f: formatter
+
+  include M1
+
+  extend M2
+
+  prepend Enumerable[Integer]
+
+  attr_accessor c: bool
+
+  attr_reader d: [String, Integer]
+
+  attr_reader f: formatter
+
+  def initialize: (String a, ?Integer? b, c: bool c, d: [String, Integer], f: formatter) -> void
+
+  def foo: (foo) -> formattable_subject
+
+  def self.bar: () -> (Integer | String)
+
+  def each: () { (Integer) -> void } -> void
+end

data/examples/rbs_syntax/refined/sig/list.rbs

@@ -0,0 +1,7 @@
+module List
+  type t[out T] = [T, t[T]] | nil
+
+  def self.cons: [T] (T, ?t[T]) -> t[T]
+
+  def self.sum: (t[Integer]) -> Integer
+end

data/examples/rbs_syntax/refined/sig/main.rbs

@@ -0,0 +1,26 @@
+LITERAL_TYPES: [Integer, String, Symbol, (true | false)]
+
+$GLOBAL_PROC: formatter
+
+type subject = (String | Integer)
+type formatter = ^(subject) [self: BasicObject] -> String
+type formattable_subject = subject & _Formattable
+
+type foo = {
+  s: String,
+  i: Integer?,
+  f: formatter
+}
+
+interface _Formattable
+  def format: (formatter formatter) -> String
+end
+
+module Formattable : _Formattable
+end
+
+class FormattableString < String
+  include Formattable
+
+  def format: (formatter formatter) -> String
+end

data/examples/rbs_syntax/sig/a.rbs

@@ -0,0 +1,47 @@
+module M1
+  def m1: (untyped n) -> ::String
+end
+
+module M2
+  def m2: (untyped s) -> untyped
+end
+
+class Base
+  @a: untyped
+
+  @b: untyped
+
+  attr_reader a: untyped
+
+  attr_reader b: untyped
+
+  def initialize: (untyped a, ?untyped? b) -> void
+end
+
+class A < Base
+  @c: untyped
+
+  @d: untyped
+
+  @f: untyped
+
+  include M1
+
+  extend M2
+
+  prepend Enumerable
+
+  attr_accessor c: untyped
+
+  attr_reader d: untyped
+
+  attr_reader f: untyped
+
+  def initialize: (untyped a, ?untyped? b, c: untyped, d: untyped, f: untyped) -> void
+
+  def foo: (untyped foo) -> untyped
+
+  def self.bar: () -> ("str" | 123)
+
+  def each: () { (untyped) -> untyped } -> untyped
+end

data/examples/rbs_syntax/sig/list.rbs

@@ -0,0 +1,7 @@
+module List
+  type t = untyped
+
+  def self.cons: (untyped item, ?untyped? rest) -> ::Array[untyped]
+
+  def self.sum: (untyped list) -> (0 | untyped)
+end

data/examples/rbs_syntax/sig/main.rbs

@@ -0,0 +1,26 @@
+LITERAL_TYPES: [Integer, String, Symbol, true | false]
+
+$GLOBAL_PROC: formatter
+
+type subject = String | Integer
+type formatter = ^(subject) [self: BasicObject] -> String
+type formattable_subject = subject & _Formattable
+
+type foo = {
+  s: String,
+  i: Integer?,
+  f: formatter
+}
+
+interface _Formattable
+  def format: (formatter formatter) -> String
+end
+
+module Formattable : _Formattable
+end
+
+class FormattableString < String
+  include Formattable
+
+  def format: (untyped formatter) -> untyped
+end

data/lib/rbs_goose/configuration.rb

@@ -1,40 +1,98 @@
 # frozen_string_literal: true
 
-require 'openai'
 require 'langchain'
 
+require 'forwardable'
+
 module RbsGoose
   class Configuration
-    def initialize(&block)
-      self.instruction = default_instruction
-      self.example_groups = default_example_groups
-      self.template_class = default_template_class
-      instance_eval(&block) if block_given?
-    end
-
-    attr_accessor :llm, :instruction, :example_groups, :template_class
-
-    def use_open_ai(open_ai_access_token, default_options: {})
-      @llm = ::Langchain::LLM::OpenAI.new(
-        api_key: open_ai_access_token,
-        default_options: {
-          completion_model_name: 'gpt-3.5-turbo-1106',
-          chat_completion_model_name: 'gpt-3.5-turbo-1106'
-        }.merge(default_options)
+    extend Forwardable
+
+    LLMConfig = Struct.new(:client, :mode, keyword_init: true)
+
+    TemplateConfig = Struct.new(:instruction, :example_groups, :template_class, keyword_init: true) do
+      def build_template
+        template_class.new(instruction:, example_groups:)
+      end
+    end
+
+    def initialize(&)
+      self.infer_template = default_infer_template
+      self.fix_error_template = default_fix_error_template
+      instance_eval(&) if block_given?
+    end
+
+    attr_accessor :llm, :infer_template, :fix_error_template
+
+    def use_open_ai( # rubocop:disable Metrics/MethodLength
+      open_ai_access_token, model_name: 'gpt-3.5-turbo-1106', mode: :chat,
+      llm_options: {}, default_options: {}
+    )
+      @llm = LLMConfig.new(
+        client: ::Langchain::LLM::OpenAI.new(
+          api_key: open_ai_access_token,
+          llm_options: { request_timeout: 600 }.merge(llm_options),
+          default_options: {
+            completion_model_name: model_name,
+            chat_completion_model_name: model_name
+          }.merge(default_options)
+        ),
+        mode:
+      )
+    end
+
+    def use_anthropic(access_token, model_name: 'claude-3-haiku-20240307', mode: :chat, default_options: {}) # rubocop:disable Metrics/MethodLength
+      @llm = LLMConfig.new(
+        client: ::Langchain::LLM::Anthropic.new(
+          api_key: access_token,
+          default_options: {
+            completion_model_name: model_name,
+            chat_completion_model_name: model_name,
+            max_tokens_to_sample: 4096
+          }.merge(default_options)
+        ),
+        mode:
       )
     end
 
-    def template
-      @template ||= template_class.new(instruction: instruction, example_groups: example_groups)
+    def use_ollama(url: 'http://localhost:11434', model_name: 'codegemma', mode: :complete, default_options: {}) # rubocop:disable Metrics/MethodLength
+      @llm = LLMConfig.new(
+        client: ::Langchain::LLM::Ollama.new(
+          url:,
+          default_options: {
+            temperature: 0.0,
+            completion_model_name: model_name,
+            chat_completion_model_name: model_name
+          }.merge(default_options)
+        ),
+        mode:
+      )
     end
 
+    def_delegator :llm, :client, :llm_client
+    def_delegator :llm, :mode, :llm_mode
+    def_delegator :infer_template, :instruction, :infer_instruction
+    def_delegator :infer_template, :example_groups, :infer_example_groups
+
     private
 
-    def default_template_class
-      Templates::DefaultTemplate
+    def default_infer_template
+      TemplateConfig.new(
+        instruction: default_infer_instruction,
+        example_groups: default_infer_example_groups,
+        template_class: Templates::InferTemplate
+      )
+    end
+
+    def default_fix_error_template
+      TemplateConfig.new(
+        instruction: default_fix_error_instruction,
+        example_groups: default_fix_error_example_groups,
+        template_class: Templates::FixErrorTemplate
+      )
     end
 
-    def default_instruction
+    def default_infer_instruction
       <<~INSTRUCTION
         Act as Ruby type inferrer.
         When ruby source codes and RBS type signatures are given, refine each RBS type signatures. Each file should be split in markdown code format.
@@ -42,8 +100,20 @@ module RbsGoose
       INSTRUCTION
     end
 
-    def default_example_groups
+    def default_infer_example_groups
       [RbsGoose::IO::ExampleGroup.default_examples[:rbs_samples]]
     end
+
+    def default_fix_error_instruction
+      <<~INSTRUCTION
+        You are a highly skilled programmer.
+        Based on the following Ruby code, the RBS code that is a type definition, and the type checking error messages for them, modify the RBS code and output it.
+        All RBS files should be output, regardless of whether they have been modified or not.
+      INSTRUCTION
+    end
+
+    def default_fix_error_example_groups
+      [RbsGoose::IO::ExampleGroup.default_examples[:fix_errors]]
+    end
   end
 end

data/lib/rbs_goose/io/example.rb

@@ -6,7 +6,7 @@ module RbsGoose
       class << self
         def from_path(ruby_path:, rbs_path:, refined_rbs_dir:, base_path:)
           Example.new(
-            typed_ruby: TypedRuby.from_path(ruby_path: ruby_path, rbs_path: rbs_path, base_path: base_path),
+            typed_ruby: TypedRuby.from_path(ruby_path:, rbs_path:, base_path:),
             refined_rbs: File.new(path: rbs_path, base_path: ::File.join(base_path, refined_rbs_dir))
           )
         end
@@ -18,7 +18,7 @@ module RbsGoose
       end
 
       def to_h
-        { typed_ruby: typed_ruby, refined_rbs: refined_rbs }
+        { typed_ruby:, refined_rbs: }
       end
 
       attr_reader :typed_ruby, :refined_rbs