saxon-rb 0.4.0-java

data/lib/saxon/document_builder.rb

@@ -0,0 +1,28 @@
+require 'saxon/xdm'
+
+module Saxon
+  # Builds XDM objects from XML sources, for use in XSLT or for query and
+  # access
+  class DocumentBuilder
+    # @api private
+    # @param [net.sf.saxon.s9api.DocumentBuilder] s9_document_builder The
+    # Saxon DocumentBuilder instance to wrap
+    def initialize(s9_document_builder)
+      @s9_document_builder = s9_document_builder
+    end
+
+    # @param [Saxon::Source] source The Saxon::Source containing the source
+    #   IO/string
+    # @return [Saxon::XDM::Node] The Saxon::XDM::Node representing the root of the
+    #   document tree
+    def build(source)
+      XDM::Node.new(@s9_document_builder.build(source.to_java))
+    end
+
+    # @return [net.sf.saxon.s9api.DocumentBuilder] The underlying Java Saxon
+    #   DocumentBuilder instance
+    def to_java
+      @s9_document_builder
+    end
+  end
+end

data/lib/saxon/item_type.rb

@@ -0,0 +1,290 @@
+require_relative 's9api'
+require_relative 'qname'
+require_relative 'item_type/lexical_string_conversion'
+require_relative 'item_type/value_to_ruby'
+
+module Saxon
+  # Represent XDM types abstractly
+  class ItemType
+    # Error raised when a Ruby class has no equivalent XDM type to be converted
+    # into
+    class UnmappedRubyTypeError < StandardError
+      def initialize(class_name)
+        @class_name = class_name
+      end
+
+      def to_s
+        "Ruby class <#{@class_name}> has no XDM type equivalent"
+      end
+    end
+
+    # Error raise when an attempt to reify an <tt>xs:*</tt> type string is
+    # made, but the type string doesn't match any of the built-in <tt>xs:*</tt>
+    # types
+    class UnmappedXSDTypeNameError < StandardError
+      def initialize(type_str)
+        @type_str = type_str
+      end
+
+      def to_s
+        "'#{@type_str}' is not recognised as an XSD built-in type"
+      end
+    end
+
+    class Factory
+      DEFAULT_SEMAPHORE = Mutex.new
+
+      attr_reader :processor
+
+      def initialize(processor)
+        @processor = processor
+      end
+
+      def s9_factory
+        return @s9_factory if instance_variable_defined?(:@s9_factory)
+        DEFAULT_SEMAPHORE.synchronize do
+          @s9_factory = S9API::ItemTypeFactory.new(processor.to_java)
+        end
+      end
+    end
+
+    TYPE_CACHE_MUTEX = Mutex.new
+    # A mapping of Ruby types to XDM type constants
+    TYPE_MAPPING = {
+      'String' => :STRING,
+      'Array'  => :ANY_ARRAY,
+      'Hash'   => :ANY_MAP,
+      'TrueClass'  => :BOOLEAN,
+      'FalseClass' => :BOOLEAN,
+      'Date' => :DATE,
+      'DateTime' => :DATE_TIME,
+      'Time' => :DATE_TIME,
+      'BigDecimal' => :DECIMAL,
+      'Integer' => :INTEGER,
+      'Float' => :FLOAT,
+      'Numeric' => :NUMERIC
+    }.freeze
+
+    # A mapping of QNames to XDM type constants
+    QNAME_MAPPING = Hash[{
+      'anyAtomicType' => :ANY_ATOMIC_VALUE,
+      'anyURI' => :ANY_URI,
+      'base64Binary' => :BASE64_BINARY,
+      'boolean' => :BOOLEAN,
+      'byte' => :BYTE,
+      'date' => :DATE,
+      'dateTime' => :DATE_TIME,
+      'dateTimeStamp' => :DATE_TIME_STAMP,
+      'dayTimeDuration' => :DAY_TIME_DURATION,
+      'decimal' => :DECIMAL,
+      'double' => :DOUBLE,
+      'duration' => :DURATION,
+      'ENTITY' => :ENTITY,
+      'float' => :FLOAT,
+      'gDay' => :G_DAY,
+      'gMonth' => :G_MONTH,
+      'gMonthDay' => :G_MONTH_DAY,
+      'gYear' => :G_YEAR,
+      'gYearMonth' => :G_YEAR_MONTH,
+      'hexBinary' => :HEX_BINARY,
+      'ID' => :ID,
+      'IDREF' => :IDREF,
+      'int' => :INT,
+      'integer' => :INTEGER,
+      'language' => :LANGUAGE,
+      'long' => :LONG,
+      'Name' => :NAME,
+      'NCName' => :NCNAME,
+      'negativeInteger' => :NEGATIVE_INTEGER,
+      'NMTOKEN' => :NMTOKEN,
+      'nonNegativeInteger' => :NON_NEGATIVE_INTEGER,
+      'nonPositiveInteger' => :NON_POSITIVE_INTEGER,
+      'normalizedString' => :NORMALIZED_STRING,
+      'NOTATION' => :NOTATION,
+      'numeric' => :NUMERIC,
+      'positiveInteger' => :POSITIVE_INTEGER,
+      'QName' => :QNAME,
+      'short' => :SHORT,
+      'string' => :STRING,
+      'time' => :TIME,
+      'token' => :TOKEN,
+      'unsignedByte' => :UNSIGNED_BYTE,
+      'unsignedInt' => :UNSIGNED_INT,
+      'unsignedLong' => :UNSIGNED_LONG,
+      'unsignedShort' => :UNSIGNED_SHORT,
+      'untypedAtomic' => :UNTYPED_ATOMIC,
+      'yearMonthDuration' => :YEAR_MONTH_DURATION
+    }.map { |local_name, constant|
+      qname = Saxon::QName.create({
+        prefix: 'xs', uri: 'http://www.w3.org/2001/XMLSchema',
+        local_name: local_name
+      })
+      [qname, constant]
+    }].freeze
+
+    # A mapping of type names/QNames to XDM type constants
+    STR_MAPPING = {
+      'array(*)' => :ANY_ARRAY,
+      'item()' => :ANY_ITEM,
+      'map(*)' => :ANY_MAP,
+      'node()' => :ANY_NODE
+    }.merge(
+      Hash[QNAME_MAPPING.map { |qname, v| [qname.to_s, v] }]
+    ).freeze
+
+    ATOMIC_VALUE_LEXICAL_STRING_CONVERTORS = Hash[
+      LexicalStringConversion::Convertors.constants.map { |const|
+        [S9API::ItemType.const_get(const), LexicalStringConversion::Convertors.const_get(const)]
+      }
+    ].freeze
+
+    ATOMIC_VALUE_TO_RUBY_CONVERTORS = Hash[
+      ValueToRuby::Convertors.constants.map { |const|
+        [S9API::ItemType.const_get(const), ValueToRuby::Convertors.const_get(const)]
+      }
+    ].freeze
+
+    class << self
+      # Get an appropriate {ItemType} for a Ruby type or given a type name as a
+      # string
+      #
+      # @return [Saxon::ItemType]
+      # @overload get_type(ruby_class)
+      #   Get an appropriate {ItemType} for object of a given Ruby class
+      #   @param ruby_class [Class] The Ruby class to get a type for
+      # @overload get_type(type_name)
+      #   Get the {ItemType} for the name
+      #   @param type_name [String] name of the built-in {ItemType} to fetch
+      # @overload get_type(item_type)
+      #   Given an instance of {ItemType}, simply return the instance
+      #   @param item_type [Saxon::ItemType] an existing ItemType instance
+      def get_type(arg)
+        case arg
+        when Saxon::ItemType
+          arg
+        else
+          fetch_type_instance(get_s9_type(arg))
+        end
+      end
+
+      private
+
+      def fetch_type_instance(s9_type)
+        TYPE_CACHE_MUTEX.synchronize do
+          @type_instance_cache = {} if !instance_variable_defined?(:@type_instance_cache)
+          if type_instance = @type_instance_cache[s9_type]
+            type_instance
+          else
+            @type_instance_cache[s9_type] = new(s9_type)
+          end
+        end
+      end
+
+      def get_s9_type(arg)
+        case arg
+        when Saxon::QName
+          get_s9_qname_mapped_type(arg)
+        when Class
+          get_s9_class_mapped_type(arg)
+        when String
+          get_s9_str_mapped_type(arg)
+        end
+      end
+
+      def get_s9_qname_mapped_type(qname)
+        if mapped_type = QNAME_MAPPING.fetch(qname, false)
+          S9API::ItemType.const_get(mapped_type)
+        else
+          raise UnmappedXSDTypeNameError, qname.to_s
+        end
+      end
+
+      def get_s9_class_mapped_type(klass)
+        class_name = klass.name
+        if mapped_type = TYPE_MAPPING.fetch(class_name, false)
+          S9API::ItemType.const_get(mapped_type)
+        else
+          raise UnmappedRubyTypeError, class_name
+        end
+      end
+
+      def get_s9_str_mapped_type(type_str)
+        if mapped_type = STR_MAPPING.fetch(type_str, false)
+          # ANY_ITEM is a method, not a constant, for reasons not entirely
+          # clear to me
+          return S9API::ItemType.ANY_ITEM if mapped_type == :ANY_ITEM
+          S9API::ItemType.const_get(mapped_type)
+        else
+          raise UnmappedXSDTypeNameError, type_str
+        end
+      end
+    end
+
+    attr_reader :s9_item_type
+    private :s9_item_type
+
+    # @api private
+    def initialize(s9_item_type)
+      @s9_item_type = s9_item_type
+    end
+
+    # Return the {QName} which represents this type
+    #
+    # @return [Saxon::QName] the {QName} of the type
+    def type_name
+      @type_name ||= Saxon::QName.new(s9_item_type.getTypeName)
+    end
+
+    # @return [Saxon::S9API::ItemType] The underlying Saxon Java ItemType object
+    def to_java
+      s9_item_type
+    end
+
+    # compares two {ItemType}s using the underlying Saxon and XDM comparision rules
+    # @param other [Saxon::ItemType]
+    # @return [Boolean]
+    def ==(other)
+      return false unless other.is_a?(ItemType)
+      s9_item_type.equals(other.to_java)
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      @hash ||= s9_item_type.hashCode
+    end
+
+    # Generate the appropriate lexical string representation of the value
+    # given the ItemType's schema definition.
+    #
+    # Types with no explcit formatter defined just get to_s called on them...
+    #
+    # @param value [Object] The Ruby value to generate the lexical string
+    #   representation of
+    # @return [String] The XML Schema-defined lexical string representation of
+    #   the value
+    def lexical_string(value)
+      lexical_string_convertor.call(value, self)
+    end
+
+    # Convert an XDM Atomic Value to an instance of an appropriate Ruby class, or return the lexical string.
+    #
+    # It's assumed that the XDM::AtomicValue is of this type, otherwise an error is raised.
+    # @param xdm_atomic_value [Saxon::XDM::AtomicValue] The XDM atomic value to be converted.
+    def ruby_value(xdm_atomic_value)
+      value_to_ruby_convertor.call(xdm_atomic_value)
+    end
+
+    private
+
+    def lexical_string_convertor
+      @lexical_string_convertor ||= ATOMIC_VALUE_LEXICAL_STRING_CONVERTORS.fetch(s9_item_type, ->(value, item) { value.to_s })
+    end
+
+    def value_to_ruby_convertor
+      @value_to_ruby_convertor ||= ATOMIC_VALUE_TO_RUBY_CONVERTORS.fetch(s9_item_type, ->(xdm_atomic_value) {
+        xdm_atomic_value.to_s
+      })
+    end
+  end
+end

data/lib/saxon/item_type/lexical_string_conversion.rb

@@ -0,0 +1,383 @@
+require 'bigdecimal'
+
+module Saxon
+  class ItemType
+    # A collection of lamba-like objects for converting Ruby values into
+    # lexical strings for specific XSD datatypes
+    module LexicalStringConversion
+      def self.validate(value, item_type, pattern)
+        str = value.to_s
+        raise Errors::BadRubyValue.new(value, item_type) unless str.match?(pattern)
+        str
+      end
+
+      class IntegerConversion
+        attr_reader :min, :max
+
+        def initialize(min, max)
+          @min, @max = min, max
+        end
+
+        def in_bounds?(integer_value)
+          gte_min?(integer_value) && lte_max?(integer_value)
+        end
+
+        def gte_min?(integer_value)
+          return true if min.nil?
+          integer_value >= min
+        end
+
+        def lte_max?(integer_value)
+          return true if max.nil?
+          integer_value <= max
+        end
+
+        def call(value, item_type)
+          integer_value = case value
+          when ::Numeric
+            value.to_i
+          else
+            Integer(LexicalStringConversion.validate(value, item_type, Patterns::INTEGER), 10)
+          end
+          raise Errors::RubyValueOutOfBounds.new(value, item_type) unless in_bounds?(integer_value)
+          integer_value.to_s
+        end
+      end
+
+      class FloatConversion
+        def initialize(size = :double)
+          @double = size == :double
+        end
+
+        def double?
+          @double
+        end
+
+        def float_value(float_value)
+          return float_value if double?
+          convert_to_single_precision(float_value)
+        end
+
+        def convert_to_single_precision(float_value)
+          [float_value].pack('f').unpack('f').first
+        end
+
+        def call(value, item_type)
+          case value
+          when ::Float::INFINITY
+            'INF'
+          when -::Float::INFINITY
+            '-INF'
+          when Numeric
+            float_value(value).to_s
+          else
+            LexicalStringConversion.validate(value, item_type, Patterns::FLOAT)
+          end
+        end
+      end
+
+      class GDateConversion
+        attr_reader :bounds, :integer_formatter, :validation_pattern
+
+        def initialize(args = {})
+          @bounds = args.fetch(:bounds)
+          @validation_pattern = args.fetch(:validation_pattern)
+          @integer_formatter = args.fetch(:integer_formatter)
+        end
+
+        def extract_value_from_validated_format(formatted_value)
+          Integer(formatted_value.gsub(validation_pattern, '\1'), 10)
+        end
+
+        def check_value_bounds!(value, item_type)
+          bounds_method = bounds.respond_to?(:include?) ? :include? : :call
+          raise Errors::RubyValueOutOfBounds.new(value, item_type) unless bounds.send(bounds_method, value)
+        end
+
+        def extract_and_check_value_bounds!(formatted_value, item_type)
+          check_value_bounds!(extract_value_from_validated_format(formatted_value), item_type)
+        end
+
+        def call(value, item_type)
+          case value
+          when Integer
+            check_value_bounds!(value, item_type)
+            sprintf(integer_formatter.call(value), value)
+          else
+            formatted_value = LexicalStringConversion.validate(value, item_type, validation_pattern)
+            extract_and_check_value_bounds!(formatted_value, item_type)
+            formatted_value
+          end
+        end
+      end
+
+      module PatternFragments
+        TIME_DURATION = /(?:T
+          (?:
+            # The time part of the format allows T0H1M1S, T1H1M, T1M1S, T1H1S, T1H, T1M, T1S
+            [0-9]+[HM]|
+            [0-9]+(?:\.[0-9]+)?S|
+            [0-9]+H[0-9]+M|
+            [0-9]+H[0-9]+(?:\.[0-9]+)?S|
+            [0-9]+M[0-9]+(?:\.[0-9]+)?S|
+            [0-9]+H[0-9]+M[0-9]+(?:\.[0-9]+)?S
+          )
+        )?/x
+        DATE = /-?[0-9]{4}-[0-9]{2}-[0-9]{2}/
+        TIME = /[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?/
+        TIME_ZONE = /(?:[\-+][0-9]{2}:[0-9]{2}|Z)?/
+        NCNAME_START_CHAR = '[A-Z]|_|[a-z]|[\u{C0}-\u{D6}]|[\u{D8}-\u{F6}]|[\u{F8}-\u{2FF}]|[\u{370}-\u{37D}]|[\u{37F}-\u{1FFF}]|[\u{200C}-\u{200D}]|[\u{2070}-\u{218F}]|[\u{2C00}-\u{2FEF}]|[\u{3001}-\u{D7FF}]|[\u{F900}-\u{FDCF}]|[\u{FDF0}-\u{FFFD}]|[\u{10000}-\u{EFFFF}]'
+        NAME_START_CHAR = ":|" + NCNAME_START_CHAR
+        NCNAME_CHAR = NCNAME_START_CHAR + '|-|\.|[0-9]|\u{B7}|[\u{0300}-\u{036F}]|[\u{203F}-\u{2040}]'
+        NAME_CHAR = ":|" + NCNAME_CHAR
+      end
+
+      module Patterns
+        def self.build(*patterns)
+          Regexp.new((['\A'] + patterns.map(&:to_s) + ['\z']).join(''))
+        end
+        DATE = build(PatternFragments::DATE, PatternFragments::TIME_ZONE)
+        DATE_TIME = build(PatternFragments::DATE, 'T', PatternFragments::TIME, PatternFragments::TIME_ZONE)
+        TIME = build(PatternFragments::TIME, PatternFragments::TIME_ZONE)
+        DURATION = build(/-?P(?!\z)(?:[0-9]+Y)?(?:[0-9]+M)?(?:[0-9]+D)?/, PatternFragments::TIME_DURATION)
+        DAY_TIME_DURATION = build(/-?P(?!\z)(?:[0-9]+D)?/, PatternFragments::TIME_DURATION)
+        YEAR_MONTH_DURATION = /\A-?P(?!\z)(?:[0-9]+Y)?(?:[0-9]+M)?\z/
+        G_DAY = build(/---([0-9]{2})/, PatternFragments::TIME_ZONE)
+        G_MONTH = build(/--([0-9]{2})/, PatternFragments::TIME_ZONE)
+        G_YEAR = build(/(-?[0-9]{4,})/, PatternFragments::TIME_ZONE)
+        G_YEAR_MONTH = build(/-?([0-9]{4,})-([0-9]{2})/, PatternFragments::TIME_ZONE)
+        G_MONTH_DAY = build(/--([0-9]{2})-([0-9]{2})/, PatternFragments::TIME_ZONE)
+        INTEGER = /\A[+-]?[0-9]+\z/
+        DECIMAL = /\A[+-]?[0-9]+(?:\.[0-9]+)?\z/
+        FLOAT = /\A(?:[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][0-9]+)?|-?INF|NaN)\z/
+        NCNAME = build("(?:#{PatternFragments::NCNAME_START_CHAR})", "(?:#{PatternFragments::NCNAME_CHAR})*")
+        NAME = build("(?:#{PatternFragments::NAME_START_CHAR})", "(?:#{PatternFragments::NAME_CHAR})*")
+        TOKEN = /\A[^\u0020\u000A\u000D\u0009]+(?: [^\u0020\u000A\u000D\u0009]+)*\z/
+        NORMALIZED_STRING = /\A[^\u000A\u000D\u0009]+\z/
+        NMTOKEN = build("(?:#{PatternFragments::NAME_CHAR})+")
+        LANGUAGE = /\A[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*\z/
+        BASE64_BINARY = /\A(?:(?:[A-Za-z0-9+\/] ?){4})*(?:(?:[A-Za-z0-9+\/] ?){3}[A-Za-z0-9+\/]|(?:[A-Za-z0-9+\/] ?){2}[AEIMQUYcgkosw048] ?=|[A-Za-z0-9+\/] ?[AQgw] ?= ?=)?\z/
+      end
+
+      module Convertors
+        ANY_URI = ->(value, item_type) {
+          uri_classes = [URI::Generic]
+          case value
+          when URI::Generic
+            value.to_s
+          else
+            begin
+              URI(value.to_s).to_s
+            rescue URI::InvalidURIError
+              raise Errors::BadRubyValue.new(value, item_type)
+            end
+          end
+        }
+        BASE64_BINARY = ->(value, item_type) {
+          Base64.strict_encode64(value.to_s.force_encoding(Encoding::ASCII_8BIT))
+        }
+        BOOLEAN = ->(value, item_type) {
+          value ? 'true' : 'false'
+        }
+        BYTE = ->(value, item_type) {
+          raise Errors::RubyValueOutOfBounds.new(value, item_type) if value.bytesize != 1
+          value = value.to_s.force_encoding(Encoding::ASCII_8BIT)
+          value.unpack('c').first.to_s
+        }
+        DATE = ->(value, item_type) {
+          if value.respond_to?(:strftime)
+            value.strftime('%F')
+          else
+            LexicalStringConversion.validate(value, item_type, Patterns::DATE)
+          end
+        }
+        DATE_TIME = ->(value, item_type) {
+          if value.respond_to?(:strftime)
+            value.strftime('%FT%T%:z')
+          else
+            LexicalStringConversion.validate(value, item_type, Patterns::DATE_TIME)
+          end
+        }
+        TIME = ->(value, item_type) {
+          LexicalStringConversion.validate(value, item_type, Patterns::TIME)
+        }
+        DATE_TIME_STAMP = DATE_TIME
+        DAY_TIME_DURATION = ->(value, item_type) {
+          case value
+          when Integer
+            sign = value.negative? ? '-' : ''
+            "#{sign}PT#{value.abs}S"
+          when BigDecimal
+            sign = value.negative? ? '-' : ''
+            "#{sign}PT#{value.abs.to_s('F')}S"
+          when Numeric
+            sign = value.negative? ? '-' : ''
+            sprintf("%sPT%0.9fS", sign, value.abs)
+          else
+            LexicalStringConversion.validate(value, item_type, Patterns::DAY_TIME_DURATION)
+          end
+        }
+        DECIMAL = ->(value, item_type) {
+          case value
+          when ::Integer
+            value.to_s
+          when ::BigDecimal
+            value.to_s('F')
+          when ::Float
+            BigDecimal(value, ::Float::DIG).to_s('F')
+          else
+            LexicalStringConversion.validate(value, item_type, Patterns::DECIMAL)
+          end
+        }
+        DOUBLE = FloatConversion.new(:single)
+        DURATION = ->(value, item_type) {
+          case value
+          when Integer
+            sign = value.negative? ? '-' : ''
+            "#{sign}PT#{value.abs}S"
+          when BigDecimal
+            sign = value.negative? ? '-' : ''
+            "#{sign}PT#{value.abs.to_s('F')}S"
+          when Numeric
+            sign = value.negative? ? '-' : ''
+            sprintf("%sPT%0.9fS", sign, value.abs)
+          else
+            LexicalStringConversion.validate(value, item_type, Patterns::DURATION)
+          end
+        }
+        FLOAT = FloatConversion.new
+        G_DAY = GDateConversion.new({
+          bounds: 1..31,
+          validation_pattern: Patterns::G_DAY,
+          integer_formatter: ->(value) { '---%02d' }
+        })
+        G_MONTH = GDateConversion.new({
+          bounds: 1..12,
+          validation_pattern: Patterns::G_MONTH,
+          integer_formatter: ->(value) { '--%02d' }
+        })
+        G_MONTH_DAY = ->(value, item_type) {
+          month_days = {
+             1 => 31,
+             2 => 29,
+             3 => 31,
+             4 => 30,
+             5 => 31,
+             6 => 30,
+             7 => 31,
+             8 => 31,
+             9 => 30,
+            10 => 31,
+            11 => 30,
+            12 => 31
+          }
+          formatted_value = LexicalStringConversion.validate(value, item_type, Patterns::G_MONTH_DAY)
+          month, day = Patterns::G_MONTH_DAY.match(formatted_value).captures.take(2).map { |i|
+            Integer(i, 10)
+          }
+          raise Errors::RubyValueOutOfBounds.new(value, item_type) if day > month_days[month]
+          formatted_value
+        }
+        G_YEAR = GDateConversion.new({
+          bounds: ->(value) { value != 0 },
+          validation_pattern: Patterns::G_YEAR,
+          integer_formatter: ->(value) {
+            value.negative? ? '%05d' : '%04d'
+          }
+        })
+        G_YEAR_MONTH = ->(value, item_type) {
+          formatted_value = LexicalStringConversion.validate(value, item_type, Patterns::G_YEAR_MONTH)
+          year, month = Patterns::G_YEAR_MONTH.match(formatted_value).captures.take(2).map { |i|
+            Integer(i, 10)
+          }
+          if year == 0 || !(1..12).include?(month)
+            raise Errors::RubyValueOutOfBounds.new(value, item_type)
+          end
+          value
+        }
+        HEX_BINARY = ->(value, item_type) {
+          value.to_s.force_encoding(Encoding::ASCII_8BIT).each_byte.map { |b| b.to_s(16) }.join
+        }
+        INT = IntegerConversion.new(-2147483648, 2147483647)
+        INTEGER = IntegerConversion.new(nil, nil)
+        LANGUAGE = ->(value, item_type) {
+          LexicalStringConversion.validate(value, item_type, Patterns::LANGUAGE)
+        }
+        LONG = IntegerConversion.new(-9223372036854775808, 9223372036854775807)
+        NAME = ->(value, item_type) {
+          LexicalStringConversion.validate(value, item_type, Patterns::NAME)
+        }
+        ID = IDREF = ENTITY = NCNAME = ->(value, item_type) {
+          LexicalStringConversion.validate(value, item_type, Patterns::NCNAME)
+        }
+        NEGATIVE_INTEGER = IntegerConversion.new(nil, -1)
+        NMTOKEN = ->(value, item_type) {
+          LexicalStringConversion.validate(value, item_type, Patterns::NMTOKEN)
+        }
+        NON_NEGATIVE_INTEGER = IntegerConversion.new(0, nil)
+        NON_POSITIVE_INTEGER = IntegerConversion.new(nil, 0)
+        NORMALIZED_STRING = ->(value, item_type) {
+          LexicalStringConversion.validate(value, item_type, Patterns::NORMALIZED_STRING)
+        }
+        POSITIVE_INTEGER = IntegerConversion.new(1, nil)
+        SHORT = IntegerConversion.new(-32768, 32767)
+        # STRING (It's questionable whether anything needs doing here)
+        TOKEN = ->(value, item_type) {
+          LexicalStringConversion.validate(value, item_type, Patterns::TOKEN)
+        }
+        UNSIGNED_BYTE = ->(value, item_type) {
+          raise Errors::RubyValueOutOfBounds.new(value, item_type) if value.bytesize != 1
+          value = value.to_s.force_encoding(Encoding::ASCII_8BIT)
+          value.unpack('C').first.to_s
+        }
+        UNSIGNED_INT = IntegerConversion.new(0, 4294967295)
+        UNSIGNED_LONG = IntegerConversion.new(0, 18446744073709551615)
+        UNSIGNED_SHORT = IntegerConversion.new(0, 65535)
+        YEAR_MONTH_DURATION = ->(value, item_type) {
+          LexicalStringConversion.validate(value, item_type, Patterns::YEAR_MONTH_DURATION)
+        }
+        QNAME = NOTATION = ->(value, item_type) {
+          raise Errors::UnconvertableNamespaceSensitveItemType
+        }
+      end
+
+      module Errors
+        # Raised during conversion from Ruby value to XDM Type lexical string
+        # when the ruby value does not conform to the Type's string
+        # representation.
+        class BadRubyValue < ArgumentError
+          attr_reader :value, :item_type
+
+          def initialize(value, item_type)
+            @value, @item_type = value, item_type
+          end
+
+          def to_s
+            "Ruby value #{value.inspect} cannot be converted to an XDM #{item_type.type_name.to_s}"
+          end
+        end
+
+        # Raised during conversion from Ruby value to XDM type lexical string
+        # when the ruby value fits the Type's string representation, but is out
+        # of the permitted bounds for the type, for instance an integer bigger
+        # than <tt>32767</tt> for the type <tt>xs:short</tt>
+        class RubyValueOutOfBounds < ArgumentError
+          attr_reader :value, :item_type
+
+          def initialize(value, item_type)
+            @value, @item_type = value, item_type
+          end
+
+          def to_s
+            "Ruby value #{value.inspect} is outside the allowed bounds of an XDM #{item_type.type_name.to_s}"
+          end
+        end
+
+        # Raised during conversion from Ruby value to XDM type if the XDM type
+        # is one of the namespace-sensitive types that cannot be created from a
+        # lexical string
+        class UnconvertableNamespaceSensitveItemType < Exception; end
+      end
+    end
+  end
+end