odin-foundation 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 41cba3e1d6ec4a7cc481423fcb6ec0ddaba15b17dbe097fdb283e2f75ea75a26
+  data.tar.gz: c114129c45abc953e0e1f8e181d6f3c35037768bd2c3f9bc89c01798492c916b
+SHA512:
+  metadata.gz: f66842bdf339de14334c2f83e2f4c739b8ab4f82fb5040050a687a28b002695bade7ce71c90928bb620597c502ee5aee4b5e81b837787148d4c916fe23657c64
+  data.tar.gz: d4bfeeb7605d2de792b932da4d9b551e667ca53cbd965e27edc47d9b554ffc8dc060dd77e62bcab89290d93d551a98acba4adc5035c9ab37828df67911174971

data/lib/odin/diff/differ.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Odin
+  module Diff
+    class Differ
+      def compute_diff(doc_a, doc_b)
+        paths_a = Set.new(doc_a.paths)
+        paths_b = Set.new(doc_b.paths)
+
+        removed = []
+        changed = []
+        added = []
+
+        # 1. Find removed: in A but not in B
+        (paths_a - paths_b).sort.each do |path|
+          removed << Types::DiffEntry.new(
+            path: path,
+            value: doc_a.get(path),
+            modifiers: doc_a.modifiers_for(path)
+          )
+        end
+
+        # 2. Find added: in B but not in A
+        (paths_b - paths_a).sort.each do |path|
+          added << Types::DiffEntry.new(
+            path: path,
+            value: doc_b.get(path),
+            modifiers: doc_b.modifiers_for(path)
+          )
+        end
+
+        # 3. Find changed: in both but different value or modifiers
+        (paths_a & paths_b).sort.each do |path|
+          val_a = doc_a.get(path)
+          val_b = doc_b.get(path)
+          mod_a = doc_a.modifiers_for(path)
+          mod_b = doc_b.modifiers_for(path)
+
+          unless values_equal?(val_a, val_b) && modifiers_equal?(mod_a, mod_b)
+            changed << Types::DiffChange.new(
+              path: path,
+              old_value: val_a,
+              new_value: val_b,
+              old_modifiers: mod_a,
+              new_modifiers: mod_b
+            )
+          end
+        end
+
+        # 4. Detect moves: removed value that appears as added value
+        moved = detect_moves(removed, added)
+
+        Types::OdinDiff.new(
+          added: added,
+          removed: removed,
+          changed: changed,
+          moved: moved
+        )
+      end
+
+      private
+
+      def values_equal?(a, b)
+        return a.nil? && b.nil? if a.nil? || b.nil?
+
+        a == b
+      end
+
+      def modifiers_equal?(a, b)
+        # Treat nil and NONE (all false) as equivalent
+        a_req = a&.required || false
+        b_req = b&.required || false
+        a_conf = a&.confidential || false
+        b_conf = b&.confidential || false
+        a_dep = a&.deprecated || false
+        b_dep = b&.deprecated || false
+        a_req == b_req && a_conf == b_conf && a_dep == b_dep
+      end
+
+      def detect_moves(removed, added)
+        moves = []
+        removed_matched = Set.new
+        added_matched = Set.new
+
+        removed.each_with_index do |rem_entry, ri|
+          next if removed_matched.include?(ri)
+
+          added.each_with_index do |add_entry, ai|
+            next if added_matched.include?(ai)
+
+            if values_equal?(rem_entry.value, add_entry.value)
+              moves << Types::DiffMove.new(
+                from_path: rem_entry.path,
+                to_path: add_entry.path,
+                value: rem_entry.value,
+                modifiers: rem_entry.modifiers
+              )
+              removed_matched << ri
+              added_matched << ai
+              break
+            end
+          end
+        end
+
+        # Remove matched entries from removed/added lists (mutate in-place)
+        removed_matched.sort.reverse_each { |i| removed.delete_at(i) }
+        added_matched.sort.reverse_each { |i| added.delete_at(i) }
+
+        moves
+      end
+    end
+  end
+end

data/lib/odin/diff/patcher.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Odin
+  module Diff
+    class Patcher
+      def apply_patch(doc, diff)
+        return clone_document(doc) if diff.empty?
+
+        builder = Types::OdinDocumentBuilder.new
+
+        # Build set of paths to skip (removed + move sources)
+        removed_paths = Set.new(diff.removed.map(&:path))
+        moved_from_paths = Set.new(diff.moved.map(&:from_path))
+        changed_paths = Set.new(diff.changed.map(&:path))
+        skip_paths = removed_paths | moved_from_paths
+
+        # 1. Copy existing assignments (except removed, moved-from, and changed)
+        doc.each_assignment do |path, value|
+          next if skip_paths.include?(path) || changed_paths.include?(path)
+
+          builder.set(path, value, modifiers: doc.modifiers_for(path))
+        end
+
+        # 2. Apply changes (update values and/or modifiers)
+        diff.changed.each do |change|
+          builder.set(change.path, change.new_value, modifiers: change.new_modifiers)
+        end
+
+        # 3. Apply moves (add at new path)
+        diff.moved.each do |move|
+          mods = doc.modifiers_for(move.from_path)
+          builder.set(move.to_path, move.value, modifiers: mods)
+        end
+
+        # 4. Apply additions
+        diff.added.each do |entry|
+          builder.set(entry.path, entry.value, modifiers: entry.modifiers)
+        end
+
+        # 5. Copy metadata
+        doc.each_metadata do |key, value|
+          builder.set_metadata(key, value)
+        end
+
+        builder.build
+      end
+
+      private
+
+      def clone_document(doc)
+        builder = Types::OdinDocumentBuilder.new
+        doc.each_assignment do |path, value|
+          builder.set(path, value, modifiers: doc.modifiers_for(path))
+        end
+        doc.each_metadata do |key, value|
+          builder.set_metadata(key, value)
+        end
+        builder.build
+      end
+    end
+  end
+end

data/lib/odin/export.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require "json"
+require "bigdecimal"
+
+module Odin
+  module Export
+    # Convert OdinDocument to JSON string
+    def self.to_json(doc, pretty: true)
+      obj = doc_to_json_obj(doc)
+      if pretty
+        JSON.pretty_generate(obj)
+      else
+        JSON.generate(obj)
+      end
+    end
+
+    # Convert OdinDocument to XML string
+    def self.to_xml(doc, root: "root", preserve_types: false, preserve_modifiers: false)
+      # When preserving modifiers, always preserve types too (matches Java behavior)
+      preserve_types = true if preserve_modifiers
+
+      xml = +%{<?xml version="1.0" encoding="UTF-8"?>\n}
+
+      ns = ""
+      if preserve_types || preserve_modifiers
+        ns = ' xmlns:odin="https://odin.foundation/ns"'
+      end
+
+      xml << "<#{root}#{ns}>\n"
+      emit_xml_assignments(doc, xml, 1, preserve_types, preserve_modifiers)
+      xml << "</#{root}>\n"
+      xml
+    end
+
+    # Convert OdinDocument to CSV string
+    def self.to_csv(doc)
+      # Find array pattern: path[index].field
+      array_pattern = /\A(.+?)\[(\d+)\]\.(.+)\z/
+      rows = {}
+      columns = []
+
+      doc.each_assignment do |path, value|
+        m = array_pattern.match(path)
+        next unless m
+
+        idx = m[2].to_i
+        field = m[3]
+        rows[idx] ||= {}
+        rows[idx][field] = value
+        columns << field unless columns.include?(field)
+      end
+
+      return "" if rows.empty? || columns.empty?
+
+      lines = []
+      lines << columns.map { |c| csv_escape(c) }.join(",")
+
+      rows.keys.sort.each do |idx|
+        row = rows[idx]
+        cells = columns.map do |col|
+          val = row[col]
+          val ? csv_escape(odin_value_to_string(val)) : ""
+        end
+        lines << cells.join(",")
+      end
+
+      lines.join("\n") + "\n"
+    end
+
+    # Convert OdinDocument to fixed-width string
+    def self.to_fixed_width(doc, columns:, line_width: nil)
+      total_width = line_width || columns.map { |c| (c[:pos] || 0) + (c[:len] || 0) }.max || 80
+
+      line = " " * total_width
+      columns.each do |col|
+        pos = col[:pos] || 0
+        len = col[:len] || 0
+        pad_char = col[:pad] || " "
+        align = col[:align] || :left
+        field_path = col[:path] || col[:name]
+
+        val = doc.get(field_path)
+        raw = val ? odin_value_to_string(val) : ""
+        raw = raw[0...len] if raw.length > len
+
+        padded = if align == :right
+                   raw.rjust(len, pad_char)
+                 else
+                   raw.ljust(len, pad_char)
+                 end
+
+        padded.chars.each_with_index do |ch, i|
+          line[pos + i] = ch if pos + i < total_width
+        end
+      end
+
+      line.rstrip + "\n"
+    end
+
+    # ── Private Helpers ──
+
+    def self.doc_to_json_obj(doc)
+      result = {}
+      # Build nested structure from flat path assignments
+      doc.each_assignment do |path, value|
+        set_nested_json(result, path, odin_value_to_json(value))
+      end
+
+      # Include metadata header as "$" key
+      meta = {}
+      doc.each_metadata do |key, value|
+        meta[key] = odin_value_to_json(value)
+      end
+      result["$"] = meta unless meta.empty?
+
+      result
+    end
+
+    def self.set_nested_json(root, path, value)
+      segments = parse_path(path)
+      current = root
+
+      segments[0...-1].each_with_index do |seg, idx|
+        next_seg = segments[idx + 1]
+        if seg.is_a?(Integer)
+          current[seg] ||= next_seg.is_a?(Integer) ? [] : {}
+          current = current[seg]
+        else
+          if next_seg.is_a?(Integer)
+            current[seg] ||= []
+          else
+            current[seg] ||= {}
+          end
+          current = current[seg]
+        end
+      end
+
+      last = segments.last
+      current[last] = value
+    end
+
+    def self.parse_path(path)
+      segments = []
+      # Split on dots but handle bracket notation
+      parts = path.split(".")
+      parts.each do |part|
+        if part.include?("[")
+          # e.g., "items[0]" -> "items", 0
+          part.scan(/([^\[\]]+)|\[(\d+)\]/) do |name, index|
+            if index
+              segments << index.to_i
+            else
+              segments << name
+            end
+          end
+        else
+          segments << part
+        end
+      end
+      segments
+    end
+
+    def self.odin_value_to_json(val)
+      case val
+      when Types::OdinNull then nil
+      when Types::OdinBoolean then val.value
+      when Types::OdinString then val.value
+      when Types::OdinInteger then val.value
+      when Types::OdinNumber then val.value
+      when Types::OdinCurrency
+        f = val.value.to_f
+        f == f.to_i && f.abs < 1e15 ? f.to_i : f
+      when Types::OdinPercent then val.value
+      when Types::OdinDate then val.raw || val.value.to_s
+      when Types::OdinTimestamp then val.raw || val.value.to_s
+      when Types::OdinTime then val.value
+      when Types::OdinDuration then val.value
+      when Types::OdinReference then "@#{val.path}"
+      when Types::OdinBinary
+        val.algorithm ? "^#{val.algorithm}:#{val.data}" : "^#{val.data}"
+      when Types::OdinArray
+        val.items.map { |item|
+          item.is_a?(Types::ArrayItem) ? odin_value_to_json(item.value) : odin_value_to_json(item)
+        }
+      when Types::OdinObject
+        val.entries.transform_values { |v| odin_value_to_json(v) }
+      else
+        val.respond_to?(:value) ? val.value : nil
+      end
+    end
+
+    def self.odin_value_to_string(val)
+      case val
+      when Types::OdinNull then ""
+      when Types::OdinBoolean then val.value.to_s
+      when Types::OdinString then val.value
+      when Types::OdinInteger then (val.raw || val.value.to_s)
+      when Types::OdinNumber then (val.raw || format_num(val.value))
+      when Types::OdinCurrency
+        val.raw || val.value.to_s("F")
+      when Types::OdinPercent then (val.raw || format_num(val.value))
+      when Types::OdinDate then val.raw || val.value.to_s
+      when Types::OdinTimestamp then val.raw || val.value.to_s
+      when Types::OdinTime then val.value
+      when Types::OdinDuration then val.value
+      when Types::OdinReference then "@#{val.path}"
+      when Types::OdinBinary
+        val.algorithm ? "^#{val.algorithm}:#{val.data}" : "^#{val.data}"
+      else
+        val.respond_to?(:value) ? val.value.to_s : ""
+      end
+    end
+
+    def self.format_num(v)
+      v == v.to_i && v.abs < 1e15 ? v.to_i.to_s : v.to_s
+    end
+
+    def self.emit_xml_assignments(doc, xml, depth, preserve_types, preserve_modifiers)
+      indent = "  " * depth
+
+      # Group assignments by top-level section
+      sections = {}
+      doc.each_assignment do |path, value|
+        parts = path.split(".", 2)
+        section = parts[0]
+        remainder = parts[1]
+
+        sections[section] ||= []
+        sections[section] << [remainder, value, path]
+      end
+
+      sections.each do |section, entries|
+        if entries.size == 1 && entries[0][0].nil?
+          # Simple field
+          _, value, full_path = entries[0]
+          emit_xml_value(xml, section, value, full_path, doc, indent, depth,
+                         preserve_types, preserve_modifiers)
+        else
+          # Nested section
+          xml << "#{indent}<#{sanitize_xml_name(section)}>\n"
+          entries.each do |remainder, value, full_path|
+            if remainder
+              emit_xml_value(xml, remainder.split(".").last, value, full_path, doc,
+                             "  " * (depth + 1), depth + 1, preserve_types, preserve_modifiers)
+            else
+              emit_xml_value(xml, section, value, full_path, doc, "  " * (depth + 1),
+                             depth + 1, preserve_types, preserve_modifiers)
+            end
+          end
+          xml << "#{indent}</#{sanitize_xml_name(section)}>\n"
+        end
+      end
+    end
+
+    def self.emit_xml_value(xml, name, value, full_path, doc, indent, _depth,
+                            preserve_types, preserve_modifiers)
+      safe_name = sanitize_xml_name(name)
+      attrs = +""
+
+      if preserve_types
+        type_name = xml_type_name(value)
+        attrs << " odin:type=\"#{type_name}\"" if type_name
+        if value.is_a?(Types::OdinCurrency) && value.currency_code
+          attrs << " odin:currencyCode=\"#{value.currency_code}\""
+        end
+      end
+
+      if preserve_modifiers
+        mods = value.modifiers || doc.modifiers_for(full_path)
+        if mods
+          attrs << ' odin:required="true"' if mods.required
+          attrs << ' odin:confidential="true"' if mods.confidential
+          attrs << ' odin:deprecated="true"' if mods.deprecated
+        end
+      end
+
+      # Skip null values in XML output (omit them entirely)
+      return if value.is_a?(Types::OdinNull)
+
+      text = xml_escape(odin_value_to_string(value))
+      xml << "#{indent}<#{safe_name}#{attrs}>#{text}</#{safe_name}>\n"
+    end
+
+    def self.xml_type_name(value)
+      case value
+      when Types::OdinInteger then "integer"
+      when Types::OdinNumber then "number"
+      when Types::OdinCurrency then "currency"
+      when Types::OdinPercent then "percent"
+      when Types::OdinBoolean then "boolean"
+      when Types::OdinDate then "date"
+      when Types::OdinTimestamp then "timestamp"
+      when Types::OdinTime then "time"
+      when Types::OdinDuration then "duration"
+      when Types::OdinReference then "reference"
+      when Types::OdinBinary then "binary"
+      else nil # string and null don't need type attr
+      end
+    end
+
+    def self.sanitize_xml_name(name)
+      name = name.to_s.gsub(/[^a-zA-Z0-9._-]/, "_")
+      name = "_#{name}" if name.match?(/\A\d/)
+      name = "element" if name.empty?
+      name
+    end
+
+    def self.xml_escape(s)
+      s.gsub("&", "&amp;")
+       .gsub("<", "&lt;")
+       .gsub(">", "&gt;")
+       .gsub('"', "&quot;")
+       .gsub("'", "&apos;")
+    end
+
+    def self.csv_escape(s)
+      if s.include?(",") || s.include?('"') || s.include?("\n") || s.include?("\r")
+        '"' + s.gsub('"', '""') + '"'
+      else
+        s
+      end
+    end
+
+    private_class_method :doc_to_json_obj, :set_nested_json, :parse_path,
+                         :odin_value_to_json, :odin_value_to_string, :format_num,
+                         :emit_xml_assignments, :emit_xml_value, :xml_type_name,
+                         :sanitize_xml_name, :xml_escape, :csv_escape
+  end
+end