rsmp 0.45.0 → 0.45.1

data/lib/rsmp/schema/validation.rb

@@ -0,0 +1,57 @@
+module RSMP
+  # Provides JSON Schema validation for RSMP messages across core and SXL versions.
+  module Schema
+    def self.core_message_type?(message)
+      type = message['type']
+      %w[
+        MessageAck
+        MessageNotAck
+        Version
+        ComponentList
+        AggregatedStatus
+        AggregatedStatusRequest
+        Watchdog
+      ].include?(type)
+    end
+
+    def self.validate_core(message, schemas, options)
+      core_version = schemas[:core] || schemas['core']
+      raise ArgumentError, 'schemas must include core' unless core_version
+
+      schema = find_schema! :core, core_version, options
+      validate_using_schema(message, schema)
+    end
+
+    def self.validate_sxls(message, schemas, options)
+      sxl_schemas = schemas.reject { |type, _version| type.to_sym == :core }
+      return [] if sxl_schemas.empty? || core_message_type?(message)
+
+      resolved = resolve_sxl(message, schemas: schemas, **options)
+      return validate_resolved_sxl(message, resolved, schemas, options) if resolved
+
+      all_errors = []
+      sxl_schemas.each do |type, version|
+        schema = find_core_sxl_schema! type, version, schema_core_version(schemas), options
+        errors = validate_using_schema(message, schema)
+        return [] if errors.empty?
+
+        all_errors.concat errors
+      end
+      all_errors
+    end
+
+    # Core must pass. SXL-defined messages pass if at least one SXL schema passes.
+    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 = validate_core(message, schemas, options)
+      errors.concat validate_sxls(message, schemas, options) if errors.empty?
+      return nil if errors.empty?
+
+      errors
+    end
+  end
+end

data/lib/rsmp/schema.rb

@@ -1,6 +1,5 @@
 require 'json_schemer'
 require 'json'
-require 'yaml'
 
 # RSMP (Road Side Message Protocol) schema validation library.
 module RSMP
@@ -11,13 +10,19 @@ module RSMP
     def self.setup
       @schemas = {}
       @schema_paths = {}
-      schemas_path = File.expand_path(File.join(__dir__, '..', '..', 'schemas'))
+      @sxl_indexes = {}
+      @core_sxl_schemas = {}
+      schemas_path = schema_root_path
       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
 
+    def self.schema_root_path
+      File.expand_path(File.join(__dir__, '..', '..', 'schemas'))
+    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
@@ -35,6 +40,8 @@ module RSMP
       @schemas[type] = {}
       @schema_paths ||= {}
       @schema_paths[type] = {}
+      clear_sxl_index(type)
+      clear_core_sxl_schemas(type)
       schema_version_paths(type_path).each { |schema_path| load_schema_version(type, schema_path) }
     end
 
@@ -53,6 +60,8 @@ module RSMP
 
       @schemas[type][version] = JSONSchemer.schema(Pathname.new(file_path))
       @schema_paths[type][version] = schema_path
+      clear_sxl_index(type, version)
+      clear_core_sxl_schemas(type, version)
     end
 
     # remove a schema type
@@ -60,6 +69,8 @@ module RSMP
       type = type.to_sym
       schemas.delete type
       @schema_paths&.delete type
+      clear_sxl_index(type)
+      clear_core_sxl_schemas(type)
     end
 
     # get schemas types
@@ -195,14 +206,7 @@ module RSMP
       version = sanitize_version version if options[:lenient]
       find_schema! type, version
 
-      path = @schema_paths&.dig(type.to_sym, version)
-      return {} unless path
-
-      yaml_path = File.join(path, 'sxl.yaml')
-      return YAML.load_file(yaml_path).fetch('meta', {}) if File.exist?(yaml_path)
-
-      json_path = File.join(path, 'rsmp.json')
-      File.exist?(json_path) ? JSON.parse(File.read(json_path)) : {}
+      sxl_index(type, version).fetch('meta', {})
     end
 
     def self.sxl_prefix(type, version, options = {})
@@ -211,82 +215,51 @@ module RSMP
 
     # 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
+    # raises an error if the schema type/version is not found, or has no status catalogue
     def self.status_catalogue(type, version)
       sxl_catalogue(type, version, :statuses).transform_keys(&:to_sym).transform_values do |status|
-        (status['arguments'] || {}).keys.map(&:to_sym)
+        status.fetch('arguments', []).map(&:to_sym)
       end
     end
 
     def self.sxl_catalogue(type, version, kind)
       find_schema! type, version
-      schema_path = @schema_paths&.dig(type.to_sym, version)
-      yaml_path = File.join(schema_path, 'sxl.yaml') if schema_path
-      raise "No sxl.yaml for #{type} #{version}" unless yaml_path && File.exist?(yaml_path)
-
-      sxl = RSMP::Convert::Import::YAML.read(yaml_path)
-      sxl.fetch(kind)
-    end
-
-    def self.core_message_type?(message)
-      type = message['type']
-      %w[
-        MessageAck
-        MessageNotAck
-        Version
-        ComponentList
-        AggregatedStatus
-        AggregatedStatusRequest
-        Watchdog
-      ].include?(type)
-    end
+      catalogue = sxl_index(type, version)[kind.to_s]
+      raise "No #{kind} catalogue for #{type} #{version}" unless catalogue
 
-    def self.validate_core(message, schemas, options)
-      core_version = schemas[:core] || schemas['core']
-      raise ArgumentError, 'schemas must include core' unless core_version
-
-      schema = find_schema! :core, core_version, options
-      validate_using_schema(message, schema)
+      catalogue
     end
 
-    def self.validate_sxls(message, schemas, options)
-      sxl_schemas = schemas.reject { |type, _version| type.to_sym == :core }
-      return [] if sxl_schemas.empty? || core_message_type?(message)
+    def self.clear_sxl_index(type = nil, version = nil)
+      @sxl_indexes ||= {}
+      return @sxl_indexes.clear unless type
 
-      resolved = resolve_sxl(message, schemas: schemas, **options)
-      if resolved
-        type, version = resolved
-        schema = find_schema! type, version, options
-        return validate_using_schema(message, schema)
+      type = type.to_sym
+      if version
+        @sxl_indexes.delete([type, version.to_s])
+      else
+        @sxl_indexes.delete_if { |key, _value| key.first == type }
       end
+    end
 
-      all_errors = []
-      sxl_schemas.each do |type, version|
-        schema = find_schema! type, version, options
-        errors = validate_using_schema(message, schema)
-        return [] if errors.empty?
-
-        all_errors.concat errors
-      end
-      all_errors
+    def self.sxl_index(type, version)
+      key = [type.to_sym, version.to_s]
+      @sxl_indexes ||= {}
+      @sxl_indexes[key] ||= load_sxl_index(type, version)
     end
 
-    # validate using core and optional SXL schemas.
-    # Core must pass. SXL-defined messages pass if at least one SXL schema passes.
-    # returns nil if validation succeeds, 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?
+    def self.load_sxl_index(type, version)
+      schema_path = @schema_paths&.dig(type.to_sym, version.to_s)
+      raise UnknownSchemaVersionError, "Unknown schema version #{type} #{version}" unless schema_path
 
-      errors = validate_core(message, schemas, options)
-      errors.concat validate_sxls(message, schemas, options) if errors.empty?
-      return nil if errors.empty?
+      index_path = File.join(schema_path, 'sxl_index.json')
+      raise Error, "Missing SXL index #{index_path}" unless File.exist?(index_path)
 
-      errors
+      JSON.parse(File.read(index_path, encoding: 'UTF-8'))
     end
   end
 end
 
+require_relative 'schema/core_sxl_resolution'
 require_relative 'schema/message_resolution'
+require_relative 'schema/validation'

data/lib/rsmp/version.rb

@@ -1,3 +1,3 @@
 module RSMP
-  VERSION = '0.45.0'.freeze
+  VERSION = '0.45.1'.freeze
 end

data/schemas/tlc/1.0.10/rsmp.json

@@ -70,5 +70,6 @@
         "$ref" : "alarms/alarms.json"
       }
     }
-  ]
+  ],
+  "minimum_core_version" : "3.1.2"
 }

data/schemas/tlc/1.0.10/sxl.yaml

@@ -3,6 +3,7 @@ meta:
   name: tlc
   description: Traffic Light Controllers
   version: 1.0.10
+  minimum_core_version: 3.1.2
 objects:
   Traffic Light Controller:
     description:

data/schemas/tlc/1.0.10/sxl_index.json

@@ -0,0 +1,356 @@
+{
+  "meta" : {
+    "name" : "tlc",
+    "description" : "Traffic Light Controllers",
+    "version" : "1.0.10",
+    "minimum_core_version" : "3.1.2"
+  },
+  "statuses" : {
+    "S0001" : {
+      "arguments" : [
+        "basecyclecounter",
+        "cyclecounter",
+        "signalgroupstatus",
+        "stage"
+      ]
+    },
+    "S0002" : {
+      "arguments" : [
+        "detectorlogicstatus"
+      ]
+    },
+    "S0003" : {
+      "arguments" : [
+        "extendedinputstatus",
+        "inputstatus"
+      ]
+    },
+    "S0004" : {
+      "arguments" : [
+        "extendedoutputstatus",
+        "outputstatus"
+      ]
+    },
+    "S0005" : {
+      "arguments" : [
+        "status"
+      ]
+    },
+    "S0006" : {
+      "arguments" : [
+        "emergencystage",
+        "status"
+      ]
+    },
+    "S0007" : {
+      "arguments" : [
+        "intersection",
+        "status"
+      ]
+    },
+    "S0008" : {
+      "arguments" : [
+        "intersection",
+        "status"
+      ]
+    },
+    "S0009" : {
+      "arguments" : [
+        "intersection",
+        "status"
+      ]
+    },
+    "S0010" : {
+      "arguments" : [
+        "intersection",
+        "status"
+      ]
+    },
+    "S0011" : {
+      "arguments" : [
+        "intersection",
+        "status"
+      ]
+    },
+    "S0012" : {
+      "arguments" : [
+        "intersection",
+        "status"
+      ]
+    },
+    "S0013" : {
+      "arguments" : [
+        "intersection",
+        "status"
+      ]
+    },
+    "S0014" : {
+      "arguments" : [
+        "status"
+      ]
+    },
+    "S0015" : {
+      "arguments" : [
+        "status"
+      ]
+    },
+    "S0016" : {
+      "arguments" : [
+        "number"
+      ]
+    },
+    "S0017" : {
+      "arguments" : [
+        "number"
+      ]
+    },
+    "S0018" : {
+      "arguments" : [
+        "number"
+      ]
+    },
+    "S0019" : {
+      "arguments" : [
+        "number"
+      ]
+    },
+    "S0020" : {
+      "arguments" : [
+        "controlmode",
+        "intersection"
+      ]
+    },
+    "S0021" : {
+      "arguments" : [
+        "detectorlogics"
+      ]
+    },
+    "S0091" : {
+      "arguments" : [
+        "status",
+        "user"
+      ]
+    },
+    "S0092" : {
+      "arguments" : [
+        "status",
+        "user"
+      ]
+    },
+    "S0095" : {
+      "arguments" : [
+        "status"
+      ]
+    },
+    "S0096" : {
+      "arguments" : [
+        "day",
+        "hour",
+        "minute",
+        "month",
+        "second",
+        "year"
+      ]
+    },
+    "S0201" : {
+      "arguments" : [
+        "starttime",
+        "vehicles"
+      ]
+    },
+    "S0202" : {
+      "arguments" : [
+        "speed",
+        "starttime"
+      ]
+    },
+    "S0203" : {
+      "arguments" : [
+        "occupancy",
+        "starttime"
+      ]
+    },
+    "S0204" : {
+      "arguments" : [
+        "B",
+        "C",
+        "F",
+        "L",
+        "LS",
+        "MC",
+        "P",
+        "PS",
+        "SP",
+        "starttime"
+      ]
+    }
+  },
+  "commands" : {
+    "M0001" : {
+      "arguments" : [
+        "intersection",
+        "securityCode",
+        "status",
+        "timeout"
+      ]
+    },
+    "M0002" : {
+      "arguments" : [
+        "securityCode",
+        "status",
+        "timeplan"
+      ]
+    },
+    "M0003" : {
+      "arguments" : [
+        "securityCode",
+        "status",
+        "traficsituation"
+      ]
+    },
+    "M0004" : {
+      "arguments" : [
+        "securityCode",
+        "status"
+      ]
+    },
+    "M0005" : {
+      "arguments" : [
+        "emergencyroute",
+        "securityCode",
+        "status"
+      ]
+    },
+    "M0006" : {
+      "arguments" : [
+        "input",
+        "securityCode",
+        "status"
+      ]
+    },
+    "M0007" : {
+      "arguments" : [
+        "securityCode",
+        "status"
+      ]
+    },
+    "M0008" : {
+      "arguments" : [
+        "mode",
+        "securityCode",
+        "status"
+      ]
+    },
+    "M0010" : {
+      "arguments" : [
+        "securityCode",
+        "status"
+      ]
+    },
+    "M0011" : {
+      "arguments" : [
+        "securityCode",
+        "status"
+      ]
+    },
+    "M0012" : {
+      "arguments" : [
+        "securityCode",
+        "status"
+      ]
+    },
+    "M0013" : {
+      "arguments" : [
+        "securityCode",
+        "status"
+      ]
+    },
+    "M0019" : {
+      "arguments" : [
+        "input",
+        "inputValue",
+        "securityCode",
+        "status"
+      ]
+    },
+    "M0103" : {
+      "arguments" : [
+        "newSecurityCode",
+        "oldSecurityCode",
+        "status"
+      ]
+    },
+    "M0104" : {
+      "arguments" : [
+        "day",
+        "hour",
+        "minute",
+        "month",
+        "second",
+        "securityCode",
+        "year"
+      ]
+    }
+  },
+  "alarms" : {
+    "A0001" : {
+      "arguments" : []
+    },
+    "A0002" : {
+      "arguments" : []
+    },
+    "A0003" : {
+      "arguments" : []
+    },
+    "A0004" : {
+      "arguments" : []
+    },
+    "A0005" : {
+      "arguments" : []
+    },
+    "A0006" : {
+      "arguments" : []
+    },
+    "A0007" : {
+      "arguments" : []
+    },
+    "A0008" : {
+      "arguments" : [
+        "timeplan"
+      ]
+    },
+    "A0009" : {
+      "arguments" : []
+    },
+    "A0101" : {
+      "arguments" : []
+    },
+    "A0201" : {
+      "arguments" : [
+        "color"
+      ]
+    },
+    "A0202" : {
+      "arguments" : [
+        "color"
+      ]
+    },
+    "A0301" : {
+      "arguments" : [
+        "detector",
+        "errormode",
+        "manual",
+        "type"
+      ]
+    },
+    "A0302" : {
+      "arguments" : [
+        "detector",
+        "errormode",
+        "logicerror",
+        "manual",
+        "type"
+      ]
+    }
+  }
+}

data/schemas/tlc/1.0.13/rsmp.json

@@ -70,5 +70,6 @@
         "$ref" : "alarms/alarms.json"
       }
     }
-  ]
+  ],
+  "minimum_core_version" : "3.1.2"
 }

data/schemas/tlc/1.0.13/sxl.yaml

@@ -3,6 +3,7 @@ meta:
   name: tlc
   description: Traffic Light Controllers
   version: 1.0.13
+  minimum_core_version: 3.1.2
 objects:
   Traffic Light Controller:
     description: