lenex-parser 3.0.0

data/lib/lenex/parser/objects/point_table.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a POINTTABLE element.
+      class PointTable
+        ATTRIBUTES = {
+          'name' => { key: :name, required: true },
+          'pointtableid' => { key: :point_table_id, required: false },
+          'version' => { key: :version, required: true }
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.map { |definition| definition[:key] }.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+
+        def initialize(**attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'POINTTABLE element is required' unless element
+
+          attributes = extract_attributes(element)
+
+          new(**attributes)
+        end
+
+        def self.extract_attributes(element)
+          ATTRIBUTES.each_with_object({}) do |(attribute_name, definition), collected|
+            value = element.attribute(attribute_name)&.value
+            ensure_required_attribute!(attribute_name, definition, value)
+            collected[definition[:key]] = value if value
+          end
+        end
+        private_class_method :extract_attributes
+
+        def self.ensure_required_attribute!(attribute_name, definition, value)
+          return unless definition[:required]
+          return unless value.nil? || value.strip.empty?
+
+          message = "POINTTABLE #{attribute_name} attribute is required"
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_required_attribute!
+      end
+    end
+  end
+end

data/lib/lenex/parser/objects/pool.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a POOL element.
+      class Pool
+        ATTRIBUTES = {
+          'lanemax' => :lane_max,
+          'lanemin' => :lane_min,
+          'temperature' => :temperature,
+          'type' => :type
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+
+        def initialize(**attributes)
+          ATTRIBUTES.each_value do |key|
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'POOL element is required' unless element
+
+          attributes = extract_attributes(element)
+
+          new(**attributes)
+        end
+
+        def self.extract_attributes(element)
+          ATTRIBUTES.each_with_object({}) do |(attribute_name, key), collected|
+            value = element.attribute(attribute_name)&.value
+            collected[key] = value if value
+          end
+        end
+        private_class_method :extract_attributes
+      end
+    end
+  end
+end

data/lib/lenex/parser/objects/qualify.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a QUALIFY element.
+      class Qualify
+        ATTRIBUTES = {
+          'conversion' => { key: :conversion, required: false },
+          'from' => { key: :from, required: true },
+          'percent' => { key: :percent, required: false },
+          'until' => { key: :until, required: false }
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.map { |definition| definition[:key] }.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+
+        def initialize(**attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'QUALIFY element is required' unless element
+
+          attributes = extract_attributes(element)
+
+          new(**attributes)
+        end
+
+        def self.extract_attributes(element)
+          ATTRIBUTES.each_with_object({}) do |(attribute_name, definition), collected|
+            value = element.attribute(attribute_name)&.value
+            ensure_required_attribute!(attribute_name, definition, value)
+            collected[definition[:key]] = value if value
+          end
+        end
+        private_class_method :extract_attributes
+
+        def self.ensure_required_attribute!(attribute_name, definition, value)
+          return unless definition[:required]
+          return unless value.nil? || value.strip.empty?
+
+          message = "QUALIFY #{attribute_name} attribute is required"
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_required_attribute!
+      end
+    end
+  end
+end

data/lib/lenex/parser/objects/ranking.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a RANKING element.
+      class Ranking
+        ATTRIBUTES = {
+          'order' => { key: :order, required: false },
+          'place' => { key: :place, required: true },
+          'resultid' => { key: :result_id, required: true }
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.map { |definition| definition[:key] }.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+
+        def initialize(**attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'RANKING element is required' unless element
+
+          attributes = extract_attributes(element)
+
+          new(**attributes)
+        end
+
+        def self.extract_attributes(element)
+          ATTRIBUTES.each_with_object({}) do |(attribute_name, definition), collected|
+            value = element.attribute(attribute_name)&.value
+            ensure_required_attribute!(attribute_name, definition, value)
+            collected[definition[:key]] = value if value
+          end
+        end
+        private_class_method :extract_attributes
+
+        def self.ensure_required_attribute!(attribute_name, definition, value)
+          return unless definition[:required]
+          return unless value.nil? || value.strip.empty?
+
+          message = "RANKING #{attribute_name} attribute is required"
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_required_attribute!
+      end
+    end
+  end
+end

data/lib/lenex/parser/objects/record.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a RECORD element.
+      class Record
+        ATTRIBUTES = {
+          'swimtime' => { key: :swim_time, required: true },
+          'status' => { key: :status, required: false },
+          'comment' => { key: :comment, required: false }
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.map { |definition| definition[:key] }.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+        attr_reader :meet_info, :swim_style, :athlete, :relay, :splits
+
+        def initialize(associations: {}, **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @meet_info = associations[:meet_info]
+          @swim_style = associations[:swim_style]
+          @athlete = associations[:athlete]
+          @relay = associations[:relay]
+          @splits = Array(associations.fetch(:splits, []))
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'RECORD element is required' unless element
+
+          attributes = extract_attributes(element)
+          ensure_required_attributes!(attributes)
+
+          new(**attributes, associations: associations_from(element))
+        end
+
+        def self.extract_attributes(element)
+          ATTRIBUTES.each_with_object({}) do |(attribute_name, definition), collected|
+            value = element.attribute(attribute_name)&.value
+            collected[definition[:key]] = value if value
+          end
+        end
+        private_class_method :extract_attributes
+
+        def self.ensure_required_attributes!(attributes)
+          value = attributes[:swim_time]
+          return unless value.nil? || value.strip.empty?
+
+          raise ::Lenex::Parser::ParseError, 'RECORD swimtime attribute is required'
+        end
+        private_class_method :ensure_required_attributes!
+
+        def self.meet_info_from(element)
+          return unless element
+
+          MeetInfo.from_xml(element)
+        end
+        private_class_method :meet_info_from
+
+        def self.swim_style_from(element)
+          raise ::Lenex::Parser::ParseError, 'RECORD SWIMSTYLE element is required' unless element
+
+          SwimStyle.from_xml(element)
+        end
+        private_class_method :swim_style_from
+
+        def self.athlete_from(element)
+          return unless element
+
+          RecordAthlete.from_xml(element)
+        end
+        private_class_method :athlete_from
+
+        def self.relay_from(element)
+          return unless element
+
+          RecordRelay.from_xml(element)
+        end
+        private_class_method :relay_from
+
+        def self.extract_splits(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('SPLIT').map do |split_element|
+            Split.from_xml(split_element)
+          end
+        end
+        private_class_method :extract_splits
+
+        def self.associations_from(element)
+          {
+            meet_info: meet_info_from(element.at_xpath('MEETINFO')),
+            swim_style: swim_style_from(element.at_xpath('SWIMSTYLE')),
+            athlete: athlete_from(element.at_xpath('ATHLETE')),
+            relay: relay_from(element.at_xpath('RELAY')),
+            splits: extract_splits(element.at_xpath('SPLITS'))
+          }
+        end
+        private_class_method :associations_from
+      end
+    end
+  end
+end

data/lib/lenex/parser/objects/record_athlete.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing an ATHLETE element within a record.
+      class RecordAthlete
+        ATTRIBUTES = {
+          'athleteid' => { key: :athlete_id, required: false },
+          'birthdate' => { key: :birthdate, required: false },
+          'firstname' => { key: :first_name, required: false },
+          'firstname.en' => { key: :first_name_en, required: false },
+          'gender' => { key: :gender, required: true },
+          'lastname' => { key: :last_name, required: false },
+          'lastname.en' => { key: :last_name_en, required: false },
+          'level' => { key: :level, required: false },
+          'license' => { key: :license, required: false },
+          'license_dbs' => { key: :license_dbs, required: false },
+          'license_dsv' => { key: :license_dsv, required: false },
+          'license_ipc' => { key: :license_ipc, required: false },
+          'nameprefix' => { key: :name_prefix, required: false },
+          'nation' => { key: :nation, required: false },
+          'passport' => { key: :passport, required: false },
+          'status' => { key: :status, required: false },
+          'swrid' => { key: :swrid, required: false }
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.map { |definition| definition[:key] }.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+        attr_reader :club, :handicap
+
+        def initialize(club: nil, handicap: nil, **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @club = club
+          @handicap = handicap
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'ATHLETE element is required' unless element
+
+          attributes = extract_attributes(element)
+          ensure_required_attributes!(attributes)
+
+          club = club_from(element.at_xpath('CLUB'))
+          handicap = Handicap.from_xml(element.at_xpath('HANDICAP'))
+
+          new(**attributes, club:, handicap:)
+        end
+
+        def self.extract_attributes(element)
+          ATTRIBUTES.each_with_object({}) do |(attribute_name, definition), collected|
+            value = element.attribute(attribute_name)&.value
+            collected[definition[:key]] = value if value
+          end
+        end
+        private_class_method :extract_attributes
+
+        def self.ensure_required_attributes!(attributes)
+          ATTRIBUTES.each_value do |definition|
+            next unless definition[:required]
+
+            key = definition[:key]
+            value = attributes[key]
+            next unless value.nil? || value.strip.empty?
+
+            message = "ATHLETE #{ATTRIBUTE_NAME_FOR[key]} attribute is required"
+            raise ::Lenex::Parser::ParseError, message
+          end
+        end
+        private_class_method :ensure_required_attributes!
+
+        ATTRIBUTE_NAME_FOR = ATTRIBUTES.each_with_object({}) do |(attribute_name, definition),
+                                                                  mapping|
+          mapping[definition[:key]] = attribute_name
+        end.freeze
+        private_constant :ATTRIBUTE_NAME_FOR
+
+        def self.club_from(element)
+          return unless element
+
+          Club.from_xml(element)
+        end
+        private_class_method :club_from
+      end
+    end
+  end
+end

data/lib/lenex/parser/objects/record_list.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a RECORDLIST element.
+      class RecordList
+        ATTRIBUTES = {
+          'course' => { key: :course, required: true },
+          'gender' => { key: :gender, required: true },
+          'handicap' => { key: :handicap, required: false },
+          'name' => { key: :name, required: true },
+          'nation' => { key: :nation, required: false },
+          'order' => { key: :order, required: false },
+          'region' => { key: :region, required: false },
+          'type' => { key: :type, required: false },
+          'updated' => { key: :updated, required: false }
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.map { |definition| definition[:key] }.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+        attr_reader :age_group, :records
+
+        def initialize(age_group: nil, records: [], **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @age_group = age_group
+          @records = Array(records)
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'RECORDLIST element is required' unless element
+
+          attributes = extract_attributes(element)
+          ensure_required_attributes!(attributes)
+
+          age_group = age_group_from(element.at_xpath('AGEGROUP'))
+          records = extract_records(element.at_xpath('RECORDS'))
+
+          new(**attributes, age_group:, records:)
+        end
+
+        def self.extract_attributes(element)
+          ATTRIBUTES.each_with_object({}) do |(attribute_name, definition), collected|
+            value = element.attribute(attribute_name)&.value
+            collected[definition[:key]] = value if value
+          end
+        end
+        private_class_method :extract_attributes
+
+        def self.ensure_required_attributes!(attributes)
+          %i[course gender name].each do |key|
+            value = attributes[key]
+            next unless value.nil? || value.strip.empty?
+
+            message = "RECORDLIST #{ATTRIBUTE_NAME_FOR[key]} attribute is required"
+            raise ::Lenex::Parser::ParseError, message
+          end
+
+          ensure_region_requires_nation!(attributes)
+        end
+        private_class_method :ensure_required_attributes!
+
+        def self.ensure_region_requires_nation!(attributes)
+          region = attributes[:region]
+          return unless region
+
+          nation = attributes[:nation]
+          return if nation && !nation.strip.empty?
+
+          message = 'RECORDLIST nation attribute is required when region attribute is present'
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_region_requires_nation!
+
+        ATTRIBUTE_NAME_FOR = ATTRIBUTES.each_with_object({}) do |(attribute_name, definition),
+                                                                  mapping|
+          mapping[definition[:key]] = attribute_name
+        end.freeze
+        private_constant :ATTRIBUTE_NAME_FOR
+
+        def self.age_group_from(element)
+          return unless element
+
+          AgeGroup.from_xml(element)
+        end
+        private_class_method :age_group_from
+
+        def self.extract_records(collection_element)
+          unless collection_element
+            raise ::Lenex::Parser::ParseError, 'RECORDLIST RECORDS element is required'
+          end
+
+          collection_element.xpath('RECORD').map do |record_element|
+            Record.from_xml(record_element)
+          end
+        end
+        private_class_method :extract_records
+      end
+    end
+  end
+end

data/lib/lenex/parser/objects/record_relay.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a RELAY element within a record.
+      class RecordRelay
+        ATTRIBUTES = {
+          'name' => :name
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+        attr_reader :club, :relay_positions
+
+        def initialize(club: nil, relay_positions: [], **attributes)
+          ATTRIBUTES.each_value do |key|
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @club = club
+          @relay_positions = Array(relay_positions)
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'RELAY element is required' unless element
+
+          attributes = extract_attributes(element)
+          club = club_from(element.at_xpath('CLUB'))
+          relay_positions = extract_relay_positions(element.at_xpath('RELAYPOSITIONS'))
+
+          new(**attributes, club:, relay_positions:)
+        end
+
+        def self.extract_attributes(element)
+          ATTRIBUTES.each_with_object({}) do |(attribute_name, key), collected|
+            value = element.attribute(attribute_name)&.value
+            collected[key] = value if value
+          end
+        end
+        private_class_method :extract_attributes
+
+        def self.club_from(element)
+          return unless element
+
+          Club.from_xml(element)
+        end
+        private_class_method :club_from
+
+        def self.extract_relay_positions(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('RELAYPOSITION').map do |position_element|
+            RecordRelayPosition.from_xml(position_element)
+          end
+        end
+        private_class_method :extract_relay_positions
+      end
+    end
+  end
+end

data/lib/lenex/parser/objects/record_relay_position.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a RELAYPOSITION element within a record.
+      class RecordRelayPosition
+        ATTRIBUTES = {
+          'number' => { key: :number, required: true },
+          'reactiontime' => { key: :reaction_time, required: false },
+          'status' => { key: :status, required: false }
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.map { |definition| definition[:key] }.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+        attr_reader :athlete
+
+        def initialize(athlete:, **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @athlete = athlete
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'RELAYPOSITION element is required' unless element
+
+          attributes = extract_attributes(element)
+          ensure_required_attributes!(attributes)
+
+          athlete_element = element.at_xpath('ATHLETE')
+          if athlete_element.nil?
+            raise ::Lenex::Parser::ParseError, 'RELAYPOSITION ATHLETE element is required'
+          end
+
+          athlete = RecordAthlete.from_xml(athlete_element)
+
+          new(**attributes, athlete:)
+        end
+
+        def self.extract_attributes(element)
+          ATTRIBUTES.each_with_object({}) do |(attribute_name, definition), collected|
+            value = element.attribute(attribute_name)&.value
+            collected[definition[:key]] = value if value
+          end
+        end
+        private_class_method :extract_attributes
+
+        def self.ensure_required_attributes!(attributes)
+          value = attributes[:number]
+          return unless value.nil? || value.strip.empty?
+
+          raise ::Lenex::Parser::ParseError, 'RELAYPOSITION number attribute is required'
+        end
+        private_class_method :ensure_required_attributes!
+      end
+    end
+  end
+end