prism-merge 1.1.3 → 1.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a36b93898e34e1e7f7b895b191ccdd3a84b1631501b3274de6a239982f2336e
-  data.tar.gz: 14abab7edea6adccdbdddfaf1e00fa42e2fc29f69b6c5c28657d6341dba112f5
+  metadata.gz: fd04362b7a3dcb058e1ddf48683905944ba9cd11bf2a3e16ffc977a286cbf707
+  data.tar.gz: 9cee5de60fd6c3d1e28737135d5003cf6c7604780906efed2c2b861a9559e46c
 SHA512:
-  metadata.gz: dd82df79c0775bb1d096971350b1f313331f7dbb071d0dae22a2c75593f8f797e8b34236c07e4706a35032276657bc763e4bbb0b7434e5949533b3585055b1b2
-  data.tar.gz: eaf27e5dbb8a47ab74003978f4fff007d1dc14c98fe65b11f94e931360b3eb672dd63c5e6b815247a60413da0208f5be1797aeda6af48b8c946f2056e13a2cdc
+  metadata.gz: 2ba7baf55a05e4512c81a5ac78aa0c26eab48576de335659dbffd46fd9b235197132eb85f056591a8b7d7e4bbffa50142c5027ced44db2aca9e320de613ca977
+  data.tar.gz: 495250d6a19a1f0d5893afa191e9ecf1bc8e499f66a401efa93cf6f8efc045d207ceefebf7d889bfe97cbe844f441da6867bec0405aefe303a0bd6974e067703

data/CHANGELOG.md

@@ -30,6 +30,31 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [1.1.4] - 2025-12-04
+
+- TAG: [v1.1.4][1.1.4t]
+- COVERAGE: 98.26% -- 902/918 lines in 9 files
+- BRANCH COVERAGE: 87.59% -- 381/435 branches in 9 files
+- 100.00% documented
+
+### Added
+
+- **Custom signature generator fallthrough support**: Custom signature generators can now return a `Prism::Node` or `FreezeNode` to fall through to the default signature computation. This allows custom generators to only override specific node types while delegating others to the built-in logic. Previously, returning `nil` was the only way to skip custom handling, but that prevented proper matching for unhandled node types.
+- **Variable assignment node signatures**: Added signature support for all variable write node types:
+  - `LocalVariableWriteNode` → `[:local_var, name]`
+  - `InstanceVariableWriteNode` → `[:ivar, name]`
+  - `ClassVariableWriteNode` → `[:cvar, name]`
+  - `GlobalVariableWriteNode` → `[:gvar, name]`
+  - `MultiWriteNode` → `[:multi_write, [target_names]]`
+
+### Removed
+
+- Removed pre-prism code in `ConflictResolver` that compared template node line numbers against destination freeze block line numbers (cross-file line comparison makes no sense)
+
+### Fixed
+
+- **Fixed template-only nodes not being added when destination has freeze blocks**: When `add_template_only_nodes: true`, template nodes with no matching signature in destination were incorrectly skipped if the destination contained freeze blocks. The bug was caused by comparing template node line numbers against destination freeze block line numbers, which is a meaningless cross-file comparison. Template-only nodes are now correctly added regardless of freeze block presence.
+
 ## [1.1.3] - 2025-12-04
 
 - TAG: [v1.1.3][1.1.3t]
@@ -182,7 +207,9 @@ Please file a bug if you notice a violation of semantic versioning.
 
 - Initial release
 
-[Unreleased]: https://github.com/kettle-rb/prism-merge/compare/v1.1.3...HEAD
+[Unreleased]: https://github.com/kettle-rb/prism-merge/compare/v1.1.4...HEAD
+[1.1.4]: https://github.com/kettle-rb/prism-merge/compare/v1.1.3...v1.1.4
+[1.1.4t]: https://github.com/kettle-rb/prism-merge/releases/tag/v1.1.4
 [1.1.3]: https://github.com/kettle-rb/prism-merge/compare/v1.1.2...v1.1.3
 [1.1.3t]: https://github.com/kettle-rb/prism-merge/releases/tag/v1.1.3
 [1.1.2]: https://github.com/kettle-rb/prism-merge/compare/v1.1.1...v1.1.2

data/README.md

@@ -338,6 +338,12 @@ By default, Prism::Merge uses intelligent structural signatures to match nodes.
 | `ModuleNode` | `[:module, name]` | Modules match by name |
 | `SingletonClassNode` | `[:singleton_class, expr]` | Singleton classes match by expression (`class << self`) |
 | `ConstantWriteNode` | `[:const, name]` | Constants match by name only (not value) |
+| `ConstantPathWriteNode` | `[:const, target]` | Namespaced constants match by full path |
+| `LocalVariableWriteNode` | `[:local_var, name]` | Local variables match by name |
+| `InstanceVariableWriteNode` | `[:ivar, name]` | Instance variables match by name |
+| `ClassVariableWriteNode` | `[:cvar, name]` | Class variables match by name |
+| `GlobalVariableWriteNode` | `[:gvar, name]` | Global variables match by name |
+| `MultiWriteNode` | `[:multi_write, targets]` | Multiple assignment matches by target names |
 | `IfNode` / `UnlessNode` | `[:if, condition]` | Conditionals match by condition expression |
 | `CaseNode` | `[:case, predicate]` | Case statements match by the expression being switched |
 | `CaseMatchNode` | `[:case_match, predicate]` | Pattern matching cases match by expression |
@@ -364,7 +370,15 @@ The following node types support **recursive body merging**, where nested conten
 
 #### Custom Signature Generator
 
-You can provide a custom signature generator to control matching behavior:
+You can provide a custom signature generator to control how nodes are matched between template and destination files. The signature generator is a callable (lambda/proc) that receives a `Prism::Node` (or `FreezeNode`) and returns one of three types of values:
+
+| Return Value | Behavior |
+|--------------|----------|
+| **Array** (e.g., `[:gem, "foo"]`) | Used as the node's signature for matching. Nodes with identical signatures are considered matches. |
+| **`nil`** | The node gets no signature and won't be matched by signature. Useful for nodes you want to skip or handle specially. |
+| **`Prism::Node` or `FreezeNode`** | Falls through to the default signature computation using the returned node. Return the original node unchanged for simple fallthrough, or return a modified node to influence default matching. |
+
+##### Basic Example
 
 ```ruby
 signature_generator = lambda do |node|
@@ -379,10 +393,36 @@ signature_generator = lambda do |node|
     # Match classes by name
     [:class, node.constant_path.slice]
   else
-    # Default matching
-    [node.class.name.split("::").last.to_sym, node.slice]
+    # Default matching - return node to fall through
+    node
   end
 end
+```
+
+##### Fallthrough Example (Recommended Pattern)
+
+The fallthrough pattern allows you to customize only specific node types while delegating everything else to the built-in signature logic:
+
+```ruby
+signature_generator = ->(node) {
+  # Only customize CallNode signatures for specific methods
+  if node.is_a?(Prism::CallNode)
+    # source() calls - match by method name only (there's usually just one)
+    return [:source] if node.name == :source
+
+    # gem() calls - match by gem name (first argument)
+    if node.name == :gem
+      first_arg = node.arguments&.arguments&.first
+      if first_arg.is_a?(Prism::StringNode)
+        return [:gem, first_arg.unescaped]
+      end
+    end
+  end
+
+  # Return the node to fall through to default signature computation
+  # This preserves correct handling for FreezeNodes, classes, modules, etc.
+  node
+}
 
 merger = Prism::Merge::SmartMerger.new(
   template_content,
@@ -393,6 +433,26 @@ merger = Prism::Merge::SmartMerger.new(
 )
 ```
 
+##### Why Fallthrough Matters
+
+When you provide a custom signature generator, it's called for **all** node types, including internal types like `FreezeNode`. If your generator returns `nil` for node types it doesn't recognize, those nodes won't be matched properly:
+
+```ruby
+# ❌ Bad: Returns nil for unrecognized nodes
+signature_generator = ->(node) {
+  return unless node.is_a?(Prism::CallNode)  # FreezeNodes get nil!
+  [:call, node.name]
+}
+
+# ✅ Good: Falls through for unrecognized nodes
+signature_generator = ->(node) {
+  if node.is_a?(Prism::CallNode)
+    return [:call, node.name]
+  end
+  node  # FreezeNodes and others use default signatures
+}
+```
+
 ### Freeze Blocks
 
 Protect sections in the destination file from being overwritten by the template using freeze markers.
@@ -1134,7 +1194,7 @@ Thanks for RTFM. ☺️
 [📌gitmoji]: https://gitmoji.dev
 [📌gitmoji-img]: https://img.shields.io/badge/gitmoji_commits-%20%F0%9F%98%9C%20%F0%9F%98%8D-34495e.svg?style=flat-square
 [🧮kloc]: https://www.youtube.com/watch?v=dQw4w9WgXcQ
-[🧮kloc-img]: https://img.shields.io/badge/KLOC-0.911-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-0.918-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
 [🔐security]: SECURITY.md
 [🔐security-img]: https://img.shields.io/badge/security-policy-259D6C.svg?style=flat
 [📄copyright-notice-explainer]: https://opensource.stackexchange.com/questions/5778/why-do-licenses-such-as-the-mit-license-specify-a-single-year

data/lib/prism/merge/conflict_resolver.rb

@@ -168,16 +168,6 @@ module Prism
               source_analysis: @dest_analysis,
             )
             matched_dest_indices << freeze_node_info[:index]
-
-            # Mark any template nodes within this freeze block range as processed
-            freeze_range = freeze_node_info[:line_range]
-            template_nodes.each do |t_node_info|
-              if freeze_range.cover?(t_node_info[:line_range].begin) &&
-                  freeze_range.cover?(t_node_info[:line_range].end)
-                # Template node is inside freeze block, skip it
-                # (we'll handle this by checking if it overlaps with a freeze block)
-              end
-            end
           end
         end
 
@@ -207,18 +197,6 @@ module Prism
           node_start = t_node_info[:line_range].begin
           node_end = t_node_info[:line_range].end
 
-          # Skip template nodes that overlap with destination freeze blocks
-          overlaps_freeze = dest_freeze_nodes.any? do |freeze_info|
-            freeze_range = freeze_info[:line_range]
-            node_start.between?(freeze_range.begin, freeze_range.end) ||
-              node_end.between?(freeze_range.begin, freeze_range.end)
-          end
-
-          if overlaps_freeze
-            current_line = node_end + 1
-            next
-          end
-
           # Check if this node will be matched or is template-only
           sig = t_node_info[:signature]
           is_matched = dest_sig_map[sig]&.any?

data/lib/prism/merge/debug_logger.rb

@@ -8,7 +8,9 @@ module Prism
     # rubocop:disable ThreadSafety/ClassInstanceVariable
     module DebugLogger
       @logger = nil
+      # :nocov:
       @enabled = ENV.fetch("PRISM_MERGE_DEBUG", "false").casecmp?("true")
+      # :nocov:
 
       class << self
         attr_reader :enabled
@@ -17,7 +19,7 @@ module Prism
         # @param message [String] The message to log
         # @param context [Hash] Optional context information
         def debug(message, context = {})
-          return unless @enabled
+          return unless enabled
 
           if logger_available?
             ensure_logger

data/lib/prism/merge/file_analysis.rb

@@ -89,12 +89,38 @@ module Prism
         generate_signature(statements[index])
       end
 
-      # Generate signature for a node
-      # @param node [Prism::Node] Node to generate signature for
+      # Generate signature for a node.
+      #
+      # If a custom signature_generator is provided, it is called first. The custom
+      # generator can return:
+      # - An array signature (e.g., `[:gem, "foo"]`) - used as the signature
+      # - `nil` - the node gets no signature (won't be matched by signature)
+      # - A `Prism::Node` or `FreezeNode` - falls through to default computation using
+      #   the returned node. This allows the custom generator to optionally modify the
+      #   node before default processing, or simply return the original node unchanged
+      #   for fallthrough.
+      #
+      # @param node [Prism::Node, FreezeNode] Node to generate signature for
       # @return [Array, nil] Signature array
+      #
+      # @example Custom generator with fallthrough
+      #   signature_generator = ->(node) {
+      #     case node
+      #     when Prism::CallNode
+      #       return [:gem, node.arguments.arguments.first.unescaped] if node.name == :gem
+      #     end
+      #     node  # Return original node for default signature computation
+      #   }
       def generate_signature(node)
         result = if @signature_generator
-          @signature_generator.call(node)
+          custom_result = @signature_generator.call(node)
+          if custom_result.is_a?(Prism::Node) || custom_result.is_a?(FreezeNode)
+            # Custom generator returned a node - use default computation on it
+            compute_node_signature(custom_result)
+          else
+            # Custom result is either an array signature or nil
+            custom_result
+          end
         else
           compute_node_signature(node)
         end
@@ -145,6 +171,7 @@ module Prism
       # so we need to explicitly require it
       def attach_comments_safely!
         @parse_result.attach_comments!
+      # :nocov:
       rescue NameError => e
         if e.message.include?("Comments")
           # On JRuby, the Comments class needs to be explicitly required
@@ -153,6 +180,7 @@ module Prism
         else
           raise
         end
+        # :nocov:
       end
 
       # Extract all nodes: freeze blocks + statements outside freeze blocks
@@ -342,6 +370,13 @@ module Prism
       #   - `ConstantWriteNode` → `[:const, name]`
       #   - `ConstantPathWriteNode` → `[:const, target]`
       #
+      #   **Variable Assignments:**
+      #   - `LocalVariableWriteNode` → `[:local_var, name]`
+      #   - `InstanceVariableWriteNode` → `[:ivar, name]`
+      #   - `ClassVariableWriteNode` → `[:cvar, name]`
+      #   - `GlobalVariableWriteNode` → `[:gvar, name]`
+      #   - `MultiWriteNode` → `[:multi_write, [target_names]]`
+      #
       #   **Conditionals:**
       #   - `IfNode` → `[:if, condition_source]`
       #   - `UnlessNode` → `[:unless, condition_source]`
@@ -437,15 +472,25 @@ module Prism
         when Prism::DefNode
           # Extract parameter names from ParametersNode
           params = if node.parameters
-            param_names = []
-            param_names.concat(node.parameters.requireds.map(&:name)) if node.parameters.requireds
-            param_names.concat(node.parameters.optionals.map(&:name)) if node.parameters.optionals
-            param_names << node.parameters.rest.name if node.parameters.rest
-            param_names.concat(node.parameters.posts.map(&:name)) if node.parameters.posts
-            param_names.concat(node.parameters.keywords.map(&:name)) if node.parameters.keywords
-            param_names << node.parameters.keyword_rest.name if node.parameters.keyword_rest
-            param_names << node.parameters.block.name if node.parameters.block
-            param_names
+            # Handle forwarding parameters (def foo(...)) specially
+            if node.parameters.is_a?(Prism::ForwardingParameterNode)
+              [:forwarding]
+            else
+              param_names = []
+              param_names.concat(node.parameters.requireds.map(&:name)) if node.parameters.requireds
+              param_names.concat(node.parameters.optionals.map(&:name)) if node.parameters.optionals
+              param_names << node.parameters.rest.name if node.parameters.rest&.respond_to?(:name)
+              param_names.concat(node.parameters.posts.map(&:name)) if node.parameters.posts
+              param_names.concat(node.parameters.keywords.map(&:name)) if node.parameters.keywords
+              # keyword_rest can be KeywordRestParameterNode (has name) or ForwardingParameterNode (no name)
+              if node.parameters.keyword_rest&.respond_to?(:name)
+                param_names << node.parameters.keyword_rest.name
+              elsif node.parameters.keyword_rest.is_a?(Prism::ForwardingParameterNode)
+                param_names << :forwarding
+              end
+              param_names << node.parameters.block.name if node.parameters.block
+              param_names
+            end
           else
             []
           end
@@ -466,8 +511,37 @@ module Prism
           [:singleton_class, expr]
 
         # === Constants ===
-        when Prism::ConstantWriteNode, Prism::ConstantPathWriteNode
-          [:const, node.name || node.target.slice]
+        when Prism::ConstantWriteNode
+          [:const, node.name]
+        when Prism::ConstantPathWriteNode
+          [:const, node.target.slice]
+
+        # === Variable assignments ===
+        when Prism::LocalVariableWriteNode
+          [:local_var, node.name]
+        when Prism::InstanceVariableWriteNode
+          [:ivar, node.name]
+        when Prism::ClassVariableWriteNode
+          [:cvar, node.name]
+        when Prism::GlobalVariableWriteNode
+          [:gvar, node.name]
+        when Prism::MultiWriteNode
+          # Multiple assignment: a, b = 1, 2
+          targets = node.lefts.map do |target|
+            case target
+            when Prism::LocalVariableTargetNode
+              target.name
+            when Prism::InstanceVariableTargetNode
+              target.name
+            when Prism::ClassVariableTargetNode
+              target.name
+            when Prism::GlobalVariableTargetNode
+              target.name
+            else
+              target.slice
+            end
+          end
+          [:multi_write, targets]
 
         # === Conditionals ===
         when Prism::IfNode, Prism::UnlessNode

data/lib/prism/merge/smart_merger.rb

@@ -68,9 +68,17 @@ module Prism
       # @param dest_content [String] Destination Ruby source code
       #
       # @param signature_generator [Proc, nil] Optional proc to generate custom node signatures.
-      #   The proc receives a Prism node and should return an array representing its signature.
+      #   The proc receives a Prism node (or FreezeNode) and should return one of:
+      #   - An array representing the node's signature (e.g., `[:gem, "foo"]`)
+      #   - `nil` to indicate the node should have no signature (won't be matched)
+      #   - A `Prism::Node` or `FreezeNode` to fall through to default signature computation
+      #     using that node. This allows custom generators to only override specific node
+      #     types while delegating others to the built-in logic. Return the original node
+      #     unchanged for simple fallthrough, or return a modified node to influence
+      #     default matching.
+      #
       #   Nodes with identical signatures are considered matches during merge.
-      #   Default: Uses {FileAnalysis#default_signature} which matches:
+      #   Default: Uses {FileAnalysis#compute_node_signature} which matches:
       #   - Conditionals by condition only (not body)
       #   - Assignments by name only (not value)
       #   - Method calls by name and args (not block)
@@ -122,14 +130,17 @@ module Prism
       #     add_template_only_nodes: false
       #   )
       #
-      # @example Custom signature matching
+      # @example Custom signature matching with fallthrough
       #   sig_gen = lambda do |node|
       #     case node
-      #     when Prism::DefNode
-      #       [:method, node.name]
-      #     else
-      #       [node.class.name, node.slice]
+      #     when Prism::CallNode
+      #       # Custom handling for gem calls - match by gem name
+      #       if node.name == :gem
+      #         return [:gem, node.arguments&.arguments&.first&.unescaped]
+      #       end
       #     end
+      #     # Return the node to fall through to default signature computation
+      #     node
       #   end
       #
       #   merger = SmartMerger.new(

data/lib/prism/merge/version.rb

@@ -5,7 +5,7 @@ module Prism
     # Version information for Prism::Merge
     module Version
       # Current version of the prism-merge gem
-      VERSION = "1.1.3"
+      VERSION = "1.1.4"
     end
     VERSION = Version::VERSION # traditional location
   end

data/sig/prism/merge.rbs

@@ -107,7 +107,11 @@ module Prism
       attr_reader statements: Array[untyped]
       attr_reader freeze_blocks: Array[freeze_block]
 
-      def initialize: (String content, ?signature_generator: (^(untyped) -> Array[untyped])?) -> void
+      # Custom signature generator return types:
+      # - Array[untyped]: Used as the node's signature for matching
+      # - nil: Node gets no signature (won't be matched by signature)
+      # - Prism::Node or FreezeNode: Falls through to default signature computation
+      def initialize: (String content, ?signature_generator: (^(untyped) -> (Array[untyped] | untyped | nil))?, ?freeze_token: String?) -> void
 
       def valid?: () -> bool
 
@@ -158,6 +162,11 @@ module Prism
       #   [:module, String]                       - module definitions
       #   [:singleton_class, String]              - singleton class definitions
       #   [:const, Symbol | String]               - constant assignments
+      #   [:local_var, Symbol]                    - local variable assignments
+      #   [:ivar, Symbol]                         - instance variable assignments
+      #   [:cvar, Symbol]                         - class variable assignments
+      #   [:gvar, Symbol]                         - global variable assignments
+      #   [:multi_write, Array[Symbol | String]]  - multiple assignment
       #   [:if, String] | [:unless, String]       - conditionals
       #   [:case, String] | [:case_match, String] - case statements
       #   [:while, String] | [:until, String]     - while/until loops
@@ -318,10 +327,14 @@ module Prism
         statistics: Hash[Symbol, Integer]
       }
 
+      # Custom signature generator return types:
+      # - Array[untyped]: Used as the node's signature for matching
+      # - nil: Node gets no signature (won't be matched by signature)
+      # - Prism::Node or FreezeNode: Falls through to default signature computation
       def initialize: (
         String template_content,
         String dest_content,
-        ?signature_generator: (^(untyped) -> Array[untyped])?,
+        ?signature_generator: (^(untyped) -> (Array[untyped] | untyped | nil))?,
         ?signature_match_preference: Symbol,
         ?add_template_only_nodes: bool,
         ?freeze_token: String?,

data.tar.gz.sig

@@ -1,2 +1,3 @@
-3�N��6M*<�D2���$��B�#C4�y��2�*�a�1��������	OI8S�O�x
�{�xN��)�����[�M�(�IK�x�D��w��!��.����L�w
-7���I7Yx��(�	˗���A8
+��'���ӾP�5t#9ġ_�$`�Z:JH)�M�	���Te���4��͓���V�zLY9�`�)�{�MAȴN2�o�Y�[�n���X
+-CR�jf�a������
+�ܐ_S]VƑ����bq�D�}�J��<����B��U�Z�=�VBb��]y�ӟP�sN�Xn���y��d�	���g]�������}���]�
1&���"rX������;����M��X{�t)E���)Ά�IM�^P�̓G'v���pKzQW �m�r��bYr#���iGZ_��o���Նݼ1��OJ s��#��ʳ`_��q��Y�w���'ӮW��D9S|���>��Huu]�-�C��d/3dR�A�i#���s�s��2p�

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prism-merge
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.4
 platform: ruby
 authors:
 - Peter H. Boling
@@ -265,10 +265,10 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://prism-merge.galtzo.com/
-  source_code_uri: https://github.com/kettle-rb/prism-merge/tree/v1.1.3
-  changelog_uri: https://github.com/kettle-rb/prism-merge/blob/v1.1.3/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-rb/prism-merge/tree/v1.1.4
+  changelog_uri: https://github.com/kettle-rb/prism-merge/blob/v1.1.4/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-rb/prism-merge/issues
-  documentation_uri: https://www.rubydoc.info/gems/prism-merge/1.1.3
+  documentation_uri: https://www.rubydoc.info/gems/prism-merge/1.1.4
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/kettle-rb/prism-merge/wiki
   news_uri: https://www.railsbling.com/tags/prism-merge