edoxen 0.7.2 → 2.1.1

data/lib/edoxen/venue.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # Venue — polymorphic by discriminator, flat on the wire.
+  #
+  # The `kind` field discriminates between physical and virtual venues.
+  # All possible fields (physical-specific and virtual-specific) live on
+  # this one class as optional attributes — only the ones matching the
+  # `kind` are populated. This avoids lutaml-model's polymorphic
+  # recursion pitfalls while keeping the wire format readable.
+  #
+  # The PhysicalVenue and VirtualVenue subclasses exist for type-checking
+  # and for carrying type-specific helpers (e.g. `#unlocode_entry`).
+  # Construct them programmatically; the YAML wire format always uses
+  # the flat shape via Venue.
+  #
+  # Replaces v0.x `Location` (physical-only) and `Meeting.virtual: Boolean`
+  # (insufficient — Zoom needs URL+passcode+dial-in).
+  class Venue < Lutaml::Model::Serializable
+    attribute :kind, :string, values: Enums::VENUE_KIND
+    attribute :name, :string
+    attribute :label, :string
+    attribute :description, :string
+    attribute :capacity, :integer
+    attribute :url, :string
+    attribute :contact_methods, ContactMethod, collection: true
+
+    # Physical-venue fields (populated when kind == "physical").
+    attribute :unlocode, :string
+    attribute :iata_code, :string
+    attribute :address, :string
+    attribute :city, :string
+    attribute :country_code, :string
+    attribute :lat, :float
+    attribute :lon, :float
+    attribute :building, :string
+    attribute :floor, :string
+    attribute :room, :string
+    attribute :access_notes, :string
+
+    # Virtual-venue fields (populated when kind == "virtual").
+    attribute :uri, :string
+    attribute :features, :string, collection: true, values: Enums::VIRTUAL_FEATURE
+    attribute :passcode, :string
+    attribute :meeting_id, :string
+    attribute :dial_in_numbers, :string, collection: true
+    attribute :waiting_room, :boolean
+    attribute :registration_required, :boolean
+
+    attribute :extensions, MeetingExtension, collection: true
+
+    def physical?
+      kind == "physical"
+    end
+
+    def virtual?
+      kind == "virtual"
+    end
+
+    # Resolve the UN/LOCODE entry via the canonical `unlocodes` gem.
+    # Returns an Unlocodes::Entry or nil when the code is empty / unknown.
+    def unlocode_entry
+      return nil if unlocode.nil? || unlocode.to_s.empty?
+
+      Edoxen::ReferenceData.find_unlocode(unlocode)
+    end
+
+    def iata_entry
+      return nil if iata_code.nil? || iata_code.to_s.empty?
+
+      Edoxen::ReferenceData.find_iata(iata_code)
+    end
+
+    def features_list
+      return "" if features.nil? || features.empty?
+
+      features.join(", ")
+    end
+  end
+end

data/lib/edoxen/venue_validator.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # VenueValidator — validates Venue instances using the `unlocodes`
+  # and `iata` gems. Returns a list of errors; empty list means valid.
+  #
+  # For PhysicalVenue with a `unlocode` or `iata_code` field, validates
+  # that the code exists in the canonical registries. Optionally
+  # auto-populates city/country_code/coordinates from the registry.
+  class VenueValidator
+    attr_reader :venue, :errors
+
+    def initialize(venue)
+      @venue = venue
+      @errors = []
+    end
+
+    def validate(auto_populate: false)
+      validate_physical(auto_populate: auto_populate) if venue.physical?
+
+      errors
+    end
+
+    def valid?
+      validate
+      errors.empty?
+    end
+
+    private
+
+    def validate_physical(auto_populate:)
+      validate_unlocode(auto_populate: auto_populate) if venue.unlocode && !venue.unlocode.to_s.empty?
+      validate_iata_code if venue.iata_code && !venue.iata_code.to_s.empty?
+    end
+
+    def validate_unlocode(auto_populate:)
+      entry = Edoxen::ReferenceData.find_unlocode(venue.unlocode)
+      if entry.nil?
+        errors << "Unknown UN/LOCODE: #{venue.unlocode}"
+        return
+      end
+
+      return unless auto_populate
+
+      venue.city ||= entry.name
+      venue.country_code ||= entry.country
+    end
+
+    def validate_iata_code
+      entry = Edoxen::ReferenceData.find_iata(venue.iata_code)
+      return if entry
+
+      errors << "Unknown IATA code: #{venue.iata_code}"
+    end
+  end
+end

data/lib/edoxen/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Edoxen
-  VERSION = "0.7.2"
+  VERSION = "2.1.1"
 end

data/lib/edoxen/virtual_venue.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # VirtualVenue — type marker for a Venue with kind == "virtual".
+  #
+  # The wire format is flat on Venue (all fields live there). This
+  # subclass exists for type-checking and to host virtual-only helpers
+  # so callers can ask `venue.is_a?(VirtualVenue)` and validators
+  # can dispatch by type.
+  class VirtualVenue < Venue
+    def initialize(attributes = {})
+      super(attributes.merge(kind: "virtual"))
+    end
+  end
+end

data/lib/edoxen/vote_record.rb

@@ -1,25 +1,29 @@
 # frozen_string_literal: true
 
 module Edoxen
-  # A single vote on a Resolution, recorded against the meeting at
-  # which the vote was taken. Mirrors
-  # edoxen-model/models/vote_record.lutaml. Each record carries the
-  # person, their affiliation (national body / liaison / committee),
-  # and the outcome (affirmative / negative / abstain / absent /
-  # not_applicable).
+  # A single vote on a Decision, recorded against the Voting instance
+  # that captured it. `voting_ref` links to the Voting URN; `decision_ref`
+  # links to the Decision URN (often derivable from the Voting's motion,
+  # but explicit for clarity).
+  #
+  # `role` is open for adopter-defined values: teller (parliamentary
+  # division counter), proxy_holder, observer, etc.
   class VoteRecord < Lutaml::Model::Serializable
-    attribute :resolution_ref, :string
+    attribute :decision_ref, :string
+    attribute :voting_ref, :string
     attribute :person, Person
     attribute :affiliation, :string
     attribute :vote, :string, values: Enums::VOTE_TYPE
+    attribute :role, :string
     attribute :notes, :string
+    attribute :extensions, MeetingExtension, collection: true
 
-    key_value do
-      map "resolution_ref", to: :resolution_ref
-      map "person", to: :person
-      map "affiliation", to: :affiliation
-      map "vote", to: :vote
-      map "notes", to: :notes
+    def affirmative?
+      vote == "affirmative"
+    end
+
+    def teller?
+      role == "teller"
     end
   end
 end

data/lib/edoxen/voting.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # Voting — state machine for a single vote on a Motion.
+  # Multiple votings can occur on the same Motion (e.g., unclear voice
+  # vote → chair calls a formal division → second Voting instance).
+  #
+  # State machine (VotingStatus):
+  #   called → in_progress → decided | withdrawn | deferred
+  class Voting < Lutaml::Model::Serializable
+    attribute :identifier, :string
+    attribute :urn, :string
+    attribute :on_motion, :string
+    attribute :status, :string, values: Enums::VOTING_STATUS
+    attribute :voting_method, :string, values: Enums::VOTING_METHOD
+    attribute :called_by, Person
+    attribute :called_at, :date_time
+    attribute :result_declared_at, :date_time
+    attribute :result, :string, values: Enums::VOTING_OUTCOME
+    attribute :counts, VotingCounts
+    attribute :casting_vote, VoteRecord
+    attribute :vote_records, VoteRecord, collection: true
+    attribute :extensions, MeetingExtension, collection: true
+
+    def decided?
+      status == "decided"
+    end
+
+    def in_progress?
+      status == "in_progress"
+    end
+
+    def passed?
+      decided? && result == "passed"
+    end
+
+    def negatived?
+      decided? && result == "negatived"
+    end
+
+    def tied?
+      decided? && result == "tied"
+    end
+  end
+end

data/lib/edoxen/voting_counts.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # VotingCounts — tally for a Voting instance.
+  class VotingCounts < Lutaml::Model::Serializable
+    attribute :ayes, :integer
+    attribute :noes, :integer
+    attribute :abstentions, :integer
+    attribute :absent, :integer
+
+    def total
+      (ayes || 0) + (noes || 0) + (abstentions || 0) + (absent || 0)
+    end
+
+    def margin
+      (ayes || 0) - (noes || 0)
+    end
+
+    def tied?
+      ayes == noes
+    end
+  end
+end

data/lib/edoxen.rb

@@ -18,36 +18,41 @@ module Edoxen
   # There are intentionally NO `require_relative` calls in this gem —
   # autoload keeps load-order semantics clean and lets us tolerate the
   # extensive cross-references between model classes
-  # (Resolution <-> Localization, ResolutionMetadata <-> Localization, etc.).
+  # (Decision <-> Localization, DecisionMetadata <-> Localization, etc.).
   autoload :VERSION, "edoxen/version"
   autoload :Error, "edoxen/error"
   autoload :ValidationError, "edoxen/error"
   autoload :Enums, "edoxen/enums"
   autoload :ReferenceData, "edoxen/reference_data"
 
-  # Information-model classes (one per file, one concept per class).
-  # Names mirror ../edoxen-model/models/*.lutaml.
+  # --- Shared behaviours (mixed into entity + metadata classes) --------
+  autoload :BodyVocabularyHost, "edoxen/body_vocabulary_host"
+  autoload :LocalizationHost, "edoxen/localization_host"
+  autoload :OfficersHost, "edoxen/officers_host"
+
+  # --- Decision side ----------------------------------------------------
   autoload :StructuredIdentifier, "edoxen/structured_identifier"
   autoload :MeetingIdentifier, "edoxen/meeting_identifier"
-  autoload :ResolutionDate, "edoxen/resolution_date"
+  autoload :DecisionDate, "edoxen/decision_date"
   autoload :Action, "edoxen/action"
   autoload :Approval, "edoxen/approval"
   autoload :Consideration, "edoxen/consideration"
   autoload :SourceUrl, "edoxen/source_url"
   autoload :Localization, "edoxen/localization"
   autoload :Url, "edoxen/url"
-  autoload :ResolutionRelation, "edoxen/resolution_relation"
-  autoload :Resolution, "edoxen/resolution"
-  autoload :ResolutionMetadata, "edoxen/resolution_metadata"
-  autoload :ResolutionCollection, "edoxen/resolution_collection"
+  autoload :DecisionRelation, "edoxen/decision_relation"
+  autoload :Decision, "edoxen/decision"
+  autoload :DecisionMetadata, "edoxen/decision_metadata"
+  autoload :DecisionCollection, "edoxen/decision_collection"
 
-  # Meeting / Agenda side. Mirrors edoxen-model/models/meeting*.lutaml.
+  # --- Meeting/Agenda side ----------------------------------------------
   autoload :DateRange, "edoxen/date_range"
-  autoload :Location, "edoxen/location"
+  autoload :ContactMethod, "edoxen/contact_method"
+  autoload :ContactIdentifier, "edoxen/contact_identifier"
+  autoload :Name, "edoxen/name"
+  autoload :Contact, "edoxen/contact"
   autoload :Person, "edoxen/person"
   autoload :HostRef, "edoxen/host_ref"
-  autoload :ScheduleItemLocalization, "edoxen/schedule_item_localization"
-  autoload :ScheduleItem, "edoxen/schedule_item"
   autoload :Deadline, "edoxen/deadline"
   autoload :Reference, "edoxen/reference"
   autoload :AgendaItem, "edoxen/agenda_item"
@@ -62,7 +67,29 @@ module Edoxen
   autoload :MeetingCollectionMetadata, "edoxen/meeting_collection_metadata"
   autoload :MeetingCollection, "edoxen/meeting_collection"
 
-  # Services.
+  # --- v2 broadened-scope entities --------------------------------------
+  autoload :ExtensionAttribute, "edoxen/extension_attribute"
+  autoload :MeetingExtension, "edoxen/meeting_extension"
+  autoload :EntityRef, "edoxen/entity_ref"
+  autoload :BodyVocabularyEntry, "edoxen/body_vocabulary_entry"
+  autoload :Venue, "edoxen/venue"
+  autoload :PhysicalVenue, "edoxen/physical_venue"
+  autoload :VirtualVenue, "edoxen/virtual_venue"
+  autoload :Motion, "edoxen/motion"
+  autoload :VotingCounts, "edoxen/voting_counts"
+  autoload :Voting, "edoxen/voting"
+  autoload :TopicDocument, "edoxen/topic_document"
+  autoload :TopicAsset, "edoxen/topic_asset"
+  autoload :Topic, "edoxen/topic"
+  autoload :RecurrenceByDay, "edoxen/recurrence_by_day"
+  autoload :Recurrence, "edoxen/recurrence"
+  autoload :MeetingSeries, "edoxen/meeting_series"
+  autoload :ComponentLocalization, "edoxen/component_localization"
+  autoload :MeetingComponent, "edoxen/meeting_component"
+  autoload :Officer, "edoxen/officer"
+  autoload :VenueValidator, "edoxen/venue_validator"
+
+  # --- Services ---------------------------------------------------------
   autoload :SchemaValidator, "edoxen/schema_validator"
   autoload :LinkChecker, "edoxen/link_checker"
   autoload :Cli, "edoxen/cli"