philiprehberger-differ 0.2.8 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b373be1315d237effea59c584220c77fb0bd1deb9ba6e238b698e4919e321de
-  data.tar.gz: 599f9707141498e91952c4d26fabe62cf1eff4ebd466d485e01403119946f1fa
+  metadata.gz: 9e8573d84ddf309e3d702cb9b90d1b407c8963cd84cf62235e6620d586949437
+  data.tar.gz: 79ddab362109ba0b8b7958ba77fe9242426a403904082e81b2c8db2f6246a2c2
 SHA512:
-  metadata.gz: 7b62b0044c3493e371c44bea5bebd02adf183fc437aec5a8e5b63b92a53cc96a33cca0274329c4bacda38cd44042f1afec6a0de93b4f768615383fd4cc3416f7
-  data.tar.gz: 5338d2c13503d74f963f3bd7e8ff4f8488adf739c7a57bfe2d735ab00190ad3052893c5d017014511c1a2c96c78f380384e274d4a427dfbc2c00da3b7c110a02
+  metadata.gz: 585f857fb63da7b81aad2ded9a2948e4cf27b5d996c6afa76480a0ff41397d3181ab02cad53ab285a8d629f15df669c6372d2d7d220b68d27168dac72f8993be
+  data.tar.gz: 20e291749bdbec14d58031833b02c9de65dc5f40bd3675407b478ce8dce20efeeb613ca9e28062b97628fd8a32cf44eb98df5e781964b5f70ac85fe1a09a6618

data/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-04-10
+
+### Added
+- `Changeset` now includes `Enumerable` for direct iteration over changes
+- `Changeset#count` returning the number of changes
+- `Changeset#paths` returning all changed paths
+- `Changeset#include?(path)` to check if a specific path was changed
+- `Changeset#summary` returning `{ added:, removed:, changed: }` counts
+
+## [0.3.0] - 2026-04-01
+
+### Added
+- `Differ.subset(changeset, path)` for filtering changes by path prefix
+- `Differ.merge(base, theirs, ours)` for three-way merge with conflict detection
+- `Differ.breaking_changes?(changeset)` for detecting removals and type changes
+
+## [0.2.9] - 2026-03-31
+
+### Added
+- Add GitHub issue templates, dependabot config, and PR template
+
 ## [0.2.8] - 2026-03-31
 
 ### Changed

data/README.md

@@ -116,6 +116,29 @@ new_data = { users: [{ id: 2, name: 'Bobby' }, { id: 1, name: 'Alice' }] }
 changeset = Philiprehberger::Differ.diff(old_data, new_data, array_key: :id)
 ```
 
+### Subset Filtering
+
+Filter a diff to only changes under a specific path:
+
+```ruby
+changeset = Philiprehberger::Differ.diff(old_data, new_data)
+user_changes = Philiprehberger::Differ.subset(changeset, 'user')
+```
+
+### Three-Way Merge
+
+```ruby
+result = Philiprehberger::Differ.merge(base, theirs, ours)
+result[:merged]     # => merged hash
+result[:conflicts]  # => [{ path:, theirs:, ours: }]
+```
+
+### Breaking Change Detection
+
+```ruby
+Philiprehberger::Differ.breaking_changes?(changeset)  # => true/false
+```
+
 ## API
 
 ### `Philiprehberger::Differ.diff(old_val, new_val, ignore: [], array_key: nil)`
@@ -131,6 +154,11 @@ Returns a Float between 0.0 (completely different) and 1.0 (identical).
 | Method | Description |
 |---|---|
 | `changed?` | Returns `true` if any differences exist |
+| `count` | Number of changes |
+| `paths` | Array of all changed paths |
+| `include?(path)` | Check if a specific path was changed |
+| `summary` | `{ added:, removed:, changed: }` counts |
+| `each` | Iterate over changes (includes `Enumerable`) |
 | `changes` | All `Change` objects |
 | `added` | Changes where `type == :added` |
 | `removed` | Changes where `type == :removed` |
@@ -141,6 +169,12 @@ Returns a Float between 0.0 (completely different) and 1.0 (identical).
 | `to_text` | Human-readable text with +/- prefixes |
 | `to_json_patch` | Array of RFC 6902 JSON Patch operations |
 
+| Method | Description |
+|---|---|
+| `Differ.subset(changeset, path)` | Filter changes to a specific path prefix |
+| `Differ.merge(base, theirs, ours)` | Three-way merge with conflict detection |
+| `Differ.breaking_changes?(changeset)` | Detect removals and type changes |
+
 ### `Change`
 
 | Attribute | Description |

data/lib/philiprehberger/differ/changeset.rb

@@ -3,12 +3,52 @@
 module Philiprehberger
   module Differ
     class Changeset
+      include Enumerable
+
       attr_reader :changes
 
       def initialize(changes = [])
         @changes = changes
       end
 
+      # Iterate over each Change.
+      #
+      # @yield [Change] each change
+      # @return [Enumerator] if no block given
+      def each(&)
+        @changes.each(&)
+      end
+
+      # Number of changes.
+      #
+      # @return [Integer]
+      def count
+        @changes.length
+      end
+
+      # Array of all changed paths.
+      #
+      # @return [Array<String>]
+      def paths
+        @changes.map(&:path)
+      end
+
+      # Check if a specific path was changed.
+      #
+      # @param path [String, Symbol] the path to check
+      # @return [Boolean]
+      def include?(path)
+        path_s = path.to_s
+        @changes.any? { |c| c.path.to_s == path_s }
+      end
+
+      # Summary counts by change type.
+      #
+      # @return [Hash{Symbol => Integer}] { added:, removed:, changed: }
+      def summary
+        { added: added.length, removed: removed.length, changed: changed.length }
+      end
+
       def changed?
         !@changes.empty?
       end

data/lib/philiprehberger/differ/version.rb

@@ -2,6 +2,6 @@
 
 module Philiprehberger
   module Differ
-    VERSION = '0.2.8'
+    VERSION = '0.4.0'
   end
 end

data/lib/philiprehberger/differ.rb

@@ -19,5 +19,96 @@ module Philiprehberger
     def self.similarity(old_val, new_val, ignore: [], array_key: nil)
       Similarity.call(old_val, new_val, ignore: ignore, array_key: array_key)
     end
+
+    # Filter changeset to only changes under a specific path prefix
+    #
+    # @param changeset [Changeset] the changeset to filter
+    # @param path [String] the path prefix to filter by
+    # @return [Changeset] new changeset with only matching changes
+    def self.subset(changeset, path)
+      prefix = path.to_s
+      filtered = changeset.changes.select do |change|
+        change.path.to_s == prefix || change.path.to_s.start_with?("#{prefix}.")
+      end
+      Changeset.new(filtered)
+    end
+
+    # Perform a three-way merge with conflict detection
+    #
+    # @param base [Hash] the common ancestor
+    # @param theirs [Hash] their changes
+    # @param ours [Hash] our changes
+    # @return [Hash] { merged: Hash, conflicts: Array }
+    def self.merge(base, theirs, ours)
+      their_changes = Comparator.call(base, theirs)
+      our_changes = Comparator.call(base, ours)
+
+      conflicts = detect_conflicts(their_changes, our_changes)
+      conflict_paths = conflicts.map { |c| c[:path] }
+
+      merged = deep_dup(base)
+      (their_changes + our_changes).each do |change|
+        next if conflict_paths.include?(change.path)
+
+        apply_merge_change(merged, change)
+      end
+
+      { merged: merged, conflicts: conflicts }
+    end
+
+    # Detect if a changeset contains breaking changes (removals or type changes)
+    #
+    # @param changeset [Changeset] the changeset to check
+    # @return [Boolean] true if breaking changes are detected
+    def self.breaking_changes?(changeset)
+      changeset.changes.any? do |change|
+        change.type == :removed ||
+          (change.type == :changed && change.old_value.class != change.new_value.class)
+      end
+    end
+
+    def self.detect_conflicts(their_changes, our_changes)
+      their_paths = their_changes.to_h { |c| [c.path, c] }
+      our_paths = our_changes.to_h { |c| [c.path, c] }
+
+      conflicts = []
+      their_paths.each do |path, their_change|
+        our_change = our_paths[path]
+        next unless our_change
+
+        if their_change.new_value != our_change.new_value
+          conflicts << { path: path, theirs: their_change.new_value, ours: our_change.new_value }
+        end
+      end
+      conflicts
+    end
+    private_class_method :detect_conflicts
+
+    def self.apply_merge_change(hash, change)
+      keys = change.path.to_s.split('.')
+      target = hash
+      keys[0..-2].each do |k|
+        k = k.to_sym if target.is_a?(Hash) && target.key?(k.to_sym)
+        target = target[k]
+      end
+
+      key = keys.last
+      key = key.to_sym if target.is_a?(Hash) && (target.key?(key.to_sym) || target.keys.any?(Symbol))
+
+      case change.type
+      when :added, :changed then target[key] = change.new_value
+      when :removed then target.delete(key)
+      end
+    end
+    private_class_method :apply_merge_change
+
+    def self.deep_dup(obj)
+      case obj
+      when Hash then obj.each_with_object({}) { |(k, v), h| h[k] = deep_dup(v) }
+      when Array then obj.map { |v| deep_dup(v) }
+      else obj
+      end
+    end
+    private_class_method :deep_dup
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: philiprehberger-differ
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.4.0
 platform: ruby
 authors:
 - Philip Rehberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-31 00:00:00.000000000 Z
+date: 2026-04-10 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby library for deep structural diffing of hashes, arrays, and nested
   objects with apply/revert, JSON Patch output, similarity scoring, and configurable
@@ -29,11 +29,11 @@ files:
 - lib/philiprehberger/differ/formatters.rb
 - lib/philiprehberger/differ/similarity.rb
 - lib/philiprehberger/differ/version.rb
-homepage: https://github.com/philiprehberger/rb-differ
+homepage: https://philiprehberger.com/open-source-packages/ruby/philiprehberger-differ
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/philiprehberger/rb-differ
+  homepage_uri: https://philiprehberger.com/open-source-packages/ruby/philiprehberger-differ
   source_code_uri: https://github.com/philiprehberger/rb-differ
   changelog_uri: https://github.com/philiprehberger/rb-differ/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/philiprehberger/rb-differ/issues