json-schema-diff 0.1.0

data/lib/json/schema/diff/comparer.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Json
+  module Schema
+    module Diff
+      class Comparer
+        def initialize(schema_parser, ignore_fields = [])
+          @schema_parser = schema_parser
+          @ignore_fields = ignore_fields.map(&:to_s)
+        end
+
+        def compare(old_json, new_json)
+          changes = []
+          compare_recursive(old_json, new_json, "", changes)
+          changes
+        end
+
+        private
+
+        def compare_recursive(old_val, new_val, path, changes)
+          # Skip ignored fields
+          return if @ignore_fields.include?(path)
+
+          field_info = @schema_parser.get_field_info(path)
+          
+          # Skip read-only fields
+          return if field_info[:read_only]
+
+          if old_val.nil? && !new_val.nil?
+            add_change(changes, path, old_val, new_val, "addition", field_info)
+          elsif !old_val.nil? && new_val.nil?
+            add_change(changes, path, old_val, new_val, "removal", field_info)
+          elsif old_val.class != new_val.class
+            add_change(changes, path, old_val, new_val, "type_change", field_info)
+          elsif old_val.is_a?(Hash) && new_val.is_a?(Hash)
+            compare_objects(old_val, new_val, path, changes)
+          elsif old_val.is_a?(Array) && new_val.is_a?(Array)
+            compare_arrays(old_val, new_val, path, changes)
+          elsif old_val != new_val
+            add_change(changes, path, old_val, new_val, "modification", field_info)
+          end
+        end
+
+        def compare_objects(old_obj, new_obj, path, changes)
+          all_keys = (old_obj.keys + new_obj.keys).uniq
+          
+          all_keys.each do |key|
+            key_path = path.empty? ? key : "#{path}.#{key}"
+            compare_recursive(old_obj[key], new_obj[key], key_path, changes)
+          end
+        end
+
+        def compare_arrays(old_arr, new_arr, path, changes)
+          max_length = [old_arr.length, new_arr.length].max
+          
+          (0...max_length).each do |index|
+            index_path = "#{path}[#{index}]"
+            old_item = index < old_arr.length ? old_arr[index] : nil
+            new_item = index < new_arr.length ? new_arr[index] : nil
+            compare_recursive(old_item, new_item, index_path, changes)
+          end
+        end
+
+        def add_change(changes, path, old_val, new_val, change_type, field_info)
+          # Check if this is a noisy field
+          is_noisy = @schema_parser.is_noisy_field?(path, old_val) || 
+                     @schema_parser.is_noisy_field?(path, new_val)
+
+          change = {
+            path: path,
+            old_value: old_val,
+            new_value: new_val,
+            change_type: change_type,
+            field_info: field_info,
+            is_noisy: is_noisy
+          }
+          
+          changes << change
+        end
+      end
+    end
+  end
+end

data/lib/json/schema/diff/formatter.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Json
+  module Schema
+    module Diff
+      class Formatter
+        COLORS = {
+          red: "\e[31m",
+          green: "\e[32m",
+          yellow: "\e[33m",
+          blue: "\e[34m",
+          magenta: "\e[35m",
+          cyan: "\e[36m",
+          reset: "\e[0m"
+        }.freeze
+
+        def initialize(format = "pretty", use_color = true)
+          @format = format
+          @use_color = use_color
+        end
+
+        def format(changes)
+          case @format
+          when "json"
+            format_json(changes)
+          else
+            format_pretty(changes)
+          end
+        end
+
+        private
+
+        def format_json(changes)
+          JSON.pretty_generate(changes.map do |change|
+            {
+              path: change[:path],
+              change_type: change[:change_type],
+              old_value: change[:old_value],
+              new_value: change[:new_value],
+              field_info: change[:field_info],
+              is_noisy: change[:is_noisy]
+            }
+          end)
+        end
+
+        def format_pretty(changes)
+          return "No changes detected." if changes.empty?
+
+          output = []
+          output << colorize("JSON Schema Diff Results", :cyan, bold: true)
+          output << "=" * 50
+          
+          # Group changes by type
+          grouped = changes.group_by { |c| c[:change_type] }
+          
+          %w[addition removal modification type_change].each do |type|
+            next unless grouped[type]
+            
+            output << ""
+            output << colorize("#{type.upcase.tr('_', ' ')}S (#{grouped[type].length}):", type_color(type), bold: true)
+            output << ""
+            
+            grouped[type].each do |change|
+              output.concat(format_change(change))
+            end
+          end
+          
+          # Summary
+          output << ""
+          output << colorize("SUMMARY:", :blue, bold: true)
+          output << "Total changes: #{changes.length}"
+          noisy_count = changes.count { |c| c[:is_noisy] }
+          output << "Noisy fields: #{noisy_count}" if noisy_count > 0
+          
+          output.join("\n")
+        end
+
+        def format_change(change)
+          lines = []
+          path = change[:path]
+          field_info = change[:field_info]
+          
+          # Path and type info
+          path_line = "  #{path}"
+          if field_info[:type]
+            path_line += " (#{field_info[:type]}"
+            path_line += ", #{field_info[:format]}" if field_info[:format]
+            path_line += ")"
+          end
+          path_line += colorize(" [noisy]", :yellow) if change[:is_noisy]
+          lines << path_line
+          
+          # Title/description if available
+          if field_info[:title]
+            lines << "    Title: #{field_info[:title]}"
+          end
+          
+          # Show enum values if applicable
+          if field_info[:enum]
+            lines << "    Allowed values: #{field_info[:enum].join(', ')}"
+          end
+          
+          # Value changes
+          case change[:change_type]
+          when "addition"
+            lines << "    #{colorize('+ Added:', :green)} #{format_value(change[:new_value])}"
+          when "removal"
+            lines << "    #{colorize('- Removed:', :red)} #{format_value(change[:old_value])}"
+          when "modification", "type_change"
+            lines << "    #{colorize('- Old:', :red)} #{format_value(change[:old_value])}"
+            lines << "    #{colorize('+ New:', :green)} #{format_value(change[:new_value])}"
+          end
+          
+          lines << ""
+          lines
+        end
+
+        def format_value(value)
+          case value
+          when String
+            "\"#{value}\""
+          when nil
+            "null"
+          else
+            value.to_s
+          end
+        end
+
+        def type_color(type)
+          case type
+          when "addition" then :green
+          when "removal" then :red
+          when "modification" then :yellow
+          when "type_change" then :magenta
+          else :blue
+          end
+        end
+
+        def colorize(text, color, bold: false)
+          return text unless @use_color
+          
+          result = "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+          result = "\e[1m#{result}" if bold
+          result
+        end
+      end
+    end
+  end
+end

data/lib/json/schema/diff/schema_parser.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Json
+  module Schema
+    module Diff
+      class SchemaParser
+        attr_reader :schema
+
+        def initialize(schema_file)
+          @schema = JSON.parse(File.read(schema_file))
+        rescue JSON::ParserError => e
+          raise Error, "Invalid JSON schema: #{e.message}"
+        rescue Errno::ENOENT => e
+          raise Error, "Schema file not found: #{e.message}"
+        end
+
+        def get_field_info(path)
+          field_schema = traverse_schema(path.split('.'))
+          return {} unless field_schema
+
+          {
+            type: field_schema["type"],
+            title: field_schema["title"],
+            description: field_schema["description"],
+            format: field_schema["format"],
+            enum: field_schema["enum"],
+            read_only: field_schema["readOnly"] || false
+          }
+        end
+
+        def is_noisy_field?(path, value)
+          field_info = get_field_info(path)
+          format = field_info[:format]
+          
+          # Check for timestamp formats
+          return true if format == "date-time" || format == "date" || format == "time"
+          
+          # Check for UUID format
+          return true if format == "uuid"
+          
+          # Check for fields that look like UUIDs or timestamps
+          if value.is_a?(String)
+            return true if value.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
+            return true if value.match?(/\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
+          end
+          
+          false
+        end
+
+        private
+
+        def traverse_schema(path_parts)
+          current = @schema
+          
+          path_parts.each do |part|
+            if current["type"] == "object" && current["properties"]
+              current = current["properties"][part]
+              return nil unless current
+            elsif current["type"] == "array" && current["items"]
+              current = current["items"]
+            else
+              return nil
+            end
+          end
+          
+          current
+        end
+      end
+    end
+  end
+end

data/lib/json/schema/diff/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Json
+  module Schema
+    module Diff
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/json/schema/diff.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+require_relative "diff/version"
+require_relative "diff/cli"
+require_relative "diff/schema_parser"
+require_relative "diff/comparer"
+require_relative "diff/formatter"
+
+module Json
+  module Schema
+    module Diff
+      class Error < StandardError; end
+    end
+  end
+end

data/sig/json/schema/diff.rbs

@@ -0,0 +1,8 @@
+module Json
+  module Schema
+    module Diff
+      VERSION: String
+      # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+    end
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: json-schema-diff
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Nesbitt
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby gem that performs semantic diffs between JSON files, using JSON
+  Schema to guide and annotate the diff output with type information, field metadata,
+  and structured change detection.
+email:
+- andrewnez@gmail.com
+executables:
+- json-schema-diff
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
+- README.md
+- Rakefile
+- SECURITY.md
+- examples/capslock/README.md
+- examples/capslock/capslock-v0.5.0.json
+- examples/capslock/capslock-v0.6.0.json
+- examples/capslock/capslock.schema.json
+- examples/generic/report-v1.2.0.json
+- examples/generic/report-v1.3.0.json
+- examples/generic/security-report.schema.json
+- examples/zizmor/README.md
+- examples/zizmor/zizmor-v0.1.0.json
+- examples/zizmor/zizmor-v0.2.0.json
+- examples/zizmor/zizmor.schema.json
+- exe/json-schema-diff
+- lib/json/schema/diff.rb
+- lib/json/schema/diff/cli.rb
+- lib/json/schema/diff/comparer.rb
+- lib/json/schema/diff/formatter.rb
+- lib/json/schema/diff/schema_parser.rb
+- lib/json/schema/diff/version.rb
+- sig/json/schema/diff.rbs
+homepage: https://github.com/andrew/json-schema-diff
+licenses: []
+metadata:
+  homepage_uri: https://github.com/andrew/json-schema-diff
+  source_code_uri: https://github.com/andrew/json-schema-diff
+  changelog_uri: https://github.com/andrew/json-schema-diff/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Semantic diff for JSON files using JSON Schema metadata
+test_files: []