opencdd 0.1.1

data/lib/opencdd/exporters/json.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Opencdd
+  module Exporters
+    class Json < Opencdd::Visitor
+      attr_reader :nodes
+
+      def initialize
+        super
+        @nodes = []
+      end
+
+      def to_json(database, pretty: true)
+        reset!
+        @nodes.clear
+        visit_database(database)
+        pretty ? JSON.pretty_generate(@nodes) : JSON.generate(@nodes)
+      end
+
+      def visit_database(database)
+        @database = database
+        super
+      end
+
+      def visit_class(klass)
+        @nodes << class_node(klass)
+        super
+      end
+
+      def visit_property(prop)
+        @nodes << property_node(prop)
+      end
+
+      def visit_unit(unit)
+        @nodes << unit_node(unit)
+      end
+
+      def visit_value_list(vl)
+        @nodes << value_list_node(vl)
+      end
+
+      def visit_value_term(vt)
+        @nodes << value_term_node(vt)
+      end
+
+      def visit_relation(rel)
+        @nodes << relation_node(rel)
+      end
+
+      def visit_view_control(vc)
+        @nodes << view_control_node(vc)
+      end
+
+      private
+
+      # ─────────────────────────────────────────────────────────────
+      # Open/closed payload builders
+      #
+      # Each per-type _node method is a thin wrapper that adds `type:`
+      # and any type-specific computed fields (e.g. Property's value_list
+      # cross-link). The bulk of every entity's payload comes from
+      # `entity_payload`, which iterates the field DSL registry
+      # (Opencdd::Entity::FieldRegistry.fields_for) — adding a field to
+      # the model is a single `field` declaration; no edits here.
+      # ─────────────────────────────────────────────────────────────
+
+      def class_node(klass)
+        entity_payload(klass).merge(type: "class").compact
+      end
+
+      def property_node(prop)
+        entity_payload(prop).merge(
+          type: "property",
+          data_type: prop.parsed_data_type&.to_s,
+          value_list: value_list_irdi_of(prop),
+        ).compact
+      end
+
+      def unit_node(unit)
+        entity_payload(unit).merge(type: "unit").compact
+      end
+
+      def value_list_node(vl)
+        entity_payload(vl).merge(type: "value_list").compact
+      end
+
+      def value_term_node(vt)
+        entity_payload(vt).merge(type: "value_term").compact
+      end
+
+      def relation_node(rel)
+        entity_payload(rel).merge(type: "relation").compact
+      end
+
+      def view_control_node(vc)
+        entity_payload(vc).merge(type: "view_control").compact
+      end
+
+      # Iterates every declared field on the entity's class (walking
+      # the ancestor chain via FieldRegistry.fields_for). Each field's
+      # value is read by name (synthetic fields call their custom
+      # reader; pure fields go through FieldReader's typed coercion).
+      #
+      # Serialization is driven by the field's value_kind so the wire
+      # shape stays consistent: IRDI → string, set_of_refs → array of
+      # strings, synonym_pairs → array of {lang, name}, etc.
+      #
+      # Deduplicates by property_id: when two field names alias the
+      # same MDC_P### (e.g. source_document and source_document_of_definition),
+      # only the first-seen declaration is emitted. Declaration order
+      # is base-class first, so the canonical name lives on Entity.
+      def entity_payload(entity)
+        # Baseline identity fields. Always present (when value is non-nil).
+        # These mirror the existing wire shape and are emitted even
+        # though they're not DSL field declarations (the model's `irdi`
+        # accessor must return the Opencdd::IRDI object, not a string).
+        payload = {
+          irdi: entity.irdi&.to_s,
+          code: entity.code,
+        }.compact
+
+        seen_property_ids = Set.new
+
+        Opencdd::Entity::FieldRegistry.fields_for(entity.class).each do |field|
+          next if field.property_id && !seen_property_ids.add?(field.property_id)
+
+          value = entity.public_send(field.name)
+          next if value.nil?
+
+          serialized = serialize_value(value, field)
+          next if serialized.nil?
+
+          payload[field.wire_name] = serialized
+
+          # For multilingual fields, also emit a language map keyed
+          # as <wire_name>_ml. Scans entity.properties for every
+          # <property_id>.<lang> key. The browser can use this for
+          # a language switcher without parsing raw_properties.
+          if field.multilingual? && field.property_id
+            ml = build_language_map(entity, field)
+            payload["#{field.wire_name}_ml"] = ml if ml && !ml.empty?
+          end
+        end
+        payload
+      end
+
+      def serialize_value(value, field)
+        # raw_properties: emit the full hash as-is, no coercion.
+        # This preserves every key from the .xls, including
+        # multilingual variants and C### workbook-specific codes.
+        return value if field.name == :raw_properties && value.is_a?(Hash)
+
+        case field.value_kind
+        when :synonym_pairs
+          return nil if value.nil?
+          value.map { |lang, name| { lang: lang, name: name } }
+        when :irdi, :identifier_ref, :class_ref
+          return nil if value.nil?
+          value.to_s
+        when :set_of_refs
+          return nil if value.nil?
+          value.map { |irdi| irdi.to_s }
+        when :string_list
+          return nil if value.nil?
+          value
+        else
+          serialize_basic(value)
+        end
+      end
+
+      def serialize_basic(value)
+        case value
+        when Opencdd::IRDI then value.to_s
+        when Array
+          # Preserve empty arrays — callers use them as "no entries"
+          # signals (e.g. sub_class_selection: [] on a class with no
+          # composition children). The payload's final .compact only
+          # drops nils, not empties.
+          value.map { |v| serialize_basic(v) }
+        when Struct
+          hash = value.to_h.transform_values { |v| serialize_basic(v) }
+          hash.compact!
+          hash.empty? ? nil : hash
+        when Opencdd::Entity::VersionHistory
+          return nil if value.empty?
+          value.entries.map { |e| serialize_basic(e) }
+        when String, Integer, Float, TrueClass, FalseClass, NilClass, Symbol
+          value
+        else
+          # Value objects (Opencdd::ClassType, Opencdd::Condition,
+          # Opencdd::ValueFormat, Opencdd::PropertyDataTypeElement, etc.)
+          # serialize via their canonical to_s. Keeps the wire shape
+          # stable without per-type branching here.
+          value.to_s
+        end
+      end
+
+      # Scans +entity.properties+ for +<property_id>.<lang>+ keys
+      # and builds a +{ lang => value }+ hash. Used for multilingual
+      # fields where the exporter emits a +<wire_name>_ml+ map
+      # alongside the source-language string.
+      def build_language_map(entity, field)
+        return nil unless field.property_id
+        prefix = "#{field.property_id}."
+        map = {}
+        entity.properties.each do |key, val|
+          next unless key.start_with?(prefix)
+          lang = key.sub(prefix, "")
+          next unless val && !val.to_s.strip.empty?
+          next unless lang =~ /\A[a-z]{2}(-[a-z0-9]+)?\z/i
+          map[lang] = val
+        end
+        bare = entity.properties[field.property_id]
+        if bare && map.empty?
+          map["en"] = bare
+        end
+        map
+      end
+
+
+      # when a property's data type is an enumeration, its values come
+      # from a named value list linked via a predication relation.
+      # The Database resolves this at finalize time; we emit the IRDI
+      # so the browser can render the cross-link without re-walking
+      # the relations.
+      def value_list_irdi_of(prop)
+        return nil unless @database
+        vl = @database.value_list_of(prop)
+        vl&.irdi&.to_s
+      end
+    end
+  end
+end

data/lib/opencdd/exporters/mermaid.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Exporters
+    class Mermaid < Opencdd::Visitor
+      attr_reader :lines
+
+      def initialize
+        super
+        @lines = ["classDiagram"]
+      end
+
+      def to_diagram(database)
+        reset!
+        @lines = ["classDiagram"]
+        visit_classes(database)
+        @lines.uniq.join("\n")
+      end
+
+      def visit_class(klass)
+        emit_class_block(klass)
+        parent_ref = klass.parent_irdi || klass.superclass_irdi
+        if parent_ref
+          parent = klass.database&.find(parent_ref)
+          if parent
+            safe = mermaid_id(parent)
+            child = mermaid_id(klass)
+            @lines << "  #{safe} <|-- #{child}"
+          end
+        end
+        klass.is_case_of_irdis.each do |ref|
+          target = klass.database&.find(ref)
+          next unless target
+          @lines << "  #{mermaid_id(target)} <.. #{mermaid_id(klass)} : is_case_of"
+        end
+        super
+      end
+
+      private
+
+      def emit_class_block(klass)
+        id = mermaid_id(klass)
+        @lines << "  class #{id} {"
+        @lines << "    <<#{klass.class_type || 'ITEM_CLASS'}>>"
+        @lines << "    +code #{klass.code}"
+        @lines << "  }"
+        note = klass.preferred_name
+        @lines << "  #{id} : #{quote_label(note)}" if note && !note.empty?
+      end
+
+      def mermaid_id(klass)
+        code = klass.code&.to_s
+        return "Class_#{klass.irdi.to_s.gsub(/[^A-Za-z0-9]/, "_")}" if code.nil? || code.empty?
+        code.gsub(/[^A-Za-z0-9_]/, "_")
+      end
+
+      def quote_label(text)
+        text.to_s.include?(":") ? "\"#{text}\"" : text.to_s
+      end
+    end
+  end
+end

data/lib/opencdd/exporters/yaml.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Opencdd
+  module Exporters
+    class Yaml < Json
+      def to_yaml(database)
+        reset!
+        @nodes.clear
+        visit_database(database)
+        @nodes.to_yaml
+      end
+    end
+  end
+end

data/lib/opencdd/exporters.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Exporters
+    autoload :Json,    "opencdd/exporters/json"
+    autoload :Yaml,    "opencdd/exporters/yaml"
+    autoload :Mermaid, "opencdd/exporters/mermaid"
+  end
+end

data/lib/opencdd/guid.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Opencdd
+  module GUID
+    PATTERN = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i.freeze
+
+    def self.generate
+      SecureRandom.uuid
+    end
+
+    def self.valid?(value)
+      return false unless value.is_a?(String)
+      PATTERN.match?(value)
+    end
+
+    def self.set_on(entity)
+      guid = generate
+      # Use the field-access seam so writes go through canonical-id
+      # resolution. Keeps GUID writes consistent with reads and
+      # avoids bypassing the Field DSL.
+      entity.write_property!(Opencdd::PropertyIds::MDC_P066, guid)
+      guid
+    end
+  end
+end

data/lib/opencdd/instance_rule.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Opencdd
+  class InstanceRule
+    Group     = Struct.new(:name, :values_by_property, keyword_init: true)
+    Exception = Struct.new(:group_name, :line_id, keyword_init: true)
+
+    attr_reader :klass, :groups, :exceptions
+
+    def initialize(klass:, groups:, exceptions: [])
+      @klass = klass
+      @groups = groups
+      @exceptions = exceptions
+      freeze
+    end
+
+    def expand
+      return [] if @groups.empty?
+
+      per_group = @groups.map { |g| expand_group(g) }
+      return [] if per_group.any?(&:empty?)
+
+      product = per_group.reduce do |acc, rows|
+        acc.product(rows).map { |a, b| a.merge(b) }
+      end
+
+      product.reject { |row| exception_match?(row) }
+              .map { |row| strip_internal(row) }
+    end
+
+    private
+
+    def expand_group(group)
+      values = group.values_by_property.transform_values do |list|
+        Array(list)
+      end
+      return [] if values.empty?
+
+      property_ids = values.keys
+      length = values.values.map(&:length).max || 0
+      length.times.map do |i|
+        row = {}
+        property_ids.each do |pid|
+          v = values[pid][i]
+          row[pid] = v unless v.nil?
+        end
+        row["__line_id__"] = "LINE#{i + 1}"
+        row["__group_name__"] = group.name
+        row
+      end
+    end
+
+    def exception_match?(row)
+      return false if @exceptions.empty?
+      group_name = row["__group_name__"]
+      line_id    = row["__line_id__"]
+      @exceptions.any? do |ex|
+        ex.group_name == group_name && ex.line_id == line_id
+      end
+    end
+
+    def strip_internal(row)
+      out = row.dup
+      out.delete("__line_id__")
+      out.delete("__group_name__")
+      out.delete("__group_indices__")
+      out
+    end
+  end
+end

data/lib/opencdd/irdi.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Opencdd
+  class IRDI
+    FULL_REGEX = %r{
+      \A
+      (?<registrant>[^/#\s]+)
+      /
+      (?<semantic>[^/#\s]*)
+      ///
+      (?<scheme>[^/#\s]+)
+      \#
+      (?<code>[^#\s]+)
+      (?:\#\#(?<smver>\d+))?
+      \z
+    }x
+
+    SHORT_REGEX = /\A[^#\/\s]+\z/
+
+    TREE_REGEX = %r{
+      \A
+      (?<registrant>[^-]+)
+      -
+      (?<semantic>[^-]*)
+      ---
+      (?<scheme>[^-]+)
+      %23
+      (?<code>[^%\s]+)
+      \z
+    }x
+
+    attr_reader :registrant, :semantic, :scheme, :code, :version
+
+    def self.parse(value)
+      return nil if value.nil?
+      s = value.to_s.strip
+      return nil if s.empty?
+
+      if (m = FULL_REGEX.match(s)) then from_match(m)
+      elsif (m = TREE_REGEX.match(s)) then from_match(m)
+      elsif SHORT_REGEX.match?(s) then from_short(s)
+      elsif s.include?("#") && (m = FULL_REGEX.match(s.gsub(/\s+/, ""))) then from_match(m)
+      else from_short(s)
+      end
+    end
+
+    def self.from_short(code)
+      new(registrant: nil, semantic: nil, scheme: nil, code: code.to_s)
+    end
+
+    def self.from_match(m)
+      caps = m.named_captures.transform_keys(&:to_sym)
+      new(
+        registrant: caps[:registrant],
+        semantic:   caps[:semantic],
+        scheme:     caps[:scheme],
+        code:       caps[:code],
+        version:    caps[:smver],
+      )
+    end
+
+    def initialize(registrant:, semantic:, scheme:, code:, version: nil)
+      @registrant = registrant&.to_s
+      @semantic   = semantic&.to_s
+      @scheme     = scheme&.to_s
+      @code       = code.to_s
+      @version    = version&.to_s
+      freeze
+    end
+
+    def full?
+      !@registrant.nil?
+    end
+
+    def short?
+      @registrant.nil?
+    end
+
+    alias_method :short, :code
+
+    def sheetmap_version
+      @version
+    end
+
+    def to_s
+      return @code if short?
+      "#{@registrant}/#{@semantic}///#{@scheme}##{@code}"
+    end
+
+    alias_method :to_str, :to_s
+
+    def to_tree_path
+      return @code if short?
+      "#{@registrant}-#{@semantic}---#{@scheme}%23#{@code}"
+    end
+
+    def with_code(new_code)
+      self.class.new(
+        registrant: @registrant,
+        semantic:   @semantic,
+        scheme:     @scheme,
+        code:       new_code.to_s,
+        version:    @version,
+      )
+    end
+
+    def eql?(other)
+      other.is_a?(Opencdd::IRDI) && to_s == other.to_s
+    end
+
+    def hash
+      to_s.hash
+    end
+
+    def ==(other)
+      eql?(other)
+    end
+
+    def inspect
+      "#<Opencdd::IRDI #{to_s.inspect}>"
+    end
+
+    def self.coerce(value)
+      return value if value.is_a?(Opencdd::IRDI)
+      parse(value)
+    end
+  end
+end