rbs-patch 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fd64b165683dbb9350cc535cd07176d1e5b74fd3814b72b7d4e94ad9e8deafe
-  data.tar.gz: 48b0f85c818af5f23bafd3d7b7acbe281b5f3c7ba8c26f270d04c1e1b910f9d3
+  metadata.gz: 3a45288c145d3c26618712866de56ebeebabc1034e29960877834d5fc0518c58
+  data.tar.gz: 12ae5d9f8fcd5721f05bac232b9dd10b8de6a23c47c73eba19801e65b3b33143
 SHA512:
-  metadata.gz: 1548885b396ccff12ebe6ae6c1b5272133248623db7360378283b9f707f17462c1bd7e5d26a9107865277e23fad005f9f83b779cdca992943bc33dccefc3bad6
-  data.tar.gz: 16da1d9c8b866dc6a4c6c0a6ed8713da52db81556a8e850f26badb6df0f25ba1fd883e81260f26764da667eea2fcb2dba0ceed4f975b7e4b71baeafe04ef5fdc
+  metadata.gz: b939dc31112ba51d86e88c66b0000ac3abcf7baa9d5b57db79af3ee8003dc2cafbb90e2d6c4d08ffb53c3aebd8bb3c1d2b1bec7609911d03f7ed12105621a2b4
+  data.tar.gz: '00998b3ec8d70b87cf45177244ed9dc0e8bdb572f95eb33e07f422a137a67922a6add9ddb06a00777de1eb00aa69eb787930b2e6b33704b890064e4c1b2683c5'

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.3"
   end
 end

data/lib/rbs/patch.rb

@@ -12,7 +12,14 @@ module RBS
     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,140 @@ 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
+    private
+
+    def walk(decls, name_stack = [], &block)
+      decls.each do |decl|
+        name = 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
+        name_stack << name
+        if decl.is_a?(::RBS::AST::Members::Base)
+          yield decl, "#{name_stack[..-2]&.join("::")}##{name_stack[-1]}"
+        else
+          yield decl, name_stack.join("::")
         end
+        walk(decl.members, name_stack, &block) if decl.is_a?(::RBS::AST::Declarations::NestedDeclarationHelper)
+        name_stack.pop
       end
+    end
 
-      classes = Set[]
-      decls.each do |decl|
-        decl.members.each do |member|
-          classes << member.name if member.respond_to?(:name)
+    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 : map[namespace]&.members # steep:ignore
+
+      # steep:ignore:start
+      if target
+        if after
+          index = target.find_index { |m| m.name.to_s == after }
+          target.insert(index + 1, decl) if index
+        elsif before
+          index = target.find_index { |m| m.name.to_s == before }
+          target.insert(index, decl) if index
+        else
+          target << decl
         end
+        decl.annotations.delete_if { |a| process_annotations([a]) }
+      else
+        @decls << decl
       end
-      decls.delete_if { |c| classes.include?(c.name) }
+      # steep:ignore:end
+    end
 
-      io = ::StringIO.new
-      RBS::Writer.new(out: io).write(decls)
-      io.rewind
-      io.read
+    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)
+
+      # steep:ignore:start
+      if namespace.empty?
+        # top level decl
+        index = @decls.find_index { |d| d.name.to_s == name }
+        @decls[index] = with
+      else
+        index = map[namespace].members.find_index do |m|
+          m.name.to_s == name
+        end
+        map[namespace].members[index] = with
+      end
+      with.annotations.delete_if { |a| process_annotations([a]) }
+      # steep:ignore:end
+    end
+
+    def delete(name)
+      map = decl_map
+      return unless map.key?(name)
+
+      sep = name.index("#") ? "#" : "::"
+      namespace, _, name = name.rpartition(sep)
+
+      # steep:ignore:start
+      if namespace.empty?
+        # top level decl
+        @decls.delete_if { |d| d.name.to_s == name }
+      else
+        map[namespace].members.delete_if { |m| m.name.to_s == name }
+      end
+      # steep:ignore: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,36 @@ 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"
 
-    def apply: (String source?, path: Pathname?) -> void
+    ANNOTATION_APPEND_AFTER: ::Regexp
+
+    ANNOTATION_PREPEND_BEFORE: ::Regexp
+
+    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 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.3
 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