canon 0.1.3 → 0.1.5

data/lib/canon/commands/diff_command.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require_relative "../comparison"
+require_relative "../diff_formatter"
+require "json"
+require "yaml"
+
+module Canon
+  module Commands
+    # Command for semantic diffing of two files
+    class DiffCommand
+      def initialize(options = {})
+        @options = options
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+      def run(file1, file2)
+        # Detect formats
+        format1 = @options[:format1] || @options[:format] || detect_format(file1)
+        format2 = @options[:format2] || @options[:format] || detect_format(file2)
+
+        # Read raw content for potential by-line diff
+        content1 = File.read(file1)
+        content2 = File.read(file2)
+
+        # Parse documents
+        doc1 = parse_document_content(content1, format1)
+        doc2 = parse_document_content(content2, format2)
+
+        # Build comparison options
+        comp_opts = build_comparison_options
+
+        # Perform semantic comparison
+        result = Canon::Comparison.equivalent?(doc1, doc2, comp_opts)
+
+        # Determine diff mode
+        mode = determine_mode(format1)
+
+        # Prepare formatted content for by-line mode
+        formatted1, formatted2 = prepare_formatted_content(
+          content1, content2, format1, mode
+        )
+
+        # Format and output results
+        formatter = Canon::DiffFormatter.new(
+          use_color: @options[:color],
+          mode: mode,
+          context_lines: @options.fetch(:context_lines, 3),
+          diff_grouping_lines: @options[:diff_grouping_lines],
+        )
+        if comp_opts[:verbose]
+          # result is always a ComparisonResult object
+          output = formatter.format(
+            result,
+            format1,
+            doc1: formatted1,
+            doc2: formatted2,
+          )
+          puts output
+          exit result.equivalent? ? 0 : 1
+        elsif result
+          # result is a boolean
+          puts formatter.send(:success_message)
+          exit 0
+        else
+          puts "Files are semantically different"
+          exit 1
+        end
+      rescue Errno::ENOENT => e
+        abort "Error: #{e.message}"
+      rescue JSON::ParserError => e
+        abort "Error parsing JSON: #{e.message}"
+      rescue Psych::SyntaxError => e
+        abort "Error parsing YAML: #{e.message}"
+      rescue Canon::Error => e
+        abort "Error: #{e.message}"
+      rescue StandardError => e
+        abort "Error processing files: #{e.message}"
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      # Build comparison options from CLI options
+      def build_comparison_options
+        opts = build_profile_and_preprocessing_options
+        match_opts = build_match_dimension_options
+
+        opts[:match] = match_opts unless match_opts.empty?
+        opts[:ignore_attr_order] = @options.fetch(:ignore_attr_order, true)
+        opts[:verbose] = @options.fetch(:verbose, false)
+
+        opts
+      end
+
+      # Build profile and preprocessing options
+      def build_profile_and_preprocessing_options
+        opts = {}
+        if @options[:match_profile]
+          opts[:match_profile] =
+            @options[:match_profile].to_sym
+        end
+        if @options[:preprocessing]
+          opts[:preprocessing] =
+            @options[:preprocessing].to_sym
+        end
+        opts
+      end
+
+      # Build match dimension options
+      def build_match_dimension_options
+        dimensions = %i[
+          text_content structural_whitespace attribute_whitespace
+          comments key_order
+        ]
+
+        dimensions.each_with_object({}) do |dim, opts|
+          opts[dim] = @options[dim].to_sym if @options[dim]
+        end
+      end
+
+      # Determine diff mode based on format and options
+      def determine_mode(format)
+        # HTML always uses by-line mode
+        return :by_line if format == :html
+
+        # Check for explicit --by-line flag for XML, JSON, YAML
+        return :by_line if @options[:by_line]
+
+        # Default: by-object mode for JSON and YAML, by-object for XML
+        :by_object
+      end
+
+      # Parse document content based on its format
+      def parse_document_content(content, format)
+        case format
+        when :xml
+          # Return string for Canon::Comparison to parse
+          content
+        when :html
+          # Return string for Canon::Comparison to parse
+          content
+        when :json
+          # Parse JSON to Ruby object
+          JSON.parse(content)
+        when :yaml
+          # Parse YAML to Ruby object
+          YAML.safe_load(content)
+        else
+          abort "Error: Unsupported format '#{format}'"
+        end
+      end
+
+      # Prepare formatted content for by-line diff
+      def prepare_formatted_content(content1, content2, format, mode)
+        return [content1, content2] unless mode == :by_line
+
+        case format
+        when :xml
+          require_relative "../pretty_printer/xml"
+          formatted1 = Canon::PrettyPrinter::Xml.new(indent: 2).format(content1)
+          formatted2 = Canon::PrettyPrinter::Xml.new(indent: 2).format(content2)
+          [formatted1, formatted2]
+        when :html
+          require_relative "../pretty_printer/html"
+          formatted1 = Canon::PrettyPrinter::Html.new(indent: 2).format(content1)
+          formatted2 = Canon::PrettyPrinter::Html.new(indent: 2).format(content2)
+          [formatted1, formatted2]
+        else
+          [content1, content2]
+        end
+      end
+
+      # Detect format from file extension
+      def detect_format(filename)
+        ext = File.extname(filename).downcase
+        case ext
+        when ".xml"
+          :xml
+        when ".html", ".htm"
+          :html
+        when ".json"
+          :json
+        when ".yaml", ".yml"
+          :yaml
+        else
+          abort "Error: Cannot detect format from extension '#{ext}'. " \
+                "Please specify --format (xml, html, json, or yaml)"
+        end
+      end
+    end
+  end
+end

data/lib/canon/commands/format_command.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "../pretty_printer/xml"
+require_relative "../pretty_printer/json"
+require_relative "../pretty_printer/html"
+
+module Canon
+  module Commands
+    # Command for canonicalizing files
+    class FormatCommand
+      def initialize(options = {})
+        @options = options
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def run(input_file)
+        # Read input file
+        content = File.read(input_file)
+
+        # Detect or use specified format
+        format = detect_format(input_file)
+
+        # Format based on mode
+        result = format_content(content, format)
+
+        # Output
+        if @options[:output]
+          File.write(@options[:output], result)
+          mode_name = @options[:mode] == "pretty" ? "Pretty-printed" : "Canonicalized"
+          puts "#{mode_name} #{format.upcase} written to #{@options[:output]}"
+        else
+          puts result
+        end
+      rescue Errno::ENOENT
+        abort "Error: File '#{input_file}' not found"
+      rescue Canon::Error => e
+        abort "Error: #{e.message}"
+      rescue StandardError => e
+        abort "Error processing file: #{e.message}"
+      end
+
+      private
+
+      def format_content(content, format)
+        mode = @options[:mode] || "c14n"
+
+        case mode
+        when "pretty"
+          format_pretty(content, format)
+        when "c14n"
+          format_canonical(content, format)
+        else
+          abort "Error: Invalid mode '#{mode}'. Use 'c14n' or 'pretty'"
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def format_pretty(content, format)
+        indent = (@options[:indent] || 2).to_i
+        indent_type = @options[:indent_type] || "space"
+
+        case format
+        when :xml
+          Canon::PrettyPrinter::Xml.new(
+            indent: indent,
+            indent_type: indent_type,
+          ).format(content)
+        when :json
+          Canon::PrettyPrinter::Json.new(
+            indent: indent,
+            indent_type: indent_type,
+          ).format(content)
+        when :html
+          Canon::PrettyPrinter::Html.new(
+            indent: indent,
+            indent_type: indent_type,
+          ).format(content)
+        when :yaml
+          # YAML formatter already pretty-prints
+          Canon.format(content, format)
+        end
+      end
+
+      def format_canonical(content, format)
+        if format == :xml && @options[:with_comments]
+          Canon::Xml::C14n.canonicalize(content, with_comments: true)
+        else
+          Canon.format(content, format)
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def detect_format(filename)
+        return @options[:format].to_sym if @options[:format]
+
+        ext = File.extname(filename).downcase
+        case ext
+        when ".xml"
+          :xml
+        when ".json"
+          :json
+        when ".yaml", ".yml"
+          :yaml
+        when ".html", ".htm"
+          :html
+        else
+          abort "Error: Cannot detect format from extension '#{ext}'. " \
+                "Please specify --format (xml, json, yaml, or html)"
+        end
+      end
+    end
+  end
+end

data/lib/canon/comparison/base_comparator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Canon
+  module Comparison
+    # Base module for comparators providing common patterns
+    # Each comparator should include this module and implement:
+    # - serialize_for_display(content, match_opts)
+    module BaseComparator
+      # Build verbose result hash with preprocessed strings
+      #
+      # @param differences [Array] Array of difference hashes
+      # @param content1 [Object] First content to compare
+      # @param content2 [Object] Second content to compare
+      # @param match_opts [Hash] Match options used during comparison
+      # @return [Hash] Hash with :differences and :preprocessed keys
+      def build_verbose_result(differences, content1, content2, match_opts)
+        {
+          differences: differences,
+          preprocessed: [
+            serialize_for_display(content1, match_opts),
+            serialize_for_display(content2, match_opts),
+          ],
+        }
+      end
+
+      # Serialize content for display in diffs
+      # This method must be implemented by each comparator
+      #
+      # @param content [Object] Content to serialize
+      # @param match_opts [Hash] Match options that were applied during comparison
+      # @return [String] Serialized content reflecting match options
+      # @raise [NotImplementedError] if not implemented by including class
+      def serialize_for_display(content, match_opts)
+        raise NotImplementedError,
+              "#{self.class.name} must implement serialize_for_display"
+      end
+    end
+  end
+end

data/lib/canon/comparison/comparison_result.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Canon
+  module Comparison
+    # Encapsulates the result of a comparison operation
+    # Provides methods to query equivalence based on normative diffs
+    class ComparisonResult
+      attr_reader :differences, :preprocessed_strings, :format, :html_version,
+                  :match_options
+
+      # @param differences [Array<DiffNode>] Array of difference nodes
+      # @param preprocessed_strings [Array<String, String>] Pre-processed content for display
+      # @param format [Symbol] Format type (:xml, :html, :json, :yaml)
+      # @param html_version [Symbol, nil] HTML version (:html4 or :html5) for HTML format only
+      # @param match_options [Hash, nil] Resolved match options used for comparison
+      def initialize(differences:, preprocessed_strings:, format:,
+html_version: nil, match_options: nil)
+        @differences = differences
+        @preprocessed_strings = preprocessed_strings
+        @format = format
+        @html_version = html_version
+        @match_options = match_options
+      end
+
+      # Check if documents are semantically equivalent (no normative diffs)
+      #
+      # @return [Boolean] true if no normative differences present
+      def equivalent?
+        !has_normative_diffs?
+      end
+
+      # Check if there are any normative (semantic) differences
+      # Includes both DiffNode objects marked as normative AND legacy Hash differences
+      # (which represent structural differences like element name mismatches)
+      #
+      # @return [Boolean] true if at least one normative diff exists
+      def has_normative_diffs?
+        @differences.any? do |diff|
+          # DiffNode objects - check if marked normative
+          if diff.is_a?(Canon::Diff::DiffNode)
+            diff.normative?
+          # Legacy Hash format - always considered normative (structural differences)
+          elsif diff.is_a?(Hash)
+            true
+          else
+            false
+          end
+        end
+      end
+
+      # Check if there are any informative (textual-only) differences
+      #
+      # @return [Boolean] true if at least one informative diff exists
+      def has_informative_diffs?
+        @differences.any? do |diff|
+          diff.is_a?(Canon::Diff::DiffNode) && diff.informative?
+        end
+      end
+
+      # Get all normative differences
+      #
+      # @return [Array<DiffNode>] Normative differences only
+      def normative_differences
+        @differences.select do |diff|
+          diff.is_a?(Canon::Diff::DiffNode) && diff.normative?
+        end
+      end
+
+      # Get all informative differences
+      #
+      # @return [Array<DiffNode>] Informative differences only
+      def informative_differences
+        @differences.select do |diff|
+          diff.is_a?(Canon::Diff::DiffNode) && diff.informative?
+        end
+      end
+    end
+  end
+end