opencdd 0.1.1

data/lib/opencdd/class_tree.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Opencdd
+  class ClassTree
+    DEFAULT_FIELDS = %i[code name].freeze
+    AVAILABLE_FIELDS = %i[code name irdi definition class_type].freeze
+
+    include Enumerable
+
+    attr_reader :database, :fields
+
+    def initialize(database, fields: DEFAULT_FIELDS)
+      @database = database
+      @fields = fields
+    end
+
+    def roots
+      @database.root_classes
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+      walk(roots, 0) { |k, _d| yield k }
+    end
+
+    def each_node
+      return enum_for(:each_node) unless block_given?
+      walk(roots, 0) { |k, d| yield k, d }
+    end
+
+    def to_h(max_depth: nil, fields: @fields)
+      roots.map { |k| node_h(k, depth: 0, max_depth: max_depth, fields: fields) }
+    end
+
+    def to_yaml(max_depth: nil, fields: @fields)
+      to_h(max_depth: max_depth, fields: fields).to_yaml
+    end
+
+    def subtree(klass, max_depth: nil, fields: @fields)
+      node_h(klass, depth: 0, max_depth: max_depth, fields: fields)
+    end
+
+    def subtree_yaml(klass, **opts)
+      subtree(klass, **opts).to_yaml
+    end
+
+    private
+
+    def walk(nodes, depth)
+      nodes.each do |node|
+        yield node, depth
+        walk(node.children, depth + 1) { |n, d| yield n, d }
+      end
+    end
+
+    def node_h(klass, depth:, max_depth:, fields:)
+      h = {}
+      fields.each { |f| merge_field!(h, klass, f) }
+
+      if max_depth.nil? || depth < max_depth
+        kids = klass.children
+        h["children"] = kids.map { |c| node_h(c, depth: depth + 1, max_depth: max_depth, fields: fields) } unless kids.empty?
+      end
+      h
+    end
+
+    def merge_field!(h, klass, field)
+      case field
+      when :code       then h["code"] = klass.code
+      when :name       then h["name"] = klass.preferred_name
+      when :irdi       then h["irdi"] = klass.irdi&.to_s
+      when :definition then h["definition"] = klass.definition unless klass.definition.to_s.empty?
+      when :class_type then h["class_type"] = klass.class_type.to_s if klass.class_type
+      else raise ArgumentError, "unknown field #{field.inspect}; valid: #{AVAILABLE_FIELDS.inspect}"
+      end
+    end
+  end
+end

data/lib/opencdd/class_type.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Opencdd
+  class ClassType
+    VALUES = %w[ITEM_CLASS CATEGORICAL_CLASS VALUE_CLASS MESSAGE_CLASS].freeze
+
+    attr_reader :value
+
+    def initialize(value)
+      raise ArgumentError, "unknown class_type: #{value}" unless VALUES.include?(value.to_s)
+      @value = value.to_s
+    end
+
+    def item?         = @value == "ITEM_CLASS"
+    def categorical?  = @value == "CATEGORICAL_CLASS"
+    def value_class?  = @value == "VALUE_CLASS"
+    def message?      = @value == "MESSAGE_CLASS"
+
+    def to_s   = @value
+    def to_sym = @value.downcase.to_sym
+
+    def self.parse(raw)
+      return nil if raw.nil? || raw.to_s.strip.empty?
+      s = raw.to_s.strip.upcase
+      return nil unless VALUES.include?(s)
+      new(s)
+    end
+
+    VALUES.each do |v|
+      define_method("#{v.downcase}?") { @value == v }
+    end
+  end
+end

data/lib/opencdd/codegen/ts.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Opencdd
+  module Codegen
+    # Serializes the Ruby registries (Opencdd::PropertyIds::REGISTRY and
+    # Opencdd::MetaClasses) to TypeScript files that the OpenCDD Editor imports
+    # at build time. The editor has no runtime dependency on Ruby.
+    module Ts
+      module_function
+
+      def generate_all(editor_dir)
+        generate_property_ids(File.join(editor_dir, "src", "models", "PropertyIds.generated.ts"))
+        generate_meta_classes(File.join(editor_dir, "src", "models", "MetaClasses.generated.ts"))
+      end
+
+      def generate_property_ids(path)
+        write_file(path, render_property_ids)
+      end
+
+      # Returns the generated TS source as a string (no filesystem
+      # access). Testable in-memory. See TODO.impl/31.
+      def render_property_ids
+        registry = Opencdd::PropertyIds::REGISTRY
+
+        out = []
+        out << "// AUTO-GENERATED by `rake generate_ts`. Do not edit by hand."
+        out << "// Source: Opencdd::PropertyIds::REGISTRY in lib/opencdd/property_ids.rb"
+        out << ""
+        out << union_type("AppliesTo", registry.values.map { |e| e.applies_to.to_s }.uniq.sort)
+        out << union_type("ValueKind", registry.values.map { |e| e.value_kind.to_s }.uniq.sort)
+        out << ""
+        out << "export interface PropertyEntry {"
+        out << "  readonly id: string;"
+        out << "  readonly aliases: readonly string[];"
+        out << "  readonly appliesTo: AppliesTo;"
+        out << "  readonly multilingual: boolean;"
+        out << "  readonly valueKind: ValueKind;"
+        out << "}"
+        out << ""
+        out << "export const REGISTRY: Readonly<Record<string, PropertyEntry>> = {"
+        registry.each_value { |e| out << "  \"#{e.id}\": #{entry_literal(e)}," }
+        out << "};"
+        out << ""
+        registry.each_key { |id| out << "export const #{id} = \"#{id}\";" }
+        out << ""
+        out << PROPERTY_HELPERS
+        out << ""
+        out << alias_map_literal(registry)
+        out.join("\n") + "\n"
+      end
+
+      def generate_meta_classes(path)
+        write_file(path, render_meta_classes)
+      end
+
+      def render_meta_classes
+        Opencdd::MetaClasses.reset!
+        metas = Opencdd::MetaClasses.all
+        type_map = Opencdd::MetaClasses::TYPE_BY_META_CLASS
+        code_map = Opencdd::MetaClasses::CODE_PROPERTY_IDS
+
+        entity_types = type_map.values.map(&:to_s).uniq.sort
+
+        out = []
+        out << "// AUTO-GENERATED by `rake generate_ts`. Do not edit by hand."
+        out << "// Source: Opencdd::MetaClasses in lib/opencdd/meta_class.rb"
+        out << ""
+        out << union_type("EntityType", entity_types)
+        out << ""
+        out << "export interface MetaClassEntry {"
+        out << "  readonly irdi: string;"
+        out << "  readonly name: string;"
+        out << "  readonly entityType: EntityType;"
+        out << "  readonly codePropertyId: string;"
+        out << "  readonly allowedPropertyIds: readonly string[];"
+        out << "}"
+        out << ""
+        out << "export const REGISTRY: Readonly<Record<string, MetaClassEntry>> = {"
+        metas.each do |mc|
+          out << "  \"#{mc.irdi}\": {"
+          out << "    irdi: \"#{mc.irdi}\","
+          out << "    name: \"#{mc.name}\","
+          out << "    entityType: \"#{type_map[mc.irdi]}\","
+          out << "    codePropertyId: \"#{code_map[mc.irdi]}\","
+          ids = mc.allowed_property_ids.map { |id| "\"#{id}\"" }.join(", ")
+          out << "    allowedPropertyIds: [#{ids}],"
+          out << "  },"
+        end
+        out << "};"
+        out << ""
+        metas.each { |mc| out << "export const #{mc.irdi} = \"#{mc.irdi}\";" }
+        out << ""
+        out << META_HELPERS
+        out.join("\n") + "\n"
+      end
+
+      def union_type(name, values)
+        body = values.map { |v| "  | \"#{v}\"" }.join("\n")
+        "export type #{name} =\n#{body};"
+      end
+
+      def entry_literal(entry)
+        aliases = entry.aliases.map { |a| "\"#{a}\"" }.join(", ")
+        "{ id: \"#{entry.id}\", aliases: [#{aliases}], appliesTo: \"#{entry.applies_to}\", " \
+          "multilingual: #{entry.multilingual}, valueKind: \"#{entry.value_kind}\" }"
+      end
+
+      def alias_map_literal(registry)
+        pairs = []
+        registry.each_value do |e|
+          e.aliases.each { |a| pairs << "  \"#{a}\": \"#{e.id}\"," }
+        end
+        "const ALIAS_MAP: Readonly<Record<string, string>> = {\n#{pairs.join("\n")}\n};"
+      end
+
+      def write_file(path, content)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content + "\n")
+        puts "Generated #{path}"
+      end
+
+      PROPERTY_HELPERS = <<~TS.freeze
+        export function entry(id: string): PropertyEntry | undefined {
+          return REGISTRY[id];
+        }
+
+        export function multilingual(id: string): boolean {
+          return REGISTRY[id]?.multilingual ?? false;
+        }
+
+        export function appliesTo(id: string): AppliesTo | undefined {
+          return REGISTRY[id]?.appliesTo;
+        }
+
+        export function valueKind(id: string): ValueKind | undefined {
+          return REGISTRY[id]?.valueKind;
+        }
+
+        export const ALL_IDS: readonly string[] = Object.keys(REGISTRY);
+
+        export function canonicalId(name: string): string | undefined {
+          if (name in REGISTRY) return name;
+          return ALIAS_MAP[name];
+        }
+
+        export function normalize(rawId: string | null | undefined): string | null {
+          if (!rawId) return null;
+          const s = rawId.trim();
+          if (!s) return null;
+          const match = s.match(/\\.([A-Za-z0-9-]+)$/);
+          if (!match) return canonicalId(s) ?? s;
+          const base = s.slice(0, s.length - match[0].length);
+          const lang = match[1];
+          const canonical = canonicalId(base) ?? base;
+          return `${canonical}.${lang}`;
+        }
+      TS
+
+      META_HELPERS = <<~TS.freeze
+        export function entry(irdi: string): MetaClassEntry | undefined {
+          return REGISTRY[irdi];
+        }
+
+        export function entityTypeFor(irdi: string): EntityType | undefined {
+          return REGISTRY[irdi]?.entityType;
+        }
+
+        export function codePropertyIdFor(irdi: string): string | undefined {
+          return REGISTRY[irdi]?.codePropertyId;
+        }
+
+        export function metaClassForType(type: EntityType): string | undefined {
+          for (const [irdi, e] of Object.entries(REGISTRY)) {
+            if (e.entityType === type) return irdi;
+          }
+          return undefined;
+        }
+
+        export const ALL_CODES: readonly string[] = Object.keys(REGISTRY);
+      TS
+    end
+  end
+end

data/lib/opencdd/codegen.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Opencdd
+  module Codegen
+    autoload :Ts, "opencdd/codegen/ts"
+  end
+end

data/lib/opencdd/composition_tree.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Opencdd
+  class CompositionTree
+    Node = Struct.new(:entity, :children, keyword_init: true) do
+      include Enumerable
+
+      def each(&block)
+        return enum_for(:each) unless block
+        walk(&block)
+      end
+
+      def walk(&block)
+        return enum_for(:walk) unless block
+        yield self
+        children&.each { |c| c.walk(&block) }
+        self
+      end
+
+      def leaf?
+        children.nil? || children.empty?
+      end
+
+      def depth
+        return 1 if leaf?
+        1 + children.map(&:depth).max
+      end
+
+      def size
+        walk.count
+      end
+
+      # Polymorphic dispatch via Entity#type — no `is_a?` chains.
+      # Adding a new entity type that should participate in trees
+      # means giving it the right `type` (already required); no
+      # edits to this file.
+      def classes
+        walk.filter_map { |n| n.entity if n.entity.type == :class }
+      end
+
+      def properties
+        walk.filter_map { |n| n.entity if n.entity.type == :property }
+      end
+    end
+
+    attr_reader :database
+
+    def initialize(database)
+      @database = database
+    end
+
+    def for(klass, max_depth: 10)
+      build_class_node(klass, Set.new, 0, max_depth)
+    end
+
+    private
+
+    def build_class_node(value, path, depth, max_depth)
+      klass = resolve_klass(value)
+      return nil unless klass
+
+      children =
+        if path.include?(klass.irdi) || depth >= max_depth
+          []
+        else
+          build_property_children(klass, path + [klass.irdi], depth + 1, max_depth)
+        end
+
+      Node.new(entity: klass, children: children)
+    end
+
+    def build_property_children(klass, path, depth, max_depth)
+      result = @database.effective_properties.for(klass)
+      result.map do |prop|
+        build_property_node(prop, path, depth, max_depth)
+      end
+    end
+
+    def build_property_node(prop, path, depth, max_depth)
+      sub = []
+      if depth < max_depth && prop.type == :property
+        class_reference_target(prop) do |target|
+          node = build_class_node(target, path, depth, max_depth)
+          sub << node if node
+        end
+        definition_class_subclasses(prop) do |target|
+          node = build_class_node(target, path, depth, max_depth)
+          sub << node if node
+        end
+      end
+      Node.new(entity: prop, children: sub)
+    end
+
+    def class_reference_target(prop)
+      return unless prop.class_reference?
+      dt = prop.parsed_data_type
+      return unless dt&.class_reference?
+      target = @database.resolve_reference(dt.class_identifier)
+      yield target if target&.type == :class
+    end
+
+    def definition_class_subclasses(prop)
+      dc_irdi = prop.definition_class_irdi
+      return unless dc_irdi
+      definition_class = @database.find(dc_irdi)
+      return unless definition_class&.type == :class && definition_class.categorical?
+      definition_class.children.each do |child|
+        yield child if child&.type == :class
+      end
+    end
+
+    def resolve_klass(value)
+      entity = value.is_a?(Opencdd::Entity) ? value : @database.resolve_reference(value)
+      entity&.type == :class ? entity : nil
+    end
+  end
+end

data/lib/opencdd/condition.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Opencdd
+  class Condition
+    SET_PATTERN = /\A\{(?<body>.*)\}\z/m.freeze
+    EXPRESSION_PATTERN = /\A
+      (?<left>[^=!<>]+?)
+      \s*
+      (?<op>==|!=)
+      \s*
+      (?<right>.+)
+    \z/x.freeze
+
+    attr_reader :left, :operator, :right
+
+    def initialize(left, operator, right)
+      @left = left.to_s.strip
+      unless %w[== !=].include?(operator.to_s)
+        raise ArgumentError, "unsupported condition operator: #{operator.inspect}"
+      end
+      @operator = operator.to_s
+      @right = right
+    end
+
+    def set?
+      @right.is_a?(Set)
+    end
+
+    def satisfied_by?(bindings)
+      hash = bindings.is_a?(Hash) ? bindings : bindings.to_h
+      actual = hash[@left] || hash[@left.to_sym]
+      return false if actual.nil?
+
+      if set?
+        contained = @right.any? { |r| matches?(actual, r) }
+        @operator == "==" ? contained : !contained
+      else
+        equal = matches?(actual, @right)
+        @operator == "==" ? equal : !equal
+      end
+    end
+
+    def to_s
+      rhs = if set?
+              "{ #{@right.to_a.join(", ")} }"
+            elsif quoted_literal?(@right)
+              "\"#{@right}\""
+            else
+              @right.to_s
+            end
+      "#{@left} #{@operator} #{rhs}"
+    end
+
+    alias_method :inspect, :to_s
+
+    def ==(other)
+      other.is_a?(Opencdd::Condition) &&
+        @left == other.left &&
+        @operator == other.operator &&
+        normalize_for_eq(@right) == normalize_for_eq(other.right)
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [@left, @operator, normalize_for_eq(@right)].hash
+    end
+
+    class << self
+      def parse(raw)
+        return nil if raw.nil? || raw.to_s.strip.empty?
+        s = raw.to_s.strip
+        if s =~ EXPRESSION_PATTERN
+          left = Regexp.last_match(:left).strip
+          op   = Regexp.last_match(:op)
+          raw_right = Regexp.last_match(:right).strip
+          new(left, op, parse_rhs(raw_right))
+        else
+          raise ArgumentError, "invalid condition expression: #{s.inspect}"
+        end
+      end
+
+      private
+
+      def parse_rhs(rhs)
+        if rhs =~ SET_PATTERN
+          body = Regexp.last_match(:body)
+          elements = body.split(/[,\s]+/).map(&:strip).reject(&:empty?)
+          Set.new(elements)
+        else
+          unquote(rhs)
+        end
+      end
+
+      def unquote(s)
+        s = s.strip
+        return s[1..-2] if s.start_with?('"') && s.end_with?('"')
+        return s[1..-2] if s.start_with?("'") && s.end_with?("'")
+        s
+      end
+    end
+
+    private
+
+    def matches?(actual, expected)
+      actual.to_s == expected.to_s
+    end
+
+    def quoted_literal?(value)
+      s = value.to_s
+      (s.start_with?('"') && s.end_with?('"')) ||
+        (s.start_with?("'") && s.end_with?("'"))
+    end
+
+    def normalize_for_eq(value)
+      value.is_a?(Set) ? value.to_a.sort : value
+    end
+  end
+end

data/lib/opencdd/data_type.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Opencdd
+  class DataType
+    SIMPLE = %w[
+      STRING_TYPE TRANSLATABLE_STRING_TYPE REAL_TYPE INTEGER_TYPE INT_TYPE
+      BOOLEAN_TYPE DATE_TYPE DATE_TIME_TYPE DATETIME_TYPE TIME_TYPE
+      IRDI_TYPE ICID_STRING ICID_STRING_TYPE URL_TYPE MIME_TYPE FILE_TYPE
+      COMPLEX_TYPE
+    ].freeze
+
+    MEASURE = %w[REAL_MEASURE_TYPE INTEGER_MEASURE_TYPE INT_MEASURE_TYPE].freeze
+
+    PARAMETERIZED = %w[CLASS_REFERENCE ENUM_STRING_TYPE ENUM_REFERENCE_TYPE].freeze
+
+    attr_reader :kind
+
+    def initialize(kind)
+      @kind = kind.to_s
+    end
+
+    def simple?    = SIMPLE.include?(@kind)
+    def measure?   = MEASURE.include?(@kind)
+    # Base default — overridden by reference-carrying subclasses.
+    # Replaces the previous `is_a?` chain across ClassReference /
+    # EnumStringType / EnumReferenceType with per-subclass override.
+    def reference? = false
+
+    def parameterized? = PARAMETERIZED.include?(@kind)
+
+    def class_reference? = false
+    def enum?            = false
+
+    def ==(other)
+      other.is_a?(Opencdd::DataType) && to_s == other.to_s
+    end
+    alias_method :eql?, :==
+
+    def hash
+      to_s.hash
+    end
+
+    def to_s
+      @kind
+    end
+
+    alias_method :inspect, :to_s
+
+    class RealMeasureType < DataType
+      def initialize
+        super("REAL_MEASURE_TYPE")
+      end
+    end
+
+    class IntegerMeasureType < DataType
+      def initialize
+        super("INTEGER_MEASURE_TYPE")
+      end
+    end
+
+    class ClassReference < DataType
+      attr_reader :class_identifier
+
+      def initialize(class_identifier)
+        super("CLASS_REFERENCE")
+        @class_identifier = class_identifier.to_s
+      end
+
+      def class_reference? = true
+      def reference?       = true
+
+      def to_s
+        "CLASS_REFERENCE(#{@class_identifier})"
+      end
+    end
+
+    class EnumStringType < DataType
+      attr_reader :value_list_identifier
+
+      def initialize(value_list_identifier)
+        super("ENUM_STRING_TYPE")
+        @value_list_identifier = value_list_identifier.to_s
+      end
+
+      def enum?      = true
+      def reference? = true
+
+      def to_s
+        "ENUM_STRING_TYPE(#{@value_list_identifier})"
+      end
+    end
+
+    class EnumReferenceType < DataType
+      attr_reader :value_list_identifier
+
+      def initialize(value_list_identifier)
+        super("ENUM_REFERENCE_TYPE")
+        @value_list_identifier = value_list_identifier.to_s
+      end
+
+      def enum?      = true
+      def reference? = true
+
+      def to_s
+        "ENUM_REFERENCE_TYPE(#{@value_list_identifier})"
+      end
+    end
+
+    class << self
+      def parse(raw)
+        return nil if raw.nil? || raw.to_s.strip.empty?
+        s = raw.to_s.strip
+
+        if s =~ /\ACLASS_REFERENCE\s*\(\s*(.+?)\s*\)\z/
+          return ClassReference.new(Regexp.last_match(1))
+        end
+        if s =~ /\AENUM_STRING_TYPE\s*\(\s*(.+?)\s*\)\z/
+          return EnumStringType.new(Regexp.last_match(1))
+        end
+        if s =~ /\AENUM_REFERENCE_TYPE\s*\(\s*(.+?)\s*\)\z/
+          return EnumReferenceType.new(Regexp.last_match(1))
+        end
+
+        case s
+        when "REAL_MEASURE_TYPE", "REAL_MEASURE"
+          RealMeasureType.new
+        when "INTEGER_MEASURE_TYPE", "INT_MEASURE_TYPE", "INTEGER_MEASURE", "INT_MEASURE"
+          IntegerMeasureType.new
+        when *SIMPLE
+          new(s)
+        else
+          raise ArgumentError, "unknown data_type: #{s.inspect}"
+        end
+      end
+
+      def parse_or_string(raw)
+        parse(raw)
+      rescue ArgumentError
+        raw.to_s
+      end
+    end
+  end
+end