xsdvi 1.0.0 → 1.0.1

data/lib/xsdvi/comparison/dual_generator.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "nokogiri"
+
+module Xsdvi
+  module Comparison
+    # Orchestrates dual generation with Java and Ruby XsdVi
+    class DualGenerator
+      attr_reader :xsd_file, :output_dir
+
+      def initialize(xsd_file, options = {})
+        @xsd_file = xsd_file
+        @root = options[:root_node_name]
+        @output_dir = options[:output_path] || default_output_dir
+        @skip_java = options[:skip_java]
+        @skip_ruby = options[:skip_ruby]
+      end
+
+      # Generate comparison
+      # @return [Hash] Generation results with paths and metadata
+      def generate
+        validate_inputs
+        setup_directories
+
+        # Generate Java output
+        java_start = Time.now
+        generate_java unless @skip_java
+        java_time = Time.now - java_start
+
+        # Generate Ruby output
+        ruby_start = Time.now
+        generate_ruby unless @skip_ruby
+        ruby_time = Time.now - ruby_start
+
+        # Extract metadata
+        java_metadata = extract_metadata(java_dir)
+        ruby_metadata = extract_metadata(ruby_dir)
+
+        # Add timing info
+        java_metadata[:generation_time] = java_time.round(2) unless @skip_java
+        ruby_metadata[:generation_time] = ruby_time.round(2) unless @skip_ruby
+
+        # Generate HTML comparison
+        html_file = generate_html(java_metadata, ruby_metadata)
+
+        {
+          output_dir: @output_dir,
+          html_file: html_file,
+          java: java_metadata,
+          ruby: ruby_metadata,
+        }
+      end
+
+      private
+
+      # Validate inputs
+      def validate_inputs
+        raise "XSD file not found: #{@xsd_file}" unless File.exist?(@xsd_file)
+        raise "Must generate at least one implementation" if @skip_java && @skip_ruby
+      end
+
+      # Setup output directories
+      def setup_directories
+        FileUtils.mkdir_p(java_dir)
+        FileUtils.mkdir_p(ruby_dir)
+      end
+
+      # Get Java output directory
+      # @return [String] Java directory path
+      def java_dir
+        File.join(@output_dir, "java")
+      end
+
+      # Get Ruby output directory
+      # @return [String] Ruby directory path
+      def ruby_dir
+        File.join(@output_dir, "ruby")
+      end
+
+      # Generate Java XsdVi output
+      def generate_java
+        puts "Generating Java XsdVi output..."
+        manager = JavaManager.new
+
+        options = {}
+        options[:root] = @root if @root
+
+        manager.generate(@xsd_file, java_dir, options)
+      end
+
+      # Generate Ruby XsdVi output
+      def generate_ruby
+        puts "Generating Ruby XsdVi output..."
+
+        # Set up the generation pipeline (same as CLI)
+        builder = Tree::Builder.new
+        xsd_handler = XsdHandler.new(builder)
+        writer_helper = Utils::Writer.new
+        svg_generator = SVG::Generator.new(writer_helper)
+
+        # Configure handler
+        xsd_handler.root_node_name = @root
+        # one_node_only should only be true when generating all elements separately
+        xsd_handler.one_node_only = (@root == "all")
+
+        # Configure generator
+        svg_generator.hide_menu_buttons = (@root == "all")
+        svg_generator.embody_style = true
+
+        # Parse XSD
+        xsd_handler.process_file(@xsd_file)
+
+        # Generate output file(s)
+        if @root == "all"
+          generate_ruby_all_elements(xsd_handler, svg_generator, builder,
+                                     writer_helper)
+        else
+          generate_ruby_single(svg_generator, builder, writer_helper)
+        end
+      end
+
+      # Generate Ruby output for all elements
+      def generate_ruby_all_elements(xsd_handler, svg_generator, builder,
+writer_helper)
+        doc = Nokogiri::XML(File.read(@xsd_file))
+        element_names = xsd_handler.get_elements_names(doc)
+
+        element_names.each do |elem_name|
+          # Reset for each element
+          builder = Tree::Builder.new
+          handler = XsdHandler.new(builder)
+          handler.root_node_name = elem_name
+          handler.one_node_only = true
+          handler.set_schema_namespace(doc, elem_name)
+          handler.process_file(@xsd_file)
+
+          output_file = File.join(ruby_dir, "#{elem_name}.svg")
+          writer_helper.new_writer(output_file)
+          svg_generator.draw(builder.root) if builder.root
+        end
+      end
+
+      # Generate Ruby output for single element
+      def generate_ruby_single(svg_generator, builder, writer_helper)
+        filename = if @root
+                     "#{@root}.svg"
+                   else
+                     "#{File.basename(@xsd_file, '.xsd')}.svg"
+                   end
+
+        output_file = File.join(ruby_dir, filename)
+        writer_helper.new_writer(output_file)
+        svg_generator.draw(builder.root) if builder.root
+      end
+
+      # Extract metadata from output directory
+      # @param dir [String] Directory path
+      # @return [Hash] Extracted metadata
+      def extract_metadata(dir)
+        extractor = MetadataExtractor.new
+        extractor.extract(dir)
+      end
+
+      # Generate HTML comparison page
+      # @param java_meta [Hash] Java metadata
+      # @param ruby_meta [Hash] Ruby metadata
+      # @return [String] Path to HTML file
+      def generate_html(java_meta, ruby_meta)
+        puts "Generating comparison HTML..."
+
+        generator = HtmlGenerator.new
+        generator.generate(
+          @output_dir,
+          java_meta,
+          ruby_meta,
+          schema_name: File.basename(@xsd_file, ".xsd"),
+        )
+      end
+
+      # Generate default output directory path
+      # @return [String] Default directory path
+      def default_output_dir
+        timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
+        schema_name = File.basename(@xsd_file, ".xsd")
+        File.join("comparisons", "#{schema_name}-#{timestamp}")
+      end
+    end
+  end
+end

data/lib/xsdvi/comparison/html_generator.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Xsdvi
+  module Comparison
+    # Generates HTML comparison page
+    class HtmlGenerator
+      TEMPLATE_PATH = File.join(__dir__,
+                                "../../../resources/comparison/template.html")
+
+      # Generate HTML comparison page
+      # @param output_dir [String] Output directory path
+      # @param java_metadata [Hash] Java generation metadata
+      # @param ruby_metadata [Hash] Ruby generation metadata
+      # @param options [Hash] Generation options
+      # @option options [String] :schema_name Schema name for display
+      # @return [String] Path to generated HTML file
+      def generate(output_dir, java_metadata, ruby_metadata, options = {})
+        template = File.read(TEMPLATE_PATH)
+
+        html = template
+          .gsub("{{SCHEMA_NAME}}", options[:schema_name] || "Schema")
+          .gsub("{{JAVA_METADATA}}", format_metadata_json(java_metadata))
+          .gsub("{{RUBY_METADATA}}", format_metadata_json(ruby_metadata))
+          .gsub("{{STATS_TABLE}}", generate_stats_table(java_metadata,
+                                                        ruby_metadata))
+          .gsub("{{ELEMENT_SELECTOR}}", generate_element_selector(
+                                          java_metadata, ruby_metadata
+                                        ))
+          .gsub("{{IS_MULTI_FILE}}", (java_metadata[:file_count] > 1).to_s)
+
+        output_file = File.join(output_dir, "comparison.html")
+        File.write(output_file, html)
+
+        output_file
+      end
+
+      private
+
+      # Format metadata as JSON
+      # @param metadata [Hash] Metadata hash
+      # @return [String] Pretty-printed JSON
+      def format_metadata_json(metadata)
+        JSON.pretty_generate(metadata)
+      end
+
+      # Generate statistics comparison table HTML
+      # @param java_meta [Hash] Java metadata
+      # @param ruby_meta [Hash] Ruby metadata
+      # @return [String] HTML table
+      def generate_stats_table(java_meta, ruby_meta)
+        rows = []
+
+        # File counts
+        rows << table_row(
+          "Files",
+          java_meta[:file_count],
+          ruby_meta[:file_count],
+          java_meta[:file_count] == ruby_meta[:file_count],
+        )
+
+        # Total size
+        rows << table_row(
+          "Total Size",
+          "#{java_meta[:total_size_kb]} KB",
+          "#{ruby_meta[:total_size_kb]} KB",
+          (java_meta[:total_size_kb] - ruby_meta[:total_size_kb]).abs < 1,
+        )
+
+        # Generation time (if available)
+        if java_meta[:generation_time] && ruby_meta[:generation_time]
+          rows << table_row(
+            "Generation Time",
+            "#{java_meta[:generation_time]}s",
+            "#{ruby_meta[:generation_time]}s",
+            nil,
+          )
+        end
+
+        # Symbol counts (sum across all files)
+        symbol_types = [
+          ["Total Symbols", :total_symbols],
+          ["Elements", :elements],
+          ["Optional Elements", :optional_elements],
+          ["Attributes", :attributes],
+          ["Sequences", :sequences],
+          ["Choices", :choices],
+          ["All Compositors", :all_compositors],
+          ["Keys", :keys],
+          ["Key References", :keyrefs],
+          ["Unique Constraints", :uniques],
+          ["Loops", :loops],
+        ]
+
+        symbol_types.each do |label, key|
+          java_total = sum_symbol_count(java_meta[:files], key)
+          ruby_total = sum_symbol_count(ruby_meta[:files], key)
+
+          next if java_total.zero? && ruby_total.zero?
+
+          rows << table_row(label, java_total, ruby_total,
+                            java_total == ruby_total)
+        end
+
+        <<~HTML
+          <table>
+            <thead>
+              <tr>
+                <th>Metric</th>
+                <th>Java XsdVi</th>
+                <th>Ruby XsdVi</th>
+                <th>Match</th>
+              </tr>
+            </thead>
+            <tbody>
+              #{rows.join("\n      ")}
+            </tbody>
+          </table>
+        HTML
+      end
+
+      # Generate a table row
+      # @param label [String] Row label
+      # @param java_val [Object] Java value
+      # @param ruby_val [Object] Ruby value
+      # @param match [Boolean, nil] Whether values match (nil for N/A)
+      # @return [String] HTML table row
+      def table_row(label, java_val, ruby_val, match)
+        match_cell = if match.nil?
+                       "<td>—</td>"
+                     elsif match
+                       "<td class='match'>✓</td>"
+                     else
+                       "<td class='mismatch'>✗</td>"
+                     end
+
+        <<~HTML.strip
+          <tr>
+                <td><strong>#{label}</strong></td>
+                <td>#{java_val}</td>
+                <td>#{ruby_val}</td>
+                #{match_cell}
+              </tr>
+        HTML
+      end
+
+      # Sum symbol counts across files
+      # @param files [Array<Hash>] File metadata array
+      # @param key [Symbol] Symbol type key
+      # @return [Integer] Total count
+      def sum_symbol_count(files, key)
+        return 0 unless files
+
+        files.sum { |f| f[key] || 0 }
+      end
+
+      # Generate element selector dropdown
+      # @param java_meta [Hash] Java metadata
+      # @param ruby_meta [Hash] Ruby metadata
+      # @return [String] HTML select element or empty string
+      def generate_element_selector(java_meta, _ruby_meta)
+        return "" if java_meta[:file_count] <= 1
+
+        options = java_meta[:files].each_with_index.map do |file, index|
+          name = File.basename(file[:name], ".svg")
+          "<option value='#{index}'>#{name}</option>"
+        end
+
+        <<~HTML
+          <div class="element-selector">
+            <label for="element-select">Select Element:</label>
+            <select id="element-select" onchange="loadFile(this.value)">
+              #{options.join("\n      ")}
+            </select>
+          </div>
+        HTML
+      end
+    end
+  end
+end

data/lib/xsdvi/comparison/java_manager.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "open-uri"
+require "fileutils"
+
+module Xsdvi
+  module Comparison
+    # Manages downloading, caching, and executing Java XsdVi
+    class JavaManager
+      JAR_URL = "https://github.com/metanorma/xsdvi/releases/download/v1.3/xsdvi-1.3.jar"
+      CACHE_DIR = File.expand_path("~/.xsdvi")
+      JAR_FILENAME = "xsdvi-1.3.jar"
+      JAR_PATH = File.join(CACHE_DIR, JAR_FILENAME)
+      EXPECTED_SIZE = 2_500_000 # ~2.5MB minimum
+
+      def initialize
+        @jar_path = JAR_PATH
+      end
+
+      # Ensure JAR is available, download if needed
+      # @return [Boolean] true if JAR is ready
+      def ensure_jar_available
+        return true if jar_valid?
+
+        puts "Downloading Java XsdVi v1.3..."
+        download_jar
+        verify_jar
+        true
+      end
+
+      # Generate SVG using Java XsdVi
+      # @param xsd_file [String] Path to XSD file
+      # @param output_dir [String] Output directory path
+      # @param options [Hash] Generation options
+      # @option options [String] :root Root element name
+      # @option options [Boolean] :all Generate all elements
+      # @return [Boolean] true if successful
+      def generate(xsd_file, output_dir, options = {})
+        ensure_java_available
+        ensure_jar_available
+
+        cmd = build_java_command(xsd_file, output_dir, options)
+        puts "Executing Java XsdVi..."
+
+        success = system(cmd)
+        raise "Java XsdVi execution failed" unless success
+
+        true
+      end
+
+      private
+
+      # Check if cached JAR is valid
+      # @return [Boolean] true if JAR exists and has valid size
+      def jar_valid?
+        File.exist?(@jar_path) && File.size(@jar_path) > EXPECTED_SIZE
+      end
+
+      # Download JAR from GitHub releases
+      def download_jar
+        FileUtils.mkdir_p(CACHE_DIR)
+
+        begin
+          URI.open(JAR_URL, "rb") do |remote|
+            File.binwrite(@jar_path, remote.read)
+          end
+        rescue StandardError => e
+          raise "Failed to download Java XsdVi: #{e.message}"
+        end
+      end
+
+      # Verify downloaded JAR integrity
+      def verify_jar
+        unless File.size(@jar_path) > EXPECTED_SIZE
+          File.delete(@jar_path)
+          raise "Downloaded JAR is invalid (size: #{File.size(@jar_path)} bytes)"
+        end
+
+        puts "✓ Java XsdVi cached at #{@jar_path}"
+      end
+
+      # Build Java command line
+      # @param xsd_file [String] Path to XSD file
+      # @param output_dir [String] Output directory path
+      # @param options [Hash] Generation options
+      # @return [String] Complete command string
+      def build_java_command(xsd_file, output_dir, options)
+        cmd_parts = ["java", "-jar", @jar_path]
+
+        # Input file is positional (no --in flag)
+        cmd_parts << File.expand_path(xsd_file)
+
+        # Root node name (including "all" for generating all elements)
+        if options[:root]
+          cmd_parts << "-rootNodeName" << options[:root]
+        end
+
+        # One node only flag (required when generating all elements separately)
+        cmd_parts << "-oneNodeOnly" if options[:root] == "all"
+
+        # Output path
+        cmd_parts << "-outputPath" << File.expand_path(output_dir)
+
+        cmd_parts.join(" ")
+      end
+
+      # Check if Java is available on system
+      # @raise [RuntimeError] if Java is not installed
+      def ensure_java_available
+        return if system("java -version", out: File::NULL, err: File::NULL)
+
+        raise <<~ERROR
+          Error: Java is required but not installed.
+
+          Please install Java from: https://java.com
+          Or use your system package manager:
+            - macOS: brew install openjdk
+            - Ubuntu/Debian: sudo apt-get install default-jdk
+            - Fedora: sudo dnf install java-latest-openjdk
+        ERROR
+      end
+    end
+  end
+end

data/lib/xsdvi/comparison/metadata_extractor.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Xsdvi
+  module Comparison
+    # Extracts metadata from SVG files for comparison
+    class MetadataExtractor
+      # Extract metadata from all SVG files in a directory
+      # @param svg_dir [String] Directory containing SVG files
+      # @return [Hash] Metadata including file count, sizes, and symbol counts
+      def extract(svg_dir)
+        files = Dir.glob(File.join(svg_dir, "*.svg"))
+
+        {
+          file_count: files.length,
+          total_size: files.sum { |f| File.size(f) },
+          total_size_kb: (files.sum { |f| File.size(f) } / 1024.0).round(1),
+          files: files.map { |f| analyze_file(f) },
+        }
+      end
+
+      private
+
+      # Analyze a single SVG file
+      # @param svg_file [String] Path to SVG file
+      # @return [Hash] File metadata and symbol counts
+      def analyze_file(svg_file)
+        content = File.read(svg_file)
+        doc = Nokogiri::XML(content)
+        # Remove namespaces to simplify XPath queries
+        doc.remove_namespaces!
+
+        {
+          name: File.basename(svg_file),
+          size: File.size(svg_file),
+          size_kb: (File.size(svg_file) / 1024.0).round(1),
+          elements: count_by_class(doc, "boxelement"),
+          optional_elements: count_by_class(doc, "boxelementoptional"),
+          attributes: count_by_class(doc, "boxattribute1", "boxattribute2"),
+          sequences: count_by_class(doc, "boxsequence"),
+          choices: count_by_class(doc, "boxchoice"),
+          all_compositors: count_by_class(doc, "boxall"),
+          compositors: count_by_class(doc, "boxcompositor"),
+          any: count_by_class(doc, "boxany"),
+          any_attribute: count_by_class(doc, "boxanyAttribute"),
+          keys: count_by_class(doc, "boxkey"),
+          keyrefs: count_by_class(doc, "boxkeyref"),
+          uniques: count_by_class(doc, "boxunique"),
+          selectors: count_by_class(doc, "boxselector"),
+          fields: count_by_class(doc, "boxfield"),
+          loops: count_by_class(doc, "boxloop"),
+          schemas: count_by_class(doc, "boxschema"),
+          total_symbols: count_all_boxes(doc),
+        }
+      end
+
+      # Count rectangles with specific CSS classes
+      # @param doc [Nokogiri::XML::Document] Parsed SVG document
+      # @param classes [Array<String>] CSS class names to match
+      # @return [Integer] Count of matching rectangles
+      def count_by_class(doc, *classes)
+        xpath = classes.map { |c| "@class='#{c}'" }.join(" or ")
+        doc.xpath("//rect[#{xpath}]").count
+      end
+
+      # Count all box elements (symbols)
+      # @param doc [Nokogiri::XML::Document] Parsed SVG document
+      # @return [Integer] Total count of box elements
+      def count_all_boxes(doc)
+        doc.xpath("//rect[starts-with(@class, 'box')]").count
+      end
+    end
+  end
+end

data/lib/xsdvi/svg/generator.rb

@@ -50,6 +50,7 @@ module Xsdvi
         print(script)
 
         print_defs(embody_style, true)
+        print("")
         print(load_resource("svg/menu_buttons.svg")) unless hide_menu_buttons
       end
 

data/lib/xsdvi/svg/symbol.rb

@@ -155,10 +155,11 @@ module Xsdvi
           wrapped_string = word_utils_wrap(desc_string, wrap_length)
           wrapped_lines = wrapped_string.split("\n")
           strings_with_breaks.concat(wrapped_lines)
+          # Match Java bug: accumulate TOTAL size, not just new lines
+          @additional_height += y_shift * strings_with_breaks.size
         end
 
         @description_string_array = strings_with_breaks
-        @additional_height = y_shift * strings_with_breaks.size
 
         prev_y = Symbol.prev_y_position || 0
         curr_y = y_position || 0
@@ -187,47 +188,55 @@ module Xsdvi
 
       # Apache Commons WordUtils.wrap(str, wrapLength, newLineStr, wrapLongWords)
       # Wraps text at wrapLength, inserting newLineStr, optionally breaking long words
+      # Java WordUtils processes multi-line input by handling each line separately
       def word_utils_wrap(input, wrap_length)
         return input if input.nil? || wrap_length < 1
 
-        input_line_length = input.length
-        return input if input_line_length <= wrap_length
+        # Split by existing newlines first (like Java WordUtils does)
+        input_lines = input.split("\n", -1) # -1 to preserve trailing empty strings
+        result_lines = []
 
-        result = []
-        offset = 0
-
-        while offset < input_line_length
-          # Handle existing newline in input
-          space_idx = input.index("\n", offset)
-          if space_idx && space_idx < wrap_length + offset
-            # There's a newline before wrap point
-            result << input[offset...space_idx]
-            offset = space_idx + 1
+        input_lines.each do |line|
+          # Handle empty lines
+          if line.empty?
+            result_lines << ""
             next
           end
 
-          # Find wrap point
-          if input_line_length - offset <= wrap_length
-            # Rest of string fits
-            result << input[offset..]
-            break
+          # Skip wrapping if line is strictly shorter than wrap_length
+          # Apache Commons only skips if length < wrap_length, not <=
+          if line.length < wrap_length
+            result_lines << line
+            next
           end
 
-          # Need to wrap - find last space before wrap_length
-          space_idx = input.rindex(" ", offset + wrap_length)
-
-          if space_idx && space_idx >= offset
-            # Found space to break at
-            result << input[offset...space_idx]
-            offset = space_idx + 1
-          else
-            # No space found - break at wrap_length (wrapLongWords=true)
-            result << input[offset...(offset + wrap_length)]
-            offset += wrap_length
+          # Wrap this line
+          offset = 0
+          line_length = line.length
+
+          while offset < line_length
+            # Rest of line fits?
+            if line_length - offset <= wrap_length
+              result_lines << line[offset..]
+              break
+            end
+
+            # Find last space before wrap point
+            space_idx = line.rindex(" ", offset + wrap_length)
+
+            if space_idx && space_idx >= offset
+              # Found space to break at
+              result_lines << line[offset...space_idx]
+              offset = space_idx + 1
+            else
+              # No space found - break at wrap_length (wrapLongWords=true)
+              result_lines << line[offset...(offset + wrap_length)]
+              offset += wrap_length
+            end
           end
         end
 
-        result.join("\n")
+        result_lines.join("\n")
       end
     end
   end

data/lib/xsdvi/svg/symbols/attribute.rb

@@ -51,7 +51,7 @@ module Xsdvi
           calc.new_width(15, namespace)
           calc.new_width(15, type)
           calc.new_width(15, 13)
-          calc.new_width(15, constraint)
+          calc.new_width(15, constraint) # Constraint includes "default: " or "fixed: " prefix
           calc.width
         end