edoxen 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2fe56ab6ddff9606df4af319cba2d372d7114bce66822968710cb15cf0886cd
-  data.tar.gz: 7e30d4153daaa03d9cab2d10170947b10c646526bcc6b156ef909a5b8557d61d
+  metadata.gz: a87eaf24182b1fd7400efbd2af10681f4059a35cd57c807759a8015a59a1c0f1
+  data.tar.gz: 53ede8ad87d1a25bbf766d7196e6437a8455f431af313ba5b9752cbd42d17050
 SHA512:
-  metadata.gz: 5665a5650d5ac075b1905095578a188d5ce4e1a94d3fac522133055d14bdc356a5f49382256f9ea3f9b7c159bc7c2d5dc5315b1fa7c5354ec8a016d2cd85f3c3
-  data.tar.gz: 6c269809b5e14f084d1a427a68a7e623466550dde648ffad9add85fae84ae5b1607de77adf70bfa5f0a90a6f04cfd4db842f0287c84d9e6120286a2eb4486d94
+  metadata.gz: a14ac6664ffa8ec1f1fcd31ace23257a740dcad3fab41ead54d542440a53618ac8ad46bb495afeb44c62db7b850d35d789ee7a888245f4e6b3ac0afe092310ee
+  data.tar.gz: 991a18091cb7ec21ddfe70b2691244b3e8a6ba869135545f6249ffa35d56439afbf578a867d56bdce6c3555f177c59f43c73f8c27abb119527af36c42e6b17fd

data/CLAUDE.md

@@ -93,9 +93,13 @@ that propagate:
 
 `lib/edoxen/schema_validator.rb` is intentionally small:
 
-- `SchemaValidator::ValidationError` — rendered as `file:line:col: msg`.
-- `#validate_file(path)` → `Array<ValidationError>`.
-- `#validate_content(content, path)` → `Array<ValidationError>`.
+- `Edoxen::ValidationError` (defined in `lib/edoxen/error.rb`) — the unified
+  validation shape. `SchemaValidator::ValidationError` is a back-compat
+  alias. Carries `file`, `line`, `column`, `pointer`, `message_text`, and
+  `source` (`:schema` / `:model` / `:syntax`) so renderers can branch on
+  failure origin. Rendered as `file:line:col: msg at \`/pointer\``.
+- `#validate_file(path)` → `Array<Edoxen::ValidationError>`.
+- `#validate_content(content, path)` → `Array<Edoxen::ValidationError>`.
 - `SchemaValidator::LineMap` — builds an indent-heuristic
   `{json_pointer => line_no}` map and resolves a JSON-Schema data
   pointer to a line via longest-prefix match. **No path-shape
@@ -119,6 +123,16 @@ that propagate:
   result back. Preserves any `# yaml-language-server: $schema=...`
   directive in the first 5 lines.
 
+Both commands delegate their expand/sort/empty/header/loop/tally/summary/exit
+scaffold to `Edoxen::Cli::Batch` — the deep module behind the seam. The
+command bodies are per-file blocks returning `Batch::Result.ok(msg)` or
+`Batch::Result.bad(errors)`. Adding a third command (e.g. `lint`, `diff`)
+is one block.
+
+`Resolution#in_language(code, fallback:)` and `Resolution#primary_localization`
+provide the canonical lookup interface — callers should not iterate
+`localizations.find { |l| l.language_code == code }` directly.
+
 Exit code is non-zero if any file fails.
 
 ## Build, test, lint
@@ -139,15 +153,15 @@ mkdir -p /tmp/out && bundle exec exe/edoxen normalize "spec/fixtures/*.yaml" --o
 
 - **No `double()` in specs** — use real `Edoxen::*` instances and fixture files.
 - **Serialization is framework-only.** Never hand-roll `to_h` / `from_h` /
-  `to_yaml` / `from_yaml` / `to_json` / `from_json` on a model class. Use
-  `attribute` + `key_value do … end` and let lutaml-model do it. Renames
-  are `map "wire_name", to: :attr` — never key-swapping inside a method.
+  `to_yaml` / `from_yaml` / `to_json` / `from_json` on a model class. Declare
+  `attribute` only — lutaml-model auto-emits an identity map for each
+  attribute when no `key_value` block is present. Add a `key_value do … end`
+  block with `map "wire_name", to: :attr` only when the wire name differs
+  from the attribute name.
 - **Wire names are `snake_case`.** Even when the LUTAML notation uses
   camelCase, the YAML wire form is `snake_case` (`agenda_item`, not
-  `agendaItem`). The attribute name on the Ruby side is also `snake_case`;
-  when they match exactly, drop the explicit `map` declaration only after
-  checking lutaml-model supports it. (Today lutaml-model needs an explicit
-  `map` for `key_value`; do not delete them.)
+  `agendaItem`). The attribute name on the Ruby side is also `snake_case`,
+  and the wire name defaults to it.
 - **Enums on the model and the schema must agree.** When you add or remove
   a value to `Enums::*`, also update the matching `enum:` list in
   `schema/edoxen.yaml` $defs. The `schema_enum_sync_spec` will catch any

data/lib/edoxen/action.rb

@@ -7,11 +7,5 @@ module Edoxen
     attribute :type, :string, values: Enums::ACTION_TYPE
     attribute :date_effective, ResolutionDate
     attribute :message, :string
-
-    key_value do
-      map "type", to: :type
-      map "date_effective", to: :date_effective
-      map "message", to: :message
-    end
   end
 end

data/lib/edoxen/approval.rb

@@ -8,12 +8,5 @@ module Edoxen
     attribute :degree, :string, values: Enums::APPROVAL_DEGREE
     attribute :date, ResolutionDate
     attribute :message, :string
-
-    key_value do
-      map "type", to: :type
-      map "degree", to: :degree
-      map "date", to: :date
-      map "message", to: :message
-    end
   end
 end

data/lib/edoxen/cli.rb

@@ -4,54 +4,101 @@ 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"
+    # Deep module behind the per-command interface. Owns the
+    # expand/sort/empty/header/loop/tally/summary/exit scaffold so
+    # `validate` and `normalize` collapse to per-file blocks.
+    #
+    # Commands call `Batch.run(self, pattern, header:)` and yield a block
+    # that returns `Result.ok(message)` or `Result.bad(errors)`. The
+    # batch runner prints progress, tallies, prints the summary, and
+    # exits with the right code.
+    #
+    # In-process; no adapter. The seam is the call site in each
+    # command method — internal to the CLI.
+    module Batch
+      # Per-file outcome. `ok` carries an optional message appended to
+      # the success indicator (e.g. "NORMALIZED → /out/path"). `bad`
+      # carries a list of pre-formatted error strings.
+      Result = Struct.new(:status, :message, :errors) do
+        def self.ok(message = nil)
+          new(:ok, message, nil)
+        end
 
-    desc "validate YAML_FILE_PATTERN",
-         "Validate one or more Edoxen YAML files against the schema and the model."
+        def self.bad(errors)
+          new(:bad, nil, Array(errors))
+        end
+      end
 
-    def validate(pattern)
-      files = expand_yaml_pattern(pattern)
-      if files.empty?
-        say "No files found matching pattern: #{pattern}", :red
-        exit 1
+      module_function
+
+      # Run a batch over every YAML file matching `pattern`.
+      #
+      # Yields each file path to the caller's block. Block must return
+      # a Batch::Result. The batch runner handles progress output,
+      # tallies, summary, and the exit code.
+      def run(cli, pattern, header:, summary_extra: [])
+        files = expand(pattern)
+        if files.empty?
+          cli.say "No files found matching pattern: #{pattern}", :red
+          exit 1
+        end
+
+        cli.say "#{header} #{files.size} file(s)...", :blue
+
+        ok_count = 0
+        bad_count = 0
+
+        files.each do |file|
+          $stdout.print "  #{File.basename(file)}... "
+          result = yield file
+          if result.status == :ok
+            label = result.message ? "✅ #{result.message}" : "✅"
+            cli.say label, :green
+            ok_count += 1
+          else
+            cli.say "❌ INVALID", :red
+            bad_count += 1
+            Array(result.errors).each { |e| cli.say "    #{e}", :red }
+          end
+        end
+
+        print_summary(cli, files.size, ok_count, bad_count, summary_extra)
+        exit(bad_count.positive? ? 1 : 0)
       end
 
-      say "🔍 Validating #{files.size} file(s)...", :blue
+      def expand(pattern)
+        Dir.glob(pattern).select { |f| File.file?(f) && f.match?(/\.ya?ml\z/i) }.sort
+      end
 
-      validator = SchemaValidator.new
-      valid_count = 0
-      invalid_count = 0
+      def print_summary(cli, total, ok_count, bad_count, summary_extra)
+        cli.say "\n📊 Summary:", :blue
+        cli.say "  Total: #{total}", :blue
+        cli.say "  Success: #{ok_count}, Failed: #{bad_count}",
+                bad_count.positive? ? :red : :green
+        rate = total.zero? ? 0 : ((ok_count.to_f / total) * 100).round(1)
+        cli.say "  Success rate: #{rate}%", :blue
+        summary_extra.each { |label, value| cli.say "  #{label}: #{value}", :blue }
+      end
+    end
 
-      files.each do |file|
-        print "  #{File.basename(file)}... "
+    package_name "edoxen"
 
+    desc "validate YAML_FILE_PATTERN",
+         "Validate one or more Edoxen YAML files against the schema and the model."
+
+    def validate(pattern)
+      validator = SchemaValidator.new
+      Batch.run(self, pattern, header: "🔍 Validating") do |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
+          Batch::Result.ok("VALID")
         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 }
+          errors = (schema_errors + model_errors).map(&:to_clickable_format)
+          Batch::Result.bad(errors)
         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",
@@ -61,77 +108,34 @@ module Edoxen
     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
+      unless valid_normalize_options?
+        say normalize_options_error, :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
+      summary_extra = [
+        ["  Output directory", options[:output]],
+        ["  Mode", options[:inplace] ? "in place" : "--output"]
+      ].compact
 
-      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
+      Batch.run(self, pattern, header: "🔄 Normalizing", summary_extra: summary_extra) do |file|
+        Batch::Result.ok(normalize_file(file))
+      rescue StandardError => e
+        Batch::Result.bad(["#{file}:1:1: #{e.message}"])
       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}"]
+      [Edoxen::ValidationError.new(
+        file: file, line: 1, column: 1,
+        message_text: "Model parsing failed: #{e.message}",
+        source: Edoxen::ValidationError::SOURCE_MODEL
+      )]
     end
 
     def extract_yaml_language_server_comment(content)
@@ -139,18 +143,39 @@ module Edoxen
       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 }
+    def valid_normalize_options?
+      return false if options[:output] && options[:inplace]
+      return false unless options[:output] || options[:inplace]
+
+      true
+    end
+
+    def normalize_options_error
+      if options[:output] && options[:inplace]
+        "Error: Cannot use both --output and --inplace options"
+      else
+        "Error: Must specify either --output or --inplace option"
+      end
+    end
+
+    # Writes the normalized YAML either to the original file (--inplace)
+    # or under the --output directory. Returns a one-line status message
+    # for the batch runner to print after the ✅.
+    def normalize_file(file)
+      original = File.read(file)
+      yaml_language_server_comment = extract_yaml_language_server_comment(original)
+      normalized = ResolutionCollection.from_yaml(original).to_yaml
+      normalized = "#{yaml_language_server_comment}\n#{normalized}" if yaml_language_server_comment
+
+      if options[:inplace]
+        File.write(file, normalized)
+        "NORMALIZED"
+      else
+        out = File.join(options[:output], File.basename(file))
+        FileUtils.mkdir_p(File.dirname(out))
+        File.write(out, normalized)
+        "NORMALIZED → #{out}"
+      end
     end
   end
 end

data/lib/edoxen/consideration.rb

@@ -7,11 +7,5 @@ module Edoxen
     attribute :type, :string, values: Enums::CONSIDERATION_TYPE
     attribute :date_effective, ResolutionDate
     attribute :message, :string
-
-    key_value do
-      map "type", to: :type
-      map "date_effective", to: :date_effective
-      map "message", to: :message
-    end
   end
 end

data/lib/edoxen/error.rb

@@ -1,7 +1,37 @@
 # 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.
+  # Base class for any Edoxen-level error. Reserved for raise-on-failure paths.
   class Error < StandardError; end
+
+  # Unified validation failure shape. Produced by both:
+  #   * SchemaValidator — JSON-Schema violations and YAML syntax errors
+  #     carry source: :schema (or :syntax for Psych::SyntaxError).
+  #   * ResolutionCollection.from_yaml rescues in the CLI — model parse
+  #     failures carry source: :model.
+  #
+  # One type at the seam means callers (CLI, future renderers, tests)
+  # handle one shape instead of N.
+  class ValidationError < Error
+    SOURCE_SCHEMA = :schema
+    SOURCE_MODEL = :model
+    SOURCE_SYNTAX = :syntax
+
+    attr_reader :file, :line, :column, :pointer, :message_text, :source
+
+    def initialize(file:, line:, column:, message_text:, pointer: "", source: SOURCE_SCHEMA)
+      @file = file
+      @line = line
+      @column = column
+      @pointer = pointer.to_s
+      @message_text = message_text
+      @source = source
+      super(to_clickable_format)
+    end
+
+    def to_clickable_format
+      suffix = @pointer.empty? ? "" : " at `#{@pointer}`"
+      "#{@file}:#{@line}:#{@column}: #{@message_text}#{suffix}"
+    end
+  end
 end

data/lib/edoxen/localization.rb

@@ -14,17 +14,5 @@ module Edoxen
     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_identifier.rb

@@ -6,10 +6,5 @@ module Edoxen
   class MeetingIdentifier < Lutaml::Model::Serializable
     attribute :venue, :string
     attribute :date, :date
-
-    key_value do
-      map "venue", to: :venue
-      map "date", to: :date
-    end
   end
 end

data/lib/edoxen/resolution.rb

@@ -4,6 +4,11 @@ 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).
+  #
+  # Wire names follow lutaml-model's default convention: each declared
+  # attribute serializes to its snake_case name on the wire. Override
+  # with an explicit `key_value do; map "wire", to: :attr; end` block
+  # only when the wire name differs.
   class Resolution < Lutaml::Model::Serializable
     attribute :identifier, StructuredIdentifier, collection: true
     attribute :type, :string, values: Enums::RESOLUTION_TYPE
@@ -17,18 +22,22 @@ module Edoxen
     attribute :urls, Url, collection: true
     attribute :localizations, Localization, collection: true
 
-    key_value do
-      map "identifier", to: :identifier
-      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
+    # Lookup by ISO 639-3 language code. Returns nil when no exact match
+    # exists and `fallback:` is false (the default); returns the first
+    # localization otherwise. Keeps the language-preference policy in
+    # one place so callers stop reimplementing `find { |l| ... }`.
+    def in_language(code, fallback: false)
+      match = localizations&.find { |loc| loc.language_code == code.to_s }
+      return match if match
+
+      fallback ? localizations&.first : nil
+    end
+
+    # The canonical rendering — English when available, else the first
+    # declared localization. Mirrors the glossarist LocalizedConcept
+    # "preferred language" notion.
+    def primary_localization
+      in_language("eng", fallback: true)
     end
   end
 end

data/lib/edoxen/resolution_collection.rb

@@ -6,10 +6,5 @@ module Edoxen
   class ResolutionCollection < Lutaml::Model::Serializable
     attribute :metadata, ResolutionMetadata
     attribute :resolutions, Resolution, collection: true
-
-    key_value do
-      map "metadata", to: :metadata
-      map "resolutions", to: :resolutions
-    end
   end
 end

data/lib/edoxen/resolution_date.rb

@@ -7,10 +7,5 @@ module Edoxen
   class ResolutionDate < Lutaml::Model::Serializable
     attribute :date, :date
     attribute :type, :string, values: Enums::RESOLUTION_DATE_TYPE
-
-    key_value do
-      map "date", to: :date
-      map "type", to: :type
-    end
   end
 end

data/lib/edoxen/resolution_metadata.rb

@@ -12,15 +12,5 @@ module Edoxen
     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

@@ -7,11 +7,5 @@ module Edoxen
     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/schema_validator.rb

@@ -21,46 +21,28 @@ module Edoxen
   # hard-coded path shapes) so adding new collection fields never requires
   # touching this class.
   class SchemaValidator
-    class ValidationError < StandardError
-      attr_reader :file, :line, :column, :pointer, :message_text
-
-      def initialize(file:, line:, column:, pointer:, message_text:)
-        @file = file
-        @line = line
-        @column = column
-        @pointer = pointer
-        @message_text = message_text
-        super(format_line(file, line, column, message_text, pointer))
-      end
-
-      def to_clickable_format
-        format_line(@file, @line, @column, @message_text, @pointer)
-      end
-
-      private
-
-      def format_line(file, line, column, message_text, pointer)
-        suffix = pointer.to_s.empty? ? "" : " at `#{pointer}`"
-        "#{file}:#{line}:#{column}: #{message_text}#{suffix}"
-      end
-    end
+    # Back-compat alias. The canonical type is Edoxen::ValidationError;
+    # this constant lets existing callers keep writing
+    # `SchemaValidator::ValidationError` after the unification.
+    ValidationError = Edoxen::ValidationError
 
     def initialize(schema_path = default_schema_path)
       @schema_path = schema_path
       @schemer = load_schemer(schema_path)
     end
 
-    # Validate a YAML file. Returns an array of ValidationError (empty = ok).
+    # Validate a YAML file. Returns an array of Edoxen::ValidationError
+    # (empty = ok).
     def validate_file(file_path)
       validate_content(File.read(file_path), file_path)
     rescue Errno::ENOENT
       [ValidationError.new(
         file: file_path, line: 1, column: 1,
-        pointer: "", message_text: "File not found"
+        message_text: "File not found", source: Edoxen::ValidationError::SOURCE_SCHEMA
       )]
     end
 
-    # Validate a YAML string. Returns an array of ValidationError.
+    # Validate a YAML string. Returns an array of Edoxen::ValidationError.
     def validate_content(content, file_path)
       data = normalize_dates(YAML.safe_load(content, permitted_classes: [Date, Time]))
       line_map = LineMap.build(content)
@@ -71,13 +53,15 @@ module Edoxen
         line, column = LineMap.locate(pointer, line_map)
         ValidationError.new(
           file: file_path, line: line, column: column,
-          pointer: pointer, message_text: message
+          message_text: message, pointer: pointer,
+          source: Edoxen::ValidationError::SOURCE_SCHEMA
         )
       end
     rescue Psych::SyntaxError => e
       [ValidationError.new(
         file: file_path, line: e.line || 1, column: e.column || 1,
-        pointer: "", message_text: "YAML syntax error: #{e.problem}"
+        message_text: "YAML syntax error: #{e.problem}",
+        source: Edoxen::ValidationError::SOURCE_SYNTAX
       )]
     end
 

data/lib/edoxen/source_url.rb

@@ -8,11 +8,5 @@ module Edoxen
     attribute :ref, :string
     attribute :format, :string
     attribute :language_code, :string
-
-    key_value do
-      map "ref", to: :ref
-      map "format", to: :format
-      map "language_code", to: :language_code
-    end
   end
 end

data/lib/edoxen/structured_identifier.rb

@@ -8,10 +8,5 @@ module Edoxen
   class StructuredIdentifier < Lutaml::Model::Serializable
     attribute :prefix, :string
     attribute :number, :string
-
-    key_value do
-      map "prefix", to: :prefix
-      map "number", to: :number
-    end
   end
 end

data/lib/edoxen/url.rb

@@ -6,11 +6,5 @@ module Edoxen
     attribute :kind, :string, values: Enums::URL_KIND
     attribute :ref, :string
     attribute :format, :string
-
-    key_value do
-      map "kind", to: :kind
-      map "ref", to: :ref
-      map "format", to: :format
-    end
   end
 end

data/lib/edoxen/version.rb

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

data/lib/edoxen.rb

@@ -21,6 +21,7 @@ module Edoxen
   # (Resolution <-> Localization, ResolutionMetadata <-> Localization, etc.).
   autoload :VERSION, "edoxen/version"
   autoload :Error, "edoxen/error"
+  autoload :ValidationError, "edoxen/error"
   autoload :Enums, "edoxen/enums"
 
   # Information-model classes (one per file, one concept per class).

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: edoxen
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Ribose Inc.