rdf-xsd 0.3.3

data/AUTHORS

@@ -0,0 +1 @@
+* Gregg Kellogg <gregg@kellogg-assoc.com>

data/README.markdown

@@ -0,0 +1,91 @@
+# Extended XSD Datatypes for RDF.rb
+
+This gem adds additional RDF::Literal subclasses for extended [XSD datatypes][]
+
+* <http://github.com/gkellogg/rdf-xsd>
+
+## Features
+
+* Additional xsd:integer subtypes
+* xsd:float based on xsd:double
+* xsd:duration
+
+Examples
+--------
+
+    require 'rdf'
+    require 'rdf/xsd'
+
+## Dependencies
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.1)
+* [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.3.3)
+* [Haml](https://rubygems.org/gems/haml) (>= 3.0.0)
+
+## Documentation
+Full documentation available on [Rubydoc.info][XSD doc]
+
+### Principle Classes
+* {RDF::Literal::Float}
+* {RDF::Literal::NonPositiveInteger}
+  * {RDF::Literal::NegativeInteger}
+* {RDF::Literal::Long}
+  * {RDF::Literal::Int}
+    * {RDF::Literal::Short}
+      * {RDF::Literal::Byte}
+* {RDF::Literal::NonNegativeInteger}
+  * {RDF::Literal::PositiveInteger}
+  * {RDF::Literal::UnsignedLong}
+    * {RDF::Literal::UnsignedInt}
+      * {RDF::Literal::UnsignedShort}
+        * {RDF::Literal::UnsignedByte}
+
+## Dependencies
+
+* [Ruby](http://ruby-lang.org/) (>= 1.8.7) or (>= 1.8.1 with [Backports][])
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.4)
+
+## Installation
+
+The recommended installation method is via [RubyGems](http://rubygems.org/).
+To install the latest official release of the `RDF::XSD` gem, do:
+
+    % [sudo] gem install rdf-xsd
+
+## Mailing List
+
+* <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
+
+## Author
+
+* [Gregg Kellogg](http://github.com/gkellogg) - <http://kellogg-assoc.com/>
+
+Contributing
+------------
+
+* Do your best to adhere to the existing coding conventions and idioms.
+* Don't use hard tabs, and don't leave trailing whitespace on any line.
+* Do document every method you add using [YARD][] annotations. Read the
+  [tutorial][YARD-GS] or just look at the existing code for examples.
+* Don't touch the `.gemspec`, `VERSION` or `AUTHORS` files. If you need to
+  change them, do so on your private branch only.
+* Do feel free to add yourself to the `CREDITS` file and the corresponding
+  list in the the `README`. Alphabetical order applies.
+* Do note that in order for us to merge any non-trivial changes (as a rule
+  of thumb, additions larger than about 15 lines of code), we need an
+  explicit [public domain dedication][PDD] on record from you.
+
+License
+-------
+
+This is free and unencumbered public domain software. For more information,
+see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
+
+Portions of tests are derived from [W3C DAWG tests](http://www.w3.org/2001/sw/DataAccess/tests/) and have [other licensing terms](http://www.w3.org/2001/sw/DataAccess/tests/data-r2/LICENSE).
+
+[Ruby]:       http://ruby-lang.org/
+[RDF]:        http://www.w3.org/RDF/
+[YARD]:       http://yardoc.org/
+[YARD-GS]:    http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
+[PDD]:        http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
+[Backports]:  http://rubygems.org/gems/backports
+[XSD Datatypes]: http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#built-in-datatypes

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

data/VERSION

@@ -0,0 +1 @@
+0.3.3

data/lib/rdf/xsd.rb

@@ -0,0 +1,18 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..')))
+require 'rdf'
+
+##
+# Plugin for RDF.rb for extended XSD datatypes.
+#
+# @example Requiring the `RDF::XSD` module
+#   require 'rdf/xsd'
+#
+# @see http://rdf.rubyforge.org/
+# @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#built-in-datatypes
+#
+# @author [Gregg Kellogg](http://greggkellogg.net/)
+module RDFa
+  autoload :VERSION,    'rdf/xsd/version'
+end
+
+Dir.glob(File.join(File.expand_path(File.dirname(__FILE__)), 'xsd', '*.rb')) {|f|  require f}

data/lib/rdf/xsd/binary.rb

@@ -0,0 +1,71 @@
+require 'base64'
+
+module RDF; class Literal
+  ##
+  # More specific sub-types of double
+  # Derived types
+  # @see http://www.w3.org/TR/xpath-functions/#datatypes
+  
+  ##
+  # hexBinary represents arbitrary hex-encoded binary data. The value space of hexBinary is the set of finite-length
+  # sequences of binary octets.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#hexBinary
+  class HexBinary < RDF::Literal
+    DATATYPE = XSD.hexBinary
+    GRAMMAR = %r(\A[0-9a-fA-F]+\Z)
+
+    ##
+    # Converts this literal into its canonical lexical representation.
+    #
+    # @return [RDF::Literal] `self`
+    def canonicalize!
+      @string = @object.downcase
+      self
+    end
+  end
+  
+  ##
+  # base64Binary represents Base64-encoded arbitrary binary data. The ·value space· of base64Binary is the set of
+  # finite-length sequences of binary octets. For base64Binary data the entire binary stream is encoded using the Base64
+  # Alphabet in [RFC 2045].
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#hexBinary
+  class Base64Binary < RDF::Literal
+    DATATYPE = XSD.base64Binary
+
+    ##
+    # @param  [String, Object] value
+    #   If given a string, it will decode it as an object value.
+    #   Otherwise, it will take the value as the object and encode to retrieve a value
+    # @option options [String] :lexical (nil)
+    def initialize(value, options = {})
+      super
+      @object = value.is_a?(String) ? ::Base64.decode64(value) : value
+      canonicalize! unless value.is_a?(String)
+    end
+    
+    ##
+    # Converts this literal into its canonical lexical representation.
+    #
+    # @return [RDF::Literal] `self`
+    # @see    http://www.w3.org/TR/xmlschema-2/#dateTime
+    def canonicalize!
+      @string = ::Base64.encode64(@object)
+      self
+    end
+
+    ##
+    # Returns `true` if the value adheres to the defined grammar of the
+    # datatype.
+    #
+    # @return [Boolean]
+    def valid?
+      Base64.strict_decode64(value.gsub(/\s+/m, ''))
+      true
+    rescue ArgumentError
+      STDERR.puts($!.inspect + ": #{value.inspect}")
+      false
+    end
+  end
+end; end #RDF::Literal

data/lib/rdf/xsd/date.rb

@@ -0,0 +1,63 @@
+require 'rdf'
+
+module RDF; class Literal
+  ##
+  # gYearMonth represents a specific gregorian month in a specific gregorian year. The value space of gYearMonth is
+  # the set of Gregorian calendar months as defined in § 5.2.1 of [ISO 8601]. Specifically, it is a set of one-month
+  # long, non-periodic instances e.g. 1999-10 to represent the whole month of 1999-10, independent of how many days this
+  # month has.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#gYearMonth
+  class YearMonth < RDF::Literal::Date
+    DATATYPE = XSD.gYearMonth
+    GRAMMAR  = %r(\A-?\d{4,}-\d{2}((?:[\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
+    FORMAT   = '%Y-%m%Z'.freeze
+  end
+
+  ##
+  # gYear represents a gregorian calendar year. The value space of gYear is the set of Gregorian calendar years as
+  # defined in § 5.2.1 of [ISO 8601]. Specifically, it is a set of one-year long, non-periodic instances e.g. lexical
+  # 1999 to represent the whole year 1999, independent of how many months and days this year has.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#gYear
+  class Year < RDF::Literal::Date
+    DATATYPE = XSD.gYear
+    GRAMMAR  = %r(\A-?\d{4,}(?:(?:[\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
+    FORMAT   = '%Y%Z'.freeze
+  end
+
+  ##
+  # gMonthDay is a gregorian date that recurs, specifically a day of the year such as the third of May. Arbitrary
+  # recurring dates are not supported by this datatype. The value space of gMonthDay is the set of calendar dates,
+  # as defined in § 3 of [ISO 8601]. Specifically, it is a set of one-day long, annually periodic instances.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#gMonthDay
+  class MonthDay < RDF::Literal::Date
+    DATATYPE = XSD.gMonthDay
+    GRAMMAR  = %r(\A\d{2}-\d{2}(?:(?:[\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
+    FORMAT   = '%m-%d%Z'.freeze
+  end
+
+  ##
+  # gDay is a gregorian day that recurs, specifically a day of the month such as the 5th of the month. Arbitrary
+  # recurring days are not supported by this datatype. The value space of gDay is the space of a set of calendar
+  # dates as defined in § 3 of [ISO 8601]. Specifically, it is a set of one-day long, monthly periodic instances.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#gDay
+  class Day < RDF::Literal::Date
+    DATATYPE = XSD.gDay
+    GRAMMAR  = %r(\A\d{2}(?:(?:[\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
+    FORMAT   = '%d%Z'.freeze
+  end
+
+  ##
+  # gMonth is a gregorian month that recurs every year. The value space of gMonth is the space of a set of calendar
+  # months as defined in § 3 of [ISO 8601]. Specifically, it is a set of one-month long, yearly periodic instances.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#gMonth
+  class Month < RDF::Literal::Date
+    DATATYPE = XSD.gMonth
+    GRAMMAR  = %r(\A\d{2}(?:(?:[\+\-]\d{2}:\d{2})|UTC|Z)?\Z).freeze
+    FORMAT   = '%m%Z'.freeze
+  end
+end; end #RDF::Literal

data/lib/rdf/xsd/double.rb

@@ -0,0 +1,8 @@
+module RDF; class Literal
+  # Note that in XML Schema, Float is not really derived from Double,
+  # but implementations are identical in Ruby
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#float
+  class Float < Double
+    DATATYPE = XSD.float
+  end
+end; end #RDF::Literal

data/lib/rdf/xsd/duration.rb

@@ -0,0 +1,195 @@
+require 'time'
+require 'date'
+
+module RDF; class Literal
+  ##
+  # A duration literal.
+  #
+  # @see   http://www.w3.org/TR/xmlschema-2/#duration
+  # @since 0.2.1
+  class Duration < Literal
+    DATATYPE = XSD.duration
+    GRAMMAR  = %r(\A(-?)P(\d+Y)?(\d+M)?(\d+D)?T?(\d+H)?(\d+M)?([\d\.]+S)?\Z).freeze
+
+    ##
+    # * Given a Numeric, assumes that it is milliseconds
+    # * Given a String, parse as xsd:duration
+    # * Hash form is used for internal representation
+    # @param  [Duration, Hash, Numeric, #to_s] value
+    # @option options [String] :lexical (nil)
+    def initialize(value, options = {})
+      super
+      @object   = case value
+      when Hash
+        value = value.dup
+        value[:yr] ||= value[:years]
+        value[:mo] ||= value[:months]
+        value[:da] ||= value[:days]
+        value[:hr] ||= value[:hours]
+        value[:mi] ||= value[:minutes]
+        value[:se] ||= value[:seconds]
+        
+        value
+      when Duration, Numeric
+        {:se => value.to_f}
+      else
+        parse(value.to_s) rescue { }
+      end
+      @object[:si] ||= 1
+    end
+
+    ##
+    # Converts this literal into its canonical lexical representation.
+    #
+    # Also normalizes elements
+    #
+    # @return [RDF::Literal] `self`
+    # @see    http://www.w3.org/TR/xmlschema-2/#dateTime
+    def canonicalize!
+      @string = @humanize = nil
+      if @object[:se].to_i > 60
+        m_r = (@object[:se].to_i / 60) - 1
+        @object[:se] -=  m_r * 60
+        @object[:mi] = @object[:mi].to_i + m_r
+      end
+      if @object[:mi].to_i > 60
+        h_r = (@object[:mi].to_i / 60) - 1
+        @object[:mi] -=  h_r * 60
+        @object[:hr] = @object[:hr].to_i +  h_r
+      end
+      if @object[:hr].to_i > 24
+        d_r = (@object[:hr].to_i / 24) - 1
+        @object[:hr] -=  d_r * 24
+        @object[:da] = @object[:da].to_i + d_r
+      end
+      if @object[:da].to_i > 30
+        m_r = (@object[:da].to_i / 30) - 1
+        @object[:da] -=  m_r * 30
+        @object[:mo] = @object[:mo].to_i + m_r
+      end
+      if @object[:mo].to_i > 12
+        y_r = (@object[:mo].to_i / 12) - 1
+        @object[:mo] -=  y_r * 12
+        @object[:yr] = @object[:yr].to_i + y_r
+      end
+      @object.to_s  # site-effect
+      self
+    end
+
+    ##
+    # Returns `true` if the value adheres to the defined grammar of the
+    # datatype.
+    #
+    # Special case for date and dateTime, for which '0000' is not a valid year
+    #
+    # @return [Boolean]
+    # @since  0.2.1
+    def valid?
+      !!(value =~ GRAMMAR)
+    end
+
+    ##
+    # Returns the value as a string.
+    #
+    # @return [String]
+    def to_s
+      @string ||= begin
+        str = @object[:si] < 0 ? "-P" : "P"
+        str << "%dY" % @object[:yr].to_i if @object[:yr]
+        str << "%dM" % @object[:mo].to_i if @object[:mo]
+        str << "%dD" % @object[:da].to_i if @object[:da]
+        str << "T" if @object[:hr] || @object[:mi] || @object[:se]
+        str << "%dH" % @object[:hr].to_i if @object[:hr]
+        str << "%dM" % @object[:mi].to_i if @object[:mi]
+        str << "#{sec_str}S" if @object[:se]
+      end
+    end
+
+    def plural(v, str)
+      "#{v} #{str}#{v == 1 ? '' : 's'}" if v
+    end
+    
+    ##
+    # Returns a human-readable value for the interval
+    def humanize(lang = :en)
+      @humanize ||= {}
+      @humanize[lang] ||= begin
+        # Just english, for now
+        ar = []
+        ar << plural(@object[:yr], "year")
+        ar << plural(@object[:mo], "month")
+        ar << plural(@object[:da], "day")
+        ar << plural(@object[:hr], "hour")
+        ar << plural(@object[:mi], "minute")
+        ar << plural(sec_str, "second") if @object[:se]
+        ar = ar.compact
+        last = ar.pop
+        first = ar.join(" ")
+        res = first.empty? ? last : "#{first} and #{last}"
+        @object[:si] < 0 ? "#{res} ago" : res
+      end
+    end
+
+    ##
+    # Equal compares as DateTime objects
+    def ==(other)
+      # If lexically invalid, use regular literal testing
+      return super unless self.valid?
+
+      case other
+      when Duration
+        return super unless other.valid?
+        self.to_f == something.to_f
+      when String
+        self.to_s(:xml) == something
+      when Numeric
+        self.to_f == something
+      when Literal::DateTime, Literal::Time, Literal::Date
+        false
+      else
+        super
+      end
+    end
+
+    # @return [Float]
+    def to_f
+      ( @object[:yr].to_i * 365 * 24 * 3600 +
+        @object[:mo].to_i * 30 * 24 * 3600 +
+        @object[:da].to_i * 24 * 3600 +
+        @object[:hr].to_i * 3600 +
+        @object[:mi].to_i * 60 +
+        @object[:se].to_f
+      ) * @object[:si]
+    end
+
+    # @return [Integer]
+    def to_i; Integer(self.to_f); end
+    
+    private
+    # Reverse convert from XSD version of duration
+    # XSD allows -P1111Y22M33DT44H55M66.666S with any combination in regular order
+    # We assume 1M == 30D, but are out of spec in this regard
+    # We only output up to hours
+    #
+    # @param [String] value XSD formatted duration
+    # @return [Duration]
+    def parse(value)
+      hash = {}
+      if value.to_s.match(GRAMMAR)
+        hash[:si] = $1 == "-" ? -1 : 1
+        hash[:yr] = $2.to_i if $2
+        hash[:mo] = $3.to_i if $3
+        hash[:da] = $4.to_i if $4
+        hash[:hr] = $5.to_i if $5
+        hash[:mi] = $6.to_i if $6
+        hash[:se] = $7.to_f if $7
+      end
+      hash
+    end
+    
+    def sec_str
+      usec = (@object[:se] * 1000).to_i % 1000
+      usec > 0 ? ("%2.3f" % @object[:se]).sub(/0*\Z/, '') : @object[:se].to_i.to_s
+    end
+  end # Duration
+end; end # RDF::Literal

data/lib/rdf/xsd/integer.rb

@@ -0,0 +1,191 @@
+module RDF; class Literal
+  ##
+  # nonPositiveInteger is derived from integer by setting the value of maxInclusive to be 0. This results in
+  # the standard mathematical concept of the non-positive integers. The value space of nonPositiveInteger is the
+  # infinite set {...,-2,-1,0}. The base type of nonPositiveInteger is integer.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#nonPositiveInteger
+  class NonPositiveInteger < Integer
+    DATATYPE = RDF::XSD.nonPositiveInteger
+    GRAMMAR  = /^(?:[\+\-]?0)|(?:-\d+)$/.freeze
+
+    ##
+    # Returns `self` negated.
+    #
+    # @return [RDF::Literal::Numeric]
+    # @since  0.2.3
+    def -@
+      if object != 0
+        # XXX Raise error?
+      end
+      super
+    end
+
+    def valid?
+      super && @object <= 0
+    end
+  end
+  
+  ##
+  # negativeInteger is derived from nonPositiveInteger by setting the value of maxInclusive to be -1. This
+  # results in the standard mathematical concept of the negative integers. The value space of negativeInteger is
+  # the infinite set {...,-2,-1}. The base type of negativeInteger is nonPositiveInteger.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#negativeInteger
+  class NegativeInteger < NonPositiveInteger
+    GRAMMAR  = /^\-\d+$/.freeze
+    DATATYPE = RDF::XSD.negativeInteger
+
+    ##
+    # Returns `self` negated.
+    #
+    # @return [RDF::Literal::Numeric]
+    # @since  0.2.3
+    def -@
+      if object != 0
+        # XXX Raise error?
+      end
+      self.class.new(-self.object)
+    end
+
+    def valid?
+      super && @object < 0
+    end
+  end
+  
+  ##
+  # long is derived from integer by setting the value of maxInclusive to be 9223372036854775807
+  # and minInclusive to be -9223372036854775808.
+  #
+  # The base type of long is integer.
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#long
+  class Long < Integer
+    DATATYPE = RDF::XSD.long
+    
+    def valid?
+      super && @object >= -9223372036854775808 && @object <= 9223372036854775807
+    end
+  end
+  
+  ##
+  # int is derived from long by setting the value of maxInclusive to be 2147483647 and minInclusive to be
+  # -2147483648. The base type of int is long.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#int
+  class Int < Long
+    DATATYPE = RDF::XSD.int
+    
+    def valid?
+      super && @object >= -2147483648 && @object <= 2147483647
+    end
+  end
+  
+  ##
+  # short is derived from int by setting the value of maxInclusive to be 32767 and minInclusive to be
+  # -32768. The base type of short is int.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#short
+  class Short < Int
+    DATATYPE = RDF::XSD.short
+    
+    def valid?
+      super && @object >= -32768 && @object <= 32767
+    end
+  end
+  
+  ##
+  # byte is derived from short by setting the value of maxInclusive to be 127 and minInclusive to be -128.
+  # The base type of byte is short.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#byte
+  class Byte < Short
+    DATATYPE = RDF::XSD.byte
+    
+    def valid?
+      super && @object >= -128 && @object <= 127
+    end
+  end
+
+  ##
+  # nonNegativeInteger is derived from integer by setting the value of minInclusive to be 0. This results in
+  # the standard mathematical concept of the non-negative integers. The value space of nonNegativeInteger is the
+  # infinite set {0,1,2,...}. The base type of nonNegativeInteger is integer.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#nonNegativeInteger
+  class NonNegativeInteger < Integer
+    GRAMMAR  = /^(?:(?:[\+\-]?0)|(?:\+?\d+))$/.freeze
+    DATATYPE = RDF::XSD.nonNegativeInteger
+
+    def valid?
+      super && @object >= 0
+    end
+  end
+  
+  ##
+  # positiveInteger is derived from nonNegativeInteger by setting the value of minInclusive to be 1. This
+  # results in the standard mathematical concept of the positive integer numbers. The value space of
+  # positiveInteger is the infinite set {1,2,...}. The base type of positiveInteger is nonNegativeInteger.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#positiveInteger
+  class PositiveInteger < NonNegativeInteger
+    GRAMMAR  = /^\+?\d+$/.freeze
+    DATATYPE = RDF::XSD.positiveInteger
+
+    def valid?
+      super && @object > 0
+    end
+  end
+  
+  ##
+  # unsignedLong is derived from nonNegativeInteger by setting the value of maxInclusive to be
+  # 18446744073709551615. The base type of unsignedLong is nonNegativeInteger.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#unsignedLong
+  class UnsignedLong < NonNegativeInteger
+    GRAMMAR  = /^\d+$/.freeze
+    DATATYPE = RDF::XSD.unsignedLong
+    
+    def valid?
+      super && @object >= 0 && @object <= 18446744073709551615
+    end
+  end
+  
+  ##
+  # unsignedInt is derived from unsignedLong by setting the value of maxInclusive to be 4294967295. The base
+  # type of unsignedInt is unsignedLong.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#unsignedInt
+  class UnsignedInt < UnsignedLong
+    DATATYPE = RDF::XSD.unsignedInt
+    
+    def valid?
+      super && @object >= 0 && @object <= 4294967295
+    end
+  end
+  
+  ##
+  # unsignedShort is derived from unsignedInt by setting the value of maxInclusive to be 65535. The base
+  # type of unsignedShort is unsignedInt.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#unsignedShort
+  class UnsignedShort < UnsignedInt
+    DATATYPE = RDF::XSD.unsignedShort
+    
+    def valid?
+      super && @object >= 0 && @object <= 65535
+    end
+  end
+  
+  ##
+  # unsignedByte is derived from unsignedShort by setting the value of maxInclusive to be 255. The base
+  # type of unsignedByte is unsignedShort.
+  #
+  # @see http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#unsignedByte
+  class UnsignedByte < UnsignedShort
+    DATATYPE = RDF::XSD.unsignedByte
+    
+    def valid?
+      super && @object >= 0 && @object <= 255
+    end
+  end
+end; end #RDF::Literal

data/lib/rdf/xsd/version.rb

@@ -0,0 +1,18 @@
+module RDF::XSD::VERSION
+  VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "VERSION")
+  MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chop.split(".")
+
+  STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
+
+  ##
+  # @return [String]
+  def self.to_s()   STRING end
+
+  ##
+  # @return [String]
+  def self.to_str() STRING end
+
+  ##
+  # @return [Array(Integer, Integer, Integer)]
+  def self.to_a() STRING.split(".") end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: rdf-xsd
+version: !ruby/object:Gem::Version
+  version: 0.3.3
+  prerelease: 
+platform: ruby
+authors:
+- Gregg
+- Kellogg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-15 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: &2165552680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *2165552680
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2165552100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :development
+  prerelease: false
+  version_requirements: *2165552100
+- !ruby/object:Gem::Dependency
+  name: rdf-spec
+  requirement: &2165551520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :development
+  prerelease: false
+  version_requirements: *2165551520
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &2165551000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *2165551000
+description: Adds RDF::Literal subclasses for extended XSD datatypes
+email: public-rdf-ruby@w3.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- AUTHORS
+- README.markdown
+- UNLICENSE
+- VERSION
+- lib/rdf/xsd/binary.rb
+- lib/rdf/xsd/date.rb
+- lib/rdf/xsd/double.rb
+- lib/rdf/xsd/duration.rb
+- lib/rdf/xsd/integer.rb
+- lib/rdf/xsd/version.rb
+- lib/rdf/xsd.rb
+homepage: http://github.com/gkellogg/rdf-xsd
+licenses:
+- Public Domain
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rdf-xsd
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Extended XSD Datatypes for RDF.rb
+test_files: []