opencdd 0.1.1

data/lib/opencdd/validator/format_rule.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Validator
+    class FormatRule < Rule
+      TOKEN_PATTERN = %r{
+        \A
+        (?<type>NR1|NR2|NR3|M|B|Date|DT|Bool)
+        (?:\s+(?<sign>S|U))?
+        (?:\.\.(?<width>\d+))?
+        (?:\.(?<decimals>\d+))?
+        \z
+      }x.freeze
+
+      def id
+        "R05"
+      end
+
+      def applies?(context)
+        !context.value_format.nil? && !context.value_format.to_s.strip.empty?
+      end
+
+      def call(value, context)
+        return true if value.nil? || value.to_s.strip.empty?
+        match = TOKEN_PATTERN.match(context.value_format.to_s.strip)
+        return false unless match
+        type_check(value, match)
+      end
+
+      def message(value, context)
+        "R05: #{value.inspect} does not match value format #{context.value_format}"
+      end
+
+      private
+
+      def type_check(value, match)
+        width = match[:width]
+        case match[:type]
+        when "NR1" then !!(Integer(value.to_s) rescue nil)
+        when "NR2", "NR3" then !!(Float(value.to_s) rescue nil)
+        when "M" then value.to_s.length <= (width || "255").to_i
+        when "B" then value.to_s.match?(/\A[01]+\z/) && value.to_s.length <= (width || "8").to_i
+        when "Date" then !!(Date.iso8601(value.to_s) rescue nil)
+        when "DT" then !!(Time.iso8601(value.to_s) rescue nil)
+        when "Bool" then %w[true false].include?(value.to_s.downcase)
+        else false
+        end
+      end
+    end
+  end
+end
+
+require "date"
+require "time"

data/lib/opencdd/validator/hierarchy_rule.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Validator
+    class HierarchyRule < Rule
+      def id
+        "R14"
+      end
+
+      def applies?(_context)
+        false
+      end
+
+      def call(_value, _context)
+        true
+      end
+
+      def self.class_hierarchy_acyclic?(database)
+        database.classes.each do |klass|
+          return false if cycle_from?(klass, database)
+        end
+        true
+      end
+
+      def self.composition_hierarchy_acyclic?(database)
+        visited = {}
+        database.classes.each do |klass|
+          return false if composition_cycle?(klass, database, visited, [])
+        end
+        true
+      end
+
+      class << self
+        private
+
+        def cycle_from?(klass, database, seen = [])
+          return false if klass.nil?
+          code = klass.irdi&.code
+          return true if seen.include?(code)
+          return false if code.nil?
+          super_irdi = klass.superclass_irdi
+          return false if super_irdi.nil?
+          parent = database.find(super_irdi) || database.find_by_code(super_irdi.code)
+          cycle_from?(parent, database, seen + [code])
+        end
+
+        def composition_cycle?(klass, database, visited, path)
+          return false if klass.nil?
+          code = klass.irdi&.code
+          return true if path.include?(code)
+          return false if visited[code]
+          visited[code] = true
+          props = klass.is_a?(Opencdd::Klass) && database ? klass.effective_properties(database) : []
+          props.any? do |prop|
+            dc = prop.is_a?(Opencdd::Property) ? prop.definition_class_irdi : nil
+            next false if dc.nil?
+            target = database.find(dc) || database.find_by_code(dc.code)
+            next false if target.nil?
+            composition_cycle?(target, database, visited, path + [code])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opencdd/validator/irdi_rule.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Validator
+    class IrdiRule < Rule
+      FULL_PATTERN = %r{
+        \A
+        [^/#\s]+
+        /
+        [^/#\s]*
+        ///
+        [^/#\s]+
+        \#
+        [^#\s]+
+        (?:\#\#\d+)?
+        (?:\#\#\#[^#]+)?
+        \z
+      }x.freeze
+
+      SHORT_PATTERN = /\A[A-Za-z0-9_]+\z/.freeze
+
+      def id
+        "R01"
+      end
+
+      def applies?(context)
+        code_column?(context) || reference_column?(context)
+      end
+
+      def call(value, context)
+        return true if value.nil? || value.to_s.strip.empty?
+        s = value.to_s.strip
+        if reference_column?(context)
+          return true unless Opencdd::IRDI.parse(s).nil?
+          return false
+        end
+        FULL_PATTERN.match?(s) || SHORT_PATTERN.match?(s) ? true : false
+      end
+
+      def message(value, _context)
+        "R01: malformed IRDI/ICID #{value.inspect}"
+      end
+
+      private
+
+      def code_column?(context)
+        context.column_iri&.start_with?(Opencdd::PropertyIds::MDC_P001) ||
+          context.column_iri == Opencdd::PropertyIds::EXT_P001
+      end
+
+      def reference_column?(context)
+        %i[identifier_ref set_of_refs class_ref].include?(context.value_kind)
+      end
+    end
+  end
+end
+

data/lib/opencdd/validator/mandatory_rule.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Validator
+    class MandatoryRule < Rule
+      def id
+        "R07"
+      end
+
+      def applies?(context)
+        context.requirement_mandatory?
+      end
+
+      def call(value, _context)
+        return false if value.nil?
+        return false if value.to_s.strip.empty?
+        true
+      end
+
+      def message(_value, context)
+        "R07: mandatory column #{context.column_iri} is empty"
+      end
+    end
+  end
+end

data/lib/opencdd/validator/pattern_rule.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Validator
+    class PatternRule < Rule
+      def id
+        "R06"
+      end
+
+      def applies?(context)
+        !context.pattern.nil? && !context.pattern.to_s.strip.empty?
+      end
+
+      def call(value, context)
+        return true if value.nil? || value.to_s.strip.empty?
+        Regexp.new(context.pattern.to_s).match?(value.to_s)
+      rescue RegexpError
+        false
+      end
+
+      def message(value, context)
+        "R06: #{value.inspect} does not match pattern #{context.pattern.inspect}"
+      end
+    end
+  end
+end

data/lib/opencdd/validator/reference_rule.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Validator
+    class ReferenceRule < Rule
+      def id
+        "R08"
+      end
+
+      def applies?(context)
+        %i[identifier_ref set_of_refs class_ref].include?(context.value_kind)
+      end
+
+      def call(value, context)
+        return true if value.nil? || value.to_s.strip.empty?
+        return false unless context.database
+        refs(value).all? do |ref|
+          parsed = Opencdd::IRDI.parse(ref)
+          context.database.find(parsed) || context.database.find_by_code(ref.to_s)
+        end
+      end
+
+      def message(value, _context)
+        "R08: reference #{value.inspect} does not resolve in this database"
+      end
+
+      private
+
+      def refs(value)
+        # SSOT: same brace/paren/comma handling as every other
+        # collection reader in the gem.
+        Opencdd::StructuredValues.unwrap_and_split(value)
+      end
+    end
+  end
+end

data/lib/opencdd/validator/rule.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Validator
+    # Deep base class for all validator rules. Owns shared guards
+    # that were previously copy-pasted across 12 rule subclasses:
+    #
+    #   - blank-value guard (skip empty cells unless +skip_blank?+
+    #     is overridden to false)
+    #   - code-column predicate
+    #   - reference-kind predicate
+    #
+    # Subclasses implement +value_passes?+ (the narrow check) and
+    # optionally override +applies?+ and +message+.
+    class Rule
+      REFERENCE_VALUE_KINDS = %i[identifier_ref set_of_refs class_ref].freeze
+
+      def id
+        raise NotImplementedError
+      end
+
+      # Default: applies to every entity. Override to narrow.
+      def applies?(context)
+        true
+      end
+
+      # Template method: skip blank values (unless the subclass
+      # overrides +skip_blank?+), then delegate to +value_passes?+.
+      def call(value, context)
+        return true if skip_blank? && blank?(value)
+        value_passes?(value, context)
+      end
+
+      def message(value, _context)
+        "#{id}: value #{value.inspect} is invalid"
+      end
+
+      # ── Hooks for subclasses ────────────────────────────────────
+      def value_passes?(value, context)
+        raise NotImplementedError
+      end
+
+      # Most rules skip empty values — MandatoryRule overrides to
+      # +false+ so it can flag missing mandatory cells.
+      def skip_blank?
+        true
+      end
+
+      # ── Shared predicates ───────────────────────────────────────
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+
+      def code_column?(context)
+        return false unless context.entity && context.entity.meta_class_irdi
+        code_pid = Opencdd::MetaClasses.code_property_id_for(context.entity.meta_class_irdi.code)
+        context.column_iri == code_pid
+      end
+
+      def reference_kind?(context)
+        REFERENCE_VALUE_KINDS.include?(context.value_kind)
+      end
+    end
+  end
+end

data/lib/opencdd/validator/runner.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Validator
+    class Runner
+      RuleContext = Struct.new(
+        :database, :entity, :column_iri, :value_kind,
+        :data_type, :value_format, :pattern, :requirement,
+        :enum_terms_resolver,
+        keyword_init: true,
+      ) do
+        def requirement_mandatory?
+          requirement.to_s.upcase == "MAND" || requirement.to_s.upcase == "KEY"
+        end
+
+        def enum_terms_for(data_type)
+          return [] unless enum_terms_resolver
+          enum_terms_resolver.call(data_type)
+        end
+      end
+
+      RULES = [
+        IrdiRule.new,
+        UniquenessRule.new,
+        MandatoryRule.new,
+        TypeRule.new,
+        EnumRule.new,
+        FormatRule.new,
+        PatternRule.new,
+        ReferenceRule.new,
+        SetRule.new,
+        SynonymRule.new,
+        ConditionRule.new,
+        DataTypeRule.new,
+        ClassReferenceRule.new,
+      ].freeze
+
+      def self.run(database, enum_terms_resolver: nil)
+        errors = []
+        database.entities.each do |entity|
+          validate_entity(entity, database, errors, enum_terms_resolver)
+        end
+        unless HierarchyRule.class_hierarchy_acyclic?(database)
+          errors << ValidationError.new(
+            sheet: nil, row: nil, column: nil, rule: "R14",
+            message: "R14: class hierarchy contains a cycle",
+          )
+        end
+        errors
+      end
+
+      def self.validate_entity(entity, database, errors, enum_terms_resolver)
+        meta = Opencdd::MetaClasses.for(entity.meta_class_irdi&.code)
+        schema = entity.schema
+        entity.each_property do |column_iri, value|
+          next if column_iri == "__row_index__"
+          context = build_context(
+            database: database, entity: entity, column_iri: column_iri,
+            value: value, schema: schema, meta: meta,
+            enum_terms_resolver: enum_terms_resolver,
+          )
+          RULES.each do |rule|
+            next unless rule.applies?(context)
+            next if rule.call(value, context)
+            errors << ValidationError.new(
+              sheet: entity.meta_class_irdi&.code,
+              row: entity.irdi&.to_s,
+              column: column_iri,
+              rule: rule.id,
+              message: rule.message(value, context),
+            )
+          end
+        end
+      end
+
+      def self.build_context(database:, entity:, column_iri:, value:, schema:, meta:, enum_terms_resolver:)
+        base = column_iri.to_s.split(".").first
+        entry = Opencdd::PropertyIds::REGISTRY[base]
+        kind = entry&.value_kind
+        column_schema = schema&.column_for(base)
+        RuleContext.new(
+          database: database,
+          entity: entity,
+          column_iri: base,
+          value_kind: kind,
+          data_type: derived_data_type(entity, base, column_schema),
+          value_format: column_schema&.value_format,
+          pattern: column_schema&.pattern,
+          requirement: column_schema&.requirement,
+          enum_terms_resolver: enum_terms_resolver,
+        )
+      end
+
+      def self.derived_data_type(entity, base, column_schema)
+        return column_schema&.data_type if column_schema&.data_type
+        return entity.data_type if entity.is_a?(Opencdd::Property) && base == Opencdd::PropertyIds::MDC_P022
+        nil
+      end
+    end
+  end
+end

data/lib/opencdd/validator/set_rule.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Validator
+    class SetRule < Rule
+      def id
+        "R09"
+      end
+
+      def applies?(context)
+        context.value_kind == :set_of_refs
+      end
+
+      def call(value, _context)
+        return true if value.nil? || value.to_s.strip.empty?
+        s = value.to_s.strip
+        return false unless s.start_with?("{") && s.end_with?("}")
+        body = s[1..-2]
+        balanced?(body)
+      end
+
+      def message(value, _context)
+        "R09: set literal #{value.inspect} is not well-formed"
+      end
+
+      private
+
+      def balanced?(body)
+        depth = 0
+        body.each_char do |ch|
+          case ch
+          when "(" then depth += 1
+          when ")" then depth -= 1
+          end
+          return false if depth.negative?
+        end
+        depth.zero?
+      end
+    end
+  end
+end

data/lib/opencdd/validator/synonym_rule.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Validator
+    class SynonymRule < Rule
+      def id
+        "R10"
+      end
+
+      def applies?(context)
+        context.column_iri == Opencdd::PropertyIds::MDC_P004_2 ||
+          context.column_iri == Opencdd::PropertyIds::MDC_P007
+      end
+
+      def call(value, _context)
+        return true if value.nil? || value.to_s.strip.empty?
+        s = value.to_s.strip
+        return false unless s.start_with?("{") && s.end_with?("}")
+        body = s[1..-2].strip
+        return true if body.empty?
+        tuples = body.split(/\)\s*,\s*/).map(&:strip)
+        tuples.all? { |t| t.start_with?("(") }
+      end
+
+      def message(value, _context)
+        "R10: synonymous-name literal #{value.inspect} is not well-formed"
+      end
+    end
+  end
+end

data/lib/opencdd/validator/type_rule.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Validator
+    class TypeRule < Rule
+      SIMPLE_PREDICATES = {
+        "BOOLEAN_TYPE"              => ->(v) { %w[true false].include?(v.to_s.downcase.strip) },
+        "STRING_TYPE"               => ->(v) { v.is_a?(String) || !v.nil? },
+        "TRANSLATABLE_STRING_TYPE"  => ->(v) { v.is_a?(String) || structured_pairs?(v) },
+        "IRDI_TYPE"                 => ->(v) { !Opencdd::IRDI.parse(v.to_s).nil? },
+        "IRDI_STRING_TYPE"          => ->(v) { !Opencdd::IRDI.parse(v.to_s).nil? },
+        "ICID_STRING"               => ->(v) { !Opencdd::IRDI.parse(v.to_s).nil? },
+        "ICID_STRING_TYPE"          => ->(v) { !Opencdd::IRDI.parse(v.to_s).nil? },
+        "DATE_TYPE"                 => ->(v) { date?(v) },
+        "DATE_TIME_TYPE"            => ->(v) { date_time?(v) },
+        "DATETIME_TYPE"             => ->(v) { date_time?(v) },
+        "REAL_TYPE"                 => ->(v) { real?(v) },
+        "INTEGER_TYPE"              => ->(v) { integer?(v) },
+        "INT_TYPE"                  => ->(v) { integer?(v) },
+        "RATIONAL_TYPE"             => ->(v) { rational?(v) },
+      }.freeze
+
+      def id
+        "R03"
+      end
+
+      def applies?(context)
+        !context.data_type.nil?
+      end
+
+      def call(value, context)
+        return true if value.nil? || value.to_s.strip.empty?
+        token = context.data_type.to_s
+        return enum_member?(value, context) if token.start_with?("ENUM_")
+        predicate = SIMPLE_PREDICATES[token]
+        return true if predicate.nil?
+        predicate.call(value) ? true : false
+      end
+
+      def message(value, context)
+        "R03: value #{value.inspect} does not satisfy data type #{context.data_type}"
+      end
+
+      def self.structured_pairs?(value)
+        s = value.to_s.strip
+        s.start_with?("{") || s.start_with?("(")
+      end
+
+      def self.date?(value)
+        !!begin
+          Date.iso8601(value.to_s)
+        rescue ArgumentError, TypeError
+          nil
+        end
+      end
+
+      def self.date_time?(value)
+        !!begin
+          Time.iso8601(value.to_s)
+        rescue ArgumentError, TypeError
+          nil
+        end
+      end
+
+      def self.real?(value)
+        !!begin
+          Float(value.to_s)
+        rescue ArgumentError, TypeError
+          nil
+        end
+      end
+
+      def self.integer?(value)
+        !!begin
+          Integer(value.to_s)
+        rescue ArgumentError, TypeError
+          nil
+        end
+      end
+
+      def self.rational?(value)
+        !!begin
+          Rational(value.to_s)
+        rescue ArgumentError, TypeError, ZeroDivisionError
+          nil
+        end
+      end
+
+      private
+
+      def enum_member?(value, context)
+        return true unless context.database
+        terms = context.enum_terms_for(context.data_type)
+        return true if terms.empty?
+        terms.any? { |t| t.to_s == value.to_s }
+      end
+    end
+  end
+end
+
+require "time"
+require "date"

data/lib/opencdd/validator/uniqueness_rule.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Validator
+    class UniquenessRule < Rule
+      def id
+        "R02"
+      end
+
+      def applies?(context)
+        code_column?(context)
+      end
+
+      def call(value, context)
+        return true if value.nil? || value.to_s.strip.empty?
+        peers = context.database.entities.filter_map { |e| e.irdi&.code if e.type == context.entity.type }
+        peers.tally[value.to_s] == 1
+      end
+
+      def message(value, _context)
+        "R02: code #{value.inspect} is not unique within its sheet"
+      end
+
+      private
+
+      def code_column?(context)
+        context.column_iri&.start_with?(Opencdd::PropertyIds::MDC_P001) ||
+          context.column_iri == Opencdd::PropertyIds::EXT_P001
+      end
+    end
+  end
+end