lenex-parser 3.0.0

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a BANK element.
+      class Bank
+        ATTRIBUTES = {
+          'accountholder' => { key: :account_holder, required: false },
+          'bic' => { key: :bic, required: false },
+          'iban' => { key: :iban, required: true },
+          'name' => { key: :name, required: false },
+          'note' => { key: :note, 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, 'BANK 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 = "BANK #{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/club.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a CLUB element.
+      class Club
+        ATTRIBUTES = {
+          'name' => { key: :name, required: true },
+          'name.en' => { key: :name_en, required: false },
+          'shortname' => { key: :shortname, required: false },
+          'shortname.en' => { key: :shortname_en, required: false },
+          'code' => { key: :code, required: false },
+          'nation' => { key: :nation, required: false },
+          'number' => { key: :number, required: false },
+          'region' => { key: :region, required: false },
+          'swrid' => { key: :swrid, required: false },
+          'type' => { key: :type, 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, :athletes, :officials, :relays
+
+        def initialize(contact: nil, athletes: [], officials: [], relays: [], **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @contact = contact
+          @athletes = Array(athletes)
+          @officials = Array(officials)
+          @relays = Array(relays)
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'CLUB element is required' unless element
+
+          attributes = extract_attributes(element)
+          ensure_required_attributes!(attributes)
+
+          contact_element = element.at_xpath('CONTACT')
+          contact = contact_element ? Contact.from_xml(contact_element) : nil
+          athletes = extract_athletes(element.at_xpath('ATHLETES'))
+          officials = extract_officials(element.at_xpath('OFFICIALS'))
+          relays = extract_relays(element.at_xpath('RELAYS'))
+
+          new(**attributes, contact:, athletes:, officials:, relays:)
+        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)
+          name = attributes[:name]
+          type = attributes[:type]
+
+          return unless name.nil? || name.strip.empty?
+          return if type == 'UNATTACHED'
+
+          raise ::Lenex::Parser::ParseError, 'CLUB name attribute is required'
+        end
+        private_class_method :ensure_required_attributes!
+
+        def self.extract_athletes(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('ATHLETE').map do |athlete_element|
+            Athlete.from_xml(athlete_element)
+          end
+        end
+        private_class_method :extract_athletes
+
+        def self.extract_officials(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('OFFICIAL').map do |official_element|
+            Official.from_xml(official_element)
+          end
+        end
+        private_class_method :extract_officials
+
+        def self.extract_relays(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('RELAY').map do |relay_element|
+            Relay.from_xml(relay_element)
+          end
+        end
+        private_class_method :extract_relays
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a CONSTRUCTOR element.
+      class Constructor
+        ATTRIBUTES = {
+          'name' => :name,
+          'registration' => :registration,
+          'version' => :version
+        }.freeze
+
+        ATTRIBUTE_KEYS = ATTRIBUTES.values.freeze
+        private_constant :ATTRIBUTE_KEYS
+
+        ATTRIBUTE_KEYS.each { |attribute| attr_reader attribute }
+        attr_reader :contact
+
+        def initialize(name:, registration:, version:, contact:)
+          @name = name
+          @registration = registration
+          @version = version
+          @contact = contact
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'CONSTRUCTOR element is required' unless element
+
+          data = attributes_from(element)
+          contact = Contact.from_xml(element.at_xpath('CONTACT'), email_required: true)
+
+          new(**data, contact:)
+        end
+
+        def self.attributes_from(element)
+          ATTRIBUTES.each_with_object({}) do |(attribute_name, key), attributes|
+            value = element.attribute(attribute_name)&.value
+            if value.nil? || value.strip.empty?
+              message = "CONSTRUCTOR #{attribute_name} attribute is required"
+              raise ::Lenex::Parser::ParseError, message
+            end
+
+            attributes[key] = value
+          end
+        end
+        private_class_method :attributes_from
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a CONTACT element.
+      class Contact
+        ATTRIBUTES = {
+          'name' => :name,
+          'street' => :street,
+          'street2' => :street2,
+          'zip' => :zip,
+          'city' => :city,
+          'state' => :state,
+          'country' => :country,
+          'phone' => :phone,
+          'mobile' => :mobile,
+          'fax' => :fax,
+          'email' => :email,
+          'internet' => :internet
+        }.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, email_required: false)
+          raise ::Lenex::Parser::ParseError, 'CONTACT element is required' unless element
+
+          data = extract_attributes(element)
+          if email_required && (data[:email].nil? || data[:email].strip.empty?)
+            raise ::Lenex::Parser::ParseError, 'CONTACT email attribute is required'
+          end
+
+          new(**data)
+        end
+
+        def self.extract_attributes(element)
+          ATTRIBUTES.each_with_object({}) do |(attribute_name, key), attributes|
+            value = element.attribute(attribute_name)&.value
+            attributes[key] = value if value
+          end
+        end
+        private_class_method :extract_attributes
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing an ENTRY element.
+      class Entry
+        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
+
+        def initialize(meet_info: nil, **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @meet_info = meet_info
+        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'))
+
+          new(**attributes, 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 = "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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object capturing entry schedule metadata on a MEET element.
+      class EntrySchedule
+        attr_reader :entry_start_date, :withdraw_until, :deadline_date, :deadline_time
+
+        def initialize(entry_start_date:, withdraw_until:, deadline_date:, deadline_time:)
+          @entry_start_date = entry_start_date
+          @withdraw_until = withdraw_until
+          @deadline_date = deadline_date
+          @deadline_time = deadline_time
+        end
+
+        def self.from_xml(meet_element)
+          attributes = {
+            entry_start_date: attribute_value(meet_element, 'entrystartdate'),
+            withdraw_until: attribute_value(meet_element, 'withdrawuntil'),
+            deadline_date: attribute_value(meet_element, 'deadline'),
+            deadline_time: attribute_value(meet_element, 'deadlinetime')
+          }
+
+          return unless attributes.values.compact.any?
+
+          new(**attributes)
+        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/event.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing an EVENT element.
+      class Event
+        ATTRIBUTES = {
+          'daytime' => { key: :daytime, required: false },
+          'eventid' => { key: :event_id, required: true },
+          'gender' => { key: :gender, required: false },
+          'maxentries' => { key: :max_entries, required: false },
+          'number' => { key: :number, required: true },
+          'order' => { key: :order, required: false },
+          'preveventid' => { key: :previous_event_id, required: false },
+          'round' => { key: :round, required: false },
+          'run' => { key: :run, required: false },
+          'timing' => { key: :timing, required: false },
+          'type' => { key: :type, 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, :swim_style, :age_groups, :heats, :time_standard_refs
+
+        def initialize(swim_style:, fee: nil, collections: {}, **attributes)
+          ATTRIBUTES.each_value do |definition|
+            key = definition[:key]
+            instance_variable_set(:"@#{key}", attributes[key])
+          end
+          @fee = fee
+          @swim_style = swim_style
+          @age_groups = Array(collections.fetch(:age_groups, []))
+          @heats = Array(collections.fetch(:heats, []))
+          @time_standard_refs = Array(collections.fetch(:time_standard_refs, []))
+        end
+
+        def self.from_xml(element)
+          raise ::Lenex::Parser::ParseError, 'EVENT element is required' unless element
+
+          attributes = extract_attributes(element)
+          fee = fee_from(element.at_xpath('FEE'))
+          swim_style = SwimStyle.from_xml(element.at_xpath('SWIMSTYLE'))
+          collections = build_collections(element)
+
+          new(**attributes, fee:, swim_style:, collections:)
+        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 = "EVENT #{attribute_name} attribute is required"
+          raise ::Lenex::Parser::ParseError, message
+        end
+        private_class_method :ensure_required_attribute!
+
+        def self.fee_from(element)
+          return unless element
+
+          Fee.from_xml(element)
+        end
+        private_class_method :fee_from
+
+        def self.extract_age_groups(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('AGEGROUP').map do |age_group_element|
+            AgeGroup.from_xml(age_group_element)
+          end
+        end
+        private_class_method :extract_age_groups
+
+        def self.extract_heats(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('HEAT').map do |heat_element|
+            Heat.from_xml(heat_element)
+          end
+        end
+        private_class_method :extract_heats
+
+        def self.extract_time_standard_refs(collection_element)
+          return [] unless collection_element
+
+          collection_element.xpath('TIMESTANDARDREF').map do |time_standard_ref_element|
+            TimeStandardRef.from_xml(time_standard_ref_element)
+          end
+        end
+        private_class_method :extract_time_standard_refs
+
+        def self.build_collections(element)
+          {
+            age_groups: extract_age_groups(element.at_xpath('AGEGROUPS')),
+            heats: extract_heats(element.at_xpath('HEATS')),
+            time_standard_refs: extract_time_standard_refs(element.at_xpath('TIMESTANDARDREFS'))
+          }
+        end
+        private_class_method :build_collections
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a FACILITY element.
+      class Facility
+        ATTRIBUTES = {
+          'city' => { key: :city, required: true },
+          'nation' => { key: :nation, required: true },
+          'name' => { key: :name, required: false },
+          'state' => { key: :state, required: false },
+          'street' => { key: :street, required: false },
+          'street2' => { key: :street2, required: false },
+          'zip' => { key: :zip, 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, 'FACILITY 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 = "FACILITY #{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/fee.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a FEE element.
+      class Fee
+        ATTRIBUTES = {
+          'currency' => { key: :currency, required: false },
+          'type' => { key: :type, required: false },
+          'value' => { key: :value, 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, 'FEE 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 = "FEE #{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/fee_schedule.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Lenex
+  module Parser
+    module Objects
+      # Value object representing a FEES collection.
+      class FeeSchedule
+        attr_reader :fees
+
+        def initialize(fees: [])
+          @fees = Array(fees)
+        end
+
+        def self.from_xml(element)
+          return unless element
+
+          fees = element.xpath('FEE').map do |fee_element|
+            Fee.from_xml(fee_element)
+          end
+
+          new(fees:)
+        end
+      end
+    end
+  end
+end