Module: WsdlMapper::TypeMapping

Defined in:
lib/wsdl_mapper/type_mapping.rb,
lib/wsdl_mapper/type_mapping/uri.rb,
lib/wsdl_mapper/type_mapping/time.rb,
lib/wsdl_mapper/type_mapping/date.rb,
lib/wsdl_mapper/type_mapping/base.rb,
lib/wsdl_mapper/type_mapping/float.rb,
lib/wsdl_mapper/type_mapping/string.rb,
lib/wsdl_mapper/type_mapping/decimal.rb,
lib/wsdl_mapper/type_mapping/boolean.rb,
lib/wsdl_mapper/type_mapping/integer.rb,
lib/wsdl_mapper/type_mapping/duration.rb,
lib/wsdl_mapper/type_mapping/date_time.rb,
lib/wsdl_mapper/type_mapping/date_parts.rb,
lib/wsdl_mapper/type_mapping/hex_binary.rb,
lib/wsdl_mapper/type_mapping/mapping_set.rb,
lib/wsdl_mapper/type_mapping/base64_binary.rb

Defined Under Namespace

Modules: DateParts Classes: Base, MappingSet

Constant Summary

DEFAULT =
MappingSet.default
Uri =
Base.new do
  register_xml_types %w[
    anyURI
  ]

  def to_ruby(string)
    URI(string.strip)
  end

  def to_xml(object)
    case object
    when URI::Generic
      object.to_s
    else
      URI.escape object.to_s
    end
  end

  def ruby_type
    ::String
  end

  def requires
    ['uri']
  end
end
Time =
Base.new do
  register_xml_types %w[
    time
  ]

  def to_ruby(string)
    zone = ::Date._parse(string)[:zone]
    ::Time.parse(string.to_s).getlocal zone
  end

  def to_xml(object)
    object.strftime '%T%:z'
  end

  def ruby_type
    ::Time
  end

  def requires
    ['time']
  end
end
Date =
Base.new do
  register_xml_types %w[
    date
  ]

  def to_ruby(string)
    ::DateTime.parse string.to_s
  end

  def to_xml(object)
    object.strftime '%F%:z'
  end

  def ruby_type
    ::DateTime
  end

  def requires
    ['date']
  end
end
Float =
Base.new do
  register_xml_types %w[
    float
    double
  ]

  def to_ruby(string)
    string.to_s.to_f
  end

  def to_xml(object)
    case object
    when ::Float, ::Integer
      object.to_s
    when Rational, BigDecimal
      object.to_f.to_s
    end
  end

  def ruby_type
    ::Float
  end
end
String =
Base.new do
  register_xml_types %w[
    ENTITIES
    ENTITY
    ID
    IDREF
    IDREFS
    language
    Name
    NCName
    NMTOKEN
    NMTOKENS
    normalizedString
    QName
    string
    token
  ]

  # TODO: non UTF-8 encodings
  def to_ruby(string)
    string.to_s
  end

  def to_xml(object)
    object.to_s
  end

  def ruby_type
    ::String
  end
end
Decimal =
Base.new do
  register_xml_types %w[
    decimal
  ]

  def to_ruby(string)
    BigDecimal.new string.to_s
  end

  def to_xml(object)
    object.to_s 'F'
  end

  def ruby_type
    BigDecimal
  end

  def requires
    ['bigdecimal']
  end
end
Boolean =
Base.new do
  register_xml_types %w[
    boolean
  ]

  def to_ruby(string)
    case string.to_s
    when 'true', '1'
      true
    when 'false', '0'
      false
    end
  end

  def to_xml(object)
    object ? 'true' : 'false'
  end

  def ruby_type
    nil
  end
end
Integer =
Base.new do
  register_xml_types %w[
    byte
    int
    integer
    long
    negativeInteger
    nonNegativeInteger
    nonPositiveInteger
    positiveInteger
    short
    unsignedLong
    unsignedInt
    unsignedShort
    unsignedByte
  ]

  def to_ruby(string)
    string.to_s.to_i
  end

  def to_xml(int)
    int.to_i.to_s
  end

  def ruby_type
    ::Fixnum
  end
end
Duration =
Base.new do
  register_xml_types %w[
    duration
  ]

  def to_ruby(string)
    duration = WsdlMapper::CoreExt::TimeDuration.new
    value = ''
    negative = false
    time = false

    string.to_s.each_char do |chr|
      case chr
      when '-'
        negative = true
      when 'P'
        duration.negative = negative
      when 'T'
        time = true
      when 'Y'
        duration.years = value.to_i
        value = ''
      when 'M'
        if time
          duration.minutes = value.to_i
        else
          duration.months = value.to_i
        end
        value = ''
      when 'D'
        duration.days = value.to_i
        value = ''
      when 'H'
        duration.hours = value.to_i
        value = ''
      when 'S'
        duration.seconds = value.to_i
        value = ''
      else
        value += chr
      end
    end

    duration
  end

  def to_xml(object)
    buf = ''

    add_period buf, object
    add_date buf, object
    add_time buf, object

    buf
  end

  def ruby_type
    WsdlMapper::CoreExt::TimeDuration
  end

  def requires
    ['wsdl_mapper/core_ext/time_duration']
  end

  def add_period(buf, d)
    buf << '-' if d.negative?
    buf << 'P'
  end

  def add_date(buf, d)
    if d.years > 0
      buf << d.years.to_s
      buf << 'Y'
    end

    if d.months > 0
      buf << d.months.to_s
      buf << 'M'
    end

    if d.days > 0
      buf << d.days.to_s
      buf << 'D'
    end
  end

  def add_time(buf, d)
    return unless [d.hours, d.minutes, d.seconds].any? { |t| t > 0 }
    buf << 'T'

    if d.hours > 0
      buf << d.hours.to_s
      buf << 'H'
    end

    if d.minutes > 0
      buf << d.minutes.to_s
      buf << 'M'
    end

    if d.seconds > 0
      buf << d.seconds.to_s
      buf << 'S'
    end
  end
end
DateTime =
Base.new do
  register_xml_types %w[
    dateTime
  ]

  def to_ruby(string)
    ::DateTime.parse string.to_s
  end

  def to_xml(object)
    object.to_s
  end

  def ruby_type
    ::DateTime
  end

  def requires
    ['date']
  end
end
HexBinary =
Base.new do
  register_xml_types %w[
    hexBinary
  ]

  def to_ruby(string)
    StringIO.new [string.to_s.strip].pack('H*')
  end

  def to_xml(io)
    io.read.unpack('H*').first
  end

  def ruby_type
    ::StringIO
  end

  def requires
    ['stringio']
  end
end
Base64Binary =
Base.new do
  register_xml_types %w[
    base64Binary
  ]

  def to_ruby(string)
    StringIO.new Base64.decode64 string
  end

  def to_xml(io)
    Base64.encode64 io.read
  end

  def ruby_type
    ::StringIO
  end

  def requires
    ['stringio']
  end
end