rsmp_schema 0.9.1 → 0.10.1

data/lib/rsmp_schema/schema.rb

@@ -1,186 +1,210 @@
 require 'json_schemer'
 
+# RSMP (Road Side Message Protocol) schema validation library.
 module RSMP
-end
-
-module RSMP::Schema
-  @@schemas = nil
-
-  def self.setup
-    @@schemas = {}
-    schemas_path = File.expand_path( File.join(__dir__,'..','..','schemas') )
-    Dir.glob("#{schemas_path}/*").select {|f| File.directory? f}.each do |type_path|
-      type = File.basename(type_path).to_sym
-      load_schema_type type, type_path
+  # Provides JSON Schema validation for RSMP messages across core and SXL versions.
+  module Schema
+    @schemas = nil
+
+    def self.setup
+      @schemas = {}
+      schemas_path = File.expand_path(File.join(__dir__, '..', '..', 'schemas'))
+      Dir.glob("#{schemas_path}/*").select { |f| File.directory? f }.each do |type_path|
+        type = File.basename(type_path).to_sym
+        load_schema_type type, type_path
+      end
     end
-  end
 
-  # load an schema from a folder. schemas are organized by version, and contain
-  # json schema files, with the entry point being rsmp.jspon, eg:
-  # tlc
-  #   1.0.7
-  #     rsmp.json
-  #     other jon schema files...
-  #   1.0.8
-  #   ...
-  #
-  #  an error is raised if the schema type already exists, and force is not set to true
-  def self.load_schema_type type, type_path, force:false
-    raise RuntimeError.new("Schema type #{type} already loaded") if @@schemas[type] && force!=true
-    @@schemas[type] = {}
-    Dir.glob("#{type_path}/*").select {|f| File.directory? f}.each do |schema_path|
-      version = File.basename(schema_path)
-      file_path = File.join(schema_path,'rsmp.json')
-      if File.exist? file_path
-        @@schemas[type][version] = JSONSchemer.schema(
-          Pathname.new(File.join(schema_path,'rsmp.json'))
+    # load an schema from a folder. schemas are organized by version, and contain
+    # json schema files, with the entry point being rsmp.jspon, eg:
+    # tlc
+    #   1.0.7
+    #     rsmp.json
+    #     other jon schema files...
+    #   1.0.8
+    #   ...
+    #
+    #  an error is raised if the schema type already exists, and force is not set to true
+    def self.load_schema_type(type, type_path, force: false)
+      raise "Schema type #{type} already loaded" if @schemas[type] && force != true
+
+      @schemas[type] = {}
+      Dir.glob("#{type_path}/*").select { |f| File.directory? f }.each do |schema_path|
+        version = File.basename(schema_path)
+        file_path = File.join(schema_path, 'rsmp.json')
+        next unless File.exist? file_path
+
+        @schemas[type][version] = JSONSchemer.schema(
+          Pathname.new(File.join(schema_path, 'rsmp.json'))
         )
       end
     end
-  end
 
-  # remove a schema type
-  def self.remove_schema_type type
-    schemas.delete type
-  end
+    # remove a schema type
+    def self.remove_schema_type(type)
+      schemas.delete type
+    end
 
-  # get schemas types
-  def self.schema_types
-    schemas.keys
-  end
+    # get schemas types
+    def self.schema_types
+      schemas.keys
+    end
 
-  # get all schemas, oganized by type and version
-  def self.schemas
-    raise RuntimeError.new("No schemas available, perhaps Schema.setup was never called?") unless @@schemas
-    @@schemas
-  end
+    # get all schemas, oganized by type and version
+    def self.schemas
+      raise 'No schemas available, perhaps Schema.setup was never called?' unless @schemas
 
-  # get array of core schema versions
-  def self.core_versions
-    versions :core
-  end
+      @schemas
+    end
 
-  # get earliest core schema version
-  def self.earliest_core_version
-    earliest_version :core
-  end
+    # get array of core schema versions
+    def self.core_versions
+      versions :core
+    end
 
-  # get latesty core schema version
-  def self.latest_core_version
-    latest_version :core
-  end
+    # get earliest core schema version
+    def self.earliest_core_version
+      earliest_version :core
+    end
 
-  # get array of  schema versions for a particular schema type
-  def self.versions type
-    schemas = find_schemas!(type).keys
-    sort_versions(schemas)
-  end
+    # get latesty core schema version
+    def self.latest_core_version
+      latest_version :core
+    end
 
-  # get earliest schema version for a particular schema type
-  def self.earliest_version type
-    schemas = find_schemas!(type).keys
-    sort_versions(schemas).first
-  end
+    # get array of  schema versions for a particular schema type
+    def self.versions(type)
+      schemas = find_schemas!(type).keys
+      sort_versions(schemas)
+    end
 
-  # get latest schema version for a particular schema type
-  def self.latest_version type
-    schemas = find_schemas!(type).keys
-    sort_versions(schemas).last
-  end
+    # get earliest schema version for a particular schema type
+    def self.earliest_version(type)
+      schemas = find_schemas!(type).keys
+      sort_versions(schemas).first
+    end
 
-  # validate an rsmp messages using a schema object
-  def self.validate_using_schema message, schema
-    raise ArgumentError.new("message missing") unless message
-    raise ArgumentError.new("schema missing") unless schema
-    unless schema.valid? message
-      schema.validate(message).map do |item|
-        [item['data_pointer'],item['type'],item['details']]
+    # get latest schema version for a particular schema type
+    def self.latest_version(type)
+      schemas = find_schemas!(type).keys
+      sort_versions(schemas).last
+    end
+
+    # validate an rsmp messages using a schema object
+    def self.validate_using_schema(message, schema)
+      raise ArgumentError, 'message missing' unless message
+      raise ArgumentError, 'schema missing' unless schema
+
+      if schema.valid? message
+        []
+      else
+        schema.validate(message).map do |item|
+          [item['data_pointer'], item['type'], item['details']]
+        end
       end
-    else
-      []
     end
-  end
 
-  # sort version strings
-  def self.sort_versions versions
-    versions.sort_by { |k| Gem::Version.new(k) }
-  end
+    # sort version strings
+    def self.sort_versions(versions)
+      versions.sort_by { |k| Gem::Version.new(k) }
+    end
 
-  # find schemas versions for particular schema type
-  # return nil if type not found
-  def self.find_schemas type
-    raise ArgumentError.new("type missing") unless type
-    schemas = @@schemas[type.to_sym]
-  end
+    # find schemas versions for particular schema type
+    # return nil if type not found
+    def self.find_schemas(type)
+      raise ArgumentError, 'type missing' unless type
 
-  # find schemas versions for particular schema type
-  # raise error if not found
-  def self.find_schemas! type
-    schemas = find_schemas type
-    raise UnknownSchemaTypeError.new("Unknown schema type #{type}") unless schemas
-    schemas
-  end
+      @schemas[type.to_sym]
+    end
 
-  # find schema for a particular schema and version
-  # return nil if not found
-  def self.find_schema type, version, options={}
-    raise ArgumentError.new("version missing") unless version
-    version = sanitize_version version if options[:lenient]
-    if version
+    # find schemas versions for particular schema type
+    # raise error if not found
+    def self.find_schemas!(type)
       schemas = find_schemas type
-      return schemas[version] if schemas
+      raise UnknownSchemaTypeError, "Unknown schema type #{type}" unless schemas
+
+      schemas
     end
-    nil
-  end
 
-  # get major.minor.patch part of a version string, where patch is optional
-  # ignore trailing characters, e.g.
-  #   3.1.3.32A => 3.1.3
-  #   3.1A3r3 >= 3.1
-  # return nil if string doesn't match
-  def self.sanitize_version version
-    # match normal semver z.y.z format
-    if matched = /^\d+\.\d+\.\d+/.match(version)
-      matched.to_s
-    # match x.y format, and add patch version zero to get z.y.0
-    elsif matched = /^\d+\.\d+/.match(version)
-      "#{matched.to_s}.0"
+    # find schema for a particular schema and version
+    # return nil if not found
+    def self.find_schema(type, version, options = {})
+      raise ArgumentError, 'version missing' unless version
+
+      version = sanitize_version version if options[:lenient]
+      if version
+        schemas = find_schemas type
+        return schemas[version] if schemas
+      end
+      nil
     end
-  end
 
-  # find schema for a particular schema and version
-  # raise error if not found
-  def self.find_schema! type, version, options={}
-    schema = find_schema type, version, options
-    raise ArgumentError.new("version missing") unless version
-    version = sanitize_version version if options[:lenient]
-    if version
-      schemas = find_schemas! type
-      schema = schemas[version]
-      return schema if schema
-    end
-    raise UnknownSchemaVersionError.new("Unknown schema version #{type} #{version}")
-  end
+    # get major.minor.patch part of a version string, where patch is optional
+    # ignore trailing characters, e.g.
+    #   3.1.3.32A => 3.1.3
+    #   3.1A3r3 >= 3.1
+    # return nil if string doesn't match
+    def self.sanitize_version(version)
+      # match normal semver z.y.z format
+      if (matched = /^\d+\.\d+\.\d+/.match(version))
+        matched.to_s
+      # match x.y format, and add patch version zero to get z.y.0
+      elsif (matched = /^\d+\.\d+/.match(version))
+        "#{matched}.0"
+      end
+    end
 
-  # true if a particular schema type and version found
-  def self.has_schema? type, version, options={}
-    find_schema(type,version, options) != nil
-  end
+    # find schema for a particular schema and version
+    # raise error if not found
+    def self.find_schema!(type, version, options = {})
+      schema = find_schema type, version, options
+      raise ArgumentError, 'version missing' unless version
+
+      version = sanitize_version version if options[:lenient]
+      if version
+        schemas = find_schemas! type
+        schema = schemas[version]
+        return schema if schema
+      end
+      raise UnknownSchemaVersionError, "Unknown schema version #{type} #{version}"
+    end
 
-  # validate using a particular schema and version
-  # raises error if schema is not found
-  # return nil if validation succeds, otherwise returns an array of errors
-  def self.validate message, schemas, options={}
-    raise ArgumentError.new("message missing") unless message
-    raise ArgumentError.new("schemas missing") unless schemas
-    raise ArgumentError.new("schemas must be a Hash") unless schemas.is_a?(Hash)
-    raise ArgumentError.new("schemas cannot be empty") unless schemas.any?
-    errors = schemas.flat_map do |type, version|
-      schema = find_schema! type, version, options
-      validate_using_schema(message, schema)
-    end
-    return nil if errors.empty?
-    errors
-  end
+    # true if a particular schema type and version found
+    def self.schema?(type, version, options = {})
+      find_schema(type, version, options) != nil
+    end
+
+    # return a catalogue of statuses for a particular schema type and version
+    # returns a hash of { status_code_id_sym => [arg_name_sym, ...] }
+    # raises an error if the schema type/version is not found, or has no sxl.yaml
+    def self.status_catalogue(type, version)
+      find_schema! type, version
+      schemas_path = File.expand_path(File.join(__dir__, '..', '..', 'schemas'))
+      yaml_path = File.join(schemas_path, type.to_s, version, 'sxl.yaml')
+      raise "No sxl.yaml for #{type} #{version}" unless File.exist?(yaml_path)
+
+      sxl = RSMP::Convert::Import::YAML.read(yaml_path)
+      sxl[:statuses].transform_keys(&:to_sym).transform_values do |status|
+        (status['arguments'] || {}).keys.map(&:to_sym)
+      end
+    end
+
+    # validate using a particular schema and version
+    # raises error if schema is not found
+    # return nil if validation succeds, otherwise returns an array of errors
+    def self.validate(message, schemas, options = {})
+      raise ArgumentError, 'message missing' unless message
+      raise ArgumentError, 'schemas missing' unless schemas
+      raise ArgumentError, 'schemas must be a Hash' unless schemas.is_a?(Hash)
+      raise ArgumentError, 'schemas cannot be empty' unless schemas.any?
+
+      errors = schemas.flat_map do |type, version|
+        schema = find_schema! type, version, options
+        validate_using_schema(message, schema)
+      end
+      return nil if errors.empty?
 
+      errors
+    end
+  end
 end

data/lib/rsmp_schema/version.rb

@@ -1,5 +1,6 @@
 module RSMP
   module Schema
-    VERSION = "0.9.1"
+    # Current version of the rsmp_schema gem.
+    VERSION = '0.10.1'.freeze
   end
-end
+end

data/lib/rsmp_schema.rb

@@ -1,7 +1,7 @@
 require 'yaml'
 require 'json_schemer'
 
-# Define module hierarchy first
+# RSMP (Road Side Message Protocol) schema validation library.
 module RSMP
 end
 
@@ -11,4 +11,4 @@ require 'rsmp_schema/convert/import/yaml'
 require 'rsmp_schema/convert/export/json_schema'
 require 'rsmp_schema/version'
 
-RSMP::Schema.setup
+RSMP::Schema.setup

data/rsmp_schema.gemspec

@@ -1,39 +1,37 @@
-lib = File.expand_path("lib", __dir__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'pathname'
-require_relative "lib/rsmp_schema/version"
+require_relative 'lib/rsmp_schema/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "rsmp_schema"
+  spec.name          = 'rsmp_schema'
   spec.version       = RSMP::Schema::VERSION
-  spec.authors       = ["Emil Tin"]
-  spec.email         = ["zf0f@kk.dk"]
+  spec.authors       = ['Emil Tin']
+  spec.email         = ['zf0f@kk.dk']
 
-  spec.summary       = "Validate RSMP message using RSMP JSON Schema."
-  spec.description   = "Validate RSMP message using RSMP JSON Schema. Support validating against core and different SXL's, in different versions."
-  spec.homepage      = "https://github.com/rsmp-nordic/rsmp_schema"
+  spec.summary       = 'Validate RSMP message using RSMP JSON Schema.'
+  spec.description   = 'Validate RSMP message using RSMP JSON Schema. Support validating against ' \
+                       "core and different SXL's, in different versions."
+  spec.homepage      = 'https://github.com/rsmp-nordic/rsmp_schema'
   spec.licenses      = ['MIT']
   spec.required_ruby_version = '>= 3.0.0'
 
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/CHANGELOG.md"
-  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/CHANGELOG.md"
+  spec.metadata['bug_tracker_uri'] = "#{spec.homepage}/issues"
+  spec.metadata['rubygems_mfa_required'] = 'true'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
 
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_dependency "json_schemer", "~> 2.4.0"
-  spec.add_dependency "thor", "~> 1.4.0"
-
-  spec.add_development_dependency "rake", "~> 13.3.0"
-  spec.add_development_dependency "rspec", "~> 3.13.0"
-  spec.add_development_dependency "rspec-expectations", "~> 3.13.0"
+  spec.add_dependency 'json_schemer', '~> 2.5'
+  spec.add_dependency 'thor', '~> 1.5'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rsmp_schema
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.1
 platform: ruby
 authors:
 - Emil Tin
 bindir: exe
 cert_chain: []
-date: 2025-09-19 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_schemer
@@ -15,70 +15,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.4.0
+        version: '2.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.4.0
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 13.3.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 13.3.0
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.13.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.13.0
-- !ruby/object:Gem::Dependency
-  name: rspec-expectations
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.13.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.13.0
+        version: '1.5'
 description: Validate RSMP message using RSMP JSON Schema. Support validating against
   core and different SXL's, in different versions.
 email:
@@ -94,6 +52,7 @@ files:
 - ".github/workflows/rspec.yaml"
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".tool-versions"
 - Gemfile
 - Gemfile.lock
@@ -966,6 +925,7 @@ metadata:
   source_code_uri: https://github.com/rsmp-nordic/rsmp_schema
   changelog_uri: https://github.com/rsmp-nordic/rsmp_schema/CHANGELOG.md
   bug_tracker_uri: https://github.com/rsmp-nordic/rsmp_schema/issues
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -980,7 +940,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Validate RSMP message using RSMP JSON Schema.
 test_files: []