rbs-siggen 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e403c0c57cc49ef98ae97fc5f63ee2f0c7bfdb3d4311fd45239fc8c7c3c18a7
-  data.tar.gz: 98fcb8dd20631d140fd925ce71f0f8864f47c0b1e3ad22cc8db536b9f3a42d25
+  metadata.gz: c368db792e08e8417cfc36a43cac9aa49e33eeeaf60c39cc7700db494832553b
+  data.tar.gz: 11ac12278d9d200e6258fb7230623213e3342006d138127b17f5fd24a454919d
 SHA512:
-  metadata.gz: fa1febf6e6fe41d8bf020f1854cf0f41e956eec2b017d5c468196cfd78cb5cd802e7f6367c027cb9d1bfaf408252181c4d018ca66ca4e63e32a47d727de995e7
-  data.tar.gz: 8bb8326380805b4a6732328e3715cf9e1315c9e3ad8d926b41857a4dff7a42185a6f9081d29dcb4a4e785c7761d2ea1f5cc67262c43e3f0141d85d0927786757
+  metadata.gz: d0ece64d8a739c938ad31197082f29fb7db72141a3932512117ea8e42073c56002b6db12fc4fdd130e25bc1d4c78178b1a39345299726344bebdab59a8059ed0
+  data.tar.gz: aec7870eb75d4fb9d568a546218d4807e1190ac9521b7e50392e0aac4089f79abc5bf6303c621cfddb6f54f44883ba6b0f0e4683a4855308b46147091173eb5c

data/Rakefile

@@ -16,3 +16,12 @@ Steep::RakeTask.new do |t|
 end
 
 task default: %i[test rubocop steep]
+
+desc "Generate siggen/*.rbs"
+task :run_erb do
+  infile = "siggen/activerecord_model.rbs.erb"
+  outfile = "siggen/activerecord_model.rbs"
+  sh %|ruby -rerb -e 'ERB.new(File.read("#{infile}"), trim_mode: ?-).run' > #{outfile}|
+end
+
+task install: :run_erb

data/Steepfile

@@ -12,5 +12,6 @@ target :test do
   unreferenced!
   signature "sig/test"
   check "test"
+  ignore "test/lib"
   configure_code_diagnostics(D::Ruby.lenient)
 end

data/exe/rbs-siggen

@@ -6,12 +6,16 @@ require "rbs/siggen"
 require "pathname"
 require "optparse"
 
-options = { sig_dir: "sig" }
+options = { sig_dirs: [], rails: false }
 parser = OptionParser.new do |opts|
   opts.banner = "Usage: rbs-siggen [options] <lib-path>"
 
-  opts.on("--sig-dir DIR", "Path to RBS signature directory (default: sig)") do |dir|
-    options[:sig_dir] = dir
+  opts.on("--sig-dir DIR", "Path to RBS signature directory (can be specified multiple times)") do |dir|
+    options[:sig_dirs] << dir
+  end
+
+  opts.on("--rails", "Preset to generate signatures for Rails applications") do
+    options[:rails] = true
   end
 
   opts.on("-v", "--version", "Show version") do
@@ -27,14 +31,47 @@ end
 
 parser.parse!
 
-if ARGV.empty?
+if ARGV.empty? && !options[:rails]
   puts parser
   exit 1
 end
 
+options[:sig_dirs] = ["sig"] if options[:sig_dirs].empty?
+
 lib_path = ARGV[0]
 
-siggen = RBS::Siggen.new(path: options[:sig_dir])
-siggen.analyze(path: Pathname(lib_path)) do |siggen, _|
-  puts siggen.generate
+siggen = RBS::Siggen.new do |env_loader|
+  options[:sig_dirs].each do |dir|
+    env_loader.add path: Pathname(dir)
+  end
+
+  Dir.glob("#{Dir.pwd}/**/rbs_collection.yaml").each do |path|
+    content = YAML.load_file(path)
+    env_loader.add path: Pathname(content["path"]) if Dir.exist?(content["path"])
+  end
+
+  if options[:rails]
+    spec = Gem::Specification.find_by_name("rbs-siggen")
+    env_loader.add path: Pathname(spec.gem_dir) / "siggen"
+  end
+end
+
+def find_rails_root(start_dir = Dir.pwd)
+  Pathname.new(start_dir).ascend do |path|
+    return path if File.exist? "#{path}/config/application.rb"
+  end
+  nil
+end
+
+if options[:rails] && lib_path.nil?
+  rails_root = find_rails_root
+  if rails_root
+    siggen.analyze(path: "#{rails_root}/db/schema.rb") do |siggen, _|
+      puts siggen.generate
+    end
+  end
+else
+  siggen.analyze(path: Pathname(lib_path)) do |siggen, _|
+    puts siggen.generate
+  end
 end

data/lib/rbs/siggen/version.rb

@@ -2,6 +2,6 @@
 
 module RBS
   class Siggen
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/rbs/siggen.rb

@@ -13,11 +13,11 @@ module RBS
     # @rbs @typing: untyped
     # @rbs @node: Parser::AST::Node
 
-    #: (path: String) -> void
-    def initialize(path: "sig")
+    #: () ?{ (RBS::EnvironmentLoader) -> void } -> void
+    def initialize
       core_root = RBS::EnvironmentLoader::DEFAULT_CORE_ROOT
       env_loader = RBS::EnvironmentLoader.new(core_root: core_root)
-      env_loader.add path: Pathname(path)
+      yield env_loader if block_given?
 
       env = RBS::Environment.new
       env_loader.load(env: env)
@@ -33,7 +33,7 @@ module RBS
 
     #: (path: String) { (Siggen, String) -> void } -> void
     def analyze(path:)
-      ruby_files = Dir.glob("#{path}/**/*.rb")
+      ruby_files = Dir.glob(path) + Dir.glob("#{path}/**/*.rb")
       ruby_files.each do |file|
         analyze_ruby(File.read(file), name: file)
         yield self, file
@@ -102,7 +102,7 @@ module RBS
                                                  annotations: annotations,
                                                  context: context,
                                                  typing: typing)
-      construction.synthesize(source.node)
+      construction.synthesize(source.node) unless source.node.nil?
 
       @typing = typing
       @node = source.node
@@ -111,64 +111,233 @@ module RBS
 
     #: () -> String
     def generate
-      result = {} #: Hash[String, Array[String]]
+      io = ::StringIO.new
+      traverse(@node) do |class_name, anno, arg_hash|
+        generated = ERB.new(anno).result_with_hash(arg_hash)
+        surround_class_def = false
+        begin
+          ::RBS::Parser.parse_signature(generated)
+        rescue ::RBS::ParsingError => e
+          if e.message =~ /Syntax error: cannot start a declaration/
+            surround_class_def = true
+          else
+            # TODO: Should output human readable error messages
+            puts generated # for debug
+            raise e
+          end
+        end
 
-      traverse(@node) do |node, call_of|
-        next unless node.type == :send
+        io.puts "class #{class_name}" if surround_class_def
+        io.puts generated
+        io.puts "end" if surround_class_def
+      end
+      io.rewind
+      _, _, decls = ::RBS::Parser.parse_signature(io.read || "")
+      return "" if decls.empty?
 
-        _, _, *args = node.children
-        args = args.map { |a| a.children[0] }
+      io = ::StringIO.new
+      ::RBS::Writer.new(out: io).write(merge_class_declarations(decls))
+      io.rewind
+      io.readlines.reject { |line| line.strip.empty? }.join
+    end
 
-        call_of.method_decls.each do |method_decl|
-          receiver_type = method_decl.method_name.type_name
-          class_name = "#{receiver_type.namespace}#{receiver_type.name}"
+    #: (Parser::AST::Node node, ?Array[untyped] stack) ?{ (String, untyped, Hash[untyped, untyped]) -> void } -> void
+    def traverse(node, stack = [], &block)
+      return unless node.is_a?(::Parser::AST::Node)
 
-          rp = method_decl.method_def.type.type.required_positionals.map(&:name)
-          arg_hash = rp.zip(args).to_h
+      call_of = begin
+        @typing.call_of(node:)
+      rescue StandardError
+        nil
+      end
+
+      if call_of.nil? ||
+         call_of.is_a?(Steep::TypeInference::MethodCall::NoMethodError) || # steep:ignore
+         call_of.is_a?(Steep::TypeInference::MethodCall::Untyped) # steep:ignore
+        node.children.each do |child|
+          traverse(child, stack, &block)
+        end
+      elsif %i[send block].include?(node.type) # steep:ignore
+        call_of.method_decls.each do |method_decl|
           annos = method_decl.method_def
                              .member_annotations
                              .filter { |a| a.string.include?("siggen:") }
                              .map { |a| a.string.split("siggen:")[1].strip }
           next if annos.empty?
 
-          result[class_name] ||= []
-          annos.each do |anno|
-            result[class_name] << ERB.new(anno).result_with_hash(arg_hash)
+          arg_hash = {} #: Hash[untyped, untyped]
+          stack.each do |n, c|
+            arg_hash.merge!({ c.method_name.to_sym => hash_to_data(create_arg_hash(n, c.method_decls.first)) })
           end
+          arg_hash.merge!(create_arg_hash(node, method_decl))
+
+          annos.each { |anno| yield(create_class_name(method_decl), anno, arg_hash) }
         end
-      end
 
-      io = ::StringIO.new
-      result.each do |key, values|
-        io.puts "class #{key}"
-        values.each do |v|
-          io.puts "  #{v}"
+        if node.type == :block
+          stack << [node, call_of]
+          node.children.each do |child|
+            traverse(child, stack, &block)
+          end
+          stack.pop
+        end
+      else # rubocop:disable Lint/DuplicateBranch
+        node.children.each do |child|
+          traverse(child, stack, &block)
         end
-        io.puts "end"
       end
-      io.rewind
-      io.read || ""
     end
 
-    #: (untyped node) ?{ (Parser::AST::Node node, untyped call_of) -> void } -> void
-    def traverse(node, &block)
-      return unless node.is_a?(::Parser::AST::Node)
+    #: (untyped) -> String
+    def create_class_name(method_decl)
+      receiver_type = method_decl.method_name.type_name.relative!
+      "#{receiver_type.namespace}#{receiver_type.name}"
+    end
 
-      call_of = begin
-        @typing.call_of(node:)
-      rescue StandardError
-        nil
+    #: (Parser::AST::Node, untyped) -> Hash[Symbol, untyped]
+    def create_arg_hash(node, method_decl)
+      send_node = node.type == :block ? node.children.first : node
+      _, _, *args = send_node.children
+      args = args.map { |arg_node| arg_node.type == :kwargs ? arg_node.children : arg_node.children[0] }.flatten
+      positional_args = args.reject { |arg_node| arg_node.respond_to?(:type) && arg_node.type == :pair }
+      keyword_args = args.filter do |arg_node|
+                       arg_node.respond_to?(:type) && arg_node.type == :pair
+                     end.to_h do |pair_node| # rubocop:disable Style/MultilineBlockChain
+                       key = pair_node.children[0].children[0]
+                       val_node = pair_node.children[1]
+                       val = val_node.children[0] || val_node
+                       val = val.type == :true if val.respond_to?(:type) # rubocop:disable Lint/BooleanSymbol
+                       [key, val]
+                     end
+
+      type = method_decl.method_def.type.type
+      hash = {} #: Hash[Symbol, untyped]
+      hash[:___node] = send_node
+      hash[:___source] = commentify(node.location.expression.source, node.location.expression.column)
+      hash[:___comment_of] = self
+
+      type.required_positionals.map(&:name).each do |name|
+        hash[name] = positional_args.shift
+      end
+      type.optional_positionals.map(&:name).each do |name|
+        hash[name] = positional_args.shift
       end
+      hash[type.rest_positionals.name] = positional_args.dup unless type.rest_positionals.nil?
 
-      unless call_of.nil? ||
-             call_of.is_a?(Steep::TypeInference::MethodCall::NoMethodError) || # steep:ignore
-             call_of.is_a?(Steep::TypeInference::MethodCall::Untyped) # steep:ignore
-        yield(node, call_of)
+      type.required_keywords.each_key do |name|
+        hash[name] = keyword_args[name]
+        keyword_args.delete(name)
       end
+      type.optional_keywords.each_key do |name|
+        hash[name] = keyword_args[name]
+        keyword_args.delete(name)
+      end
+      hash[type.rest_keywords.name] = keyword_args.dup unless type.rest_keywords.nil?
+      hash
+    end
+
+    #: (Hash[Symbol, untyped]) -> untyped
+    def hash_to_data(hash)
+      Data.define(*hash.keys).new(*hash.values)
+    end
 
-      node.children.each do |child|
-        traverse(child, &block)
+    #: (Array[untyped]) -> Array[untyped]
+    def merge_class_declarations(decls)
+      # 同じ名前のClass宣言をグループ化
+      grouped = decls.group_by do |decl|
+        case decl
+        when RBS::AST::Declarations::Class
+          [:class,
+           decl.name]
+        when RBS::AST::Declarations::Module
+          [:module,
+           decl.name]
+        else
+          [:other, decl.object_id] # その他はマージしない
+        end
       end
+
+      grouped.map do |(kind, _name), group|
+        if kind == :class && group.size > 1
+          # 複数のClass宣言をマージ
+          primary = group.find(&:super_class) || group.first
+          merged_members = merge_class_declarations(group.flat_map(&:members))
+          merged_annotations = group.flat_map(&:annotations).uniq
+          merged_comment = group.map(&:comment).compact.first
+
+          RBS::AST::Declarations::Class.new(
+            name: primary.name,
+            type_params: primary.type_params,
+            super_class: primary.super_class,
+            members: merged_members,
+            annotations: merged_annotations,
+            location: primary.location,
+            comment: merged_comment
+          )
+        elsif kind == :module && group.size > 1
+          # 複数のModule宣言をマージ
+          primary = group.first
+          merged_members = merge_class_declarations(group.flat_map(&:members))
+          merged_annotations = group.flat_map(&:annotations).uniq
+          merged_comment = group.map(&:comment).compact.first
+          merged_self_types = group.flat_map(&:self_types).uniq
+
+          RBS::AST::Declarations::Module.new(
+            name: primary.name,
+            type_params: primary.type_params,
+            self_types: merged_self_types,
+            members: merged_members,
+            annotations: merged_annotations,
+            location: primary.location,
+            comment: merged_comment
+          )
+        else
+          group
+        end
+      end.flatten
+    end
+
+    #: (String) -> Array[untyped]
+    def method_definitions(type_with_name)
+      definition_builder = RBS::DefinitionBuilder.new(env: @env)
+
+      definition = if type_with_name.include?("#")
+                     type, name = type_with_name.split("#")
+                     return [] if type.nil? || name.nil?
+
+                     type_name = TypeName.parse(type).absolute!
+                     return [] unless @env.module_name?(type_name)
+
+                     definition_builder.build_instance(type_name)
+                   else
+                     type, name = type_with_name.split(".")
+                     return [] if type.nil? || name.nil?
+
+                     type_name = TypeName.parse(type).absolute!
+                     return [] unless @env.module_name?(type_name)
+
+                     definition_builder.build_singleton(TypeName.parse(type).absolute!)
+                   end
+
+      method = definition.methods[name.to_sym]
+      return [] unless method
+
+      method.defs.map(&:member)
+    end
+
+    #: (String) -> String
+    def comment_of(type_with_name)
+      method_definitions(type_with_name).map(&:comment).map(&:string).join("\n")
+    end
+
+    #: (String, ?Integer) -> String
+    def commentify(string, start_column = 0)
+      string.each_line.map { |line| "# #{line.sub(/\A {0,#{start_column}}/, "")}" }.join.chomp.gsub(/\A# /, "")
+    end
+
+    #: (String) -> String
+    def [](type_with_name)
+      commentify(comment_of(type_with_name))
     end
   end
 end

data/sig/generated/rbs/siggen/version.rbs

@@ -0,0 +1,7 @@
+# Generated from lib/rbs/siggen/version.rb with RBS::Inline
+
+module RBS
+  class Siggen
+    VERSION: ::String
+  end
+end

data/sig/generated/rbs/siggen.rbs

@@ -2,14 +2,14 @@
 
 module RBS
   class Siggen
-    @env: RBS::Environment
+    @node: Parser::AST::Node
 
     @typing: untyped
 
-    @node: Parser::AST::Node
+    @env: RBS::Environment
 
-    # : (path: String) -> void
-    def initialize: (path: String) -> void
+    # : () ?{ (RBS::EnvironmentLoader) -> void } -> void
+    def initialize: () ?{ (RBS::EnvironmentLoader) -> void } -> void
 
     # : (String sig_string, ?name: String) -> void
     def add_signature: (String sig_string, ?name: String) -> void
@@ -23,7 +23,31 @@ module RBS
     # : () -> String
     def generate: () -> String
 
-    # : (untyped node) ?{ (Parser::AST::Node node, untyped call_of) -> void } -> void
-    def traverse: (untyped node) ?{ (Parser::AST::Node node, untyped call_of) -> void } -> void
+    # : (Parser::AST::Node node, ?Array[untyped] stack) ?{ (String, untyped, Hash[untyped, untyped]) -> void } -> void
+    def traverse: (Parser::AST::Node node, ?Array[untyped] stack) ?{ (String, untyped, Hash[untyped, untyped]) -> void } -> void
+
+    # : (untyped) -> String
+    def create_class_name: (untyped) -> String
+
+    # : (Parser::AST::Node, untyped) -> Hash[Symbol, untyped]
+    def create_arg_hash: (Parser::AST::Node, untyped) -> Hash[Symbol, untyped]
+
+    # : (Hash[Symbol, untyped]) -> untyped
+    def hash_to_data: (Hash[Symbol, untyped]) -> untyped
+
+    # : (Array[untyped]) -> Array[untyped]
+    def merge_class_declarations: (Array[untyped]) -> Array[untyped]
+
+    # : (String) -> Array[untyped]
+    def method_definitions: (String) -> Array[untyped]
+
+    # : (String) -> String
+    def comment_of: (String) -> String
+
+    # : (String, ?Integer) -> String
+    def commentify: (String, ?Integer) -> String
+
+    # : (String) -> String
+    def []: (String) -> String
   end
 end

data/siggen/activerecord_model.rbs

@@ -0,0 +1,116 @@
+module ActiveRecord
+  class Schema
+    def self.[]: (untyped version) -> ActiveRecord::Migration::Current
+  end
+  class Migration
+    class Current
+      def define: (version: untyped) { () [self: instance] -> void } -> void
+      %a{siggen:
+        # In schema.rb, this model is declared as:
+        #
+        # ```ruby
+        # <%= ___source %>
+        # ```
+        class <%= table_name.classify %>
+          include GeneratedAttributeMethods
+        end
+      }
+      def create_table: (untyped table_name, **untyped options) { (ActiveRecord::ConnectionAdapters::ColumnMethods t) -> void } -> void
+    end
+  end
+  module ConnectionAdapters
+    module ColumnMethods
+        %a{siggen:
+          class <%= create_table.table_name.classify %>
+            module GeneratedAttributeMethods
+              <% names.each do |name| %>
+                # In schema.rb, this column is declared as:
+                #
+                # ```ruby
+                # <%= ___source %>
+                # ```
+                #
+                # This method delegates to `ActiveRecord::AttributeMethods::Read` `#_read_attribute`,
+                # passing `"<%= name %>"` as the `attr_name` argument.
+                #
+                # See the documentation comment for the delegated method below:
+                #
+                # <%= ___comment_of["ActiveRecord::AttributeMethods::Read#read_attribute"] %>
+                def <%= name %>: () -> ::String<%= "?" unless options[:null] == false %>
+              <% end %>
+            end
+          end
+        }
+        def text: (*Array[untyped] names, **untyped options) -> void
+        %a{siggen:
+          class <%= create_table.table_name.classify %>
+            module GeneratedAttributeMethods
+              <% names.each do |name| %>
+                # In schema.rb, this column is declared as:
+                #
+                # ```ruby
+                # <%= ___source %>
+                # ```
+                #
+                # This method delegates to `ActiveRecord::AttributeMethods::Read` `#_read_attribute`,
+                # passing `"<%= name %>"` as the `attr_name` argument.
+                #
+                # See the documentation comment for the delegated method below:
+                #
+                # <%= ___comment_of["ActiveRecord::AttributeMethods::Read#read_attribute"] %>
+                def <%= name %>: () -> ::String<%= "?" unless options[:null] == false %>
+              <% end %>
+            end
+          end
+        }
+        def string: (*Array[untyped] names, **untyped options) -> void
+        %a{siggen:
+          class <%= create_table.table_name.classify %>
+            module GeneratedAttributeMethods
+              <% names.each do |name| %>
+                # In schema.rb, this column is declared as:
+                #
+                # ```ruby
+                # <%= ___source %>
+                # ```
+                #
+                # This method delegates to `ActiveRecord::AttributeMethods::Read` `#_read_attribute`,
+                # passing `"<%= name %>"` as the `attr_name` argument.
+                #
+                # See the documentation comment for the delegated method below:
+                #
+                # <%= ___comment_of["ActiveRecord::AttributeMethods::Read#read_attribute"] %>
+                def <%= name %>: () -> ::ActiveSupport::TimeWithZone<%= "?" unless options[:null] == false %>
+              <% end %>
+            end
+          end
+        }
+        def datetime: (*Array[untyped] names, **untyped options) -> void
+        %a{siggen:
+          class <%= create_table.table_name.classify %>
+            module GeneratedAttributeMethods
+              <% names.each do |name| %>
+                # In schema.rb, this column is declared as:
+                #
+                # ```ruby
+                # <%= ___source %>
+                # ```
+                #
+                # This method delegates to `ActiveRecord::AttributeMethods::Read` `#_read_attribute`,
+                # passing `"<%= name %>"` as the `attr_name` argument.
+                #
+                # See the documentation comment for the delegated method below:
+                #
+                # <%= ___comment_of["ActiveRecord::AttributeMethods::Read#read_attribute"] %>
+                def <%= name %>: () -> ::Integer<%= "?" unless options[:null] == false %>
+              <% end %>
+            end
+          end
+        }
+        def integer: (*Array[untyped] names, **untyped options) -> void
+    end
+    class TableDefinition
+      include ColumnMethods
+    end
+  end
+end

data/siggen/activerecord_model.rbs.erb

@@ -0,0 +1,53 @@
+<%# ruby -rerb -e 'ERB.new(File.read("siggen/activerecord_model.rbs.erb"), trim_mode: ?-).run' > siggen/activerecord_model.rbs -%>
+module ActiveRecord
+  class Schema
+    def self.[]: (untyped version) -> ActiveRecord::Migration::Current
+  end
+  class Migration
+    class Current
+      def define: (version: untyped) { () [self: instance] -> void } -> void
+      %a{siggen:
+        # In schema.rb, this model is declared as:
+        #
+        # ```ruby
+        # <%%= ___source %>
+        # ```
+        class <%%= table_name.classify %>
+          include GeneratedAttributeMethods
+        end
+      }
+      def create_table: (untyped table_name, **untyped options) { (ActiveRecord::ConnectionAdapters::ColumnMethods t) -> void } -> void
+    end
+  end
+  module ConnectionAdapters
+    module ColumnMethods
+      <%- { text: "::String", string: "::String", datetime: "::ActiveSupport::TimeWithZone", integer: "::Integer" }.each do |key, type| -%>
+        %a{siggen:
+          class <%%= create_table.table_name.classify %>
+            module GeneratedAttributeMethods
+              <%% names.each do |name| %>
+                # In schema.rb, this column is declared as:
+                #
+                # ```ruby
+                # <%%= ___source %>
+                # ```
+                #
+                # This method delegates to `ActiveRecord::AttributeMethods::Read` `#_read_attribute`,
+                # passing `"<%%= name %>"` as the `attr_name` argument.
+                #
+                # See the documentation comment for the delegated method below:
+                #
+                # <%%= ___comment_of["ActiveRecord::AttributeMethods::Read#read_attribute"] %>
+                def <%%= name %>: () -> <%= type %><%%= "?" unless options[:null] == false %>
+              <%% end %>
+            end
+          end
+        }
+        def <%= key %>: (*Array[untyped] names, **untyped options) -> void
+      <%- end -%>
+    end
+    class TableDefinition
+      include ColumnMethods
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbs-siggen
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Koji NAKAMURA
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement
@@ -55,7 +69,9 @@ files:
 - rbs_collection.lock.yaml
 - rbs_collection.yaml
 - sig/generated/rbs/siggen.rbs
-- sig/rbs/siggen.rbs
+- sig/generated/rbs/siggen/version.rbs
+- siggen/activerecord_model.rbs
+- siggen/activerecord_model.rbs.erb
 homepage: https://github.com/kozy4324/rbs-siggen
 licenses:
 - MIT

data/sig/rbs/siggen.rbs

@@ -1,5 +0,0 @@
-module RBS
-  class Siggen
-    VERSION: String
-  end
-end