lenex-parser 3.0.0

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a HANDICAP element.
+      class Handicap
+        ATTRIBUTES = {
+          'breast' => { key: :breast, required: true, missing_behavior: :warn },
+          'breaststatus' => { key: :breast_status, required: false },
+          'exception' => { key: :exception, required: false },
+          'free' => { key: :free, required: false },
+          'freestatus' => { key: :free_status, required: false },
+          'medley' => { key: :medley, required: false },
+          'medleystatus' => { key: :medley_status, 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)
+          return unless element
+
+          attributes = extract_attributes(element)
+          ensure_required_attributes!(attributes)
+
+          new(**attributes)
+        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 && !value.strip.empty?
+          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?
+
+            attribute_name = ATTRIBUTE_NAME_FOR.fetch(key)
+            message = "HANDICAP #{attribute_name} attribute is required"
+            handle_missing_required_attribute(definition, message)
+          end
+        end
+        private_class_method :ensure_required_attributes!
+
+        def self.handle_missing_required_attribute(definition, message)
+          behavior = definition.fetch(:missing_behavior, :raise)
+          case behavior
+          when :warn
+            emit_warning(message)
+          else
+            raise ::Lenex::Parser::ParseError, message
+          end
+        end
+        private_class_method :handle_missing_required_attribute
+
+        def self.emit_warning(message)
+          warn(message)
+        end
+        private_class_method :emit_warning
+
+        ATTRIBUTE_NAME_FOR = ATTRIBUTES.each_with_object({}) do |(attribute_name, definition),
+                                                                     mapping|
+          mapping[definition[:key]] = attribute_name
+        end.freeze
+        private_constant :ATTRIBUTE_NAME_FOR
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a HEAT element.
+      class Heat
+        ATTRIBUTES = {
+          'agegroupid' => { key: :age_group_id, required: false },
+          'daytime' => { key: :daytime, required: false },
+          'final' => { key: :final, required: false },
+          'heatid' => { key: :heat_id, required: true },
+          'number' => { key: :number, required: true },
+          'order' => { key: :order, 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 }
+
+        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, 'HEAT 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 = "HEAT #{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/host_club.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing host club metadata on a MEET element.
+      class HostClub
+        attr_reader :name, :url
+
+        def initialize(name:, url: nil)
+          @name = name
+          @url = url
+        end
+
+        def self.from_xml(meet_element)
+          name = attribute_value(meet_element, 'hostclub')
+          url = attribute_value(meet_element, 'hostclub.url')
+
+          return unless name || url
+
+          new(name:, url:)
+        end
+
+        def self.attribute_value(element, attribute_name)
+          value = element.attribute(attribute_name)&.value
+          return if value.nil? || value.strip.empty?
+
+          value
+        end
+        private_class_method :attribute_value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a JUDGE element.
+      class Judge
+        ATTRIBUTES = {
+          'number' => { key: :number, required: false },
+          'officialid' => { key: :official_id, required: true },
+          'remarks' => { key: :remarks, required: false },
+          'role' => { key: :role, 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, 'JUDGE 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 = "JUDGE #{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/lenex.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing the LENEX root element.
+      class Lenex
+        attr_reader :version, :revision, :constructor, :meets, :record_lists, :time_standard_lists
+
+        def initialize(version:, revision:, constructor:, collections: {})
+          @version = version
+          @revision = revision
+          @constructor = constructor
+          @meets = Array(collections.fetch(:meets, []))
+          @record_lists = Array(collections.fetch(:record_lists, []))
+          @time_standard_lists = Array(collections.fetch(:time_standard_lists, []))
+        end
+
+        def self.from_xml(element)
+          version = version_from(element)
+          constructor = Constructor.from_xml(element.at_xpath('CONSTRUCTOR'))
+          revision = element.attribute('revision')&.value
+          collections = build_collections(element)
+
+          new(version:, revision:, constructor:, collections:)
+        end
+
+        def self.version_from(element)
+          version = element.attribute('version')&.value
+          return version if version && !version.strip.empty?
+
+          raise ::Lenex::Parser::ParseError, 'LENEX version attribute is required'
+        end
+        private_class_method :version_from
+
+        def self.build_collections(element)
+          {
+            meets: extract_meets(element.at_xpath('MEETS')),
+            record_lists: extract_record_lists(element.at_xpath('RECORDLISTS')),
+            time_standard_lists: extract_time_standard_lists(element.at_xpath('TIMESTANDARDLISTS'))
+          }
+        end
+        private_class_method :build_collections
+
+        def self.extract_meets(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('MEET').map { |meet_element| Meet.from_xml(meet_element) }
+        end
+        private_class_method :extract_meets
+
+        def self.extract_record_lists(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('RECORDLIST').map do |record_list_element|
+            RecordList.from_xml(record_list_element)
+          end
+        end
+        private_class_method :extract_record_lists
+
+        def self.extract_time_standard_lists(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('TIMESTANDARDLIST').map do |time_standard_list_element|
+            TimeStandardList.from_xml(time_standard_list_element)
+          end
+        end
+        private_class_method :extract_time_standard_lists
+      end
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Helper namespace that extracts MEET associations from XML nodes.
+      module MeetAssociations
+        module_function
+
+        def build(element)
+          metadata_from(element).merge(collections_from(element))
+        end
+
+        def metadata_from(element)
+          core_metadata(element).merge(optional_metadata(element))
+        end
+        private_class_method :metadata_from
+
+        def core_metadata(element)
+          {
+            contact: contact_from(element.at_xpath('CONTACT')),
+            age_date: association_from(element.at_xpath('AGEDATE'), AgeDate),
+            bank: association_from(element.at_xpath('BANK'), Bank),
+            facility: association_from(element.at_xpath('FACILITY'), Facility),
+            point_table: association_from(element.at_xpath('POINTTABLE'), PointTable),
+            qualify: association_from(element.at_xpath('QUALIFY'), Qualify),
+            pool: association_from(element.at_xpath('POOL'), Pool)
+          }
+        end
+        private_class_method :core_metadata
+
+        def optional_metadata(element)
+          {
+            fee_schedule: FeeSchedule.from_xml(element.at_xpath('FEES')),
+            host_club: HostClub.from_xml(element),
+            organizer: Organizer.from_xml(element),
+            entry_schedule: EntrySchedule.from_xml(element)
+          }
+        end
+        private_class_method :optional_metadata
+
+        def collections_from(element)
+          {
+            clubs: extract_clubs(element.at_xpath('CLUBS')),
+            sessions: extract_sessions(element.at_xpath('SESSIONS'))
+          }
+        end
+        private_class_method :collections_from
+
+        def association_from(element, klass)
+          return unless element
+
+          klass.from_xml(element)
+        end
+        private_class_method :association_from
+
+        def contact_from(element)
+          return unless element
+
+          Contact.from_xml(element)
+        end
+        private_class_method :contact_from
+
+        def extract_clubs(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('CLUB').map { |club_element| Club.from_xml(club_element) }
+        end
+        private_class_method :extract_clubs
+
+        def extract_sessions(collection_element)
+          unless collection_element
+            raise ::Lenex::Parser::ParseError, 'MEET SESSIONS element is required'
+          end
+
+          session_elements = collection_element.xpath('SESSION')
+          if session_elements.empty?
+            raise ::Lenex::Parser::ParseError, 'MEET SESSIONS element is required'
+          end
+
+          session_elements.map { |session_element| Session.from_xml(session_element) }
+        end
+        private_class_method :extract_sessions
+      end
+
+      # Value object representing a MEET element.
+      class Meet
+        ATTRIBUTES = {
+          'name' => { key: :name, required: true },
+          'name.en' => { key: :name_en, required: false },
+          'city' => { key: :city, required: true },
+          'city.en' => { key: :city_en, required: false },
+          'nation' => { key: :nation, required: true },
+          'course' => { key: :course, required: false },
+          'number' => { key: :number, required: false },
+          'reservecount' => { key: :reserve_count, required: false },
+          'startmethod' => { key: :start_method, required: false },
+          'timing' => { key: :timing, required: false },
+          'touchpadmode' => { key: :touchpad_mode, required: false },
+          'type' => { key: :type, required: false },
+          'entrytype' => { key: :entry_type, required: false },
+          'maxentriesathlete' => { key: :max_entries_athlete, required: false },
+          'maxentriesrelay' => { key: :max_entries_relay, required: false },
+          'altitude' => { key: :altitude, required: false },
+          'swrid' => { key: :swrid, required: false },
+          'result.url' => { key: :result_url, required: false }
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.map { |definition| definition[:key] }.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ASSOCIATION_DEFAULTS = {
+          contact: nil,
+          clubs: [],
+          sessions: [],
+          age_date: nil,
+          bank: nil,
+          facility: nil,
+          point_table: nil,
+          qualify: nil,
+          pool: nil,
+          fee_schedule: nil,
+          host_club: nil,
+          organizer: nil,
+          entry_schedule: nil
+        }.freeze
+
+        ASSOCIATION_KEYS = ASSOCIATION_DEFAULTS.keys.freeze
+        private_constant :ASSOCIATION_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+        ASSOCIATION_KEYS.each { |attribute| attr_reader attribute }
+
+        def initialize(**attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          ASSOCIATION_DEFAULTS.each do |key, default|
+            value = attributes.fetch(key, default)
+            value = Array(value) if %i[clubs sessions].include?(key)
+            instance_variable_set(:"@#{key}", value)
+          end
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'MEET element is required' unless element
+
+          attributes = extract_attributes(element)
+          associations = MeetAssociations.build(element)
+
+          new(**attributes, **associations)
+        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 = "MEET #{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/meet_info.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a MEETINFO element.
+      class MeetInfo
+        ATTRIBUTES = {
+          'approved' => :approved,
+          'city' => :city,
+          'course' => :course,
+          'date' => :date,
+          'daytime' => :daytime,
+          'name' => :name,
+          'nation' => :nation,
+          'qualificationtime' => :qualification_time,
+          'state' => :state,
+          'timing' => :timing
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+        attr_reader :pool
+
+        def initialize(pool: nil, **attributes)
+          ATTRIBUTES.each_value do |key|
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @pool = pool
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'MEETINFO element is required' unless element
+
+          attributes = extract_attributes(element)
+          pool = pool_from(element.at_xpath('POOL'))
+
+          new(**attributes, pool:)
+        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.pool_from(element)
+          return unless element
+
+          Pool.from_xml(element)
+        end
+        private_class_method :pool_from
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing an OFFICIAL element.
+      class Official
+        ATTRIBUTES = {
+          'firstname' => { key: :first_name, required: true },
+          'gender' => { key: :gender, required: false },
+          'grade' => { key: :grade, required: false },
+          'lastname' => { key: :last_name, required: true },
+          'license' => { key: :license, required: false },
+          'nameprefix' => { key: :name_prefix, required: false },
+          'nation' => { key: :nation, required: false },
+          'officialid' => { key: :official_id, required: true },
+          'passport' => { key: :passport, 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 :contact
+
+        def initialize(contact: nil, **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @contact = contact
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'OFFICIAL element is required' unless element
+
+          attributes = extract_attributes(element)
+          contact = contact_from(element.at_xpath('CONTACT'))
+
+          new(**attributes, contact:)
+        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 = "OFFICIAL #{attribute_name} attribute is required"
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_required_attribute!
+
+        def self.contact_from(element)
+          return unless element
+
+          Contact.from_xml(element)
+        end
+        private_class_method :contact_from
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing organizer metadata on a MEET element.
+      class Organizer
+        attr_reader :name, :url
+
+        def initialize(name:, url: nil)
+          @name = name
+          @url = url
+        end
+
+        def self.from_xml(meet_element)
+          name = attribute_value(meet_element, 'organizer')
+          url = attribute_value(meet_element, 'organizer.url')
+
+          return unless name || url
+
+          new(name:, url:)
+        end
+
+        def self.attribute_value(element, attribute_name)
+          value = element.attribute(attribute_name)&.value
+          return if value.nil? || value.strip.empty?
+
+          value
+        end
+        private_class_method :attribute_value
+      end
+    end
+  end
+end