fhirpath-rb 0.1.1

data/lib/fhirpath/engine/nodes/fp_quantity.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Fhirpath
+  module Engine
+    module Nodes
+      # Ruby port of fhirpath-py's FP_Quantity (fhirpathpy/engine/nodes.py): printing back as
+      # "value unit", exposing `.value` through member invocation, the calendar duration/
+      # time-unit conversion-factor equality used by `=`/`distinct`/`repeat`/`intersect`
+      # (https://hl7.org/fhirpath/#equals), the more lenient `equivalent?` used by `~`, and
+      # `conv_unit_to` (used by `toQuantity(unit)` for explicit unit conversion, and by
+      # `general_equivalent?`/`deep_equal` below for cross-unit comparisons).
+      class FPQuantity
+        # Bare calendar-duration words and already-quoted UCUM codes all normalize to the
+        # quoted UCUM code, mirroring fhirpath-py's FP_Quantity.timeUnitsToUCUM.
+        TIME_UNITS_TO_UCUM = {
+          "years" => "'a'", "months" => "'mo'", "weeks" => "'wk'", "days" => "'d'",
+          "hours" => "'h'", "minutes" => "'min'", "seconds" => "'s'", "milliseconds" => "'ms'",
+          "year" => "'a'", "month" => "'mo'", "week" => "'wk'", "day" => "'d'",
+          "hour" => "'h'", "minute" => "'min'", "second" => "'s'", "millisecond" => "'ms'",
+          "'a'" => "'a'", "'mo'" => "'mo'", "'wk'" => "'wk'", "'d'" => "'d'",
+          "'h'" => "'h'", "'min'" => "'min'", "'s'" => "'s'", "'ms'" => "'ms'"
+        }.freeze
+
+        # Which quantity units are valid for date/time arithmetic (FPDateTime#plus/FPTime#plus),
+        # and which canonical duration unit each one means. Mirrors fhirpath-py's
+        # FP_Quantity._arithmetic_duration_units — deliberately narrower than TIME_UNITS_TO_UCUM
+        # above: the quoted UCUM year/month codes ("'a'"/"'mo'") are NOT valid here (only the
+        # bare words "year"/"month" are), per https://hl7.org/fhirpath/#datetime-arithmetic.
+        ARITHMETIC_DURATION_UNITS = {
+          "years" => :year, "months" => :month, "weeks" => :week, "days" => :day,
+          "hours" => :hour, "minutes" => :minute, "seconds" => :second, "milliseconds" => :millisecond,
+          "year" => :year, "month" => :month, "week" => :week, "day" => :day,
+          "hour" => :hour, "minute" => :minute, "second" => :second, "millisecond" => :millisecond,
+          "'wk'" => :week, "'d'" => :day, "'h'" => :hour,
+          "'min'" => :minute, "'s'" => :second, "'ms'" => :millisecond
+        }.freeze
+
+        YEAR_MONTH_FACTORS = {
+          "years" => BigDecimal("12"), "year" => BigDecimal("12"), "'a'" => BigDecimal("12"),
+          "months" => BigDecimal("1"), "month" => BigDecimal("1"), "'mo'" => BigDecimal("1")
+        }.freeze
+
+        TIME_FACTORS = {
+          "weeks" => BigDecimal("604800000"), "week" => BigDecimal("604800000"), "'wk'" => BigDecimal("604800000"),
+          "days" => BigDecimal("86400000"), "day" => BigDecimal("86400000"), "'d'" => BigDecimal("86400000"),
+          "hours" => BigDecimal("3600000"), "hour" => BigDecimal("3600000"), "'h'" => BigDecimal("3600000"),
+          "minutes" => BigDecimal("60000"), "minute" => BigDecimal("60000"), "'min'" => BigDecimal("60000"),
+          "seconds" => BigDecimal("1000"), "second" => BigDecimal("1000"), "'s'" => BigDecimal("1000"),
+          "milliseconds" => BigDecimal("1"), "millisecond" => BigDecimal("1"), "'ms'" => BigDecimal("1")
+        }.freeze
+
+        # conv_unit_to's year/month table is deliberately narrower than YEAR_MONTH_FACTORS above
+        # (only the quoted UCUM codes) — matches fhirpath-py's separate _year_month_conversion_factor.
+        CONV_YEAR_MONTH_FACTORS = { "'a'" => BigDecimal("12"), "'mo'" => BigDecimal("1") }.freeze
+
+        LENGTH_FACTORS = {
+          "'m'" => BigDecimal("1"), "'cm'" => BigDecimal("0.01"), "'mm'" => BigDecimal("0.001")
+        }.freeze
+
+        WEIGHT_FACTORS = {
+          "'kg'" => BigDecimal("1"), "lbs" => BigDecimal("0.453592"), "'[lb_av]'" => BigDecimal("0.453592")
+        }.freeze
+
+        attr_reader :value, :unit
+
+        def initialize(value, unit)
+          @value = value
+          @unit = unit
+        end
+
+        def to_s
+          "#{Util.format_number(value)} #{unit}"
+        end
+
+        # Per https://hl7.org/fhirpath/#equals, a UCUM "'a'" (annum, a fixed Julian year) is
+        # never equal to a calendar "year"/"years" even though both are 12 months for
+        # `equivalent?` purposes — only `=` makes this distinction, not `~`.
+        def ==(other)
+          return false unless other.is_a?(FPQuantity)
+          return false if year_month_category?(other) && (unit == "'a'" || other.unit == "'a'")
+
+          equivalent?(other)
+        end
+
+        def equivalent?(other)
+          return false unless other.is_a?(FPQuantity)
+          return general_equivalent?(other) unless same_convertible_category?(other)
+
+          scaled(self) == scaled(other)
+        end
+
+        def self.conv_unit_to(from_unit, value, to_unit)
+          convert_by_table(CONV_YEAR_MONTH_FACTORS, from_unit, value, to_unit) ||
+            convert_by_table(TIME_FACTORS, from_unit, value, to_unit) ||
+            convert_by_table(LENGTH_FACTORS, from_unit, value, to_unit) ||
+            convert_weight(from_unit, value, to_unit) ||
+            convert_mass(from_unit, value, to_unit)
+        end
+
+        def self.convert_by_table(factors, from_unit, value, to_unit)
+          from_factor = factors[from_unit]
+          to_factor = factors[to_unit]
+          return nil unless from_factor && to_factor
+
+          new(from_factor * value / to_factor, to_unit)
+        end
+        private_class_method :convert_by_table
+
+        def self.convert_weight(from_unit, value, to_unit)
+          from_factor = WEIGHT_FACTORS[from_unit]
+          to_factor = WEIGHT_FACTORS[to_unit]
+          return nil unless from_factor && to_factor
+
+          converted = (from_factor * value) / to_factor
+          new(converted.round(0, BigDecimal::ROUND_UP), to_unit)
+        end
+        private_class_method :convert_weight
+
+        private
+
+        def exact_match?(other)
+          value == other.value && unit == other.unit
+        end
+
+        def year_month_category?(other)
+          YEAR_MONTH_FACTORS.key?(unit) && YEAR_MONTH_FACTORS.key?(other.unit)
+        end
+
+        def same_convertible_category?(other)
+          year_month_category?(other) || (TIME_FACTORS.key?(unit) && TIME_FACTORS.key?(other.unit))
+        end
+
+        def scaled(quantity)
+          factor = YEAR_MONTH_FACTORS[quantity.unit] || TIME_FACTORS[quantity.unit]
+          quantity.value * factor
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/nodes/fp_quantity_deep_equal.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    module Nodes
+      # Reopens FPQuantity (see fp_quantity.rb) to add the mass (g/mg) conv_unit_to category,
+      # `#deep_equal` (used by `=`/`~` when comparing a raw FHIR Quantity element — converted to
+      # a System.Quantity by quoting its UCUM `code` as-is, e.g. code "a" becomes unit "'a'", see
+      # ResourceNode#convert_data — against a literal using the calendar *word* form "year";
+      # those must compare equal, unlike plain `==`, which deliberately excludes "'a'" from
+      # year/month equality), and `#equivalent?`'s general (non-year/month, non-weeks/days/time)
+      # fallback for `=`. Mirrors fhirpath-py's FP_Quantity.deep_equal and the "else" branch of
+      # FP_Quantity.__eq__; see Equality#pairwise_equal?/Equality#equivalence.
+      class FPQuantity
+        MASS_FACTORS = { "'g'" => BigDecimal("1"), "'mg'" => BigDecimal("0.001") }.freeze
+
+        # Mirrors fhirpath-py's FP_Quantity.mapUCUMCodeToTimeUnits.values() — the bare calendar
+        # words a converted-from-FHIR-Quantity's unit (always a quoted UCUM code) is compared
+        # against via #deep_equal rather than plain #==.
+        CALENDAR_WORDS = %w[year month week day hour minute second millisecond].freeze
+
+        def self.convert_mass(from_unit, value, to_unit)
+          from_factor = MASS_FACTORS[from_unit]
+          to_factor = MASS_FACTORS[to_unit]
+          return nil unless from_factor && to_factor
+
+          converted = (from_factor * value) / to_factor
+          new(converted.round(0, BigDecimal::ROUND_HALF_UP), to_unit)
+        end
+        private_class_method :convert_mass
+
+        def deep_equal(other)
+          return self == other unless other.is_a?(FPQuantity)
+          return equivalent?(other) if year_month_category?(other)
+          return self == other if unit == other.unit
+
+          round_trip_equal?(other)
+        end
+
+        private
+
+        def round_trip_equal?(other)
+          converted = self.class.conv_unit_to(unit, value, other.unit)
+          return self == other unless converted
+
+          reverse_converted = self.class.conv_unit_to(converted.unit, converted.value, unit)
+          return self == other unless reverse_converted
+
+          value == reverse_converted.value && unit == reverse_converted.unit
+        end
+
+        # Mirrors fhirpath-py's FP_Quantity.__eq__ "else" branch: units outside the year/month
+        # and weeks/days/time categories (e.g. length, weight, mass) are compared by converting
+        # one side to the other's unit — falling back to an exact value+unit match if they
+        # aren't in any shared convertible category at all.
+        def general_equivalent?(other)
+          return exact_match?(other) if unit == other.unit
+
+          converted = self.class.conv_unit_to(unit, value, other.unit)
+          return exact_match?(other) unless converted
+
+          other.value == converted.value && other.unit == converted.unit
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/nodes/fp_time.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Fhirpath
+  module Engine
+    module Nodes
+      # Minimal Ruby port of fhirpath-py's FP_Time (fhirpathpy/engine/nodes.py): printing a time
+      # literal back out verbatim, and the FHIRPath equals() comparison
+      # (https://hl7.org/fhirpath/#equals). Mirrors FPDateTime's approach (see there for the
+      # precision-comparison rationale); the leading "T" is optional since both a `@Thh:mm...`
+      # literal (stripped of "@T" before construction) and a raw "Thh:mm..." string (as stored
+      # in a resource) must parse the same. `#plus` (time + duration quantity arithmetic) lives
+      # in fp_time_arithmetic.rb, which reopens this class.
+      class FPTime
+        FORMAT = /
+          \AT?(?<hour>\d{2})
+          (?::(?<minute>\d{2})
+            (?::(?<second>\d{2})(?:\.(?<fraction>\d+))?)?
+          )?
+          (?<timezone>Z|[+-]\d{2}:\d{2})?
+        \z/x
+
+        COMPONENTS = %i[hour minute second].freeze
+        DEFAULTS = { hour: "0", minute: "0", second: "0" }.freeze
+        TIME_READERS = { hour: :hour, minute: :min, second: :sec }.freeze
+
+        attr_reader :source
+
+        def initialize(source)
+          @source = source
+          @match = FORMAT.match(source)
+          raise Fhirpath::Error, "Invalid time literal: #{source}" unless @match
+        end
+
+        def to_s
+          source
+        end
+
+        def ==(other)
+          equals(other) == true
+        end
+
+        # See FPDateTime#equals for the precision-comparison rationale.
+        def equals(other)
+          return false unless other.is_a?(self.class)
+
+          fields = shared_fields(other)
+          self_precision, other_precision = precisions(other, fields)
+
+          return time_of_day == other.time_of_day if self_precision == other_precision
+
+          compare_up_to_min_precision(other, fields, [self_precision, other_precision].min)
+        end
+
+        def to_instant
+          Time.new(2000, 1, 1, component_value(:hour), component_value(:minute), second_value, timezone).getutc
+        end
+
+        # A timezone shift can roll the fixed reference date in to_instant over to the next (or
+        # previous) day; unlike DateTime, Time comparisons only care about wall-clock time, so
+        # this discards the date and keeps just seconds-since-midnight (with sub-second
+        # precision) — matching Python's `datetime.time()` truncation.
+        def time_of_day
+          utc = to_instant
+          (utc.hour * 3600) + (utc.min * 60) + utc.sec + utc.subsec
+        end
+
+        # See FPDateTime#compare for the precision-comparison rationale.
+        def compare(other)
+          fields = shared_fields(other)
+          self_precision, other_precision = precisions(other, fields)
+
+          return time_of_day <=> other.time_of_day if self_precision == other_precision
+
+          compare_by_field(other, fields, [self_precision, other_precision].min)
+        end
+
+        protected
+
+        def normalized
+          @normalized ||= begin
+            utc = to_instant
+            COMPONENTS.to_h { |c| [c, @match[c] ? utc.public_send(TIME_READERS[c]) : nil] }
+          end
+        end
+
+        def timezone?
+          !@match[:timezone].nil?
+        end
+
+        private
+
+        def shared_fields(other)
+          COMPONENTS.reject { |c| normalized[c].nil? && other.normalized[c].nil? }
+        end
+
+        def precisions(other, fields)
+          [fields.count { |c| !normalized[c].nil? }, fields.count { |c| !other.normalized[c].nil? }]
+        end
+
+        def compare_up_to_min_precision(other, fields, min_precision)
+          fields.first(min_precision).each do |c|
+            return nil if normalized[c].nil? || other.normalized[c].nil?
+            return false if normalized[c] != other.normalized[c]
+          end
+
+          return false if timezone? != other.timezone?
+
+          nil
+        end
+
+        def compare_by_field(other, fields, min_precision)
+          fields.first(min_precision).each do |c|
+            return -1 if normalized[c].nil? || other.normalized[c].nil?
+
+            ordinal = normalized[c] <=> other.normalized[c]
+            return ordinal unless ordinal.zero?
+          end
+
+          nil
+        end
+
+        def component_value(component)
+          (@match[component] || DEFAULTS[component]).to_i
+        end
+
+        def second_value
+          component_value(:second) + (@match[:fraction] ? Rational("0.#{@match[:fraction]}") : 0)
+        end
+
+        def timezone
+          value = @match[:timezone]
+          value.nil? || value == "Z" ? "+00:00" : value
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/nodes/fp_time_arithmetic.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Fhirpath
+  module Engine
+    module Nodes
+      # Reopens FPTime (see fp_time.rb) to add `#plus` — see FPDateTime#plus for the overall
+      # approach. Unlike FPDateTime, arithmetic here ignores this literal's timezone entirely
+      # (adding to the wall-clock digits, keeping whatever offset was already there) and wraps
+      # past midnight — matching fhirpath-py's FP_TimeBase#plus for FP_Time, which only supports
+      # hour/minute/second/millisecond durations (never day-and-above, since a bare time has no
+      # date to carry a day rollover into).
+      class FPTime
+        def plus(quantity)
+          value = quantity.value.to_i
+          unit = FPQuantity::ARITHMETIC_DURATION_UNITS[quantity.unit]
+          raise Fhirpath::Error, "Cannot add #{quantity} to #{self}" unless time_unit?(unit)
+
+          precision = time_precision
+          delta = time_delta(unit, value, precision, quantity)
+          wrapped = (total_seconds + delta) % 86_400
+          self.class.new("T#{format_clock(wrapped, precision)}#{@match[:timezone]}")
+        end
+
+        private
+
+        TIME_ARITHMETIC_UNITS = %i[hour minute second millisecond].freeze
+        TIME_ARITHMETIC_FIELDS = %i[hour minute second fraction].freeze
+
+        def time_unit?(unit)
+          TIME_ARITHMETIC_UNITS.include?(unit)
+        end
+
+        def time_precision
+          TIME_ARITHMETIC_FIELDS.count { |c| @match[c] }
+        end
+
+        def total_seconds
+          whole = (component_value(:hour) * 3600) + (component_value(:minute) * 60) + component_value(:second)
+          Util.to_big_decimal(whole) + (@match[:fraction] ? BigDecimal("0.#{@match[:fraction]}") : 0)
+        end
+
+        # Below full (hour:minute:second[.millisecond]) precision, a duration finer than the
+        # literal's own precision is converted up to whole minutes/hours first (truncating, per
+        # fhirpath-py); at full precision "second" additions keep the quantity's own fractional
+        # value (the spec: sub-second arithmetic isn't approximated).
+        def time_delta(unit, value, precision, quantity)
+          case precision
+          when 2 then time_delta_at_hour_minute_precision(unit, value)
+          when 3, 4 then time_delta_at_second_precision(unit, value, quantity)
+          else
+            raise Fhirpath::Error, "Cannot add #{unit} at precision #{precision} to #{self}"
+          end
+        end
+
+        def time_delta_at_hour_minute_precision(unit, value)
+          case unit
+          when :hour then value * 3600
+          when :minute then value * 60
+          when :second then trunc_div(value, 60) * 60
+          when :millisecond then trunc_div(value, 60_000) * 60
+          end
+        end
+
+        def time_delta_at_second_precision(unit, value, quantity)
+          case unit
+          when :hour then value * 3600
+          when :minute then value * 60
+          when :second then quantity.value
+          when :millisecond then Util.to_big_decimal(value) / 1000
+          end
+        end
+
+        def trunc_div(numerator, denominator)
+          numerator.fdiv(denominator).truncate
+        end
+
+        # Precision 2 (hour:minute only, no seconds in the source literal) keeps the output at
+        # that same granularity — printing an explicit ":00" seconds field here would make this
+        # result's precision look finer than the original, which throws off equals()'s
+        # differing-precision comparison against another precision-2 literal (only fields both
+        # sides actually specify may be compared; an extra field one side has and the other
+        # doesn't is `nil`/empty, not a match, per https://hl7.org/fhirpath/#equals).
+        def format_clock(seconds_value, precision)
+          whole = seconds_value.to_i
+          hour = whole / 3600
+          minute = (whole % 3600) / 60
+          clock = "#{two_digits(hour)}:#{two_digits(minute)}"
+          return clock if precision == 2
+
+          "#{clock}:#{format_seconds_field(whole % 60, seconds_value - whole)}"
+        end
+
+        def format_seconds_field(second, frac)
+          return two_digits(second) if frac.zero?
+
+          "#{two_digits(second)}.#{frac_digits(frac)}"
+        end
+
+        def two_digits(number)
+          number.to_s.rjust(2, "0")
+        end
+
+        def frac_digits(frac)
+          frac.to_s("F").sub(/\A0\./, "").sub(/0+\z/, "")
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/nodes/resource_node.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Fhirpath
+  module Engine
+    module Nodes
+      # Ruby port of fhirpath-py's ResourceNode (fhirpathpy/engine/nodes.py): wraps a node of
+      # data reached while navigating a resource, tracking its FHIRPath "path" (e.g.
+      # "Patient.name"), the property name/index it was reached through, and the raw data
+      # itself.
+      class ResourceNode
+        attr_reader :data, :path, :prop_name, :index
+
+        def initialize(data, path, prop_name: nil, index: nil)
+          path = data["resourceType"] if data.is_a?(::Hash) && data.key?("resourceType")
+
+          @data = data
+          @path = path
+          @prop_name = prop_name
+          @index = index
+        end
+
+        def ==(other)
+          data == (other.is_a?(ResourceNode) ? other.data : other)
+        end
+
+        # A path with no dot is already a bare type name (e.g. "Observation", or "id" once
+        # path2Type has resolved it during navigation). A dotted path with a model active means
+        # this node is a nested element with no specific named type — a FHIR BackboneElement;
+        # without a model, fall back to inferring the type from the raw Ruby value.
+        def type_info(model)
+          return nil if path.nil?
+
+          match = path.match(/\ASystem\.(.*)\z/)
+          return TypeInfo.new(match[1], TypeInfo::SYSTEM) if match
+          return TypeInfo.new(path, TypeInfo::FHIR) unless path.include?(".")
+          return TypeInfo.new("BackboneElement", TypeInfo::FHIR) if model
+
+          TypeInfo.create_by_value_in_namespace(TypeInfo::FHIR, data)
+        end
+
+        # A UCUM-coded quantity-shaped object (e.g. a FHIR Quantity/Duration/Age element:
+        # {"value" => ..., "unit" => ..., "system" => "http://unitsofmeasure.org", "code" => ...})
+        # resolves to an FPQuantity built from its "code", not its (human-readable) "unit". A
+        # present "comparator" (e.g. ">5 mg") makes the value an inexact bound, not a precise
+        # quantity — System.Quantity has no comparator concept, so it can't be converted.
+        def convert_data
+          return data unless data.is_a?(::Hash) && data["system"] == "http://unitsofmeasure.org"
+
+          if data.key?("comparator")
+            raise Fhirpath::Error, "Cannot convert a Quantity with a comparator to System.Quantity"
+          end
+
+          code = data["code"]
+          unit = FPQuantity::TIME_UNITS_TO_UCUM[code] || "'#{code}'"
+          FPQuantity.new(data["value"], unit)
+        end
+
+        def self.create_node(data, path = nil, prop_name: nil, index: nil)
+          return data if data.is_a?(ResourceNode)
+
+          new(data, path, prop_name: prop_name, index: index)
+        end
+      end
+    end
+  end
+end

data/lib/fhirpath/engine/nodes/type_info.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Fhirpath
+  module Engine
+    module Nodes
+      # Ruby port of fhirpath-py's TypeInfo (fhirpathpy/engine/nodes.py), used by `ofType`/`is`/
+      # `as`. fhirpath-py stashes the active model on a `TypeInfo.model` class attribute (set as
+      # a side effect inside is_fn/as_fn, with an acknowledged "TODO: incorrect place" — it's a
+      # workaround for ResourceNode#get_type_info not otherwise having access to ctx); here the
+      # model is threaded through explicitly instead, since a class-level global would make
+      # model-less and model-bearing `is`/`as` calls interfere across evaluations run in the
+      # same process (as this gem's own test suite does).
+      class TypeInfo
+        SYSTEM = "System"
+        FHIR = "FHIR"
+
+        attr_reader :name, :namespace
+
+        def initialize(name, namespace)
+          @name = name
+          @namespace = namespace
+        end
+
+        def is_(other, model)
+          return false unless other.is_a?(TypeInfo) && namespace_compatible?(other)
+          return name == other.name unless model && (namespace.nil? || namespace == FHIR)
+
+          self.class.subtype?(model, name, other.name)
+        end
+
+        def self.from_value(value, model)
+          return value.type_info(model) if value.is_a?(ResourceNode)
+
+          create_by_value_in_namespace(SYSTEM, value)
+        end
+
+        # Walks the model's type hierarchy (subtype -> parent, falling back to path2Type) from
+        # type_name looking for super_type.
+        def self.subtype?(model, type_name, super_type)
+          while type_name
+            return true if type_name == super_type
+
+            type_name = model.dig("type2Parent", type_name) || model.dig("path2Type", type_name)
+          end
+
+          false
+        end
+
+        def self.create_by_value_in_namespace(namespace, value)
+          name = type_name_for(value)
+          name = namespace == SYSTEM ? system_name(name) : name
+          new(name, namespace)
+        end
+
+        # Mirrors fhirpath-py's TypeInfo.create_by_value_in_namespace: every System-namespace
+        # name is capitalized, EXCEPT "dateTime" — Ruby's (and Python's) #capitalize also
+        # downcases the rest of the string, which would mangle "dateTime" into "Datetime".
+        def self.system_name(name)
+          return "DateTime" if name == "dateTime"
+
+          name.capitalize
+        end
+
+        TYPE_NAMES_BY_CLASS = {
+          ::Integer => "integer",
+          ::Float => "decimal",
+          ::BigDecimal => "decimal",
+          FPDateTime => "dateTime",
+          FPTime => "time",
+          FPQuantity => "Quantity",
+          ::String => "string",
+          ::Hash => "object"
+        }.freeze
+
+        def self.type_name_for(value)
+          return "boolean" if [true, false].include?(value)
+
+          matched = TYPE_NAMES_BY_CLASS.find { |klass, _name| value.is_a?(klass) }
+          matched ? matched.last : value.class.name
+        end
+
+        private
+
+        def namespace_compatible?(other)
+          namespace.nil? || other.namespace.nil? || namespace == other.namespace
+        end
+      end
+    end
+  end
+end