lenex-parser 3.0.0

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a RELAY element.
+      class Relay
+        ATTRIBUTES = {
+          'agemax' => { key: :age_max, required: true },
+          'agemin' => { key: :age_min, required: true },
+          'agetotalmax' => { key: :age_total_max, required: true },
+          'agetotalmin' => { key: :age_total_min, required: true },
+          'gender' => { key: :gender, required: true },
+          'handicap' => { key: :handicap, required: false },
+          'name' => { key: :name, required: false },
+          'number' => { key: :number, 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 :relay_positions, :entries, :results
+
+        def initialize(relay_positions: [], entries: [], results: [], **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @relay_positions = Array(relay_positions)
+          @entries = Array(entries)
+          @results = Array(results)
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'RELAY element is required' unless element
+
+          attributes = extract_attributes(element)
+          relay_positions = extract_relay_positions(element.at_xpath('RELAYPOSITIONS'))
+          entries = extract_entries(element.at_xpath('ENTRIES'))
+          results = extract_results(element.at_xpath('RESULTS'))
+
+          new(**attributes, relay_positions:, entries:, results:)
+        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 = "RELAY #{attribute_name} attribute is required"
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_required_attribute!
+
+        def self.extract_relay_positions(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('RELAYPOSITION').map do |position_element|
+            RelayPosition.from_xml(position_element)
+          end
+        end
+        private_class_method :extract_relay_positions
+
+        def self.extract_entries(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('ENTRY').map do |entry_element|
+            RelayEntry.from_xml(entry_element)
+          end
+        end
+        private_class_method :extract_entries
+
+        def self.extract_results(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('RESULT').map do |result_element|
+            RelayResult.from_xml(result_element)
+          end
+        end
+        private_class_method :extract_results
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a relay ENTRY element.
+      class RelayEntry
+        ATTRIBUTES = {
+          'agegroupid' => { key: :age_group_id, required: false },
+          'entrycourse' => { key: :entry_course, required: false },
+          'entrydistance' => { key: :entry_distance, required: false },
+          'entrytime' => { key: :entry_time, required: false },
+          'eventid' => { key: :event_id, required: true },
+          'handicap' => { key: :handicap, required: false },
+          'heatid' => { key: :heat_id, required: false },
+          'lane' => { key: :lane, 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 :meet_info, :relay_positions
+
+        def initialize(meet_info: nil, relay_positions: [], **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @meet_info = meet_info
+          @relay_positions = Array(relay_positions)
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'ENTRY element is required' unless element
+
+          attributes = extract_attributes(element)
+          meet_info = meet_info_from(element.at_xpath('MEETINFO'))
+          relay_positions = extract_relay_positions(element.at_xpath('RELAYPOSITIONS'))
+
+          new(**attributes, meet_info:, relay_positions:)
+        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 = "ENTRY #{attribute_name} attribute is required"
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_required_attribute!
+
+        def self.meet_info_from(element)
+          return unless element
+
+          MeetInfo.from_xml(element)
+        end
+        private_class_method :meet_info_from
+
+        def self.extract_relay_positions(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('RELAYPOSITION').map do |position_element|
+            RelayPosition.from_xml(position_element)
+          end
+        end
+        private_class_method :extract_relay_positions
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a RELAYPOSITION element.
+      class RelayPosition
+        ATTRIBUTES = {
+          'athleteid' => { key: :athlete_id, required: false },
+          '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, :meet_info
+
+        def initialize(athlete: nil, meet_info: nil, **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @athlete = athlete
+          @meet_info = meet_info
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'RELAYPOSITION element is required' unless element
+
+          attributes = extract_attributes(element)
+          athlete = athlete_from(element.at_xpath('ATHLETE'))
+          meet_info = meet_info_from(element.at_xpath('MEETINFO'))
+
+          new(**attributes, athlete:, meet_info:)
+        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 = "RELAYPOSITION #{attribute_name} attribute is required"
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_required_attribute!
+
+        def self.athlete_from(element)
+          return unless element
+
+          Athlete.from_xml(element)
+        end
+        private_class_method :athlete_from
+
+        def self.meet_info_from(element)
+          return unless element
+
+          MeetInfo.from_xml(element)
+        end
+        private_class_method :meet_info_from
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a relay RESULT element.
+      class RelayResult
+        ATTRIBUTES = {
+          'comment' => { key: :comment, required: false },
+          'eventid' => { key: :event_id, required: false },
+          'handicap' => { key: :handicap, required: false },
+          'heatid' => { key: :heat_id, required: false },
+          'lane' => { key: :lane, required: false },
+          'points' => { key: :points, required: false },
+          'reactiontime' => { key: :reaction_time, required: false },
+          'resultid' => { key: :result_id, required: true },
+          'status' => { key: :status, required: false },
+          'swimdistance' => { key: :swim_distance, required: false },
+          'swimtime' => { key: :swim_time, required: true }
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.map { |definition| definition[:key] }.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+        attr_reader :relay_positions, :splits
+
+        def initialize(relay_positions: [], splits: [], **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @relay_positions = Array(relay_positions)
+          @splits = Array(splits)
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'RESULT element is required' unless element
+
+          attributes = extract_attributes(element)
+          relay_positions = extract_relay_positions(element.at_xpath('RELAYPOSITIONS'))
+          splits = extract_splits(element.at_xpath('SPLITS'))
+
+          new(**attributes, relay_positions:, splits:)
+        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 = "RESULT #{attribute_name} attribute is required"
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_required_attribute!
+
+        def self.extract_relay_positions(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('RELAYPOSITION').map do |position_element|
+            RelayPosition.from_xml(position_element)
+          end
+        end
+        private_class_method :extract_relay_positions
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a RESULT element.
+      class Result
+        ATTRIBUTES = {
+          'comment' => { key: :comment, required: false },
+          'entrycourse' => { key: :entry_course, required: false },
+          'entrytime' => { key: :entry_time, required: false },
+          'eventid' => { key: :event_id, required: false },
+          'handicap' => { key: :handicap, required: false },
+          'heatid' => { key: :heat_id, required: false },
+          'lane' => { key: :lane, required: false },
+          'points' => { key: :points, required: false },
+          'reactiontime' => { key: :reaction_time, required: false },
+          'resultid' => { key: :result_id, required: true },
+          'status' => { key: :status, required: false },
+          'swimdistance' => { key: :swim_distance, required: false },
+          'swimtime' => { key: :swim_time, required: true }
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.map { |definition| definition[:key] }.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+        attr_reader :splits
+
+        def initialize(splits: [], **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @splits = Array(splits)
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'RESULT element is required' unless element
+
+          attributes = extract_attributes(element)
+          splits = extract_splits(element.at_xpath('SPLITS'))
+
+          new(**attributes, splits:)
+        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 = "RESULT #{attribute_name} attribute is required"
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_required_attribute!
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a SESSION element.
+      class Session
+        ATTRIBUTES = {
+          'course' => { key: :course, required: false },
+          'date' => { key: :date, required: true },
+          'daytime' => { key: :daytime, required: false },
+          'endtime' => { key: :endtime, required: false },
+          'maxentriesathlete' => { key: :max_entries_athlete, required: false },
+          'maxentriesrelay' => { key: :max_entries_relay, required: false },
+          'name' => { key: :name, required: false },
+          'number' => { key: :number, required: true },
+          'officialmeeting' => { key: :official_meeting, required: false },
+          'remarksjudge' => { key: :remarks_judge, required: false },
+          'teamleadermeeting' => { key: :team_leader_meeting, required: false },
+          'timing' => { key: :timing, required: false },
+          'touchpadmode' => { key: :touchpad_mode, required: false },
+          'warmupfrom' => { key: :warmup_from, required: false },
+          'warmupuntil' => { key: :warmup_until, 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 :fee_schedule, :pool, :judges, :events
+
+        def initialize(fee_schedule: nil, pool: nil, judges: [], events: [], **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @fee_schedule = fee_schedule
+          @pool = pool
+          @judges = Array(judges)
+          @events = Array(events)
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'SESSION element is required' unless element
+
+          attributes = extract_attributes(element)
+
+          fee_schedule = FeeSchedule.from_xml(element.at_xpath('FEES'))
+          pool = pool_from(element.at_xpath('POOL'))
+          judges = extract_judges(element.at_xpath('JUDGES'))
+          events = extract_events(element.at_xpath('EVENTS'))
+
+          new(**attributes, fee_schedule:, pool:, judges:, events:)
+        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 = "SESSION #{attribute_name} attribute is required"
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_required_attribute!
+
+        def self.pool_from(element)
+          return unless element
+
+          Pool.from_xml(element)
+        end
+        private_class_method :pool_from
+
+        def self.extract_judges(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('JUDGE').map do |judge_element|
+            Judge.from_xml(judge_element)
+          end
+        end
+        private_class_method :extract_judges
+
+        def self.extract_events(collection_element)
+          unless collection_element
+            raise ::Lenex::Parser::ParseError, 'SESSION EVENTS element is required'
+          end
+
+          events = collection_element.xpath('EVENT').map do |event_element|
+            Event.from_xml(event_element)
+          end
+
+          return events unless events.empty?
+
+          raise ::Lenex::Parser::ParseError, 'SESSION must include at least one EVENT element'
+        end
+        private_class_method :extract_events
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a SPLIT element.
+      class Split
+        ATTRIBUTES = {
+          'distance' => { key: :distance, required: true },
+          'swimtime' => { key: :swim_time, 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, 'SPLIT 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 = "SPLIT #{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/swim_style.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a SWIMSTYLE element.
+      class SwimStyle
+        ATTRIBUTES = {
+          'code' => { key: :code, required: false },
+          'distance' => { key: :distance, required: true },
+          'name' => { key: :name, required: false },
+          'relaycount' => { key: :relay_count, required: true },
+          'stroke' => { key: :stroke, required: true },
+          'swimstyleid' => { key: :swim_style_id, required: false },
+          'technique' => { key: :technique, 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, 'SWIMSTYLE 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 = "SWIMSTYLE #{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/time_standard.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a TIMESTANDARD element.
+      class TimeStandard
+        ATTRIBUTES = {
+          'swimtime' => { key: :swim_time, required: true }
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.map { |definition| definition[:key] }.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+        attr_reader :swim_style
+
+        def initialize(swim_style:, **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @swim_style = swim_style
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'TIMESTANDARD element is required' unless element
+
+          attributes = extract_attributes(element)
+          swim_style = SwimStyle.from_xml(element.at_xpath('SWIMSTYLE'))
+
+          new(**attributes, swim_style:)
+        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 = "TIMESTANDARD #{attribute_name} attribute is required"
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_required_attribute!
+      end
+    end
+  end
+end