rdf_context 0.4.7 → 0.4.8

data/History.txt

@@ -1,3 +1,9 @@
+=== 0.4.8
+* Add Duration and support in Literal
+* Add datatype support for xs:boolean, xs:double, xs:duration and xs:time.
+* Literal::Encoding#encode_contents properly encodes different datatypes to string.
+* Literal#to_native converts literal value to appropriate native object based on datatype.
+
 === 0.4.7
 * Graph identifiers only URIRef or BNode; Literal not supported by SQL Store.
 * Namespace#+ updated to not use URIRef logic for creating URIs, as this removes part of the URI in the case that the URI does not end with / or #.

data/Rakefile

@@ -46,13 +46,13 @@ end
 require 'spec/rake/spectask'
 Spec::Rake::SpecTask.new(:spec) do |spec|
   spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
+  spec.spec_files = FileList['spec/*_spec.rb']
 end
 
 desc "Run specs through RCov"
 Spec::Rake::SpecTask.new(:rcov) do |spec|
   spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
+  spec.pattern = 'spec/*_spec.rb'
   spec.rcov = true
 end
 

data/VERSION

@@ -1 +1 @@
-0.4.7
+0.4.8

data/lib/rdf_context.rb

@@ -55,6 +55,8 @@ module RdfContext
   RDFS_NS     = Namespace.new("http://www.w3.org/2000/01/rdf-schema#", "rdfs")
   XHV_NS      = Namespace.new("http://www.w3.org/1999/xhtml/vocab#", "xhv")
   XML_NS      = Namespace.new("http://www.w3.org/XML/1998/namespace", "xml")
+  XSD_NS      = Namespace.new("http://www.w3.org/2001/XMLSchema#", "xsd")
+  XSI_NS      = Namespace.new("http://www.w3.org/2001/XMLSchema-instance", "xsi")
 
   XH_MAPPING  = {"" => Namespace.new("http://www.w3.org/1999/xhtml/vocab\#", nil)}
 end

data/lib/rdf_context/duration.rb

@@ -0,0 +1,113 @@
+# An XSD duration
+module RdfContext
+  class Duration
+    attr_accessor :ne, :yr, :mo, :da, :hr, :mi, :se
+  
+    # * Given an integer, assumes that it is milliseconds
+    # * Given a time, extract second
+    # * Given a Flaat, use value direcly
+    # * Given a String, parse as xsd:duration
+    def initialize(value)
+      case value
+      when Hash
+        @ne = value[:ne] || 1
+        @yr = value[:yr] || value[:years] || 0
+        @mo = value[:mo] || value[:months] || 0
+        @da = value[:da] || value[:days] || 0
+        @hr = value[:hr] || value[:hours] || 0
+        @mi = value[:mi] || value[:minutes] || 0
+        @se = value[:se] || value[:seconds] || 0
+      when Duration
+        @se = value.to_f
+      when Numeric
+        @se = value
+      else
+        @se = value.to_i
+      end
+      
+      self.normalize
+    end
+  
+    def self.parse(value)
+      # 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
+      if value.to_s.match(/^(-?)P(\d+Y)?(\d+M)?(\d+D)?T?(\d+H)?(\d+M)?([\d\.]+S)?$/)
+        hash = {}
+        hash[:ne] = $1 == "-" ? -1 : 1
+        hash[:yr] = $2.to_i
+        hash[:mo] = $3.to_i
+        hash[:da] = $4.to_i
+        hash[:hr] = $5.to_i
+        hash[:mi] = $6.to_i
+        hash[:se] = $7.to_f
+        value = hash
+      end
+
+      self.new(value)
+    end
+    
+    def to_f
+      (((((@yr.to_i * 12 + @mo.to_i) * 30 + @da.to_i) * 24 + @hr.to_i) * 60 + @mi.to_i) * 60 + @se.to_f) * (@ne || 1)
+    end
+    
+    def to_i; Integer(self.to_f); end
+    def eql?(something)
+      case something
+      when Duration
+        self.to_f == something.to_f
+      when String
+        self.to_s(:xml) == something
+      when Numeric
+        self.to_f == something
+      else
+        false
+      end
+    end
+    alias_method :==, :eql?
+   
+    def to_s(format = nil)
+      usec = (@se * 1000).to_i % 1000
+      sec_str = usec > 0 ? "%2.3f" % @se : @se.to_i.to_s
+      
+      if format == :xml
+        str = @ne < 0 ? "-P" : "P"
+        str << "%dY" % @yr if @yr > 0
+        str << "%dM" % @mo if @mo > 0
+        str << "%dD" % @da if @da > 0
+        str << "T" if @hr + @mi + @se > 0
+        str << "%dH" % @hr if @hr > 0
+        str << "%dM" % @mi if @mi > 0
+        str << "#{sec_str}S" if @se > 0
+      else
+        ar = []
+        ar << "%d years"    % @yr     if @yr > 0
+        ar << "%d months"   % @mo     if @mo > 0
+        ar << "%d days"     % @da     if @da > 0
+        ar << "%d hours"    % @hr     if @hr > 0
+        ar << "%d minutes"  % @mi     if @mi > 0
+        ar << "%s seconds"  % sec_str if @se > 0
+        last = ar.pop
+        first = ar.join(", ")
+        res = first.empty? ? last : "#{first} and #{last}"
+        ne < 0 ? "#{res} ago" : res
+      end
+    end
+    
+    protected
+    
+      # Normalize representation by adding everything up and then breaking it back down again
+      def normalize
+        s = self.to_f
+        
+        @ne = s < 0 ? -1 : 1
+        s = s * @ne
+        _mi, @se = s.divmod(60)
+        _hr, @mi = _mi.to_i.divmod(60)
+        _da, @hr = _hr.divmod(24)
+        _mo, @da = _da.divmod(30)
+        @yr, @mo = _mo.divmod(12)
+      end
+  end
+end

data/lib/rdf_context/graph.rb

@@ -325,7 +325,7 @@ module RdfContext
     # after sorting each graph.
     #
     # We just follow Python RDFlib's lead and do a simple comparison
-    def eql? (other)
+    def eql?(other)
       #puts "eql? size #{self.size} vs #{other.size}"
       return false if !other.is_a?(Graph) || self.size != other.size
       return false unless other.identifier.to_s == identifier.to_s

data/lib/rdf_context/literal.rb

@@ -4,6 +4,9 @@ begin
 rescue LoadError
 end
 
+require 'parsedate'
+require File.join(File.dirname(__FILE__), 'duration')
+
 module RdfContext
   # An RDF Literal, with value, encoding and language elements.
   class Literal
@@ -15,29 +18,49 @@ module RdfContext
         @value = URIRef.new(value.to_s) if value
       end
 
-      # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#int")</tt>
-      def self.integer
-        @integer ||= coerce "http://www.w3.org/2001/XMLSchema#int"
+      # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#boolean")</tt>
+      def self.boolean
+        @boolean ||= coerce XSD_NS.boolean
+      end
+
+      # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#double")</tt>
+      def self.double
+        @double ||= coerce XSD_NS.double
       end
 
       # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#float")</tt>
       def self.float
-        @float ||= coerce "http://www.w3.org/2001/XMLSchema#float"
+        @float ||= coerce XSD_NS.float
       end
 
-      # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#string")</tt>
-      def self.string
-        @string ||= coerce "http://www.w3.org/2001/XMLSchema#string"
+      # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#int")</tt>
+      def self.integer
+        @integer ||= coerce XSD_NS.int
       end
-      
+
       # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#date")</tt>
       def self.date
-        @date ||= coerce "http://www.w3.org/2001/XMLSchema#date"
+        @date ||= coerce XSD_NS.date
       end
       
       # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#dateTime")</tt>
       def self.datetime
-        @datetime ||= coerce "http://www.w3.org/2001/XMLSchema#dateTime"
+        @datetime ||= coerce XSD_NS.dateTime
+      end
+      
+      # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#duration")</tt>
+      def self.duration
+        @duration ||= coerce XSD_NS.duration
+      end
+      
+      # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#string")</tt>
+      def self.string
+        @string ||= coerce XSD_NS.string
+      end
+      
+      # Shortcut for <tt>Literal::Encoding.new("http://www.w3.org/2001/XMLSchema#time")</tt>
+      def self.time
+        @time ||= coerce XSD_NS.time
       end
       
       # Create from URI, empty or nil string
@@ -108,7 +131,14 @@ module RdfContext
       
       # Encode literal contents
       def encode_contents(contents, options)
-        contents
+        case @value
+        when XSD_NS.boolean   then %w(1 true).include?(contents.to_s) ? "true" : "false"
+        when XSD_NS.time      then contents.is_a?(Time) ? contents.strftime("%H:%M:%S%Z").sub(/\+00:00|UTC/, "Z") : contents.to_s
+        when XSD_NS.dateTime  then contents.is_a?(DateTime) ? contents.strftime("%Y-%m-%dT%H:%M:%S%Z").sub(/\+00:00|UTC/, "Z") : contents.to_s
+        when XSD_NS.date      then contents.is_a?(Date) ? contents.strftime("%Y-%m-%d%Z").sub(/\+00:00|UTC/, "Z") : contents.to_s
+        when XSD_NS.duration  then contents.is_a?(Duration) ? contents.to_s(:xml) : contents.to_s
+        else                       contents.to_s
+        end
       end
     end
     
@@ -292,12 +322,15 @@ module RdfContext
     # Infer the proper XML datatype for the given object
     def self.infer_encoding_for(object)
       case object
-      when Integer  then Encoding.new("http://www.w3.org/2001/XMLSchema#int")
-      when Float    then Encoding.new("http://www.w3.org/2001/XMLSchema#float")
-      when Time     then Encoding.new("http://www.w3.org/2001/XMLSchema#time")
-      when DateTime then Encoding.new("http://www.w3.org/2001/XMLSchema#dateTime")
-      when Date     then Encoding.new("http://www.w3.org/2001/XMLSchema#date")
-      else               Encoding.new("http://www.w3.org/2001/XMLSchema#string")
+      when TrueClass  then Encoding.boolean
+      when FalseClass then Encoding.boolean
+      when Integer    then Encoding.integer
+      when Float      then Encoding.float
+      when Time       then Encoding.time
+      when DateTime   then Encoding.datetime
+      when Date       then Encoding.date
+      when Duration   then Encoding.duration
+      else                 Encoding.string
       end
     end
 
@@ -337,6 +370,21 @@ module RdfContext
       encoding.format_as_trix(@contents, @lang)
     end
     
+    # Create native representation for value
+    def to_native
+      case encoding
+      when Encoding.boolean   then @contents.to_s == "true"
+      when Encoding.double    then @contents.to_s.to_f
+      when Encoding.integer   then @contents.to_s.to_i
+      when Encoding.float     then @contents.to_s.to_f
+      when Encoding.time      then Time.parse(@contents.to_s)
+      when Encoding.datetime  then DateTime.parse(@contents.to_s)
+      when Encoding.date      then Date.parse(@contents.to_s)
+      when Encoding.duration  then Duration.parse(@contents.to_s)
+      else                         @contents.to_s
+      end
+    end
+    
     # Return content and hash appropriate for encoding in XML
     #
     # ==== Example

data/lib/rdf_context/store/list_store.rb

@@ -30,7 +30,7 @@ module RdfContext
 
     # Check to see if this graph contains the specified triple
     def contains?(triple, context = nil)
-      !@triples.find_index(triple).nil?
+      @triples.any? {|t| t == triple}
     end
 
     # Triples from graph, optionally matching subject, predicate, or object.

data/lib/rdf_context/uriref.rb

@@ -78,9 +78,15 @@ module RdfContext
   
     # Output URI as QName using URI binding
     def to_qname(uri_binding = {})
-      @namespace ||= uri_binding[self.base]
-      raise RdfException, "Couldn't find QName for #{@uri}" unless @namespace
-      "#{@namespace.prefix}:#{self.short_name}"
+      "#{namespace(uri_binding).prefix}:#{self.short_name}"
+    end
+    
+    def namespace(uri_binding = {})
+      @namespace ||= begin
+        ns = uri_binding[self.base]
+        raise RdfException, "Couldn't find namespace for #{@uri}" unless ns
+        ns
+      end
     end
     
     def inspect

data/spec/duration_spec.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+describe "Duration" do
+  it "should create from Hash" do
+    Duration.new(:seconds => 10, :minutes => 1).to_i.should == 70
+  end
+
+  it "should create from Duration" do
+    d = Duration.new(:seconds => 10, :minutes => 1)
+    Duration.new(d).to_i.should == 70
+  end
+  it "should create from Numeric" do
+    Duration.new(70.2).to_i.should == 70
+    Duration.new(70.2).to_f.should == 70.2
+  end
+  
+  it "should create from Integer string" do
+    Duration.new("70").to_f.should == 70
+  end
+  
+  it "should parse formatted string" do
+    Duration.parse('-P1111Y11M23DT4H55M16.666S').to_i.should == -34587060916
+  end
+  
+  describe "normalization" do
+  end
+  
+  describe "output format" do
+    subject { Duration.parse('P1111Y11M23DT4H55M16.666S') }
+    
+    it "should output xml" do
+      subject.to_s(:xml).should == "P1111Y11M23DT4H55M16.666S"
+    end
+    
+    it "should output human readable" do
+      subject.to_s.should == "1111 years, 11 months, 23 days, 4 hours, 55 minutes and 16.666 seconds"
+    end
+    
+    it "should output integer" do
+      subject.to_i.should == 34587060916
+    end
+    
+    it "should output float" do
+      subject.to_f.should == 34587060916.666
+    end
+  end
+end

data/spec/literal_spec.rb

@@ -103,9 +103,29 @@ describe "Literals: " do
     end
   end
   
+  describe "a boolean" do
+    subject { Literal.typed(true, "http://www.w3.org/2001/XMLSchema#boolean") }
+    describe "encodings" do
+      it "should return n3" do subject.to_n3.should == "\"true\"^^<http://www.w3.org/2001/XMLSchema#boolean>" end
+      it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+      it "should return xml_args" do subject.xml_args.should == ["true", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#boolean"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#boolean\">true</typedLiteral>" end
+    end
+
+    it "should infer type" do
+      int = Literal.build_from(true)
+      int.encoding.should == "http://www.w3.org/2001/XMLSchema#boolean"
+    end
+
+    it "should have string contents" do subject.contents.should == "true" end
+    it "should have native contents" do subject.to_native.should == true end
+    it "should coerce 1" do Literal.typed("1", XSD_NS.boolean).contents.should == "true" end
+    it "should coerce 1" do Literal.typed("0", XSD_NS.boolean).contents.should == "false" end
+  end
+    
   describe "an integer" do
+    subject { Literal.typed(5, "http://www.w3.org/2001/XMLSchema#int") }
     describe "encodings" do
-      subject { Literal.typed(5, "http://www.w3.org/2001/XMLSchema#int") }
       it "should return n3" do subject.to_n3.should == "\"5\"^^<http://www.w3.org/2001/XMLSchema#int>" end
       it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
       it "should return xml_args" do subject.xml_args.should == ["5", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#int"}] end
@@ -116,11 +136,14 @@ describe "Literals: " do
       int = Literal.build_from(15)
       int.encoding.should == "http://www.w3.org/2001/XMLSchema#int"
     end
+
+    it "should have string contents" do subject.contents.should == "5" end
+    it "should have native contents" do subject.to_native.should == 5 end
   end
     
   describe "a float" do
+    subject { Literal.typed(15.4, "http://www.w3.org/2001/XMLSchema#float") }
     describe "encodings" do
-      subject { Literal.typed(15.4, "http://www.w3.org/2001/XMLSchema#float") }
       it "should return n3" do subject.to_n3.should == "\"15.4\"^^<http://www.w3.org/2001/XMLSchema#float>" end
       it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
       it "should return xml_args" do subject.xml_args.should == ["15.4", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#float"}] end
@@ -131,36 +154,85 @@ describe "Literals: " do
       float = Literal.build_from(15.4)
       float.encoding.should == "http://www.w3.org/2001/XMLSchema#float"
     end
+
+    it "should have string contents" do subject.contents.should == "15.4" end
+    it "should have native contents" do subject.to_native.should == 15.4 end
   end
 
   describe "a date" do
+    before(:each) { @value = Date.parse("2010-01-02Z") }
+    subject { Literal.typed(@value, "http://www.w3.org/2001/XMLSchema#date") }
     describe "encodings" do
-      subject { Literal.typed("2010-01-02", "http://www.w3.org/2001/XMLSchema#date") }
-      it "should return n3" do subject.to_n3.should == "\"2010-01-02\"^^<http://www.w3.org/2001/XMLSchema#date>" end
+      it "should return n3" do subject.to_n3.should == "\"2010-01-02Z\"^^<http://www.w3.org/2001/XMLSchema#date>" end
       it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
-      it "should return xml_args" do subject.xml_args.should == ["2010-01-02", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#date"}] end
-      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#date\">2010-01-02</typedLiteral>" end
+      it "should return xml_args" do subject.xml_args.should == ["2010-01-02Z", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#date"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#date\">2010-01-02Z</typedLiteral>" end
     end
 
     it "should infer type" do
-      int = Literal.build_from(Date::civil(2010, 1, 2))
+      int = Literal.build_from(@value)
       int.encoding.should == "http://www.w3.org/2001/XMLSchema#date"
     end
+
+    it "should have string contents" do subject.contents.should == "2010-01-02Z" end
+    it "should have native contents" do subject.to_native.should ==  @value end
   end
   
-  describe "a date time" do
+  describe "a dateTime" do
+    before(:each) { @value = DateTime.parse('2010-01-03T01:02:03Z') }
+    subject { Literal.typed(@value, "http://www.w3.org/2001/XMLSchema#dateTime") }
     describe "encodings" do
-      subject { Literal.typed("2010-01-03T01:02:03", "http://www.w3.org/2001/XMLSchema#dateTime") }
-      it "should return n3" do subject.to_n3.should == "\"2010-01-03T01:02:03\"^^<http://www.w3.org/2001/XMLSchema#dateTime>" end
+      it "should return n3" do subject.to_n3.should == "\"2010-01-03T01:02:03Z\"^^<http://www.w3.org/2001/XMLSchema#dateTime>" end
       it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
-      it "should return xml_args" do subject.xml_args.should == ["2010-01-03T01:02:03", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#dateTime"}] end
-      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#dateTime\">2010-01-03T01:02:03</typedLiteral>" end
+      it "should return xml_args" do subject.xml_args.should == ["2010-01-03T01:02:03Z", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#dateTime"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#dateTime\">2010-01-03T01:02:03Z</typedLiteral>" end
     end
     
     it "should infer type" do
-      int = Literal.build_from(DateTime.parse('2010-01-03T01:02:03'))
+      int = Literal.build_from(@value)
       int.encoding.should == "http://www.w3.org/2001/XMLSchema#dateTime"
     end
+
+    it "should have string contents" do subject.contents.should == "2010-01-03T01:02:03Z" end
+    it "should have native contents" do subject.to_native.should ==  @value end
+  end
+  
+  describe "a time" do
+    before(:each) { @value = Time.parse('01:02:03Z') }
+    subject { Literal.typed(@value, "http://www.w3.org/2001/XMLSchema#time") }
+    describe "encodings" do
+      it "should return n3" do subject.to_n3.should == "\"01:02:03Z\"^^<http://www.w3.org/2001/XMLSchema#time>" end
+      it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+      it "should return xml_args" do subject.xml_args.should == ["01:02:03Z", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#time"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#time\">01:02:03Z</typedLiteral>" end
+    end
+    
+    it "should infer type" do
+      int = Literal.build_from(@value)
+      int.encoding.should == "http://www.w3.org/2001/XMLSchema#time"
+    end
+
+    it "should have string contents" do subject.contents.should == "01:02:03Z" end
+    it "should have native contents" do subject.to_native.should ==  @value end
+  end
+  
+  describe "a duration" do
+    before(:each) { @value = Duration.parse('-P1111Y11M23DT4H55M16.666S') }
+    subject { Literal.typed(@value, "http://www.w3.org/2001/XMLSchema#duration") }
+    describe "encodings" do
+      it "should return n3" do subject.to_n3.should == "\"-P1111Y11M23DT4H55M16.666S\"^^<http://www.w3.org/2001/XMLSchema#duration>" end
+      it "should return ntriples" do subject.to_ntriples.should == subject.to_n3 end
+      it "should return xml_args" do subject.xml_args.should == ["-P1111Y11M23DT4H55M16.666S", {"rdf:datatype" => "http://www.w3.org/2001/XMLSchema#duration"}] end
+      it "should return TriX" do subject.to_trix.should == "<typedLiteral datatype=\"http://www.w3.org/2001/XMLSchema#duration\">-P1111Y11M23DT4H55M16.666S</typedLiteral>" end
+    end
+    
+    it "should infer type" do
+      int = Literal.build_from(@value)
+      int.encoding.should == "http://www.w3.org/2001/XMLSchema#duration"
+    end
+
+    it "should have string contents" do subject.contents.should == "-P1111Y11M23DT4H55M16.666S" end
+    it "should have native contents" do subject.to_native.should ==  @value end
   end
   
   describe "XML Literal" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rdf_context
 version: !ruby/object:Gem::Version 
-  version: 0.4.7
+  version: 0.4.8
 platform: ruby
 authors: 
 - Gregg Kellogg
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-16 00:00:00 -08:00
+date: 2010-01-20 00:00:00 -08:00
 default_executable: rdf_context
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -106,6 +106,7 @@ files:
 - lib/rdf_context.rb
 - lib/rdf_context/bnode.rb
 - lib/rdf_context/conjunctive_graph.rb
+- lib/rdf_context/duration.rb
 - lib/rdf_context/exceptions.rb
 - lib/rdf_context/graph.rb
 - lib/rdf_context/literal.rb
@@ -129,6 +130,7 @@ files:
 - script/console
 - spec/bnode_spec.rb
 - spec/conjunctive_graph_spec.rb
+- spec/duration_spec.rb
 - spec/graph_spec.rb
 - spec/list_store_spec.rb
 - spec/literal_spec.rb
@@ -676,6 +678,7 @@ summary: RdfContext is an RDF library for Ruby supporting contextual graphs, mul
 test_files: 
 - spec/bnode_spec.rb
 - spec/conjunctive_graph_spec.rb
+- spec/duration_spec.rb
 - spec/graph_spec.rb
 - spec/list_store_spec.rb
 - spec/literal_spec.rb