rbs-patch 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fd64b165683dbb9350cc535cd07176d1e5b74fd3814b72b7d4e94ad9e8deafe
-  data.tar.gz: 48b0f85c818af5f23bafd3d7b7acbe281b5f3c7ba8c26f270d04c1e1b910f9d3
+  metadata.gz: ef229a0a3efd1a66cdc57652ef80b173d19311652f376422a06bad6d61d3c7b5
+  data.tar.gz: 364bff243f157949a91b88c936a953e88cf275589312c664df1a9f6cc2d89c40
 SHA512:
-  metadata.gz: 1548885b396ccff12ebe6ae6c1b5272133248623db7360378283b9f707f17462c1bd7e5d26a9107865277e23fad005f9f83b779cdca992943bc33dccefc3bad6
-  data.tar.gz: 16da1d9c8b866dc6a4c6c0a6ed8713da52db81556a8e850f26badb6df0f25ba1fd883e81260f26764da667eea2fcb2dba0ceed4f975b7e4b71baeafe04ef5fdc
+  metadata.gz: ad22a7fbeff8115b185977f5d21bfdbd51b53485f1e1896dc0e692fccbf6e8de82b90f499e3702343dbb579798cbe86b4ad871926aa8089763d4e1599d9c29e2
+  data.tar.gz: 2850321317aa8b97317f315b4dce55af70330c724cd279dadbd5f8b0c8f9edc3e4305dbfaeca0aa85365123caa1772b4bb7137487df4b7fbf6c9b6d9ab66c7aa

data/README.md

@@ -27,7 +27,160 @@ gem install rbs-patch
 
 ## Usage
 
-TODO: Write usage instructions here
+### Basic Usage
+
+```bash
+# Apply patches to RBS files
+rbs-patch base.rbs patch1.rbs patch2.rbs
+
+# Mix files and directories
+rbs-patch lib/types/ sig/patches/
+
+# Output goes to stdout - redirect to save
+rbs-patch base.rbs patch.rbs > output.rbs
+```
+
+### Programmatic Usage
+
+```ruby
+require 'rbs/patch'
+
+p = RBS::Patch.new
+
+# Load from a single file
+p.apply(path: Pathname("sig/user.rbs"))
+
+# Load from a directory (all .rbs files)
+p.apply(path: Pathname("sig/patches"))
+
+# Apply from string
+p.apply(<<~RBS)
+  class User
+    %a{patch:override}
+    def name: () -> String?
+  end
+RBS
+
+puts p.to_s
+```
+
+### Annotation Syntax
+
+All patch operations use RBS annotations with the format `%a{patch:operation}` or `%a{patch:operation:target}`.
+
+#### Method-level Operations
+
+##### `override` - Replace existing method signature
+
+```ruby
+class User
+  %a{patch:override}
+  def name: () -> String?  # Replaces existing method signature at the same position
+end
+```
+
+##### `delete` - Remove method signature
+
+```ruby
+class User
+  %a{patch:delete}
+  def email: () -> String  # Removes this method from the class
+end
+```
+
+##### `append_after(method_name)` - Insert method after specified method
+
+```ruby
+class User
+  %a{patch:append_after(name)}
+  def nickname: () -> String?  # Inserts after the 'name' method
+end
+```
+
+##### `prepend_before(method_name)` - Insert method before specified method
+
+```ruby
+class User
+  %a{patch:prepend_before(name)}
+  def id: () -> Integer  # Inserts before the 'name' method
+end
+```
+
+#### Class/Module-level Operations
+
+##### `override` - Replace entire class/module
+
+```ruby
+%a{patch:override}
+class User
+  def name: () -> String  # Completely replaces the User class definition
+end
+```
+
+##### `delete` - Remove class/module
+
+```ruby
+%a{patch:delete}
+class User
+end  # Removes the entire User class
+```
+
+##### `append_after(ClassName)` - Insert class/module after specified class
+
+```ruby
+%a{patch:append_after(User)}
+class Admin
+  def permissions: () -> Array[String]
+end  # Inserts Admin class after User class
+```
+
+##### `prepend_before(ClassName)` - Insert class/module before specified class
+
+```ruby
+%a{patch:prepend_before(User)}
+class Guest
+  def readonly: () -> bool
+end  # Inserts Guest class before User class
+```
+
+### Working with Nested Modules
+
+Operations work correctly within nested module structures:
+
+```ruby
+module MyApp
+  module Models
+    %a{patch:append_after(User)}
+    class Admin
+      def role: () -> String
+    end
+  end
+end
+```
+
+### Merging Multiple Definitions
+
+Without annotations, multiple class definitions are merged:
+
+```ruby
+p.apply(<<~RBS)
+  class User
+    def name: () -> String
+  end
+RBS
+
+p.apply(<<~RBS)
+  class User
+    def email: () -> String  # Adds to existing User class
+  end
+RBS
+
+# Result:
+# class User
+#   def name: () -> String
+#   def email: () -> String
+# end
+```
 
 ## Development
 

data/Rakefile

@@ -9,4 +9,10 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
-task default: %i[test rubocop]
+require "steep/rake_task"
+Steep::RakeTask.new do |t|
+  t.check.severity_level = :error
+  t.watch.verbose
+end
+
+task default: %i[test rubocop steep]

data/Steepfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+target :lib do
+  signature "sig"
+
+  check "lib"
+  library "rbs"
+end

data/exe/rbs-patch

@@ -6,6 +6,8 @@ require "rbs/patch"
 require "pathname"
 
 if ARGV.empty?
+  puts "rbs-patch #{RBS::Patch::VERSION}"
+  puts ""
   puts "Usage: rbs-patch RBS_FILE_PATH [RBS_FILE_PATH ...]"
   puts ""
   puts "Examples:"

data/lib/rbs/patch/version.rb

@@ -2,6 +2,6 @@
 
 module RBS
   class Patch
-    VERSION = "0.1.2"
+    VERSION = "0.1.4"
   end
 end

data/lib/rbs/patch.rb

@@ -8,11 +8,18 @@ module RBS
   class Patch # rubocop:disable Style/Documentation
     ANNOTATION_OVERRIDE       = "patch:override"
     ANNOTATION_DELETE         = "patch:delete"
-    ANNOTATION_APPEND_AFTER   = /\Apatch:append_after:(.*)\Z/
-    ANNOTATION_PREPEND_BEFORE = /\Apatch:prepend_before:(.*)\Z/
+    ANNOTATION_APPEND_AFTER   = /\Apatch:append_after\((.*)\)\Z/
+    ANNOTATION_PREPEND_BEFORE = /\Apatch:prepend_before\((.*)\)\Z/
 
     def initialize
-      @env = ::RBS::Environment.new
+      @decls = []
+    end
+
+    def to_s
+      io = ::StringIO.new
+      ::RBS::Writer.new(out: io).write(@decls)
+      io.rewind
+      io.read || ""
     end
 
     def apply(source = nil, path: nil)
@@ -22,83 +29,153 @@ module RBS
           next if files.include?(path)
 
           files << path
-          apply Buffer.new(name: path, content: path.read(encoding: "UTF-8"))
+          apply ::RBS::Buffer.new(name: path, content: path.read(encoding: "UTF-8"))
         end
         return
       end
 
-      _, dirs, decls = ::RBS::Parser.parse_signature(source)
-      @env.add_source(::RBS::Source::RBS.new(source, dirs, decls))
-      @env.class_decls.each_value.map do |class_entry|
-        class_entry.context_decls.map { _2 }.inject do |decl_a, decl_b|
-          decl_b.members.delete_if do |member_b|
-            ope, arg = if member_b.annotations.any? { |a| a.string == ANNOTATION_OVERRIDE }
-                         [:override, nil]
-                       elsif member_b.annotations.any? { |a| a.string == ANNOTATION_DELETE }
-                         [:delete, nil]
-                       elsif (anno = member_b.annotations.find { |a| a.string.match(ANNOTATION_APPEND_AFTER) })
-                         [:append_after, anno.string.match(ANNOTATION_APPEND_AFTER)[1]]
-                       elsif (anno = member_b.annotations.find { |a| a.string.match(ANNOTATION_PREPEND_BEFORE) })
-                         [:prepend_before, anno.string.match(ANNOTATION_PREPEND_BEFORE)[1]]
-                       end
-
-            next unless ope
-
-            case ope
-            when :override
-              index = decl_a.members.find_index { |member_a| member_a.name == member_b.name }
-              if index
-                decl_a.members[index] = decl_a.members[index].update(overloads: member_b.overloads)
-                true
-              else
-                false
-              end
-            when :delete
-              decl_a.members.reject! { |member_a| member_a.name == member_b.name }
-            when :append_after, :prepend_before
-              target_name = arg.to_sym
-              index = decl_a.members.find_index { |member_a| member_a.name == target_name }
-              if index
-                if ope == :append_after
-                  offset = 1
-                  annotations = member_b.annotations.reject { |a| a.string.match(ANNOTATION_APPEND_AFTER) }
-                else
-                  offset = 0
-                  annotations = member_b.annotations.reject { |a| a.string.match(ANNOTATION_PREPEND_BEFORE) }
-                end
-                decl_a.members.insert(index + offset, member_b.update(annotations:))
-                true
-              else
-                false
-              end
-            end
-          end
-          decl_a
+      _, _, decls = ::RBS::Parser.parse_signature(source)
+      walk(decls) do |decl, name|
+        ope, arg = process_annotations(decl.annotations) if decl.respond_to?(:annotations) # steep:ignore
+
+        case ope
+        when :override
+          override(name, with: decl)
+        when :delete
+          delete(name)
+        when :append_after
+          add(decl, to: name, after: arg)
+        when :prepend_before
+          add(decl, to: name, before: arg)
+        else
+          add(decl, to: name)
         end
       end
     end
 
-    def to_s
-      decls = @env.class_decls.each_value.map do |class_entry|
-        decls = class_entry.context_decls.map { _2 }
-        decls.each_with_object(decls.first.update(members: [])) do |decl, new_decl|
-          # merge multiple class decls into a single one
-          new_decl.members.concat decl.members
-        end
+    private
+
+    def extract_name(decl)
+      if decl.is_a?(::RBS::AST::Declarations::AliasDecl) # rubocop:disable Style/CaseLikeIf
+        decl.new_name.to_s
+      elsif decl.is_a?(::RBS::AST::Declarations::Base)
+        decl.name.to_s
+      elsif decl.is_a?(::RBS::AST::Members::LocationOnly)
+        ""
+      elsif decl.is_a?(::RBS::AST::Members::Alias) # rubocop:disable Lint/DuplicateBranch
+        decl.new_name.to_s
+      else # rubocop:disable Lint/DuplicateBranch
+        # ::RBS::AST::Members::t
+        decl.name.to_s
       end
+    end
+
+    def extract_members(decl)
+      decl.members if decl.is_a?(::RBS::AST::Declarations::NestedDeclarationHelper)
+    end
 
-      classes = Set[]
+    def walk(decls, name_stack = [], &block)
       decls.each do |decl|
-        decl.members.each do |member|
-          classes << member.name if member.respond_to?(:name)
+        name_stack << extract_name(decl)
+        if decl.is_a?(::RBS::AST::Members::Base)
+          yield decl, "#{name_stack[..-2]&.join("::")}##{name_stack[-1]}"
+        else
+          yield decl, name_stack.join("::")
         end
+        members = extract_members(decl)
+        walk(members, name_stack, &block) if members
+        name_stack.pop
       end
-      decls.delete_if { |c| classes.include?(c.name) }
+    end
 
-      io = ::StringIO.new
-      RBS::Writer.new(out: io).write(decls)
-      io.rewind
-      io.read
+    def decl_map
+      # @type var map: Hash[String, ::RBS::Patch::t]
+      map = {}
+      walk(@decls) { |decl, name| map[name] = decl }
+      map
+    end
+
+    def add(decl, to:, after: nil, before: nil)
+      map = decl_map
+      return if map.key?(to)
+
+      sep = decl.is_a?(::RBS::AST::Members::Base) ? "#" : "::"
+      namespace, = to.rpartition(sep)
+
+      target = namespace.empty? ? @decls : extract_members(map[namespace])
+
+      if target
+        decl.annotations.delete_if { |a| process_annotations([a]) } # steep:ignore
+        if after
+          index = target.find_index { |m| extract_name(m) == after }
+          if index
+            # steep:ignore:start
+            decl = decl.update(location: target[index].location.dup) if decl.respond_to?(:update) # rubocop:disable Style/RedundantSelfAssignment
+            # steep:ignore:end
+            target.insert(index + 1, decl)
+          end
+        elsif before
+          index = target.find_index { |m| extract_name(m) == before }
+          if index
+            # steep:ignore:start
+            decl = decl.update(location: target[index].location.dup) if decl.respond_to?(:update) # rubocop:disable Style/RedundantSelfAssignment
+            # steep:ignore:end
+            target.insert(index, decl)
+          end
+        else
+          target << decl
+        end
+      else
+        @decls << decl # steep:ignore
+      end
+    end
+
+    def override(name, with:)
+      map = decl_map
+      return unless map.key?(name)
+
+      sep = with.is_a?(::RBS::AST::Members::Base) ? "#" : "::"
+      namespace, _, name = name.rpartition(sep)
+
+      if namespace.empty?
+        # top level decl
+        index = @decls.find_index { |d| extract_name(d) == name }
+        @decls[index] = with # steep:ignore
+      else
+        members = extract_members(map[namespace])
+        index = members.find_index do |m| # steep:ignore
+          extract_name(m) == name
+        end
+        members[index] = with # steep:ignore
+      end
+      with.annotations.delete_if { |a| process_annotations([a]) } # steep:ignore
+    end
+
+    def delete(name)
+      map = decl_map
+      return unless map.key?(name)
+
+      sep = name.index("#") ? "#" : "::"
+      namespace, _, name = name.rpartition(sep)
+
+      if namespace.empty?
+        # top level decl
+        @decls.delete_if { |d| extract_name(d) == name }
+      else
+        extract_members(map[namespace])&.delete_if { |m| extract_name(m) == name }
+      end
+    end
+
+    def process_annotations(annotations) # steep:ignore
+      if annotations.any? { |a| a.string == ANNOTATION_OVERRIDE }
+        [:override, nil]
+      elsif annotations.any? { |a| a.string == ANNOTATION_DELETE }
+        [:delete, nil]
+      elsif (anno = annotations.find { |a| a.string.match(ANNOTATION_APPEND_AFTER) })
+        [:append_after, anno.string.match(ANNOTATION_APPEND_AFTER)&.[](1) || ""]
+      elsif (anno = annotations.find { |a| a.string.match(ANNOTATION_PREPEND_BEFORE) })
+        [:prepend_before, anno.string.match(ANNOTATION_PREPEND_BEFORE)&.[](1) || ""]
+      end
     end
   end
 end

data/sig/rbs/patch.rbs

@@ -2,12 +2,40 @@ module RBS
   class Patch
     VERSION: String
 
-    @env: untyped
+    @decls: ::Array[::RBS::AST::Declarations::t]
 
-    def initialize: () -> void
+    ANNOTATION_OVERRIDE: "patch:override"
+
+    ANNOTATION_DELETE: "patch:delete"
+
+    ANNOTATION_APPEND_AFTER: ::Regexp
+
+    ANNOTATION_PREPEND_BEFORE: ::Regexp
 
-    def apply: (String source?, path: Pathname?) -> void
+    def initialize: () -> void
 
     def to_s: () -> String
+
+    def apply: (?untyped? String, ?path: Pathname?) -> void
+
+    type t = ::RBS::AST::Declarations::t | ::RBS::AST::Members::t
+
+    private
+
+    def extract_name: (t decl) -> String
+
+    def extract_members: (t decl) -> (Array[::RBS::AST::Declarations::Class::member] | Array[::RBS::AST::Declarations::Module::member] | nil)
+
+    def walk: (Array[t] decls, ?Array[String] name_stack) { (::RBS::AST::Declarations::t | ::RBS::AST::Members::t, String) -> void } -> void
+
+    def decl_map: () -> Hash[String, t]
+
+    def add: (t decl, to: String, ?after: String?, ?before: String?) -> void
+
+    def override: (String name, with: t) -> void
+
+    def delete: (String name) -> void
+
+    def process_annotations: (Array[::RBS::AST::Annotation] annotations) -> ([:override, nil] | [:delte, nil] | [:append_after, String] | [:prepend_before, String] | nil)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rbs-patch
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Koji NAKAMURA
@@ -13,16 +13,16 @@ dependencies:
   name: rbs
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.0.0.dev.5
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.0.0.dev.5
+        version: '3.0'
 description: RBS::Patch manages RBS (Ruby Signature) type definitions through patches.
   It applies incremental changes to existing RBS signatures.
 email:
@@ -35,6 +35,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- Steepfile
 - exe/rbs-patch
 - lib/rbs/patch.rb
 - lib/rbs/patch/version.rb