dsv7-parser 7.0.0

data/lib/dsv7/parser.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'parser/version'
+require_relative 'parser/engine'
+require_relative 'validator'
+require_relative 'stream'
+require_relative 'lex'
+
+module Dsv7
+  module Parser
+    class Error < StandardError; end
+
+    # Generic streaming parser that auto-detects the list type from the
+    # first effective FORMAT line and yields events for any DSV7 list.
+    # Yields [:format|:element|:end, payload, line_number].
+    # The first event is always :format with payload
+    #   { list_type: <String>, version: <String> }.
+    def self.parse(input, &block)
+      enum = Enumerator.new { |y| Engine.stream_any(input, y) }
+      return enum.each(&block) if block_given?
+
+      enum
+    end
+
+    # Streaming parser for Wettkampfdefinitionsliste (WKDL).
+    # Yields [:format|:element|:end, payload, line_number].
+    # Performs inline comment stripping, tolerates BOM, and scrubs UTF-8.
+    def self.parse_wettkampfdefinitionsliste(input, &block)
+      enum = Enumerator.new { |y| Engine.stream_list(input, y, 'Wettkampfdefinitionsliste') }
+      return enum.each(&block) if block_given?
+
+      enum
+    end
+
+    # Streaming parser for Vereinsmeldeliste (VML).
+    # Same contract as parse_wettkampfdefinitionsliste, but expects
+    # FORMAT:Vereinsmeldeliste;7; as the first effective line.
+    def self.parse_vereinsmeldeliste(input, &block)
+      enum = Enumerator.new { |y| Engine.stream_list(input, y, 'Vereinsmeldeliste') }
+      return enum.each(&block) if block_given?
+
+      enum
+    end
+
+    # Streaming parser for Wettkampfergebnisliste (ERG).
+    # Same contract as the other parse_* methods, but expects
+    # FORMAT:Wettkampfergebnisliste;7; as the first effective line.
+    def self.parse_wettkampfergebnisliste(input, &block)
+      enum = Enumerator.new { |y| Engine.stream_list(input, y, 'Wettkampfergebnisliste') }
+      return enum.each(&block) if block_given?
+
+      enum
+    end
+
+    # Streaming parser for Vereinsergebnisliste (VRL).
+    # Same contract as the other parse_* methods, but expects
+    # FORMAT:Vereinsergebnisliste;7; as the first effective line.
+    def self.parse_vereinsergebnisliste(input, &block)
+      enum = Enumerator.new { |y| Engine.stream_list(input, y, 'Vereinsergebnisliste') }
+      return enum.each(&block) if block_given?
+
+      enum
+    end
+    # no additional private class methods
+  end
+end

data/lib/dsv7/stream.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Dsv7
+  module Stream
+    module_function
+
+    # Puts IO into binary mode when possible (no-op for StringIO)
+    def binmode_if_possible(io)
+      io.binmode
+    rescue StandardError
+      # ignore
+    end
+
+    # Reads potential UTF-8 BOM from the start of IO.
+    # Returns true if a BOM was found (and consumed), false otherwise.
+    # If no BOM was found, unread the peeked bytes back into the IO.
+    def read_bom?(io)
+      head = io.read(3)
+      return false if head.nil? || head.empty?
+
+      if head.bytes == [0xEF, 0xBB, 0xBF]
+        true
+      else
+        head.bytes.reverse_each { |b| io.ungetbyte(b) }
+        false
+      end
+    end
+
+    # Normalizes a raw line by trimming trailing LF/CR and forcing UTF-8.
+    # If invalid encoding is detected, it scrubs replacement chars and
+    # calls the optional on_invalid callback.
+    def sanitize_line(raw, on_invalid: nil)
+      s = raw.delete_suffix("\n").delete_suffix("\r")
+      s.force_encoding(Encoding::UTF_8)
+      return s if s.valid_encoding?
+
+      on_invalid&.call
+      s.scrub('�')
+    end
+
+    # Removes inline single-line comments in the form: (* ... *)
+    def strip_inline_comment(line)
+      return line unless line.include?('(*') && line.include?('*)')
+
+      line.gsub(/\(\*.*?\*\)/, '')
+    end
+
+    # Iterates sanitized lines, yielding [line, line_number].
+    # Returns true if any CRLF lines were observed.
+    def each_sanitized_line(io, on_invalid: nil)
+      had_crlf = false
+      line_number = 0
+      io.each_line("\n") do |raw|
+        line_number += 1
+        had_crlf ||= raw.end_with?("\r\n")
+        yield sanitize_line(raw, on_invalid: on_invalid), line_number
+      end
+      had_crlf
+    end
+  end
+end

data/lib/dsv7/validator/cardinality.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Dsv7
+  class Validator
+    # Validates Wettkampfdefinitionsliste element cardinalities
+    class WkCardinality
+      def initialize(result, wk_elements)
+        @result = result
+        @wk_elements = wk_elements
+      end
+
+      def validate!
+        require_exactly_one(
+          %w[ERZEUGER VERANSTALTUNG VERANSTALTUNGSORT AUSSCHREIBUNGIMNETZ
+             VERANSTALTER AUSRICHTER MELDEADRESSE MELDESCHLUSS]
+        )
+        forbid_more_than_one(%w[BANKVERBINDUNG BESONDERES NACHWEIS])
+        require_at_least_one(%w[ABSCHNITT WETTKAMPF WERTUNG MELDEGELD])
+      end
+
+      private
+
+      def require_exactly_one(elements)
+        elements.each do |el|
+          count = @wk_elements[el]
+          if count.zero?
+            @result.add_error("Wettkampfdefinitionsliste: missing required element '#{el}'")
+          elsif count != 1
+            @result.add_error(
+              "Wettkampfdefinitionsliste: element '#{el}' occurs #{count} times (expected 1)"
+            )
+          end
+        end
+      end
+
+      def forbid_more_than_one(elements)
+        elements.each do |el|
+          count = @wk_elements[el]
+          next if count <= 1
+
+          @result.add_error(
+            "Wettkampfdefinitionsliste: element '#{el}' occurs #{count} times (max 1)"
+          )
+        end
+      end
+
+      def require_at_least_one(elements)
+        elements.each do |el|
+          count = @wk_elements[el]
+          next if count >= 1
+
+          @result.add_error("Wettkampfdefinitionsliste: missing required element '#{el}'")
+        end
+      end
+    end
+
+    # Validates Vereinsmeldeliste element cardinalities
+    class VmlCardinality
+      def initialize(result, elements)
+        @result = result
+        @elements = elements
+      end
+
+      def validate!
+        require_exactly_one(%w[ERZEUGER VERANSTALTUNG VEREIN ANSPRECHPARTNER])
+        require_at_least_one(%w[ABSCHNITT WETTKAMPF])
+      end
+
+      private
+
+      def require_exactly_one(elements)
+        elements.each do |el|
+          count = @elements[el]
+          if count.zero?
+            @result.add_error("Vereinsmeldeliste: missing required element '#{el}'")
+          elsif count != 1
+            @result.add_error(
+              "Vereinsmeldeliste: element '#{el}' occurs #{count} times (expected 1)"
+            )
+          end
+        end
+      end
+
+      def require_at_least_one(elements)
+        elements.each do |el|
+          count = @elements[el]
+          next if count >= 1
+
+          @result.add_error("Vereinsmeldeliste: missing required element '#{el}'")
+        end
+      end
+    end
+
+    # Validates Wettkampfergebnisliste element cardinalities
+    class ErgCardinality
+      def initialize(result, elements)
+        @result = result
+        @elements = elements
+      end
+
+      def validate!
+        require_exactly_one(%w[ERZEUGER VERANSTALTUNG VERANSTALTER AUSRICHTER])
+        require_at_least_one(%w[ABSCHNITT WETTKAMPF WERTUNG VEREIN])
+      end
+
+      private
+
+      def require_exactly_one(elements)
+        elements.each do |el|
+          count = @elements[el]
+          if count.zero?
+            @result.add_error("Wettkampfergebnisliste: missing required element '#{el}'")
+          elsif count != 1
+            @result.add_error(
+              "Wettkampfergebnisliste: element '#{el}' occurs #{count} times (expected 1)"
+            )
+          end
+        end
+      end
+
+      def require_at_least_one(elements)
+        elements.each do |el|
+          count = @elements[el]
+          next if count >= 1
+
+          @result.add_error("Wettkampfergebnisliste: missing required element '#{el}'")
+        end
+      end
+    end
+
+    # Validates Vereinsergebnisliste element cardinalities
+    class VrlCardinality
+      def initialize(result, elements)
+        @result = result
+        @elements = elements
+      end
+
+      def validate!
+        require_exactly_one(%w[ERZEUGER VERANSTALTUNG VERANSTALTER AUSRICHTER])
+        require_at_least_one(%w[ABSCHNITT WETTKAMPF WERTUNG VEREIN])
+      end
+
+      private
+
+      def require_exactly_one(elements)
+        elements.each do |el|
+          count = @elements[el]
+          if count.zero?
+            @result.add_error("Vereinsergebnisliste: missing required element '#{el}'")
+          elsif count != 1
+            @result.add_error(
+              "Vereinsergebnisliste: element '#{el}' occurs #{count} times (expected 1)"
+            )
+          end
+        end
+      end
+
+      def require_at_least_one(elements)
+        elements.each do |el|
+          count = @elements[el]
+          next if count >= 1
+
+          @result.add_error("Vereinsergebnisliste: missing required element '#{el}'")
+        end
+      end
+    end
+  end
+end

data/lib/dsv7/validator/core.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../stream'
+require_relative '../lex'
+require_relative 'line_analyzer'
+
+module Dsv7
+  class Validator
+    # Core pipeline for validator: encoding + line parsing
+    class Core
+      def initialize(result, filename)
+        @result = result
+        @filename = filename
+      end
+
+      def call_io(io)
+        Dsv7::Stream.binmode_if_possible(io)
+        check_bom_and_rewind(io)
+        process_lines(io)
+      end
+
+      private
+
+      def check_bom_and_rewind(io)
+        bom = Dsv7::Stream.read_bom?(io)
+        @result.add_error('UTF-8 BOM detected (spec requires UTF-8 without BOM)') if bom
+      end
+
+      def process_lines(io)
+        analyzer = LineAnalyzer.new(@result)
+        had_crlf = iterate(io) { |line, line_number| analyzer.process_line(line, line_number) }
+        @result.add_warning('CRLF line endings detected') if had_crlf
+        analyzer.finish
+        check_filename(@filename)
+        @result
+      end
+
+      def iterate(io, &block)
+        Dsv7::Stream.each_sanitized_line(
+          io,
+          on_invalid: -> { @result.add_error('File is not valid UTF-8 encoding') }
+        ) do |line, line_number|
+          block.call(line, line_number)
+        end
+      end
+
+      def check_filename(filename)
+        return if filename.nil?
+        return if filename.match(/^\d{4}-\d{2}-\d{2}-[^.]+\.DSV7$/)
+
+        @result.add_warning(
+          "Filename '#{filename}' does not follow 'JJJJ-MM-TT-Ort-Zusatz.DSV7'"
+        )
+      end
+    end
+  end
+end

data/lib/dsv7/validator/line_analyzer.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative '../stream'
+require_relative 'line_analyzer_common'
+require_relative 'schemas/wk_schema'
+require_relative 'schemas/vml_schema'
+require_relative 'schemas/erg_schema'
+require_relative 'schemas/vrl_schema'
+
+module Dsv7
+  class Validator
+    class LineAnalyzer
+      include LineAnalyzerWk
+      include LineAnalyzerVml
+      include LineAnalyzerErg
+      include LineAnalyzerVrl
+
+      def initialize(result)
+        @result = result
+        @effective_index = 0
+        @format_line_index = nil
+        @dateiende_index = nil
+        @after_dateiende_effective_line_number = nil
+        init_schemas_and_counters
+      end
+
+      def init_schemas_and_counters
+        @wk_elements = Hash.new(0)
+        @wk_schema = WkSchema.new(@result)
+        @vml_elements = Hash.new(0)
+        @vml_schema = VmlSchema.new(@result)
+        @erg_elements = Hash.new(0)
+        @erg_schema = ErgSchema.new(@result)
+        @vrl_elements = Hash.new(0)
+        @vrl_schema = VrlSchema.new(@result)
+      end
+
+      def process_line(line, line_number)
+        check_comment_balance(line, line_number)
+        trimmed = strip_inline_comment(line)
+        return if trimmed.empty?
+
+        @effective_index += 1
+        return handle_first_effective(trimmed, line_number) if @effective_index == 1
+        return @dateiende_index = line_number if trimmed == 'DATEIENDE'
+
+        handle_content_line(trimmed, line_number)
+      end
+
+      def finish
+        post_validate_positions
+        validate_wk_list_elements if @result.list_type == 'Wettkampfdefinitionsliste'
+        validate_vml_list_elements if @result.list_type == 'Vereinsmeldeliste'
+        validate_erg_list_elements if @result.list_type == 'Wettkampfergebnisliste'
+        validate_vrl_list_elements if @result.list_type == 'Vereinsergebnisliste'
+      end
+
+      private
+
+      def check_comment_balance(line, line_number)
+        return unless line.include?('(*') || line.include?('*)')
+
+        opens = line.scan('(*').size
+        closes = line.scan('*)').size
+        return unless opens != closes
+
+        @result.add_error("Unmatched comment delimiters (line #{line_number})")
+      end
+
+      def handle_first_effective(trimmed, line_number)
+        @format_line_index = line_number
+        check_format_line(trimmed, line_number)
+      end
+
+      def strip_inline_comment(line)
+        Dsv7::Stream.strip_inline_comment(line).strip
+      end
+
+      def check_format_line(trimmed, line_number)
+        m = Dsv7::Lex.parse_format(trimmed)
+        return format_error(line_number) unless m
+
+        list_type, ver = m
+        # Enforce numeric version token for exact syntax compatibility
+        return format_error(line_number) unless ver.match?(/^\d+$/)
+
+        @result.set_format(list_type, ver)
+        check_list_type(list_type, line_number)
+        check_format_version(ver, line_number)
+      end
+
+      def format_error(line_number)
+        @result.add_error(
+          "First non-empty line must be 'FORMAT:<Listentyp>;7;' " \
+          "(line #{line_number})"
+        )
+      end
+
+      def check_list_type(list_type, line_number)
+        return if Validator::ALLOWED_LIST_TYPES.include?(list_type)
+
+        @result.add_error("Unknown list type in FORMAT: '#{list_type}' (line #{line_number})")
+      end
+
+      def check_format_version(ver, line_number)
+        return if ver == '7'
+
+        @result.add_error("Unsupported format version '#{ver}', expected '7' (line #{line_number})")
+      end
+
+      def require_semicolon(trimmed, line_number)
+        return if trimmed.include?(';')
+
+        @result.add_error("Missing attribute delimiter ';' (line #{line_number})")
+      end
+
+      def post_validate_positions
+        @result.add_error('Missing FORMAT line at top of file') if @format_line_index.nil?
+        return @result.add_error("Missing 'DATEIENDE' terminator line") if @dateiende_index.nil?
+
+        return unless @after_dateiende_effective_line_number
+
+        n = @after_dateiende_effective_line_number
+        @result.add_error("Content found after 'DATEIENDE' (line #{n})")
+      end
+
+      def handle_content_line(trimmed, line_number)
+        @after_dateiende_effective_line_number ||= line_number if @dateiende_index
+        require_semicolon(trimmed, line_number)
+        track_wk_element(trimmed)
+        track_vml_element(trimmed)
+        track_erg_element(trimmed)
+        track_vrl_element(trimmed)
+        validate_wk_line(trimmed, line_number)
+        validate_vml_line(trimmed, line_number)
+        validate_erg_line(trimmed, line_number)
+        validate_vrl_line(trimmed, line_number)
+      end
+    end
+  end
+end

data/lib/dsv7/validator/line_analyzer_common.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative '../lex'
+require_relative 'cardinality'
+
+module Dsv7
+  class Validator
+    # Handles line-by-line structural checks for WKDL-specific logic
+    module LineAnalyzerWk
+      def track_wk_element(trimmed)
+        return unless @result.list_type == 'Wettkampfdefinitionsliste'
+
+        pair = Dsv7::Lex.element(trimmed)
+        return unless pair
+
+        name, = pair
+        return if name == 'FORMAT'
+        return if name == 'DATEIENDE'
+
+        @wk_elements[name] += 1
+      end
+
+      def validate_wk_list_elements
+        WkCardinality.new(@result, @wk_elements).validate!
+      end
+
+      def validate_wk_line(trimmed, line_number)
+        return unless @result.list_type == 'Wettkampfdefinitionsliste'
+
+        pair = Dsv7::Lex.element(trimmed)
+        return unless pair
+
+        name, attrs = pair
+        return if %w[FORMAT DATEIENDE].include?(name)
+
+        @wk_schema.validate_element(name, attrs, line_number)
+      end
+    end
+
+    # Handles line-by-line structural checks for VML-specific logic
+    module LineAnalyzerVml
+      def track_vml_element(trimmed)
+        return unless @result.list_type == 'Vereinsmeldeliste'
+
+        pair = Dsv7::Lex.element(trimmed)
+        return unless pair
+
+        name, = pair
+        return if name == 'FORMAT'
+        return if name == 'DATEIENDE'
+
+        @vml_elements[name] += 1
+      end
+
+      def validate_vml_list_elements
+        VmlCardinality.new(@result, @vml_elements).validate!
+      end
+
+      def validate_vml_line(trimmed, line_number)
+        return unless @result.list_type == 'Vereinsmeldeliste'
+
+        pair = Dsv7::Lex.element(trimmed)
+        return unless pair
+
+        name, attrs = pair
+        return if %w[FORMAT DATEIENDE].include?(name)
+
+        @vml_schema.validate_element(name, attrs, line_number)
+      end
+    end
+
+    # Handles line-by-line checks for Wettkampfergebnisliste
+    module LineAnalyzerErg
+      def track_erg_element(trimmed)
+        return unless @result.list_type == 'Wettkampfergebnisliste'
+
+        pair = Dsv7::Lex.element(trimmed)
+        return unless pair
+
+        name, = pair
+        return if name == 'FORMAT'
+        return if name == 'DATEIENDE'
+
+        @erg_elements[name] += 1
+      end
+
+      def validate_erg_list_elements
+        return if @erg_elements.empty?
+
+        ErgCardinality.new(@result, @erg_elements).validate!
+      end
+
+      def validate_erg_line(trimmed, line_number)
+        return unless @result.list_type == 'Wettkampfergebnisliste'
+
+        pair = Dsv7::Lex.element(trimmed)
+        return unless pair
+
+        name, attrs = pair
+        return if %w[FORMAT DATEIENDE].include?(name)
+
+        @erg_schema.validate_element(name, attrs, line_number)
+      end
+    end
+
+    # Handles line-by-line checks for Vereinsergebnisliste
+    module LineAnalyzerVrl
+      def track_vrl_element(trimmed)
+        return unless @result.list_type == 'Vereinsergebnisliste'
+
+        pair = Dsv7::Lex.element(trimmed)
+        return unless pair
+
+        name, = pair
+        return if name == 'FORMAT'
+        return if name == 'DATEIENDE'
+
+        @vrl_elements[name] += 1
+      end
+
+      def validate_vrl_list_elements
+        return if @vrl_elements.empty?
+
+        VrlCardinality.new(@result, @vrl_elements).validate!
+      end
+
+      def validate_vrl_line(trimmed, line_number)
+        return unless @result.list_type == 'Vereinsergebnisliste'
+
+        pair = Dsv7::Lex.element(trimmed)
+        return unless pair
+
+        name, attrs = pair
+        return if %w[FORMAT DATEIENDE].include?(name)
+
+        @vrl_schema.validate_element(name, attrs, line_number)
+      end
+    end
+  end
+end

data/lib/dsv7/validator/result.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Dsv7
+  class Validator
+    # Result container for validation
+    class Result
+      attr_reader :errors, :warnings, :list_type, :version
+
+      def initialize
+        @errors = []
+        @warnings = []
+        @list_type = nil
+        @version = nil
+      end
+
+      def add_error(message)
+        @errors << message
+      end
+
+      def add_warning(message)
+        @warnings << message
+      end
+
+      def set_format(list_type, version)
+        @list_type = list_type
+        @version = version
+      end
+
+      def valid?
+        @errors.empty?
+      end
+    end
+  end
+end