edoxen 0.1.1 → 0.3.0

data/lib/edoxen/cli.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "thor"
+require "fileutils"
+
+module Edoxen
+  # Thor command-line surface for the gem. Two responsibilities:
+  #   * `validate PATTERN` — runs both JSON-Schema validation and the
+  #     Ruby model parser against each matching YAML file.
+  #   * `normalize PATTERN (--output DIR | --inplace)` — round-trips each
+  #     matching YAML file through the Ruby model, preserving any
+  #     `# yaml-language-server: $schema=...` directive on the first line.
+  #
+  # The CLI deliberately does NOT own schema-or-model decisions — those
+  # live in `SchemaValidator` and `Lutaml::Model` respectively. It only
+  # glues them together and formats output.
+  class Cli < Thor
+    package_name "edoxen"
+
+    desc "validate YAML_FILE_PATTERN",
+         "Validate one or more Edoxen YAML files against the schema and the model."
+
+    def validate(pattern)
+      files = expand_yaml_pattern(pattern)
+      if files.empty?
+        say "No files found matching pattern: #{pattern}", :red
+        exit 1
+      end
+
+      say "🔍 Validating #{files.size} file(s)...", :blue
+
+      validator = SchemaValidator.new
+      valid_count = 0
+      invalid_count = 0
+
+      files.each do |file|
+        print "  #{File.basename(file)}... "
+
+        schema_errors = validator.validate_file(file)
+        model_errors = collect_model_errors(file)
+
+        if schema_errors.empty? && model_errors.empty?
+          say "✅ VALID", :green
+          valid_count += 1
+        else
+          say "❌ INVALID", :red
+          invalid_count += 1
+          schema_errors.each { |e| say "    #{e.to_clickable_format}", :red }
+          model_errors.each { |m| say "    #{file}:1:1: #{m}", :red }
+        end
+      end
+
+      print_summary(files.size, valid_count, invalid_count, validator_type: :binary)
+      exit(invalid_count.positive? ? 1 : 0)
+    end
+
+    desc "normalize YAML_FILE_PATTERN",
+         "Round-trip YAML file(s) through the Edoxen model (--output DIR or --inplace)."
+
+    option :output, type: :string, desc: "Output directory for normalized files"
+    option :inplace, type: :boolean, desc: "Modify files in place (no backup)"
+
+    def normalize(pattern)
+      if options[:output] && options[:inplace]
+        say "Error: Cannot use both --output and --inplace options", :red
+        exit 1
+      end
+
+      unless options[:output] || options[:inplace]
+        say "Error: Must specify either --output or --inplace option", :red
+        exit 1
+      end
+
+      files = expand_yaml_pattern(pattern)
+      if files.empty?
+        say "No files found matching pattern: #{pattern}", :red
+        exit 1
+      end
+
+      say "🔄 Normalizing #{files.size} file(s)...", :blue
+
+      success_count = 0
+      error_count = 0
+
+      files.each do |file|
+        print "  #{File.basename(file)}... "
+        begin
+          yaml_language_server_comment = extract_yaml_language_server_comment(File.read(file))
+          normalized = ResolutionCollection.from_yaml(File.read(file)).to_yaml
+          normalized = "#{yaml_language_server_comment}\n#{normalized}" if yaml_language_server_comment
+
+          if options[:inplace]
+            File.write(file, normalized)
+            say "✅ NORMALIZED", :green
+          else
+            out = File.join(options[:output], File.basename(file))
+            FileUtils.mkdir_p(File.dirname(out))
+            File.write(out, normalized)
+            say "✅ NORMALIZED → #{out}", :green
+          end
+          success_count += 1
+        rescue StandardError => e
+          say "❌ FAILED — #{e.message}", :red
+          error_count += 1
+        end
+      end
+
+      print_summary(files.size, success_count, error_count, validator_type: :lax,
+                                                            extra: [
+                                                              ["  Output directory", options[:output]],
+                                                              ["  Mode", options[:inplace] ? "in place" : "--output"]
+                                                            ].compact)
+      exit(error_count.positive? ? 1 : 0)
+    end
+
+    no_commands do
+      # Reserved for private Thor plumbing if we add it later.
+    end
+
+    private
+
+    def expand_yaml_pattern(pattern)
+      Dir.glob(pattern).select { |f| File.file?(f) && f.match?(/\.ya?ml\z/i) }.sort
+    end
+
+    # Round-trip the file through the model to catch structural issues
+    # (missing nested classes, type mismatches) that the JSON-Schema can't
+    # express. The model is permissive about field names — schema is the
+    # strict source.
+    def collect_model_errors(file)
+      ResolutionCollection.from_yaml(File.read(file))
+      []
+    rescue StandardError => e
+      ["Model parsing failed: #{e.message}"]
+    end
+
+    def extract_yaml_language_server_comment(content)
+      lines = content.split("\n").first(5)
+      lines.find { |l| l.strip.match?(/\A#\s*yaml-language-server:\s*\$schema=/) }&.rstrip
+    end
+
+    def print_summary(total, ok_count, bad_count, validator_type:, extra: [])
+      say "\n📊 Summary:", :blue
+      say "  Total: #{total}", :blue
+      label_text = if validator_type == :binary
+                     "  Valid: #{ok_count}, Invalid: #{bad_count}"
+                   else
+                     "  Success: #{ok_count}, Failed: #{bad_count}"
+                   end
+      say label_text, bad_count.positive? ? :red : :green
+      success_rate = total.zero? ? 0 : ((ok_count.to_f / total) * 100).round(1)
+      say "  Success rate: #{success_rate}%", :blue
+      extra.each { |label, value| say "  #{label}: #{value}", :blue }
+    end
+  end
+end

data/lib/edoxen/consideration.rb

@@ -1,47 +1,16 @@
 # frozen_string_literal: true
 
-# Consideration {
-#   type: ConsiderationType
-#   dateEffective: Date
-#   message: Text
-# }
-
-# enum ConsiderationType {
-#   having / having regard
-#   noting
-#   recognizing
-#   acknowledging
-#   recalling / further recalling
-#   reaffirming
-#   considering
-#   taking into account
-#   pursuant to
-#   bearing in mind
-#   emphasizing
-#   concerned
-#   accepts
-#   observing
-#   referring
-#   acting
-#   empowers
-#   reaffirming
-# }
-
-require "lutaml/model"
-
 module Edoxen
+  # Basis for a resolution: a verb (having, noting, considering, ...) plus
+  # one effective date and the elaborated reasoning.
   class Consideration < Lutaml::Model::Serializable
-    CONSIDERATION_TYPE_ENUM = %w[having noting recognizing acknowledging recalling reaffirming considering
-                                 taking-into-account pursuant-to bearing-in-mind emphasizing concerned accepts observing
-                                 referring acting empowers reaffirming].freeze
-
-    attribute :type, :string, values: CONSIDERATION_TYPE_ENUM
-    attribute :date, :date
+    attribute :type, :string, values: Enums::CONSIDERATION_TYPE
+    attribute :date_effective, ResolutionDate
     attribute :message, :string
 
     key_value do
       map "type", to: :type
-      map "date", to: :date
+      map "date_effective", to: :date_effective
       map "message", to: :message
     end
   end

data/lib/edoxen/enums.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # Single source of truth for every enum used by the Edoxen information model.
+  #
+  # Mirrors ../edoxen-model/models/*.lutaml, deduped.
+  # Both:
+  #   * Ruby model attribute declarations (`attribute :type, :string, values: Enums::ACTION_TYPE`)
+  #   * JSON-Schema (`schema/edoxen.yaml`)
+  # reference these constants.
+  #
+  # The schema <-> Ruby enum-sync spec asserts the YAML schema's enum arrays
+  # equal these arrays. If you change a constant here, change the schema in
+  # the same PR.
+  module Enums
+    ACTION_TYPE = %w[
+      adopts thanks approves decides declares asks invites
+      resolves confirms welcomes recommends requests congratulates
+      instructs urges appoints calls-upon encourages affirms elects
+      authorizes charges states remarks judges sanctions abrogates empowers
+    ].freeze
+
+    CONSIDERATION_TYPE = %w[
+      having noting recognizing acknowledging recalling reaffirming
+      considering taking-into-account pursuant-to bearing-in-mind
+      emphasizing concerned accepts observing referring acting empowers
+    ].freeze
+
+    RESOLUTION_TYPE = %w[resolution recommendation decision declaration].freeze
+
+    RESOLUTION_RELATION_TYPE = %w[
+      annexOf hasAnnex updates refines replaces considers
+    ].freeze
+
+    RESOLUTION_DATE_TYPE = %w[adoption drafted discussed].freeze
+
+    APPROVAL_TYPE = %w[affirmative negative].freeze
+
+    APPROVAL_DEGREE = %w[unanimous majority minority].freeze
+
+    URL_KIND = %w[access report].freeze
+  end
+end

data/lib/edoxen/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # Base class for any Edoxen-level error. Reserved for raise-on-failure paths;
+  # schema validation errors live under SchemaValidator::ValidationError.
+  class Error < StandardError; end
+end

data/lib/edoxen/localization.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # A monolingual rendering of a Resolution. Mirrors the glossarist
+  # LocalizedConcept pattern: language-agnostic fields live on the
+  # parent Resolution; per-language content lives here.
+  class Localization < Lutaml::Model::Serializable
+    attribute :language_code, :string
+    attribute :script, :string
+    attribute :title, :string
+    attribute :subject, :string
+    attribute :message, :string
+    attribute :considering, :string
+    attribute :considerations, Consideration, collection: true
+    attribute :approvals, Approval, collection: true
+    attribute :actions, Action, collection: true
+
+    key_value do
+      map "language_code", to: :language_code
+      map "script", to: :script
+      map "title", to: :title
+      map "subject", to: :subject
+      map "message", to: :message
+      map "considering", to: :considering
+      map "considerations", to: :considerations
+      map "approvals", to: :approvals
+      map "actions", to: :actions
+    end
+  end
+end

data/lib/edoxen/{meeting_identfier.rb → meeting_identifier.rb}

@@ -1,12 +1,8 @@
 # frozen_string_literal: true
 
-# MeetingIdentifier {
-#   venue: String
-#   date: DateTime
-# }
-require "lutaml/model"
-
 module Edoxen
+  # Identifier of a meeting (venue + date). Singular — the meeting a
+  # particular Resolution belongs to.
   class MeetingIdentifier < Lutaml::Model::Serializable
     attribute :venue, :string
     attribute :date, :date

data/lib/edoxen/resolution.rb

@@ -1,61 +1,34 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
-
 module Edoxen
+  # A formal Resolution. Language-agnostic admin fields live here; every
+  # translatable field is wrapped inside `localizations[]` (one entry per
+  # available language; at least one is required by the schema).
   class Resolution < Lutaml::Model::Serializable
-    RESOLUTION_TYPE_ENUM = %w[resolution recommendation decision declaration].freeze
-
-    attribute :category, :string
-    attribute :dates, :date, collection: true
-    attribute :subject, :string
-    attribute :title, :string
-    attribute :type, :string, values: RESOLUTION_TYPE_ENUM
-    attribute :identifier, :string
-    attribute :considerations, Consideration, collection: true
-    attribute :approvals, Approval, collection: true
-    attribute :actions, Action, collection: true
+    attribute :identifier, StructuredIdentifier, collection: true
+    attribute :type, :string, values: Enums::RESOLUTION_TYPE
+    attribute :doi, :string
+    attribute :urn, :string
+    attribute :agenda_item, :string
+    attribute :dates, ResolutionDate, collection: true
+    attribute :categories, :string, collection: true
+    attribute :meeting, MeetingIdentifier
+    attribute :relations, ResolutionRelation, collection: true
+    attribute :urls, Url, collection: true
+    attribute :localizations, Localization, collection: true
 
     key_value do
-      map "category", to: :category
-      map "dates", to: :dates
-      map "subject", to: :subject
-      map "title", to: :title
-      map "type", to: :type
       map "identifier", to: :identifier
-      map "considerations", to: :considerations
-      map "approvals", to: :approvals
-      map "actions", to: :actions
+      map "type", to: :type
+      map "doi", to: :doi
+      map "urn", to: :urn
+      map "agenda_item", to: :agenda_item
+      map "dates", to: :dates
+      map "categories", to: :categories
+      map "meeting", to: :meeting
+      map "relations", to: :relations
+      map "urls", to: :urls
+      map "localizations", to: :localizations
     end
-
-    # Example of a Resolution
-    # category: Resolutions related to JWG 1
-    # dates:
-    #   - 2019-10-17
-    # subject: ISO/TC 154
-    # title: "Adoption of NWIP ballot for ISO/PWI 9735-11 "Electronic data..."
-    # identifier: 2019-01
-    # considerations:
-    #   - type: considering
-    #     date_effective: 2019-10-17
-    #     message: considering the voting result ...
-
-    #   - type: considering
-    #     date_effective: 2019-10-17
-    #     message: considering the importance of ...
-
-    #   - type: considering
-    #     date_effective: 2019-10-17
-    #     message: considering the request from JWG1...
-
-    # approvals:
-    #   - type: affirmative
-    #     degree: unanimous
-    #     message: The resolution was taken by unanimity.
-
-    # actions:
-    #   - type: resolves
-    #     date_effective: 2019-10-17
-    #     message: resolves to submit ISO 9735-11...
   end
 end

data/lib/edoxen/resolution_collection.rb

@@ -1,25 +1,15 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
-
 module Edoxen
+  # Top-level container for a published resolution collection: metadata
+  # plus the list of resolutions.
   class ResolutionCollection < Lutaml::Model::Serializable
-    attribute :metadata, :hash
+    attribute :metadata, ResolutionMetadata
     attribute :resolutions, Resolution, collection: true
 
     key_value do
       map "metadata", to: :metadata
       map "resolutions", to: :resolutions
     end
-
-    # Example of a ResolutionCollection
-    # metadata:
-    #   title: Resolutions of the 38th plenary meeting of ISO/TC 154
-    #   date: 2019-10-17
-    #   source: ISO/TC 154 Secretariat
-    # resolutions:
-    #   - category: Resolutions related to JWG 1
-    #     dates: 2019/10/17
-    #     ...
   end
 end

data/lib/edoxen/resolution_date.rb

@@ -1,33 +1,16 @@
 # frozen_string_literal: true
 
-# class ResolutionRelation {
-#   source: StructuredIdentifier (Resolution)
-#   destination: StructuredIdentifier (Resolution)
-#   type: ResolutionRelationType
-# }
+module Edoxen
+  # Date with semantic kind (adoption, drafted, discussed).
+  # ResolutionDate is the only carrier of a *typed* date in the model —
+  # plain `Date` in lutaml-model has no semantic context.
+  class ResolutionDate < Lutaml::Model::Serializable
+    attribute :date, :date
+    attribute :type, :string, values: Enums::RESOLUTION_DATE_TYPE
 
-# enum ResolutionRelationType {
-#   annexOf {
-#     This resolution is an annex to the target resolution.
-#   }
-
-#   hasAnnex {
-#     The target resolution is an annex of the source resolution.
-#   }
-
-#   updates {
-#     This resolution updates the target resolution.
-#   }
-
-#   refines {
-#     This resolution refines the target resolution.
-#   }
-
-#   replaces/obsoletes {
-#     This resolution replaces/obsoletes the target resolution.
-#   }
-
-#   considers {
-#     This resolution is made in consideration of the target resolution.
-#   }
-# }
+    key_value do
+      map "date", to: :date
+      map "type", to: :type
+    end
+  end
+end

data/lib/edoxen/resolution_metadata.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # Collection-level metadata: the title (string for default / single-language
+  # collections, or `title_localized[]` for multilingual), the meeting date,
+  # the source secretariat, per-language source PDFs, and the host venue.
+  class ResolutionMetadata < Lutaml::Model::Serializable
+    attribute :title, :string
+    attribute :title_localized, Localization, collection: true
+    attribute :date, :date
+    attribute :source, :string
+    attribute :source_urls, SourceUrl, collection: true
+    attribute :city, :string
+    attribute :country_code, :string
+
+    key_value do
+      map "title", to: :title
+      map "title_localized", to: :title_localized
+      map "date", to: :date
+      map "source", to: :source
+      map "source_urls", to: :source_urls
+      map "city", to: :city
+      map "country_code", to: :country_code
+    end
+  end
+end

data/lib/edoxen/resolution_relation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Edoxen
+  # Directed relation between two resolutions, identified by their
+  # StructuredIdentifier (prefix + number).
+  class ResolutionRelation < Lutaml::Model::Serializable
+    attribute :source, StructuredIdentifier
+    attribute :destination, StructuredIdentifier
+    attribute :type, :string, values: Enums::RESOLUTION_RELATION_TYPE
+
+    key_value do
+      map "source", to: :source
+      map "destination", to: :destination
+      map "type", to: :type
+    end
+  end
+end

data/lib/edoxen/resolution_set.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "metadata"
+require_relative "resolution"
+
+module Edoxen
+  class ResolutionSet < Lutaml::Model::Serializable
+    attribute :metadata, Metadata
+    attribute :resolutions, Resolution, collection: true
+
+    key_value do
+      map "metadata", to: :metadata
+      map "resolutions", to: :resolutions
+    end
+  end
+end