odin-foundation 1.0.0

data/lib/odin/types/directive.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Odin
+  module Types
+    class OdinDirective
+      attr_reader :name, :value
+
+      def initialize(name, value = nil)
+        @name = -name.to_s
+        @value = value&.freeze
+        freeze
+      end
+
+      def ==(other)
+        other.is_a?(OdinDirective) && name == other.name && value == other.value
+      end
+      alias eql? ==
+
+      def hash
+        [name, value].hash
+      end
+
+      def to_s
+        value ? "#{name}(#{value})" : name
+      end
+    end
+  end
+end

data/lib/odin/types/document.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Odin
+  module Types
+    class OdinDocument
+      def initialize(assignments:, metadata:, modifiers:, comments:)
+        @assignments = assignments.freeze
+        @metadata = metadata.freeze
+        @modifiers = modifiers.freeze
+        @comments = comments.freeze
+        freeze
+      end
+
+      def get(path)
+        @assignments[path]
+      end
+
+      def [](path)
+        get(path)
+      end
+
+      def paths
+        @assignments.keys
+      end
+
+      def include?(path)
+        @assignments.key?(path)
+      end
+      alias has_path? include?
+
+      def size
+        @assignments.size
+      end
+      alias length size
+
+      def assignments
+        @assignments
+      end
+
+      def metadata
+        @metadata
+      end
+
+      def metadata_value(key)
+        @metadata[key]
+      end
+
+      def modifiers_for(path)
+        @modifiers[path]
+      end
+
+      def all_modifiers
+        @modifiers
+      end
+
+      def comment_for(path)
+        @comments[path]
+      end
+
+      def all_comments
+        @comments
+      end
+
+      def empty?
+        @assignments.empty? && @metadata.empty?
+      end
+
+      def each_assignment(&block)
+        @assignments.each(&block)
+      end
+
+      def each_metadata(&block)
+        @metadata.each(&block)
+      end
+
+      def ==(other)
+        other.is_a?(OdinDocument) &&
+          assignments == other.assignments &&
+          metadata == other.metadata
+      end
+      alias eql? ==
+
+      def hash
+        [assignments, metadata].hash
+      end
+
+      def self.empty
+        new(assignments: {}, metadata: {}, modifiers: {}, comments: {})
+      end
+    end
+  end
+end

data/lib/odin/types/document_builder.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Odin
+  module Types
+    class OdinDocumentBuilder
+      def initialize
+        @assignments = {}
+        @metadata = {}
+        @modifiers = {}
+        @comments = {}
+      end
+
+      def set(path, value, modifiers: nil, comment: nil)
+        @assignments[path] = value
+        @modifiers[path] = modifiers if modifiers
+        @comments[path] = comment if comment
+        self
+      end
+
+      def set_metadata(key, value)
+        @metadata[key] = value
+        self
+      end
+
+      def set_string(path, value, modifiers: nil)
+        set(path, OdinString.new(value), modifiers: modifiers)
+      end
+
+      def set_integer(path, value, modifiers: nil)
+        set(path, OdinInteger.new(value), modifiers: modifiers)
+      end
+
+      def set_number(path, value, modifiers: nil)
+        set(path, OdinNumber.new(value), modifiers: modifiers)
+      end
+
+      def set_boolean(path, value, modifiers: nil)
+        set(path, value ? TRUE_VAL : FALSE_VAL, modifiers: modifiers)
+      end
+
+      def set_null(path, modifiers: nil)
+        set(path, NULL, modifiers: modifiers)
+      end
+
+      def set_currency(path, value, currency_code: nil, decimal_places: 2, modifiers: nil)
+        set(path, OdinCurrency.new(value, currency_code: currency_code,
+                                          decimal_places: decimal_places), modifiers: modifiers)
+      end
+
+      def remove(path)
+        @assignments.delete(path)
+        @modifiers.delete(path)
+        @comments.delete(path)
+        self
+      end
+
+      def build
+        OdinDocument.new(
+          assignments: @assignments.dup,
+          metadata: @metadata.dup,
+          modifiers: @modifiers.dup,
+          comments: @comments.dup
+        )
+      end
+    end
+  end
+end

data/lib/odin/types/dyn_value.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require "json"
+require "bigdecimal"
+
+module Odin
+  module Types
+    class DynValue
+      TYPES = %i[
+        null bool integer float float_raw
+        currency currency_raw percent reference binary
+        date timestamp time duration
+        string array object
+      ].freeze
+
+      attr_reader :type, :value, :decimal_places, :currency_code
+
+      def initialize(type:, value: nil, decimal_places: 0, currency_code: nil)
+        @type = type
+        @value = value
+        @decimal_places = decimal_places
+        @currency_code = currency_code&.freeze
+        freeze
+      end
+
+      # Factory methods
+      def self.of_null
+        new(type: :null)
+      end
+
+      def self.of_bool(v)
+        new(type: :bool, value: v)
+      end
+
+      def self.of_integer(v)
+        new(type: :integer, value: v.to_i)
+      end
+
+      def self.of_float(v)
+        new(type: :float, value: v.to_f)
+      end
+
+      def self.of_float_raw(raw)
+        new(type: :float_raw, value: raw.to_s)
+      end
+
+      def self.of_string(v)
+        new(type: :string, value: v.to_s)
+      end
+
+      def self.of_array(items)
+        new(type: :array, value: items)
+      end
+
+      def self.of_object(entries)
+        new(type: :object, value: entries)
+      end
+
+      def self.of_currency(v, dp = 2, code = nil)
+        new(type: :currency, value: v.to_f, decimal_places: dp, currency_code: code)
+      end
+
+      def self.of_currency_raw(raw, dp = 2, code = nil)
+        new(type: :currency_raw, value: raw.to_s, decimal_places: dp, currency_code: code)
+      end
+
+      def self.of_percent(v)
+        new(type: :percent, value: v.to_f)
+      end
+
+      def self.of_reference(p)
+        new(type: :reference, value: p.to_s)
+      end
+
+      def self.of_binary(data)
+        new(type: :binary, value: data)
+      end
+
+      def self.of_date(v)
+        new(type: :date, value: v)
+      end
+
+      def self.of_timestamp(v)
+        new(type: :timestamp, value: v)
+      end
+
+      def self.of_time(v)
+        new(type: :time, value: v.to_s)
+      end
+
+      def self.of_duration(v)
+        new(type: :duration, value: v.to_s)
+      end
+
+      # Helpers: parse JSON strings into DynValue arrays/objects
+      def self.extract_array(json_string)
+        parsed = JSON.parse(json_string)
+        raise ArgumentError, "Not a JSON array" unless parsed.is_a?(::Array)
+
+        of_array(parsed.map { |item| from_json_value(item) })
+      end
+
+      def self.extract_object(json_string)
+        parsed = JSON.parse(json_string)
+        raise ArgumentError, "Not a JSON object" unless parsed.is_a?(::Hash)
+
+        of_object(parsed.transform_values { |v| from_json_value(v) })
+      end
+
+      def self.from_json_value(val)
+        case val
+        when nil         then of_null
+        when true, false then of_bool(val)
+        when Integer     then of_integer(val)
+        when Float       then of_float(val)
+        when String      then of_string(val)
+        when Array       then of_array(val.map { |v| from_json_value(v) })
+        when Hash        then of_object(val.transform_values { |v| from_json_value(v) })
+        else of_string(val.to_s)
+        end
+      end
+
+      # Type predicates
+      def null?;      type == :null; end
+      def bool?;      type == :bool; end
+      def integer?;   type == :integer; end
+      def float?;     type == :float || type == :float_raw; end
+      def currency?;  type == :currency || type == :currency_raw; end
+      def percent?;   type == :percent; end
+      def string?;    type == :string; end
+      def array?;     type == :array; end
+      def object?;    type == :object; end
+      def reference?; type == :reference; end
+      def binary?;    type == :binary; end
+      def date?;      type == :date; end
+      def timestamp?; type == :timestamp; end
+      def time?;      type == :time; end
+      def duration?;  type == :duration; end
+      def numeric?;   integer? || float? || currency? || percent?; end
+
+      def temporal?; date? || timestamp? || time? || duration?; end
+
+      # Coercion accessors
+      def as_bool;    value; end
+      def as_int;     value.to_i; end
+      def as_float;   value.to_f; end
+      def as_string;  value.to_s; end
+      def as_array;   value; end
+      def as_object;  value; end
+
+      # Coerce to numeric value
+      def to_number
+        case type
+        when :integer then value
+        when :float then value
+        when :float_raw then value.to_f
+        when :currency then value.to_f
+        when :currency_raw then value.to_f
+        when :percent then value
+        when :string
+          return value.to_i if value.match?(/\A-?\d+\z/)
+          return value.to_f if value.match?(/\A-?\d+(\.\d+)?([eE][+-]?\d+)?\z/)
+
+          0
+        when :bool then value ? 1 : 0
+        else 0
+        end
+      end
+
+      # Coerce to string representation
+      def to_string
+        case type
+        when :null then ""
+        when :bool then value.to_s
+        when :integer, :float, :percent then value.to_s
+        when :float_raw, :currency_raw then value.to_s
+        when :currency then value.is_a?(BigDecimal) ? value.to_s("F") : value.to_s
+        when :string then value
+        when :array then JSON.generate(to_ruby)
+        when :object then JSON.generate(to_ruby)
+        else value.to_s
+        end
+      end
+
+      # Truthiness: null/false/0/"" are falsy
+      def truthy?
+        case type
+        when :null then false
+        when :bool then value
+        when :integer then value != 0
+        when :float, :float_raw then to_number != 0.0
+        when :string then !value.empty?
+        when :currency, :currency_raw then to_number != 0.0
+        when :percent then value != 0.0
+        when :array then true
+        when :object then true
+        else true
+        end
+      end
+
+      # Object/array access helpers
+      def get(key)
+        return nil unless object?
+
+        value[key]
+      end
+
+      def get_index(index)
+        return nil unless array?
+
+        value[index]
+      end
+
+      def ==(other)
+        other.is_a?(DynValue) && type == other.type && value == other.value &&
+          decimal_places == other.decimal_places && currency_code == other.currency_code
+      end
+      alias eql? ==
+
+      def hash
+        [type, value, decimal_places, currency_code].hash
+      end
+
+      # Convert Ruby native object to DynValue
+      def self.from_ruby(obj)
+        case obj
+        when DynValue    then obj
+        when nil         then of_null
+        when true, false then of_bool(obj)
+        when Integer     then of_integer(obj)
+        when Float       then of_float(obj)
+        when BigDecimal  then of_float(obj.to_f)
+        when String      then of_string(obj)
+        when Array       then of_array(obj.map { |v| from_ruby(v) })
+        when Hash        then of_object(obj.transform_keys(&:to_s).transform_values { |v| from_ruby(v) })
+        else of_string(obj.to_s)
+        end
+      end
+
+      # Convert DynValue to Ruby native object
+      def to_ruby
+        case type
+        when :null then nil
+        when :bool then value
+        when :integer then value
+        when :float then value
+        when :float_raw then value.to_f
+        when :string then value
+        when :currency then value.is_a?(BigDecimal) ? value.to_f : value.to_f
+        when :currency_raw then value.to_f
+        when :percent then value
+        when :date, :timestamp, :time, :duration then value.to_s
+        when :reference then value
+        when :binary then value
+        when :array then value.map(&:to_ruby)
+        when :object then value.transform_values(&:to_ruby)
+        else value
+        end
+      end
+
+      def to_s
+        case type
+        when :null then "null"
+        when :bool then value.to_s
+        else value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/odin/types/errors.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Odin
+  module Errors
+    module ParseErrorCode
+      UNEXPECTED_CHARACTER           = -"P001"
+      BARE_STRING_NOT_ALLOWED        = -"P002"
+      INVALID_ARRAY_INDEX            = -"P003"
+      UNTERMINATED_STRING            = -"P004"
+      INVALID_ESCAPE_SEQUENCE        = -"P005"
+      INVALID_TYPE_PREFIX            = -"P006"
+      DUPLICATE_PATH_ASSIGNMENT      = -"P007"
+      INVALID_HEADER_SYNTAX          = -"P008"
+      INVALID_DIRECTIVE              = -"P009"
+      MAXIMUM_DEPTH_EXCEEDED         = -"P010"
+      MAXIMUM_DOCUMENT_SIZE_EXCEEDED = -"P011"
+      INVALID_UTF8_SEQUENCE          = -"P012"
+      NON_CONTIGUOUS_ARRAY_INDICES   = -"P013"
+      EMPTY_DOCUMENT                 = -"P014"
+      ARRAY_INDEX_OUT_OF_RANGE       = -"P015"
+
+      ALL = {
+        "P001" => "Unexpected character",
+        "P002" => "Strings must be quoted",
+        "P003" => "Invalid array index",
+        "P004" => "Unterminated string",
+        "P005" => "Invalid escape sequence",
+        "P006" => "Invalid type prefix",
+        "P007" => "Duplicate path assignment",
+        "P008" => "Invalid header syntax",
+        "P009" => "Invalid directive",
+        "P010" => "Maximum depth exceeded",
+        "P011" => "Maximum document size exceeded",
+        "P012" => "Invalid UTF-8 sequence",
+        "P013" => "Non-contiguous array indices",
+        "P014" => "Empty document",
+        "P015" => "Array index out of range"
+      }.freeze
+
+      def self.message(code)
+        ALL[code] || "Unknown error"
+      end
+    end
+
+    module ValidationErrorCode
+      REQUIRED_FIELD_MISSING           = -"V001"
+      TYPE_MISMATCH                    = -"V002"
+      VALUE_OUT_OF_BOUNDS              = -"V003"
+      PATTERN_MISMATCH                 = -"V004"
+      INVALID_ENUM_VALUE               = -"V005"
+      ARRAY_LENGTH_VIOLATION           = -"V006"
+      UNIQUE_CONSTRAINT_VIOLATION      = -"V007"
+      INVARIANT_VIOLATION              = -"V008"
+      CARDINALITY_CONSTRAINT_VIOLATION = -"V009"
+      CONDITIONAL_REQUIREMENT_NOT_MET  = -"V010"
+      UNKNOWN_FIELD                    = -"V011"
+      CIRCULAR_REFERENCE               = -"V012"
+      UNRESOLVED_REFERENCE             = -"V013"
+
+      ALL = {
+        "V001" => "Required field missing",
+        "V002" => "Type mismatch",
+        "V003" => "Value out of bounds",
+        "V004" => "Pattern mismatch",
+        "V005" => "Invalid enum value",
+        "V006" => "Array length violation",
+        "V007" => "Unique constraint violation",
+        "V008" => "Invariant violation",
+        "V009" => "Cardinality constraint violation",
+        "V010" => "Conditional requirement not met",
+        "V011" => "Unknown field",
+        "V012" => "Circular reference",
+        "V013" => "Unresolved reference"
+      }.freeze
+
+      def self.message(code)
+        ALL[code] || "Unknown error"
+      end
+    end
+
+    class OdinError < StandardError
+      attr_reader :code
+
+      def initialize(code, message)
+        @code = code
+        super("[#{code}] #{message}")
+      end
+    end
+
+    class ParseError < OdinError
+      attr_reader :line, :column
+
+      def initialize(code, line, column, detail = nil)
+        @line = line
+        @column = column
+        msg = ParseErrorCode.message(code)
+        msg = "#{msg}: #{detail}" if detail
+        msg = "#{msg} at line #{line}, column #{column}"
+        super(code, msg)
+      end
+    end
+
+    class ValidationError
+      attr_reader :path, :code, :message, :expected, :actual, :schema_path
+
+      def initialize(code:, path:, message:, expected: nil, actual: nil, schema_path: nil)
+        @code = code
+        @path = path
+        @message = message
+        @expected = expected
+        @actual = actual
+        @schema_path = schema_path
+      end
+
+      def to_s
+        "[#{code}] #{message} at '#{path}'"
+      end
+    end
+
+    class ValidationResult
+      attr_reader :errors
+
+      def initialize(errors = [])
+        @errors = errors.freeze
+      end
+
+      def valid?
+        errors.empty?
+      end
+
+      def self.valid
+        new([])
+      end
+
+      def self.with_errors(errors)
+        new(errors)
+      end
+    end
+
+    class PatchError < OdinError
+      attr_reader :path
+
+      def initialize(message, path)
+        @path = path
+        super("PATCH", "#{message} at '#{path}'")
+      end
+    end
+  end
+end

data/lib/odin/types/modifiers.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Odin
+  module Types
+    class OdinModifiers
+      attr_reader :required, :confidential, :deprecated, :attr
+
+      def initialize(required: false, confidential: false, deprecated: false, attr: nil)
+        @required = required
+        @confidential = confidential
+        @deprecated = deprecated
+        @attr = attr
+        freeze
+      end
+
+      NONE = new
+
+      def any?
+        required || confidential || deprecated
+      end
+
+      def ==(other)
+        other.is_a?(OdinModifiers) &&
+          required == other.required &&
+          confidential == other.confidential &&
+          deprecated == other.deprecated &&
+          self.attr == other.attr
+      end
+      alias eql? ==
+
+      def hash
+        [required, confidential, deprecated, self.attr].hash
+      end
+
+      def to_s
+        parts = []
+        parts << "required" if required
+        parts << "confidential" if confidential
+        parts << "deprecated" if deprecated
+        parts << "attr=#{self.attr}" if self.attr
+        parts.empty? ? "OdinModifiers(none)" : "OdinModifiers(#{parts.join(', ')})"
+      end
+    end
+  end
+end