modspec 0.1.0 → 0.1.1

data/lib/modspec/conformance_class.rb

@@ -1,19 +1,21 @@
-require "shale"
-require_relative "./conformance_test"
-require_relative "./identifier"
+# frozen_string_literal: true
 
-module Modspec
+require "lutaml/model"
+require_relative "conformance_test"
+require_relative "identifier"
 
-  class ConformanceClass < Shale::Mapper
+module Modspec
+  class ConformanceClass < Lutaml::Model::Serializable
     attribute :identifier, Identifier
-    attribute :name, Shale::Type::String
-    attribute :description, Shale::Type::String
-    attribute :classification, Shale::Type::String
+    attribute :name, :string
+    attribute :description, :string
+    attribute :guidance, :string, collection: true
+    attribute :classification, :string
     attribute :dependencies, Identifier, collection: true
     attribute :target, Identifier, collection: true
     attribute :tests, ConformanceTest, collection: true
     attribute :belongs_to, Identifier, collection: true
-    attribute :reference, Shale::Type::String
+    attribute :reference, :string
 
     xml do
       root "conformance-class"
@@ -25,8 +27,35 @@ module Modspec
       map_element "tests", to: :tests
       map_element "belongs_to", to: :belongs_to
       map_element "description", to: :description
+      map_element "guidance", to: :guidance
       map_element "reference", to: :reference
     end
-  end
 
+    def validate
+      errors = super()
+      errors.concat(validate_identifier_prefix)
+      errors.concat(validate_class_children_mapping)
+      errors.concat(tests.flat_map(&:validate))
+      errors
+    end
+
+    private
+
+    def validate_class_children_mapping
+      if tests.empty?
+        ["Conformance class #{identifier} has no child conformance tests"]
+      else
+        []
+      end
+    end
+
+    def validate_identifier_prefix
+      errors = []
+      expected_prefix = "#{identifier}/"
+      tests.each do |test|
+        errors << "Conformance test #{test.identifier} does not share the expected prefix #{expected_prefix}" unless test.identifier.to_s.start_with?(expected_prefix)
+      end
+      errors
+    end
+  end
 end

data/lib/modspec/conformance_test.rb

@@ -1,21 +1,22 @@
-require "shale"
-require_relative "./identifier"
+# frozen_string_literal: true
 
-module Modspec
+require "lutaml/model"
+require_relative "identifier"
 
-  class ConformanceTest < Shale::Mapper
+module Modspec
+  class ConformanceTest < Lutaml::Model::Serializable
     attribute :identifier, Identifier
-    attribute :name, Shale::Type::String
+    attribute :name, :string
     attribute :dependencies, Identifier, collection: true
     attribute :targets, Identifier, collection: true
     attribute :belongs_to, Identifier, collection: true
-    attribute :description, Shale::Type::String
-    attribute :guidance, Shale::Type::String, collection: true
-    attribute :purpose, Shale::Type::String
-    attribute :method, Shale::Type::String # Inspection, etc.
-    attribute :type, Shale::Type::String
-    attribute :reference, Shale::Type::String
-    attribute :abstract, Shale::Type::Boolean
+    attribute :description, :string
+    attribute :guidance, :string, collection: true
+    attribute :purpose, :string
+    attribute :method, :string # Inspection, etc.
+    attribute :type, :string
+    attribute :reference, :string
+    attribute :abstract, :boolean
 
     xml do
       root "conformance-test"
@@ -32,6 +33,32 @@ module Modspec
       map_element "type", to: :type
       map_element "reference", to: :reference
     end
-  end
 
+    attr_accessor :corresponding_requirements, :parent_class
+
+    def validate
+      errors = super()
+      errors.concat(validate_requirement_mapping)
+      errors.concat(validate_class_mapping)
+      errors
+    end
+
+    private
+
+    def validate_requirement_mapping
+      if corresponding_requirements.empty?
+        ["Conformance test #{identifier} has no corresponding requirements"]
+      else
+        []
+      end
+    end
+
+    def validate_class_mapping
+      if parent_class.nil? || !parent_class.tests.include?(self)
+        ["Conformance test #{identifier} does not belong to its parent class"]
+      else
+        []
+      end
+    end
+  end
 end

data/lib/modspec/identifier.rb

@@ -1,7 +1,9 @@
-require "shale"
+# frozen_string_literal: true
+
+require "lutaml/model"
 
 module Modspec
-  class Identifier < Shale::Type::String
-    # attribute :identifier, Shale::Type::String
+  class Identifier < Lutaml::Model::Type::String
+    # attribute :identifier, :string
   end
 end

data/lib/modspec/normative_statement.rb

@@ -1,28 +1,32 @@
-require "shale"
-require_relative "./identifier"
+# frozen_string_literal: true
+
+require "lutaml/model"
+require_relative "identifier"
 
 module Modspec
-  class NormativeStatementPart < Shale::Mapper
-    attribute :statement, Shale::Type::String
+  class NormativeStatementPart < Lutaml::Model::Serializable
+    attribute :statement, :string
   end
 
-  class NormativeStatement < Shale::Mapper
+  class NormativeStatement < Lutaml::Model::Serializable
     attribute :identifier, Identifier
-    attribute :name, Shale::Type::String
-    attribute :subject, Shale::Type::String
-    attribute :statement, Shale::Type::String
-    attribute :condition, Shale::Type::String
-    attribute :guidance, Shale::Type::String
+    attribute :name, :string
+    attribute :subject, :string
+    attribute :statement, :string
+    attribute :condition, :string
+    attribute :guidance, :string, collection: true
     attribute :inherit, Identifier, collection: true
     attribute :indirect_dependency, Identifier, collection: true
     attribute :implements, Identifier, collection: true
     attribute :dependencies, Identifier, collection: true
     attribute :belongs_to, Identifier, collection: true
-    attribute :reference, Shale::Type::String
-    attribute :parts, NormativeStatementPart, collection:true
+    attribute :reference, :string
+    attribute :parts, NormativeStatementPart, collection: true
 
     # in the future validate: recommendation, permission, requirement
-    attribute :obligation, Shale::Type::String
+    attribute :obligation, :string,
+              values: %w[recommendation permission requirement],
+              default: -> { "requirement" }
 
     xml do
       root "normative-statement"
@@ -41,6 +45,37 @@ module Modspec
       map_element "obligation", to: :obligation
       map_element "parts", to: :parts
     end
-  end
 
+    def validate(suite = nil)
+      errors = super()
+      errors.concat(validate_dependencies(suite)) if suite
+      errors.concat(validate_nested_requirement)
+      errors
+    end
+
+    private
+
+    def validate_dependencies(suite)
+      errors = []
+      all_dependencies = (dependencies + indirect_dependency + implements).flatten.compact.map(&:to_s)
+      all_identifiers = suite.all_identifiers.map(&:to_s)
+      all_dependencies.each do |dep|
+        errors << "Requirement #{identifier} has an invalid dependency: #{dep}" unless all_identifiers.include?(dep)
+      end
+      errors
+    end
+
+    def validate_nested_requirement
+      if has_parent_requirement?
+        ["Nested requirement detected: #{identifier}"]
+      else
+        []
+      end
+    end
+
+    def has_parent_requirement?
+      # Implementation depends on how you determine if a requirement is nested
+      false
+    end
+  end
 end

data/lib/modspec/normative_statements_class.rb

@@ -1,20 +1,21 @@
-require "shale"
-require_relative "./normative_statement"
-require_relative "./identifier"
+# frozen_string_literal: true
 
-module Modspec
+require "lutaml/model"
+require_relative "normative_statement"
+require_relative "identifier"
 
-  class NormativeStatementsClass < Shale::Mapper
+module Modspec
+  class NormativeStatementsClass < Lutaml::Model::Serializable
     attribute :identifier, Identifier
-    attribute :name, Shale::Type::String
-    attribute :description, Shale::Type::String
-    attribute :subject, Shale::Type::String
-    attribute :guidance, Shale::Type::String
+    attribute :name, :string
+    attribute :description, :string
+    attribute :subject, :string
+    attribute :guidance, :string, collection: true
     attribute :dependencies, Identifier, collection: true
     attribute :normative_statements, NormativeStatement, collection: true
     attribute :belongs_to, Identifier, collection: true
-    attribute :reference, Shale::Type::String
-    attribute :source, Shale::Type::String
+    attribute :reference, :string
+    attribute :source, :string
 
     xml do
       root "normative-statements-class"
@@ -29,6 +30,32 @@ module Modspec
       map_element "reference", to: :reference
       map_element "source", to: :source
     end
-  end
 
+    def validate(suite = nil)
+      errors = super()
+      errors.concat(validate_identifier_prefix)
+      errors.concat(validate_class_children_mapping)
+      errors.concat(normative_statements.flat_map { |n| n.validate(suite) })
+      errors
+    end
+
+    private
+
+    def validate_identifier_prefix
+      errors = []
+      expected_prefix = "#{identifier}/"
+      normative_statements.each do |statement|
+        errors << "Normative statement #{statement.identifier} does not share the expected prefix #{expected_prefix}" unless statement.identifier.to_s.start_with?(expected_prefix)
+      end
+      errors
+    end
+
+    def validate_class_children_mapping
+      if normative_statements.empty?
+        ["Requirement class #{identifier} has no child requirements"]
+      else
+        []
+      end
+    end
+  end
 end

data/lib/modspec/suite.rb

@@ -1,11 +1,13 @@
-require "shale"
+# frozen_string_literal: true
+
+require "lutaml/model"
 
 module Modspec
-  class Suite < Shale::Mapper
+  class Suite < Lutaml::Model::Serializable
     attribute :identifier, Identifier
-    attribute :name, Shale::Type::String
-    attribute :normative_statements_classes, NormativeStatementsClass, collection:true
-    attribute :conformance_classes, ConformanceClass, collection:true
+    attribute :name, :string
+    attribute :normative_statements_classes, NormativeStatementsClass, collection: true
+    attribute :conformance_classes, ConformanceClass, collection: true
 
     xml do
       root "suite"
@@ -14,5 +16,240 @@ module Modspec
       map_element "normative-statements-classes", to: :normative_statements_classes
       map_element "conformance-classes", to: :conformance_classes
     end
+
+    def validate
+      setup_relationships
+      self.all_identifiers = nil
+      errors = super()
+      errors.concat(validate_cycles)
+      errors.concat(validate_label_uniqueness)
+      errors.concat(validate_dependencies)
+      errors.concat(normative_statements_classes.flat_map { |n| n.validate(self) })
+      errors.concat(conformance_classes.flat_map(&:validate))
+      errors
+    end
+
+    def combine(other_suite)
+      raise ArgumentError, "Argument must be a Modspec::Suite" unless other_suite.is_a?(Modspec::Suite)
+
+      combined_suite = dup
+      combined_suite.all_identifiers = nil
+      combined_suite.normative_statements_classes += other_suite.normative_statements_classes
+      combined_suite.conformance_classes += other_suite.conformance_classes
+
+      # Ensure uniqueness of identifiers
+      combined_suite.normative_statements_classes.uniq!(&:identifier)
+      combined_suite.conformance_classes.uniq!(&:identifier)
+
+      combined_suite.name = "#{name} + #{other_suite.name}"
+
+      combined_suite
+    end
+
+    def all_identifiers
+      @all_identifiers ||= (normative_statements_classes.flat_map(&:normative_statements) +
+                            conformance_classes.flat_map(&:tests) +
+                            normative_statements_classes +
+                            conformance_classes).map(&:identifier)
+    end
+
+    attr_writer :all_identifiers
+
+    def resolve_conflicts(other_suite)
+      resolve_conflicts_for(normative_statements_classes, other_suite.normative_statements_classes)
+      resolve_conflicts_for(conformance_classes, other_suite.conformance_classes)
+    end
+
+    def self.from_yaml_files(*files)
+      combined_suite = new
+      files.each do |file|
+        suite = from_yaml(File.read(file))
+        combined_suite = combined_suite.combine(suite)
+      end
+      combined_suite.name = "Combined Suite"
+      combined_suite
+    end
+
+    def setup_relationships
+      all_requirements = normative_statements_classes.flat_map(&:normative_statements)
+
+      conformance_classes.each do |cc|
+        cc.tests.each do |ct|
+          ct.corresponding_requirements = all_requirements.select do |r|
+            ct.targets.map(&:to_s).include?(r.identifier.to_s)
+          end
+          ct.parent_class = cc
+        end
+      end
+    end
+
+    private
+
+    def resolve_conflicts_for(self_collection, other_collection)
+      other_collection.each do |other_item|
+        existing_item = self_collection.find { |item| item.identifier == other_item.identifier }
+        if existing_item
+          # Merge attributes of conflicting items
+          merge_attributes(existing_item, other_item)
+        else
+          self_collection << other_item
+        end
+      end
+    end
+
+    def merge_attributes(existing_item, other_item)
+      existing_item.class.attribute_names.each do |attr|
+        next if %i[identifier name].include?(attr)
+
+        if existing_item.send(attr).is_a?(Array)
+          existing_item.send(attr).concat(other_item.send(attr)).uniq!
+        elsif existing_item.send(attr).nil?
+          existing_item.send("#{attr}=", other_item.send(attr))
+        end
+      end
+    end
+
+    def validate_cycles
+      graph = build_dependency_graph
+      cycles = detect_cycles(graph)
+      cycles.map { |cycle| "Cycle detected: #{cycle.join(" -> ")}" }
+    end
+
+    def build_dependency_graph
+      graph = {}
+      all_statements = normative_statements_classes.flat_map(&:normative_statements) +
+                       conformance_classes.flat_map(&:tests)
+
+      all_statements.each do |statement|
+        id = statement.identifier.to_s
+        graph[id] = Set.new
+        graph[id].merge(statement.dependencies.map(&:to_s)) if statement.respond_to?(:dependencies)
+        graph[id].merge(statement.indirect_dependency.map(&:to_s)) if statement.respond_to?(:indirect_dependency)
+        graph[id].merge(statement.implements.map(&:to_s)) if statement.respond_to?(:implements)
+        graph[id].merge(statement.targets.map(&:to_s)) if statement.respond_to?(:targets)
+      end
+
+      graph
+    end
+
+    def detect_cycles(graph)
+      cycles = []
+      visited = Set.new
+      recursion_stack = Set.new
+
+      graph.each_key do |node|
+        unless visited.include?(node)
+          cycle = detect_cycle_util(node, graph, visited, recursion_stack, [])
+          cycles << cycle if cycle
+        end
+      end
+
+      cycles
+    end
+
+    def detect_cycle_util(node, graph, visited, recursion_stack, path)
+      visited.add(node)
+      recursion_stack.add(node)
+      path.push(node)
+
+      # Check if the node exists in the graph and has dependencies
+      if graph[node]
+        graph[node].each do |neighbor|
+          if !visited.include?(neighbor)
+            cycle = detect_cycle_util(neighbor, graph, visited, recursion_stack, path)
+            return cycle if cycle
+          elsif recursion_stack.include?(neighbor)
+            return path[path.index(neighbor)..] + [neighbor]
+          end
+        end
+      else
+        # If the node doesn't exist in the graph, log a warning
+        puts "Warning: Node #{node} referenced but not found in the graph"
+      end
+
+      path.pop
+      recursion_stack.delete(node)
+      nil
+    end
+
+    def validate_label_uniqueness
+      labels = {}
+      errors = []
+      all_statements = normative_statements_classes.flat_map(&:normative_statements) +
+                       conformance_classes.flat_map(&:tests)
+      all_statements.each do |statement|
+        if labels[statement.identifier]
+          errors << "Duplicate identifier found: #{statement.identifier}"
+        else
+          labels[statement.identifier] = true
+        end
+      end
+      errors
+    end
+
+    def validate_dependencies
+      all_identifiers = collect_all_identifiers
+
+      errors = []
+      normative_statements_classes.each do |nsc|
+        errors.concat(validate_class_dependencies(nsc, all_identifiers))
+        nsc.normative_statements.each do |ns|
+          errors.concat(validate_statement_dependencies(ns, all_identifiers))
+        end
+      end
+
+      conformance_classes.each do |cc|
+        errors.concat(validate_class_dependencies(cc, all_identifiers))
+        cc.tests.each do |ct|
+          errors.concat(validate_test_targets(ct, all_identifiers))
+        end
+      end
+
+      errors
+    end
+
+    def collect_all_identifiers
+      identifiers = {}
+
+      normative_statements_classes.each do |nsc|
+        identifiers[nsc.identifier.to_s] = nsc
+        nsc.normative_statements.each do |ns|
+          identifiers[ns.identifier.to_s] = ns
+        end
+      end
+
+      conformance_classes.each do |cc|
+        identifiers[cc.identifier.to_s] = cc
+        cc.tests.each do |ct|
+          identifiers[ct.identifier.to_s] = ct
+        end
+      end
+
+      identifiers
+    end
+
+    def validate_class_dependencies(klass, all_identifiers)
+      errors = []
+      klass.dependencies&.each do |dep|
+        errors << "Invalid dependency #{dep} in #{klass.identifier}" unless all_identifiers.key?(dep.to_s)
+      end
+      errors
+    end
+
+    def validate_statement_dependencies(statement, all_identifiers)
+      errors = []
+      statement.dependencies&.each do |dep|
+        errors << "Invalid dependency #{dep} in #{statement.identifier}" unless all_identifiers.key?(dep.to_s)
+      end
+      errors
+    end
+
+    def validate_test_targets(test, all_identifiers)
+      errors = []
+      test.targets&.each do |target|
+        errors << "Invalid target #{target} in #{test.identifier}" unless all_identifiers.key?(target.to_s)
+      end
+      errors
+    end
   end
 end

data/lib/modspec/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Modspec
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/modspec.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
 require_relative "modspec/version"
-require "shale"
-require "shale/adapter/nokogiri"
+require "lutaml/model"
 
 module Modspec
-  Shale.xml_adapter = Shale::Adapter::Nokogiri
-
   class Error < StandardError; end
+
   # Your code goes here...
 end
 
@@ -17,3 +15,15 @@ require_relative "modspec/normative_statements_class"
 require_relative "modspec/conformance_test"
 require_relative "modspec/conformance_class"
 require_relative "modspec/suite"
+
+require "lutaml/model/xml_adapter/nokogiri_adapter"
+require "lutaml/model/json_adapter/standard_json_adapter"
+require "lutaml/model/toml_adapter/toml_rb_adapter"
+require "lutaml/model/yaml_adapter/standard_yaml_adapter"
+
+Lutaml::Model::Config.configure do |config|
+  config.xml_adapter = Lutaml::Model::XmlAdapter::NokogiriAdapter
+  config.yaml_adapter = Lutaml::Model::YamlAdapter::StandardYamlAdapter
+  config.json_adapter = Lutaml::Model::JsonAdapter::StandardJsonAdapter
+  config.toml_adapter = Lutaml::Model::TomlAdapter::TomlRbAdapter
+end

data/modspec.gemspec

@@ -13,8 +13,8 @@ Gem::Specification.new do |spec|
   spec.email = ["open.source@ribose.com"]
 
   spec.summary = "Library to work with OGC ModSpec."
-  spec.homepage      = "https://github.com/metanorma/modspec-ruby"
-  spec.license       = "BSD-2-Clause"
+  spec.homepage = "https://github.com/metanorma/modspec-ruby"
+  spec.license = "BSD-2-Clause"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
@@ -22,20 +22,14 @@ Gem::Specification.new do |spec|
   spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
 
   # Specify which files should be added to the gem when it is released.
-  spec.files         = all_files_in_git
-                       .reject { |f| f.match(%r{\A(?:test|spec|features|bin|\.)/}) }
+  spec.files = all_files_in_git
+               .reject { |f| f.match(%r{\A(?:test|features|bin|\.)/}) }
 
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "lutaml-model", "~> 0.3.10"
   spec.add_dependency "nokogiri"
-  spec.add_dependency "shale"
-  # spec.add_dependency "thor"
-
-  spec.add_development_dependency "pry", "~> 0.14.0"
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rspec", "~> 3.10"
-  # spec.add_development_dependency "rubocop"
-  spec.add_development_dependency "equivalent-xml", "~> 0.6"
+  spec.add_dependency "toml-rb"
 end