modspec 0.1.4 → 0.2.1

data/spec/modspec/conformance_test_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Modspec::ConformanceTest do
     Modspec::NormativeStatement.new(
       identifier: "/req/basic-ypr/position",
       name: "Expression of outer frame",
-      statement: "The `Basic_YPR.position` attribute shall represent the outer frame, specified by an implicit WGS-84 CRS and an implicit EPSG 4461-CS (LTP-ENU) coordinate system and explicit parameters to define the tangent point."
+      statement: "The `Basic_YPR.position` attribute shall represent the outer frame.",
     )
   end
 
@@ -13,18 +13,18 @@ RSpec.describe Modspec::ConformanceTest do
     Modspec::NormativeStatementsClass.new(
       identifier: "/req/basic-ypr",
       name: "Basic-YPR logical model SDU",
-      normative_statements: [normative_statement]
+      normative_statements: [normative_statement],
     )
   end
 
   let(:conformance_test) do
-    Modspec::ConformanceTest.new(
+    described_class.new(
       identifier: "/conf/basic-ypr/position",
       name: "Verify expression of outer frame",
       targets: ["/req/basic-ypr/position"],
-      description: "To confirm that an implementation of a Basic-YPR consists of an Outer Frame specified by an implicit WGS-84 CRS and an implicit EPSG 4461-CS (LTP-ENU) coordinate system and explicit parameters to define the tangent point.",
+      description: "To confirm outer frame.",
       purpose: "Verify that this requirement is satisfied.",
-      method: "Inspection"
+      test_method: "Inspection",
     )
   end
 
@@ -32,7 +32,7 @@ RSpec.describe Modspec::ConformanceTest do
     Modspec::ConformanceClass.new(
       identifier: "/conf/basic-ypr",
       name: "Basic-YPR logical model SDU conformance",
-      tests: [conformance_test]
+      tests: [conformance_test],
     )
   end
 
@@ -45,7 +45,7 @@ RSpec.describe Modspec::ConformanceTest do
   end
 
   before do
-    suite # Ensure the suite is created and relationships are set up
+    suite
   end
 
   it "has an identifier" do
@@ -65,7 +65,26 @@ RSpec.describe Modspec::ConformanceTest do
       errors = conformance_test.validate
       expect(errors).to be_empty
     end
+
+    it "returns errors when corresponding_requirements is nil" do
+      conformance_test.corresponding_requirements = nil
+      errors = conformance_test.validate
+      expect(errors).to include(a_string_matching(/no corresponding requirements/))
+    end
+
+    it "returns errors when corresponding_requirements is empty" do
+      conformance_test.corresponding_requirements = []
+      errors = conformance_test.validate
+      expect(errors).to include(a_string_matching(/no corresponding requirements/))
+    end
+
+    it "returns errors when parent_class is nil" do
+      conformance_test.parent_class = nil
+      errors = conformance_test.validate
+      expect(errors).to include(a_string_matching(/does not belong to its parent class/))
+    end
   end
+
   it "has a corresponding requirement" do
     expect(conformance_test.corresponding_requirements).to include(normative_statement)
   end

data/spec/modspec/normative_statement_spec.rb

@@ -2,23 +2,23 @@
 
 RSpec.describe Modspec::NormativeStatement do
   let(:global_sdu_statement) do
-    Modspec::NormativeStatement.new(
+    described_class.new(
       identifier: "/req/global/sdu",
       name: "SDU conforms to the 'Structural Data Unit - SDU' stereotype",
-      statement: "Implementations using encoded SDUs SHALL conform to the logical description of the Logical Model elements with the 'Structural Data Unit - SDU' stereotype."
+      statement: "Implementations using encoded SDUs SHALL conform to the logical description of the Logical Model elements with the 'Structural Data Unit - SDU' stereotype.",
     )
   end
 
   let(:tangent_point_statement) do
-    Modspec::NormativeStatement.new(
+    described_class.new(
       identifier: "/req/tangent-point",
       name: "Tangent point requirements",
-      statement: "Common tangent point requirements for SDUs that include tangent points."
+      statement: "Common tangent point requirements for SDUs that include tangent points.",
     )
   end
 
   let(:normative_statement) do
-    Modspec::NormativeStatement.new(
+    described_class.new(
       identifier: "/req/basic-ypr/position",
       name: "Expression of outer frame",
       statement: "The `Basic_YPR.position` attribute shall represent the outer frame, specified by an implicit WGS-84 CRS and an implicit EPSG 4461-CS (LTP-ENU) coordinate system and explicit parameters to define the tangent point.",
@@ -26,7 +26,7 @@ RSpec.describe Modspec::NormativeStatement do
       subject: "Basic_YPR.position",
       inherit: ["/req/global/sdu"],
       dependencies: ["/req/tangent-point"],
-      guidance: ["Ensure the coordinate system is correctly specified."]
+      guidance: ["Ensure the coordinate system is correctly specified."],
     )
   end
 
@@ -34,17 +34,18 @@ RSpec.describe Modspec::NormativeStatement do
     suite = Modspec::Suite.new
     global_class = Modspec::NormativeStatementsClass.new(
       identifier: "/req/global",
-      normative_statements: [global_sdu_statement]
+      normative_statements: [global_sdu_statement],
     )
     tangent_point_class = Modspec::NormativeStatementsClass.new(
       identifier: "/req/tangent-point",
-      normative_statements: [tangent_point_statement]
+      normative_statements: [tangent_point_statement],
     )
     basic_ypr_class = Modspec::NormativeStatementsClass.new(
       identifier: "/req/basic-ypr",
-      normative_statements: [normative_statement]
+      normative_statements: [normative_statement],
     )
-    suite.normative_statements_classes = [global_class, tangent_point_class, basic_ypr_class]
+    suite.normative_statements_classes = [global_class, tangent_point_class,
+                                          basic_ypr_class]
     suite
   end
 
@@ -61,7 +62,8 @@ RSpec.describe Modspec::NormativeStatement do
   end
 
   it "has a valid obligation" do
-    expect(%w[requirement recommendation permission]).to include(normative_statement.obligation)
+    expect(%w[requirement recommendation
+              permission]).to include(normative_statement.obligation)
   end
 
   describe "#validate" do
@@ -72,7 +74,9 @@ RSpec.describe Modspec::NormativeStatement do
 
     it "returns errors for an invalid obligation" do
       normative_statement.obligation = "invalid"
-      expect { normative_statement.validate! }.to raise_error(Lutaml::Model::ValidationError) do |error|
+      expect do
+        normative_statement.validate!
+      end.to raise_error(Lutaml::Model::ValidationError) do |error|
         expect(error).to include(Lutaml::Model::InvalidValueError)
         expect(error.error_messages).to include("obligation is `invalid`, must be one of the following [recommendation, permission, requirement]")
       end

data/spec/modspec/normative_statements_class_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Modspec::NormativeStatementsClass do
     Modspec::NormativeStatement.new(
       identifier: "/req/basic-ypr/position",
       name: "Expression of outer frame",
-      statement: "The `Basic_YPR.position` attribute shall represent the outer frame, specified by an implicit WGS-84 CRS and an implicit EPSG 4461-CS (LTP-ENU) coordinate system and explicit parameters to define the tangent point."
+      statement: "The `Basic_YPR.position` attribute shall represent the outer frame.",
     )
   end
 
@@ -13,17 +13,17 @@ RSpec.describe Modspec::NormativeStatementsClass do
     Modspec::NormativeStatement.new(
       identifier: "/req/basic-ypr/angles",
       name: "Expression of inner frame",
-      statement: "The `Basic_YPR.angles` attribute shall represent the inner frame, which is a rotation-only transformation with Yaw, Pitch, and Roll (YPR) angles."
+      statement: "The `Basic_YPR.angles` attribute shall represent the inner frame.",
     )
   end
 
   let(:normative_statements_class) do
-    Modspec::NormativeStatementsClass.new(
+    described_class.new(
       identifier: "/req/basic-ypr",
       name: "Basic-YPR logical model SDU",
-      description: "The Basic-YPR Target has a simple structure with no options. Position is specified as a point in an LTP-ENU frame and rotation is specified by yaw, pitch, and roll angles specified in decimal degrees.",
+      description: "The Basic-YPR Target has a simple structure.",
       dependencies: ["/req/global", "/req/tangent-point"],
-      normative_statements: [normative_statement1, normative_statement2]
+      normative_statements: [normative_statement1, normative_statement2],
     )
   end
 
@@ -55,7 +55,19 @@ RSpec.describe Modspec::NormativeStatementsClass do
     it "returns errors if there are no normative statements" do
       normative_statements_class.normative_statements = []
       errors = normative_statements_class.validate
-      expect(errors).not_to be_empty
+      expect(errors).to include(a_string_matching(/no child requirements/))
+    end
+
+    it "returns errors if statement identifier does not share prefix" do
+      normative_statements_class.normative_statements = [
+        Modspec::NormativeStatement.new(
+          identifier: "/req/other/mismatch",
+          name: "Mismatched",
+          statement: "stmt",
+        ),
+      ]
+      errors = normative_statements_class.validate
+      expect(errors).to include(a_string_matching(/does not share the expected prefix/))
     end
   end
 end

data/spec/modspec/suite_spec.rb

@@ -9,10 +9,10 @@ RSpec.describe Modspec::Suite do
   let(:time_rc) { File.read("spec/fixtures/time-rc.yaml") }
   let(:frame_spec_rc) { File.read("spec/fixtures/frame-spec-rc.yaml") }
 
-  let(:global_suite) { Modspec::Suite.from_yaml(global_rc) }
-  let(:tangent_point_suite) { Modspec::Suite.from_yaml(tangent_point_rc) }
-  let(:time_suite) { Modspec::Suite.from_yaml(time_rc) }
-  let(:frame_spec_suite) { Modspec::Suite.from_yaml(frame_spec_rc) }
+  let(:global_suite) { described_class.from_yaml(global_rc) }
+  let(:tangent_point_suite) { described_class.from_yaml(tangent_point_rc) }
+  let(:time_suite) { described_class.from_yaml(time_rc) }
+  let(:frame_spec_suite) { described_class.from_yaml(frame_spec_rc) }
 
   describe ".from_yaml" do
     it "parses a requirements class YAML file" do
@@ -32,46 +32,218 @@ RSpec.describe Modspec::Suite do
     it "returns no errors for a valid combined suite" do
       base_suite = described_class.from_yaml(rc_yaml)
       combined_suite = base_suite
-                       .combine(global_suite)
-                       .combine(tangent_point_suite)
-                       .combine(time_suite)
-                       .combine(frame_spec_suite)
+        .combine(global_suite)
+        .combine(tangent_point_suite)
+        .combine(time_suite)
+        .combine(frame_spec_suite)
 
       errors = combined_suite.validate
-      if errors.any?
-        puts "Validation errors:"
-        errors.each { |error| puts "  #{error}" }
-      end
       expect(errors).to be_empty
     end
+
+    it "detects duplicate identifiers" do
+      suite = described_class.new(
+        identifier: "/suite",
+        name: "Test",
+        normative_statements_classes: [
+          Modspec::NormativeStatementsClass.new(
+            identifier: "/req/test",
+            normative_statements: [
+              Modspec::NormativeStatement.new(identifier: "/req/test/a",
+                                              name: "A", statement: "a"),
+              Modspec::NormativeStatement.new(identifier: "/req/test/a",
+                                              name: "A2", statement: "a2"),
+            ],
+          ),
+        ],
+        conformance_classes: [],
+      )
+
+      errors = suite.validate
+      expect(errors).to include(a_string_matching(/Duplicate identifier/))
+    end
+
+    it "detects dependency cycles" do
+      ns_a = Modspec::NormativeStatement.new(
+        identifier: "/req/test/a", name: "A", statement: "a",
+        dependencies: ["/req/test/b"]
+      )
+      ns_b = Modspec::NormativeStatement.new(
+        identifier: "/req/test/b", name: "B", statement: "b",
+        dependencies: ["/req/test/a"]
+      )
+
+      suite = described_class.new(
+        identifier: "/suite",
+        name: "Test",
+        normative_statements_classes: [
+          Modspec::NormativeStatementsClass.new(
+            identifier: "/req/test",
+            normative_statements: [ns_a, ns_b],
+          ),
+        ],
+        conformance_classes: [],
+      )
+
+      errors = suite.validate
+      expect(errors).to include(a_string_matching(/Cycle detected/))
+    end
+
+    it "detects invalid dependencies" do
+      suite = described_class.new(
+        identifier: "/suite",
+        name: "Test",
+        normative_statements_classes: [
+          Modspec::NormativeStatementsClass.new(
+            identifier: "/req/test",
+            dependencies: ["/req/nonexistent"],
+            normative_statements: [
+              Modspec::NormativeStatement.new(
+                identifier: "/req/test/a", name: "A", statement: "a",
+                dependencies: ["/req/missing"]
+              ),
+            ],
+          ),
+        ],
+        conformance_classes: [],
+      )
+
+      errors = suite.validate
+      expect(errors).to include(a_string_matching(/Invalid dependencies .* in \/req\/test\b/))
+      expect(errors).to include(a_string_matching(/Invalid dependencies .* in \/req\/test\/a/))
+    end
+
+    it "detects invalid conformance test targets" do
+      suite = described_class.new(
+        identifier: "/suite",
+        name: "Test",
+        normative_statements_classes: [
+          Modspec::NormativeStatementsClass.new(
+            identifier: "/req/test",
+            normative_statements: [
+              Modspec::NormativeStatement.new(identifier: "/req/test/a",
+                                              name: "A", statement: "a"),
+            ],
+          ),
+        ],
+        conformance_classes: [
+          Modspec::ConformanceClass.new(
+            identifier: "/conf/test",
+            tests: [
+              Modspec::ConformanceTest.new(
+                identifier: "/conf/test/a",
+                name: "CT-A",
+                targets: ["/req/nonexistent"],
+              ),
+            ],
+          ),
+        ],
+      )
+
+      errors = suite.validate
+      expect(errors).to include(a_string_matching(/Invalid targets .* in \/conf\/test\/a/))
+    end
+
+    it "detects invalid indirect_dependency references" do
+      suite = described_class.new(
+        identifier: "/suite",
+        name: "Test",
+        normative_statements_classes: [
+          Modspec::NormativeStatementsClass.new(
+            identifier: "/req/test",
+            normative_statements: [
+              Modspec::NormativeStatement.new(
+                identifier: "/req/test/a", name: "A", statement: "a",
+                indirect_dependency: ["/req/ghost"]
+              ),
+            ],
+          ),
+        ],
+        conformance_classes: [],
+      )
+
+      errors = suite.validate
+      expect(errors).to include(a_string_matching(/indirect dependency.*in \/req\/test\/a/))
+    end
+
+    it "detects invalid implements references" do
+      suite = described_class.new(
+        identifier: "/suite",
+        name: "Test",
+        normative_statements_classes: [
+          Modspec::NormativeStatementsClass.new(
+            identifier: "/req/test",
+            implements: ["/req/phantom"],
+            normative_statements: [],
+          ),
+        ],
+        conformance_classes: [],
+      )
+
+      errors = suite.validate
+      expect(errors).to include(a_string_matching(/implements.*in \/req\/test/))
+    end
+
+    it "detects invalid conformance test dependencies" do
+      suite = described_class.new(
+        identifier: "/suite",
+        name: "Test",
+        normative_statements_classes: [],
+        conformance_classes: [
+          Modspec::ConformanceClass.new(
+            identifier: "/conf/test",
+            tests: [
+              Modspec::ConformanceTest.new(
+                identifier: "/conf/test/a",
+                name: "CT-A",
+                dependencies: ["/conf/nonexistent"],
+              ),
+            ],
+          ),
+        ],
+      )
+
+      errors = suite.validate
+      expect(errors).to include(a_string_matching(/Invalid dependencies .* in \/conf\/test\/a/))
+    end
   end
 
   describe "#combine" do
-    let(:suite1) { described_class.from_yaml(File.read("spec/fixtures/basic-ypr-rc.yaml")) }
-    let(:suite2) { described_class.from_yaml(File.read("spec/fixtures/basic-quaternion-rc.yaml")) }
+    let(:suite1) do
+      described_class.from_yaml(File.read("spec/fixtures/basic-ypr-rc.yaml"))
+    end
+    let(:suite2) do
+      described_class.from_yaml(File.read("spec/fixtures/basic-quaternion-rc.yaml"))
+    end
 
     it "combines two suites" do
       combined_suite = suite1.combine(suite2)
       expect(combined_suite.name).to eq("#{suite1.name} + #{suite2.name}")
       expect(combined_suite.normative_statements_classes.count).to eq(
         suite1.normative_statements_classes.count +
-        suite2.normative_statements_classes.count
+        suite2.normative_statements_classes.count,
       )
     end
 
+    it "raises ArgumentError for non-Suite argument" do
+      expect { suite1.combine("not a suite") }.to raise_error(ArgumentError)
+    end
+
+    it "deduplicates by identifier" do
+      combined = suite1.combine(suite1)
+      nsc_count = combined.normative_statements_classes.count
+      expect(nsc_count).to eq(suite1.normative_statements_classes.count)
+    end
+
     it "resolves conflicts when combining suites" do
       combined_suite = suite1
-                       .combine(suite2)
-                       .combine(global_suite)
-                       .combine(tangent_point_suite)
-                       .combine(time_suite)
-                       .combine(frame_spec_suite)
+        .combine(suite2)
+        .combine(global_suite)
+        .combine(tangent_point_suite)
+        .combine(time_suite)
+        .combine(frame_spec_suite)
 
       errors = combined_suite.validate
-      if errors.any?
-        puts "Validation errors:"
-        errors.each { |error| puts "  #{error}" }
-      end
       expect(errors).to be_empty
     end
   end
@@ -85,24 +257,13 @@ RSpec.describe Modspec::Suite do
       expect(combined_suite).to be_a(described_class)
       expect(combined_suite.name).to eq("Combined Suite")
 
-      # Ensure the combined suite has content
       expect(combined_suite.normative_statements_classes).not_to be_empty
       expect(combined_suite.conformance_classes).not_to be_empty
 
-      # Validate the combined suite
       errors = combined_suite.validate
-
-      if errors.any?
-        puts "Validation errors:"
-        errors.each { |error| puts "  #{error}" }
-      end
-
-      # Check for specific error types
-      expect(errors).not_to include(a_string_matching(/Conformance test .* has no corresponding requirement/))
+      expect(errors).not_to include(a_string_matching(/has no corresponding requirement/))
       expect(errors).not_to include(a_string_matching(/Cycle detected/))
-      expect(errors).not_to include(a_string_matching(/Requirement .* has an invalid dependency/))
-
-      # If there are still errors, they should be of a different nature
+      expect(errors).not_to include(a_string_matching(/has an invalid dependency/))
       expect(errors).to be_empty
     end
   end

data/spec/modspec_spec.rb

@@ -2,24 +2,24 @@
 
 RSpec.describe Modspec do
   it "has a version number" do
-    expect(Modspec::VERSION).not_to be nil
+    expect(Modspec::VERSION).not_to be_nil
   end
 
   Dir.glob("spec/fixtures/*-rc.yaml").each do |file|
     it "parses normative statements class #{file}" do
-      yaml = IO.read(file)
-      Modspec::Suite.from_yaml(yaml)
+      source_yaml = File.read(file)
+      output_yaml = Modspec::Suite.from_yaml(source_yaml).to_yaml
 
-      # TODO: tests
+      expect(output_yaml).to be_yaml_equivalent_to(source_yaml)
     end
   end
 
   Dir.glob("spec/fixtures/*-cc.yaml").each do |file|
     it "parses conformance class #{file}" do
-      yaml = IO.read(file)
-      Modspec::Suite.from_yaml(yaml)
+      source_yaml = File.read(file)
+      output_yaml = Modspec::Suite.from_yaml(source_yaml).to_yaml
 
-      # TODO: tests
+      expect(output_yaml).to be_yaml_equivalent_to(source_yaml)
     end
   end
 end

data/spec/spec_helper.rb

@@ -2,6 +2,7 @@
 
 require "modspec"
 require "yaml"
+require "canon"
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modspec
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.1
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-28 00:00:00.000000000 Z
+date: 2026-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: 0.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -65,6 +65,7 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
+- CLAUDE.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - README.adoc
@@ -137,6 +138,7 @@ metadata:
   homepage_uri: https://github.com/metanorma/modspec-ruby
   source_code_uri: https://github.com/metanorma/modspec-ruby
   bug_tracker_uri: https://github.com/metanorma/modspec-ruby/issues
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths: