edoxen 0.1.1 → 0.1.2

data/lib/edoxen/action.rb

@@ -1,65 +1,32 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
+require_relative "resolution_date"
 
 module Edoxen
   class Action < Lutaml::Model::Serializable
     ACTION_TYPE_ENUM = %w[
-      adopts thanks approves decides declares asks invites resolves confirms
-      welcomes recommends requests congratulates instructs urges appoints
-      resolves further instructs calls-upon encourages affirms elects
-      authorizes charges states remarks judges sanctions abrogates empowers
+      accepts acknowledges adoption adopts agrees allocates appoints appreciates
+      appreciation approves asks assigns chairs communicating confirms consults considers
+      creates decides defines delegates delivering directs disbands drafting elects
+      empowers encourages endorses estabilishes establishes gathering identifies
+      instructs investigates notes notifies recognises nominates
+      recognizes recommends registers regrets request requests resolves restates reminds replaces
+      scopes secures sends supports thanks welcomes withdraws
     ].freeze
 
     attribute :type, :string, values: ACTION_TYPE_ENUM
-    attribute :date_effective, :date
+    attribute :dates, ResolutionDate, collection: true
     attribute :message, :string
     attribute :subject, :string
+    attribute :degree, :string
 
     key_value do
       map "type", to: :type
-      map "date_effective", to: :date_effective
       map "message", to: :message
       map "subject", to: :subject
+      map "degree", to: :degree
+      map "dates", to: :dates
     end
   end
 end
-
-# Action {
-#   type: ActionType
-#   dateEffective: Date
-#   message: Text
-# }
-
-# enum ActionType {
-#   adopts
-#   thanks / expresses-appreciation (subjects)
-#   approves
-#   decides
-#   declares
-#   asks (subjects)
-#   invites / further invites (subjects)
-#   resolves
-#   confirms
-#   welcomes (subjects)
-#   recommends
-#   requests (subjects)
-#   congratulates (subjects)
-#   instructs (subjects)
-#   urges (subjects)
-#   appoints (subjects)
-#   resolves further
-#   instructs (subjects)
-#   calls upon (subjects)
-#   encourages (subjects)
-#   affirms / reaffirming (subjects)
-#   elects
-#   authorizes
-#   charges
-#   states
-#   remarks
-#   judges
-#   sanctions
-#   abrogates
-#   empowers
-# }

data/lib/edoxen/approval.rb

@@ -1,23 +1,7 @@
 # frozen_string_literal: true
 
-# Approval {
-#   type: ApprovalType
-#   degree: ApprovalDegree
-#   date: Date
-#   message: Text
-# }
-
-# enum ApprovalType {
-#   affirmative
-#   negative
-# }
-
-# enum ApprovalDegree {
-#   unanimous
-#   majority
-#   minority
-# }
 require "lutaml/model"
+require_relative "resolution_date"
 
 module Edoxen
   class Approval < Lutaml::Model::Serializable
@@ -26,13 +10,13 @@ module Edoxen
 
     attribute :type, :string, values: APPROVAL_TYPE_ENUM
     attribute :degree, :string, values: APPROVAL_DEGREE_ENUM
-    attribute :date, :date
+    attribute :dates, ResolutionDate, collection: true
     attribute :message, :string
 
     key_value do
       map "type", to: :type
       map "degree", to: :degree
-      map "date", to: :date
+      map "dates", to: :dates
       map "message", to: :message
     end
   end

data/lib/edoxen/cli.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "thor"
+require "fileutils"
+require_relative "schema_validator"
+
+module Edoxen
+  class Cli < Thor
+    desc "validate YAML_FILE_PATTERN", "Validate YAML files against Edoxen schema"
+    def validate(pattern)
+      files = expand_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 validation
+        schema_errors = validator.validate_file(file)
+
+        # Model parsing validation
+        model_errors = []
+        begin
+          content = File.read(file)
+          Edoxen::ResolutionSet.from_yaml(content)
+        rescue StandardError => e
+          model_errors << "Model parsing failed: #{e.message}"
+        end
+
+        if schema_errors.empty? && model_errors.empty?
+          say "✅ VALID", :green
+          valid_count += 1
+        else
+          say "❌ INVALID", :red
+          invalid_count += 1
+
+          # Show schema validation errors with clickable links
+          unless schema_errors.empty?
+            say "    Schema Validation Errors:", :red
+            schema_errors.each do |error|
+              say "      #{error.to_clickable_format}", :red
+            end
+          end
+
+          # Show model parsing errors
+          unless model_errors.empty?
+            say "    Model Parsing Errors:", :red
+            model_errors.each do |error|
+              say "      #{file}:1:1: #{error}", :red
+            end
+          end
+        end
+      end
+
+      say "\n📊 Validation Summary:", :blue
+      say "  Valid files: #{valid_count}", :green
+      say "  Invalid files: #{invalid_count}", invalid_count.positive? ? :red : :green
+      say "  Success rate: #{((valid_count.to_f / files.size) * 100).round(1)}%", :blue
+
+      exit(invalid_count.positive? ? 1 : 0)
+    end
+
+    desc "normalize YAML_FILE_PATTERN", "Normalize YAML files using Edoxen schema"
+    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_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
+          # Load and parse the file
+          content = File.read(file)
+
+          # Extract yaml-language-server comment if present
+          yaml_language_server_comment = extract_yaml_language_server_comment(content)
+
+          resolution_set = Edoxen::ResolutionSet.from_yaml(content)
+
+          # Normalize by serializing back to YAML
+          normalized_yaml = resolution_set.to_yaml
+
+          # Prepend the yaml-language-server comment if it was present
+          normalized_yaml = "#{yaml_language_server_comment}\n#{normalized_yaml}" if yaml_language_server_comment
+
+          if options[:inplace]
+            # Write directly to the original file
+            File.write(file, normalized_yaml)
+            say "✅ NORMALIZED", :green
+          else
+            # Write to output directory
+            output_file = File.join(options[:output], File.basename(file))
+            FileUtils.mkdir_p(File.dirname(output_file))
+            File.write(output_file, normalized_yaml)
+            say "✅ NORMALIZED → #{output_file}", :green
+          end
+
+          success_count += 1
+        rescue StandardError => e
+          say "❌ FAILED", :red
+          say "    Error: #{e.message}", :red
+          error_count += 1
+        end
+      end
+
+      say "\n📊 Normalization Summary:", :blue
+      say "  Successful: #{success_count}", :green
+      say "  Failed: #{error_count}", error_count.positive? ? :red : :green
+      say "  Success rate: #{((success_count.to_f / files.size) * 100).round(1)}%", :blue
+
+      if options[:output]
+        say "  Output directory: #{options[:output]}", :blue
+      elsif options[:inplace]
+        say "  Files modified in place", :yellow
+      end
+
+      exit(error_count.positive? ? 1 : 0)
+    end
+
+    private
+
+    def expand_pattern(pattern)
+      # Handle glob patterns
+      files = Dir.glob(pattern).select { |f| File.file?(f) }
+
+      # Filter for YAML files
+      files.select { |f| f.match?(/\.(ya?ml)$/i) }.sort
+    end
+
+    def extract_yaml_language_server_comment(content)
+      lines = content.split("\n")
+
+      # Look for yaml-language-server comment in the first few lines
+      lines.first(5).each do |line|
+        if line.strip.match?(/^#\s*yaml-language-server:\s*\$schema=/)
+          return line.rstrip # Only strip trailing whitespace, keep the #
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/edoxen/consideration.rb

@@ -1,48 +1,25 @@
 # 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"
+require_relative "resolution_date"
 
 module Edoxen
   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
+    CONSIDERATION_TYPE_ENUM = %w[
+      acknowledging basing considering identifying noting recalling recognises according following
+      recognising recognizing
+    ].freeze
 
     attribute :type, :string, values: CONSIDERATION_TYPE_ENUM
-    attribute :date, :date
+    attribute :dates, ResolutionDate, collection: true
     attribute :message, :string
+    attribute :subject, :string
 
     key_value do
       map "type", to: :type
-      map "date", to: :date
+      map "dates", to: :dates
       map "message", to: :message
+      map "subject", to: :subject
     end
   end
 end

data/lib/edoxen/metadata.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "resolution_date"
+require_relative "url"
+
+module Edoxen
+  class Metadata < Lutaml::Model::Serializable
+    attribute :title, :string
+    attribute :identifier, :string
+    attribute :dates, ResolutionDate, collection: true
+    attribute :source, :string
+    attribute :venue, :string
+    attribute :chair, :string
+    attribute :urls, Url, collection: true
+
+    key_value do
+      map "title", to: :title
+      map "identifier", to: :identifier
+      map "dates", to: :dates
+      map "source", to: :source
+      map "venue", to: :venue
+      map "chair", to: :chair
+      map "urls", to: :urls
+    end
+  end
+end

data/lib/edoxen/resolution.rb

@@ -1,61 +1,47 @@
 # frozen_string_literal: true
 
 require "lutaml/model"
+require_relative "resolution_date"
+require_relative "consideration"
+require_relative "approval"
+require_relative "action"
+require_relative "meeting_identifier"
+require_relative "resolution_relation"
 
 module Edoxen
   class Resolution < Lutaml::Model::Serializable
     RESOLUTION_TYPE_ENUM = %w[resolution recommendation decision declaration].freeze
 
-    attribute :category, :string
-    attribute :dates, :date, collection: true
+    attribute :dates, ResolutionDate, collection: true
     attribute :subject, :string
     attribute :title, :string
     attribute :type, :string, values: RESOLUTION_TYPE_ENUM
     attribute :identifier, :string
+    attribute :message, :string
+    attribute :considering, :string
     attribute :considerations, Consideration, collection: true
     attribute :approvals, Approval, collection: true
     attribute :actions, Action, collection: true
+    attribute :meeting_identifier, MeetingIdentifier
+    attribute :relations, ResolutionRelation, collection: true
+    attribute :categories, :string, collection: true
+    attribute :urls, Url, 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 "message", to: :message
+      map "considering", to: :considering
       map "considerations", to: :considerations
       map "approvals", to: :approvals
       map "actions", to: :actions
+      map "meeting_identifier", to: :meeting_identifier
+      map "relations", to: :relations
+      map "categories", to: :categories
+      map "urls", to: :urls
     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_date.rb

@@ -1,33 +1,17 @@
 # frozen_string_literal: true
 
-# class ResolutionRelation {
-#   source: StructuredIdentifier (Resolution)
-#   destination: StructuredIdentifier (Resolution)
-#   type: ResolutionRelationType
-# }
+require "lutaml/model"
 
-# enum ResolutionRelationType {
-#   annexOf {
-#     This resolution is an annex to the target resolution.
-#   }
+module Edoxen
+  class ResolutionDate < Lutaml::Model::Serializable
+    attribute :start, :date
+    attribute :end, :date
+    attribute :kind, :string, values: %w[ballot enactment effective decision meeting]
 
-#   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 "start", to: :start
+      map "end", to: :end
+      map "kind", to: :kind
+    end
+  end
+end

data/lib/edoxen/{resolution_relationship.rb → resolution_relation.rb}

@@ -35,7 +35,7 @@
 require "lutaml/model"
 
 module Edoxen
-  class ResolutionRelationship < Lutaml::Model::Serializable
+  class ResolutionRelation < Lutaml::Model::Serializable
     RESOLUTION_RELATIONSHIP_ENUM = %w[annexOf hasAnnex updates refines replaces obsoletes considers].freeze
 
     attribute :source, :string

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