tripod 0.3.6 → 0.4.0

data/README.md

@@ -29,21 +29,21 @@ ActiveModel-style Ruby ORM for RDF Linked Data. Works with SPARQL 1.1 HTTP endpo
           include Tripod::Resource
 
           # these are the default rdf-type and graph for resources of this class
-          rdf_type 'http://person'
-          graph_uri 'http://people'
-
-          field :name, 'http://name'
-          field :knows, 'http://knows', :multivalued => true
-          field :aliases, 'http://alias', :multivalued => true
-          field :age, 'http://age', :datatype => RDF::XSD.integer
-          field :important_dates, 'http://importantdates', :datatype => RDF::XSD.date, :multivalued => true
+          rdf_type 'http://example.com/person'
+          graph_uri 'http://example.com/people'
+
+          field :name, 'http://example.com/name'
+          field :knows, 'http://example.com/knows', :multivalued => true
+          field :aliases, 'http://example.com/alias', :multivalued => true
+          field :age, 'http://example.com/age', :datatype => RDF::XSD.integer
+          field :important_dates, 'http://example.com/importantdates', :datatype => RDF::XSD.date, :multivalued => true
         end
 
         # Note: Active Model validations are supported
 
 4. Use it
 
-        uri = 'http://ric'
+        uri = 'http://example.com/ric'
         p = Person.new(uri)
         p.name = 'Ric'
         p.age = 31
@@ -53,7 +53,7 @@ ActiveModel-style Ruby ORM for RDF Linked Data. Works with SPARQL 1.1 HTTP endpo
 
         people = Person.all.resources #=> returns all people as an array
 
-        ric = Person.find('http://ric') #=> returns a single Person object.
+        ric = Person.find('http://example.com/ric') #=> returns a single Person object.
 
 ## Note:
 
@@ -64,16 +64,16 @@ Tripod doesn't supply a database. You need to install one. I recommend [Fuseki](
 
 ## Eager Loading
 
-        asa = Person.find('http://asa')
-        ric = Person.find('http://ric')
+        asa = Person.find('http://example.com/asa')
+        ric = Person.find('http://example.com/ric')
         ric.knows = asa.uri
 
         ric.eager_load_predicate_triples! #does a big DESCRIBE statement behind the scenes
-        knows = ric.get_related_resource('http://knows', Resource)
+        knows = ric.get_related_resource('http://example.com/knows', Resource)
         knows.label # this won't cause another database lookup
 
         ric.eager_load_object_triples! #does a big DESCRIBE statement behind the scenes
-        asa = ric.get_related_resource('http://asa', Person) # returns a fully hydrated Person object for asa, without an extra lookup
+        asa = ric.get_related_resource('http://example.com/asa', Person) # returns a fully hydrated Person object for asa, without an extra lookup
 
 ## Defining a graph at instantiation-time
 
@@ -84,7 +84,7 @@ Tripod doesn't supply a database. You need to install one. I recommend [Fuseki](
           # notice also that you don't need to supply an rdf type or graph here!
         end
 
-        r = Resource.new('http://foo', 'http://mygraph')
+        r = Resource.new('http://example.com/foo', 'http://example.com/mygraph')
         r.label = "example"
         r.save
 
@@ -94,8 +94,8 @@ Tripod doesn't supply a database. You need to install one. I recommend [Fuseki](
 
 ## Reading and writing arbitrary predicates
 
-        r.write_predicate(RDF.type, 'http://myresource/type')
-        r.read_predicate(RDF.type) #=> [RDF::URI.new("http://myresource/type")]
+        r.write_predicate(RDF.type, 'http://example.com/myresource/type')
+        r.read_predicate(RDF.type) #=> [RDF::URI.new("http://example.com/myresource/type")]
 
 ## Finders and criteria
 
@@ -103,7 +103,7 @@ Tripod doesn't supply a database. You need to install one. I recommend [Fuseki](
         # It doesn't actually do anything against the DB until you run resources, first, or count on it.
         # (from Tripod::CriteriaExecution)
 
-        Person.all #=> returns a Tripod::Criteria object which selects all resources of rdf_type http://person, in the http://people graph
+        Person.all #=> returns a Tripod::Criteria object which selects all resources of rdf_type http://example.com/person, in the http://example.com/people graph
 
         Resource.all #=> returns a criteria object to return resources in the database (as no rdf_type or graph_uri specified at class level)
 
@@ -114,17 +114,17 @@ Tripod doesn't supply a database. You need to install one. I recommend [Fuseki](
         Person.count  #=> returns the count of all people (by crafting a count query under the covers that only returns a count)
 
         # note that you need to use ?uri as the variable for the subject.
-        Person.where("?uri <http://name> 'Joe'") #=> returns a Tripod::Criteria object
+        Person.where("?uri <http://example.com/name> 'Joe'") #=> returns a Tripod::Criteria object
 
-        Resource.graph("http://mygraph") #=> Retruns a criteria object with a graph restriction (note: if graph_uri set on the class, it will default to using this)
+        Resource.graph("http://example.com/mygraph") #=> Retruns a criteria object with a graph restriction (note: if graph_uri set on the class, it will default to using this)
 
         Resource.find_by_sparql('SELECT ?uri ?graph WHERE { GRAPH ?graph { ?uri ?p ?o } }') #=> allows arbitrary sparql. Again, use ?uri for the variable of the subjects (and ?graph for the graph).
 
 ## Chainable criteria
 
-        Person.all.where("?uri <http://name> 'Ric'").where("?uri <http://knows> <http://asa>).first
+        Person.all.where("?uri <http://example.com/name> 'Ric'").where("?uri <http://example.com/knows> <http://example.com/asa>).first
 
-        Person.where("?uri <http://name> ?name").limit(1).offset(0).order("DESC(?name)")
+        Person.where("?uri <http://example.com/name> ?name").limit(1).offset(0).order("DESC(?name)")
 
 
 [Full Documentation](http://rubydoc.info/gems/tripod/frames)

data/lib/tripod/finders.rb

@@ -95,7 +95,7 @@ module Tripod::Finders
         uris_sparql_str = uris.map{ |u| "<#{u.to_s}>" }.join(" ")
 
         # Do a big describe statement, and read the results into an in-memory repo
-        triples_string = Tripod::SparqlClient::Query.describe("DESCRIBE #{uris_sparql_str}")
+        triples_string = Tripod::SparqlClient::Query.query("DESCRIBE #{uris_sparql_str}", "application/n-triples")
 
         RDF::Reader.for(:ntriples).new(triples_string) do |reader|
           reader.each_statement do |statement|

data/lib/tripod/persistence.rb

@@ -14,7 +14,7 @@ module Tripod::Persistence
     attr_accessor :query
 
     def commit
-      Tripod::SparqlClient::Update::update(self.query)
+      Tripod::SparqlClient::Update.update(self.query)
       clear_transaction
     end
 

data/lib/tripod/repository.rb

@@ -34,8 +34,7 @@ module Tripod::Repository
         end
       end
     else
-
-    triples = Tripod::SparqlClient::Query::describe("DESCRIBE <#{uri}>")
+      triples = Tripod::SparqlClient::Query.query("DESCRIBE <#{uri}>", "application/n-triples")
       @repository = RDF::Repository.new
       RDF::Reader.for(:ntriples).new(triples) do |reader|
         reader.each_statement do |statement|

data/lib/tripod/sparql_client.rb

@@ -10,20 +10,25 @@ module Tripod::SparqlClient
     # @example Run a query
     #   Tripod::SparqlClient::Query.query('SELECT * WHERE {?s ?p ?o}')
     #
+    # @param [ String ] sparql The sparql query.
+    # @param [ String ] accept_header The accept header to send with the request
+    # @param [ Hash ] any extra params to send with the request
     # @return [ RestClient::Response ]
-    def self.query(sparql, format='json', headers = {})
+    def self.query(sparql, accept_header, extra_params={})
 
       begin
-        params = { :params => {:query => sparql, :output => format } }
-        hdrs = headers.merge(params)
+        params = {:query => sparql}.merge(extra_params)
+        hdrs = {:accept => accept_header, :params => params}
 
-        make_the_call =
-          -> { RestClient::Request.execute(
+        make_the_call = -> {
+          response = RestClient::Request.execute(
             :method => :get,
             :url => Tripod.query_endpoint,
             :headers => hdrs,
             :timeout => Tripod.timeout_seconds
-          ) }
+          )
+          response.body
+        }
 
         if Tripod.cache_store # if a cache store is configured
           # SHA-2 the key to keep the it within the small limit for many cache stores (e.g. Memcached is 250bytes)
@@ -40,69 +45,19 @@ module Tripod::SparqlClient
       end
     end
 
-    # Runs a SELECT +query+ against the endpoint. Returns a hash of the results.
-    # Specify +raw_format+ if you want the results raw, as returned from the SPARQL endpoint.
+    # Runs a SELECT +query+ against the endpoint. Returns a Hash of the results.
     #
     # @param [ String ] query The query to run
-    # @param [ String ] raw_format valid formats are: 'json', 'text', 'csv', 'xml'
     #
     # @example Run a SELECT query
     #   Tripod::SparqlClient::Query.select('SELECT * WHERE {?s ?p ?o}')
     #
     # @return [ Hash, String ]
-    def self.select(query, raw_format=nil)
-      query_response = self.query(query, (raw_format || 'json'))
-      if raw_format
-        query_response.body
-      else
-        JSON.parse(query_response.body)["results"]["bindings"]
-      end
-    end
-
-    # Executes a DESCRIBE +query+ against the SPARQL endpoint.
-    # Executes the +query+ and returns ntriples by default
-    #
-    # @example Run a DESCRIBE query
-    #   Tripod::SparqlClient::Query.select('DESCRIBE <http://foo>')
-    #
-    # @param [ String ] query The query to run
-    # @param [ String ] accept_header The header to pass to the database.
-    # 
-    # @return [ String ] the raw response from the endpoint
-    def self.describe(query, accept_header='application/n-triples')
-      response = self.query(query, nil, {:accept=>accept_header})
-      return response.body
-    end
-
-    # Executes an ASK +query+ against the SPARQL endpoint.
-    # Executes the +query+ and returns text by default
-    #
-    # @example Run a ASK query
-    #   Tripod::SparqlClient::Query.select('ASK <http://foo>')
-    #
-    # @param [ String ] query The query to run
-    # @param [ String ] accept_header The format parameter to send to the database. Valud valid formats are text, xml, json
-    # 
-    # @return [ String ] the raw response from the endpoint
-    def self.ask(query, format='text')
-      response = self.query(query, format)
-      return response.body
+    def self.select(query)
+      query_response = self.query(query, "application/sparql-results+json")
+      JSON.parse(query_response)["results"]["bindings"]
     end
 
-    # Executes a CONSTRUCT +query+ against the SPARQL endpoint.
-    # Executes the +query+ and returns ntriples by default
-    #
-    # @example Run a CONSTRUCT query
-    #   Tripod::SparqlClient::Query.select('CONSTRUCT <http://foo>')
-    #
-    # @param [ String ] query The query to run
-    # @param [ String ] accept_header The header to pass to the database.
-    # 
-    # @return [ String ] the raw response from the endpoint
-    def self.construct(query, accept_header='application/n-triples')
-      response = self.query(query, nil, {:accept=>accept_header})
-      return response.body
-    end
   end
 
   module Update

data/lib/tripod/version.rb

@@ -1,3 +1,3 @@
 module Tripod
-  VERSION = "0.3.6"
+  VERSION = "0.4.0"
 end

data/spec/app/models/person.rb

@@ -2,14 +2,14 @@ class Person
 
   include Tripod::Resource
 
-  rdf_type 'http://person'
-  graph_uri 'http://graph'
-
-  field :name, 'http://name'
-  field :father, 'http://father'
-  field :knows, 'http://knows', :multivalued => true
-  field :aliases, 'http://alias', :multivalued => true
-  field :age, 'http://age', :datatype => RDF::XSD.integer
-  field :important_dates, 'http://importantdates', :datatype => RDF::XSD.date, :multivalued => true
+  rdf_type 'http://example.com/person'
+  graph_uri 'http://example.com/graph'
+
+  field :name, 'http://example.com/name'
+  field :father, 'http://example.com/father'
+  field :knows, 'http://example.com/knows', :multivalued => true
+  field :aliases, 'http://exmample.com/alias', :multivalued => true
+  field :age, 'http://example.com/age', :datatype => RDF::XSD.integer
+  field :important_dates, 'http://example.com/importantdates', :datatype => RDF::XSD.date, :multivalued => true
 
 end

data/spec/tripod/attributes_spec.rb

@@ -4,13 +4,13 @@ describe Tripod::Attributes do
   describe ".read_attribute" do
 
     let!(:other_person) do
-      p = Person.new('http://garry')
+      p = Person.new('http://example.com/id/garry')
       p.save!
       p
     end
 
     let(:person) do
-      p = Person.new('http://barry')
+      p = Person.new('http://example.com/id/barry')
       p.name = 'Barry'
       p.father = other_person.uri
       p
@@ -49,13 +49,13 @@ describe Tripod::Attributes do
     end
 
     context "where field is given and single-valued" do
-      let(:field) { Person.send(:field_for, :hat_type, 'http://hat', {}) }
+      let(:field) { Person.send(:field_for, :hat_type, 'http://example.com/hat', {}) }
       before do
-        person.stub(:read_predicate).with('http://hat').and_return(['fez'])
+        person.stub(:read_predicate).with('http://example.com/hat').and_return(['fez'])
       end
 
       it "should use the predicate name from the given field" do
-        person.should_receive(:read_predicate).with('http://hat').and_return(['fez'])
+        person.should_receive(:read_predicate).with('http://example.com/hat').and_return(['fez'])
         person.read_attribute(:hat_type, field)
       end
 
@@ -65,9 +65,9 @@ describe Tripod::Attributes do
     end
 
     context "where field is given and is multi-valued" do
-      let(:field) { Person.send(:field_for, :hat_types, 'http://hat', {multivalued: true}) }
+      let(:field) { Person.send(:field_for, :hat_types, 'http://example.com/hat', {multivalued: true}) }
       before do
-        person.stub(:read_predicate).with('http://hat').and_return(['fez', 'bowler'])
+        person.stub(:read_predicate).with('http://example.com/hat').and_return(['fez', 'bowler'])
       end
 
       it "should return an array of values" do
@@ -83,7 +83,7 @@ describe Tripod::Attributes do
   end
 
   describe ".write_attribute" do
-    let(:person) { Person.new('http://barry') }
+    let(:person) { Person.new('http://example.com/id/barry') }
 
     it "should write the given attribute" do
       person[:name] = 'Barry'
@@ -92,40 +92,40 @@ describe Tripod::Attributes do
 
     it "should co-erce the value given to the correct datatype" do
       person[:age] = 34
-      person.read_predicate('http://age').first.datatype.should == RDF::XSD.integer
+      person.read_predicate('http://example.com/age').first.datatype.should == RDF::XSD.integer
     end
 
     context "where the attribute is multi-valued" do
       it "should co-erce all the values to the correct datatype" do
         person[:important_dates] = [Date.today]
-        person.read_predicate('http://importantdates').first.datatype.should == RDF::XSD.date
+        person.read_predicate('http://example.com/importantdates').first.datatype.should == RDF::XSD.date
       end
     end
 
     context "where field is given" do
-      let(:field) { Person.send(:field_for, :hat_type, 'http://hat', {}) }
+      let(:field) { Person.send(:field_for, :hat_type, 'http://example.com/hat', {}) }
 
       it "should derive the predicate name from the given field" do
-        person.write_attribute(:hat_type, 'http://bowlerhat', field)
-        person.read_predicate('http://hat').first.to_s.should == 'http://bowlerhat'
+        person.write_attribute(:hat_type, 'http://example.com/bowlerhat', field)
+        person.read_predicate('http://example.com/hat').first.to_s.should == 'http://example.com/bowlerhat'
       end
     end
 
     context "where a field of a particular datatype is given" do
-      let(:field) { Person.send(:field_for, :hat_size, 'http://hatsize', {datatype: RDF::XSD.integer}) }
+      let(:field) { Person.send(:field_for, :hat_size, 'http://example.com/hatsize', {datatype: RDF::XSD.integer}) }
 
       it "should derive the datatype from the given field" do
         person.write_attribute(:hat_size, 10, field)
-        person.read_predicate('http://hatsize').first.datatype.should == RDF::XSD.integer
+        person.read_predicate('http://example.com/hatsize').first.datatype.should == RDF::XSD.integer
       end
     end
 
     context "where a multi-valued field of a given datatype is given" do
-      let(:field) { Person.send(:field_for, :hat_heights, 'http://hatheight', {datatype: RDF::XSD.integer, multivalued: true}) }
+      let(:field) { Person.send(:field_for, :hat_heights, 'http://example.com/hatheight', {datatype: RDF::XSD.integer, multivalued: true}) }
 
       it "should co-erce the values passed" do
         person.write_attribute(:hat_heights, [5, 10, 15], field)
-        person.read_predicate('http://hatheight').first.datatype.should == RDF::XSD.integer
+        person.read_predicate('http://example.com/hatheight').first.datatype.should == RDF::XSD.integer
       end
     end
 

data/spec/tripod/criteria_execution_spec.rb

@@ -11,14 +11,14 @@ describe Tripod::Criteria do
   end
 
   let!(:john) do
-    p = Person.new('http://john')
+    p = Person.new('http://example.com/id/john')
     p.name = "John"
     p.save!
     p
   end
 
   let!(:barry) do
-    p = Person.new('http://barry')
+    p = Person.new('http://example.com/id/barry')
     p.name = "Barry"
     p.save!
     p
@@ -28,22 +28,22 @@ describe Tripod::Criteria do
 
     context "for a class with an rdf_type and graph" do
       it "should return a SELECT query based with an rdf type restriction" do
-        person_criteria.send(:build_select_query).should == "SELECT DISTINCT ?uri (<http://graph> as ?graph) WHERE { GRAPH <http://graph> { ?uri a <http://person> . ?uri ?p ?o } }"
+        person_criteria.send(:build_select_query).should == "SELECT DISTINCT ?uri (<http://example.com/graph> as ?graph) WHERE { GRAPH <http://example.com/graph> { ?uri a <http://example.com/person> . ?uri ?p ?o } }"
       end
 
       context "and extra restrictions" do
         before { person_criteria.where("[pattern]") }
 
         it "should return a SELECT query with the extra restriction" do
-          person_criteria.send(:build_select_query).should == "SELECT DISTINCT ?uri (<http://graph> as ?graph) WHERE { GRAPH <http://graph> { ?uri a <http://person> . ?uri ?p ?o . [pattern] } }"
+          person_criteria.send(:build_select_query).should == "SELECT DISTINCT ?uri (<http://example.com/graph> as ?graph) WHERE { GRAPH <http://example.com/graph> { ?uri a <http://example.com/person> . ?uri ?p ?o . [pattern] } }"
         end
       end
 
       context "with an overriden graph" do
-        before { person_criteria.graph("http://anothergraph") }
+        before { person_criteria.graph("http://example.com/anothergraph") }
 
          it "should override the graph in the query" do
-          person_criteria.send(:build_select_query).should == "SELECT DISTINCT ?uri (<http://anothergraph> as ?graph) WHERE { GRAPH <http://anothergraph> { ?uri a <http://person> . ?uri ?p ?o } }"
+          person_criteria.send(:build_select_query).should == "SELECT DISTINCT ?uri (<http://example.com/anothergraph> as ?graph) WHERE { GRAPH <http://example.com/anothergraph> { ?uri a <http://example.com/person> . ?uri ?p ?o } }"
         end
       end
     end
@@ -62,10 +62,10 @@ describe Tripod::Criteria do
       end
 
       context "with a graph set" do
-        before { resource_criteria.graph("http://graphy") }
+        before { resource_criteria.graph("http://example.com/graphy") }
 
          it "should override the graph in the query" do
-          resource_criteria.send(:build_select_query).should == "SELECT DISTINCT ?uri (<http://graphy> as ?graph) WHERE { GRAPH <http://graphy> { ?uri ?p ?o } }"
+          resource_criteria.send(:build_select_query).should == "SELECT DISTINCT ?uri (<http://example.com/graphy> as ?graph) WHERE { GRAPH <http://example.com/graphy> { ?uri ?p ?o } }"
         end
       end
     end
@@ -92,7 +92,7 @@ describe Tripod::Criteria do
 
     context "with extra restrictions" do
 
-      before { person_criteria.where("?uri <http://name> 'John'") }
+      before { person_criteria.where("?uri <http://example.com/name> 'John'") }
 
       it "should return a set of hydrated objects for the type and restrictions" do
          person_criteria.resources.to_a.should == [john]
@@ -118,7 +118,7 @@ describe Tripod::Criteria do
 
     it "should return a set of hydrated objects for the criteria" do
       person_criteria.count.should == 2
-      person_criteria.where("?uri <http://name> 'John'").count.should ==1
+      person_criteria.where("?uri <http://example.com/name> 'John'").count.should ==1
     end
 
     it "should call Query.select with the 'count sparql'" do
@@ -128,7 +128,7 @@ describe Tripod::Criteria do
     end
 
     it "should execute the right Sparql" do
-      sparql = "SELECT COUNT(*) { SELECT DISTINCT ?uri (<http://graph> as ?graph) WHERE { GRAPH <http://graph> { ?uri a <http://person> . ?uri ?p ?o } }  LIMIT 10 OFFSET 20 }"
+      sparql = "SELECT COUNT(*) { SELECT DISTINCT ?uri (<http://example.com/graph> as ?graph) WHERE { GRAPH <http://example.com/graph> { ?uri a <http://example.com/person> . ?uri ?p ?o } }  LIMIT 10 OFFSET 20 }"
       Tripod::SparqlClient::Query.should_receive(:select).with(sparql).and_call_original
       Person.all.limit(10).offset(20).count
     end
@@ -137,10 +137,10 @@ describe Tripod::Criteria do
 
   describe "exeuting a chained criteria" do
 
-    let(:chained_criteria) { Person.where("?uri <http://name> ?name").limit(1).offset(0).order("DESC(?name)") }
+    let(:chained_criteria) { Person.where("?uri <http://example.com/name> ?name").limit(1).offset(0).order("DESC(?name)") }
 
     it "should run the right Sparql" do
-      sparql = "SELECT DISTINCT ?uri (<http://graph> as ?graph) WHERE { GRAPH <http://graph> { ?uri a <http://person> . ?uri <http://name> ?name } } ORDER BY DESC(?name) LIMIT 1 OFFSET 0"
+      sparql = "SELECT DISTINCT ?uri (<http://example.com/graph> as ?graph) WHERE { GRAPH <http://example.com/graph> { ?uri a <http://example.com/person> . ?uri <http://example.com/name> ?name } } ORDER BY DESC(?name) LIMIT 1 OFFSET 0"
       Tripod::SparqlClient::Query.should_receive(:select).with(sparql).and_call_original
       chained_criteria.resources
     end

data/spec/tripod/criteria_spec.rb

@@ -18,7 +18,7 @@ describe Tripod::Criteria do
 
     context "with rdf_type set on the class" do
       it "should initialize the where clauses to include a type restriction" do
-        person_criteria.where_clauses.should == ["?uri a <http://person>", "?uri ?p ?o"]
+        person_criteria.where_clauses.should == ["?uri a <http://example.com/person>", "?uri ?p ?o"]
       end
     end
 
@@ -109,8 +109,8 @@ describe Tripod::Criteria do
 
   describe "#graph" do
     it "sets the graph_uri for this criteria, as a string" do
-      resource_criteria.graph(RDF::URI("http://foobar"))
-      resource_criteria.graph_uri.should == "http://foobar"
+      resource_criteria.graph(RDF::URI("http://example.com/foobar"))
+      resource_criteria.graph_uri.should == "http://example.com/foobar"
     end
   end
 

data/spec/tripod/eager_loading_spec.rb

@@ -4,15 +4,15 @@ describe Tripod::EagerLoading do
 
    before do
 
-    @name = Resource.new('http://name', 'http://names')
+    @name = Resource.new('http://example.com/name', 'http://example.com/names')
     @name.label = "Name"
     @name.save!
 
-    @peter = Person.new('http://peter')
+    @peter = Person.new('http://example.com/peter')
     @peter.name = "Peter"
     @peter.save!
 
-    @john = Person.new('http://john')
+    @john = Person.new('http://example.com/john')
     @john.name = "john"
     @john.knows = @peter.uri
     @john.save!
@@ -25,7 +25,7 @@ describe Tripod::EagerLoading do
     end
 
     it "should add triples to the repository for the predicates" do
-      triples = @peter.repository.query([ RDF::URI.new('http://name'), :predicate, :object] )
+      triples = @peter.repository.query([ RDF::URI.new('http://example.com/name'), :predicate, :object] )
       triples.to_a.length.should_not == 0
       triples.first.predicate.should == RDF::RDFS.label
       triples.first.object.to_s.should == "Name"
@@ -43,11 +43,11 @@ describe Tripod::EagerLoading do
       triples = @john.repository.query([ @peter.uri, :predicate, :object] )
       triples.to_a.length.should_not == 0
 
-      triples.first.predicate.should == RDF.type
-      triples.first.object.to_s.should == RDF::URI('http://person')
+      triples.to_a[1].predicate.should == RDF.type
+      triples.to_a[1].object.to_s.should == RDF::URI('http://example.com/person')
 
-      triples.to_a[1].predicate.should == RDF::URI('http://name')
-      triples.to_a[1].object.to_s.should == "Peter"
+      triples.to_a[0].predicate.should == RDF::URI('http://example.com/name')
+      triples.to_a[0].object.to_s.should == "Peter"
     end
 
   end
@@ -66,7 +66,7 @@ describe Tripod::EagerLoading do
       context "and related resource doesn't exist" do
 
         it "should return nil" do
-          res = @john.get_related_resource(RDF::URI.new('http://nonexistent/person'), Person)
+          res = @john.get_related_resource(RDF::URI.new('http://example.com/nonexistent/person'), Person)
           res.should be_nil
         end
       end
@@ -95,16 +95,16 @@ describe Tripod::EagerLoading do
 
       it "should not call find" do
         Person.should_not_receive(:find)
-        @john.get_related_resource(RDF::URI.new('http://name'), Resource)
+        @john.get_related_resource(RDF::URI.new('http://example.com/name'), Resource)
       end
 
       it "should get the right instance of the resource class passed in" do
-        res = @john.get_related_resource(RDF::URI.new('http://name'), Resource)
+        res = @john.get_related_resource(RDF::URI.new('http://example.com/name'), Resource)
         res.should == @name
       end
 
       it "should be possible to call methods on the returned object" do
-        @john.get_related_resource(RDF::URI.new('http://name'), Resource).label.should == @name.label
+        @john.get_related_resource(RDF::URI.new('http://example.com/name'), Resource).label.should == @name.label
       end
     end
 

data/spec/tripod/fields_spec.rb

@@ -5,7 +5,7 @@ describe Tripod::Fields do
   describe ".field" do
 
     let(:barry) do
-      b = Person.new('http://barry')
+      b = Person.new('http://example.com/id/barry')
       b.name = 'Barry'
       b
       b

data/spec/tripod/finders_spec.rb

@@ -3,14 +3,14 @@ require "spec_helper"
 describe Tripod::Finders do
 
   let(:ric) do
-    r = Person.new('http://example.com/people/id/ric')
+    r = Person.new('http://example.com/id/ric')
     r.name = "ric"
-    r.knows = RDF::URI.new("http://bill")
+    r.knows = RDF::URI.new("http://example.com/id/bill")
     r
   end
 
   let(:bill) do
-    b = Person.new('http://example.com/people/id/bill')
+    b = Person.new('http://example.com/id/bill')
     b.name = "bill"
     b
   end
@@ -27,12 +27,12 @@ describe Tripod::Finders do
 
       it 'hydrates and return an object' do
         person.name.should == "ric"
-        person.knows.should == [RDF::URI('http://bill')]
+        person.knows.should == [RDF::URI('http://example.com/id/bill')]
       end
 
       it 'sets the graph on the instantiated object' do
         person.graph_uri.should_not be_nil
-        person.graph_uri.should == RDF::URI("http://graph")
+        person.graph_uri.should == RDF::URI("http://example.com/graph")
       end
 
       it "returns a non-new record" do
@@ -43,15 +43,15 @@ describe Tripod::Finders do
 
     context 'when record does not exist' do
       it 'raises not found' do
-        lambda { Person.find('http://nonexistent') }.should raise_error(Tripod::Errors::ResourceNotFound)
+        lambda { Person.find('http://example.com/nonexistent') }.should raise_error(Tripod::Errors::ResourceNotFound)
       end
     end
 
     context 'with graph_uri supplied' do
       it 'should use that graph to call new' do
         ric # trigger the lazy load
-        Person.should_receive(:new).with(ric.uri, 'http://graphx').and_call_original
-        Person.find(ric.uri, "http://graphx")
+        Person.should_receive(:new).with(ric.uri, 'http://example.com/graphx').and_call_original
+        Person.find(ric.uri, "http://example.com/graphx")
       end
     end
 
@@ -135,7 +135,7 @@ describe Tripod::Finders do
       res.last.should == bill
 
       res.first.name.should == "ric"
-      res.first.knows.should == [RDF::URI.new("http://bill")]
+      res.first.knows.should == [RDF::URI.new("http://example.com/id/bill")]
     end
 
     it 'uses the uri and graph variables if supplied' do

data/spec/tripod/persistence_spec.rb

@@ -3,28 +3,28 @@ require "spec_helper"
 describe Tripod::Persistence do
 
   let(:unsaved_person) do
-    @unsaved_uri = @uri = 'http://uri'
-    @graph_uri = 'http://graph'
+    @unsaved_uri = @uri = 'http://example.com/uri'
+    @graph_uri = 'http://example.com/graph'
     @graph1 = RDF::Graph.new(@graph_uri)
     stmt = RDF::Statement.new
     stmt.subject = RDF::URI.new(@uri)
-    stmt.predicate = RDF::URI.new('http://pred')
-    stmt.object = RDF::URI.new('http://obj')
+    stmt.predicate = RDF::URI.new('http://example.com/pred')
+    stmt.object = RDF::URI.new('http://example.com/obj')
     @graph1 << stmt
-    p = Person.new(@uri, 'http://graph')
+    p = Person.new(@uri, 'http://example.com/graph')
     p.hydrate!(:graph => @graph1)
     p
   end
 
   let(:saved_person) do
-    @saved_uri = @uri2 = 'http://uri2'
+    @saved_uri = @uri2 = 'http://example.com/uri2'
     @graph2 = RDF::Graph.new
     stmt = RDF::Statement.new
     stmt.subject = RDF::URI.new(@uri2)
-    stmt.predicate = RDF::URI.new('http://pred2')
-    stmt.object = RDF::URI.new('http://obj2')
+    stmt.predicate = RDF::URI.new('http://example.com/pred2')
+    stmt.object = RDF::URI.new('http://example.com/obj2')
     @graph2 << stmt
-    p = Person.new(@uri2, 'http://graph')
+    p = Person.new(@uri2, 'http://example.com/graph')
     p.hydrate!(:graph => @graph2)
     p.save
     p
@@ -35,7 +35,7 @@ describe Tripod::Persistence do
 
     context "with no graph_uri set" do
       it 'should raise a GraphUriNotSet error' do
-        p = Resource.new('http://arbitrary/resource')
+        p = Resource.new('http://example.com/arbitrary/resource')
         lambda { p.save }.should raise_error(Tripod::Errors::GraphUriNotSet)
       end
     end
@@ -49,8 +49,8 @@ describe Tripod::Persistence do
       repo_statements = p2.repository.statements
       repo_statements.count.should == 1
       repo_statements.first.subject.should == RDF::URI.new(@uri)
-      repo_statements.first.predicate.should == RDF::URI.new('http://pred')
-      repo_statements.first.object.should == RDF::URI.new('http://obj')
+      repo_statements.first.predicate.should == RDF::URI.new('http://example.com/pred')
+      repo_statements.first.object.should == RDF::URI.new('http://example.com/obj')
     end
 
 
@@ -86,7 +86,7 @@ describe Tripod::Persistence do
   end
 
   describe '.update_attribute' do
-    let (:person) { Person.new('http://newperson') }
+    let (:person) { Person.new('http://example.com/newperson') }
     before { person.stub(:save) }
 
     it 'should write the attribute' do
@@ -101,7 +101,7 @@ describe Tripod::Persistence do
   end
 
   describe '.update_attributes' do
-    let (:person) { Person.new('http://newperson') }
+    let (:person) { Person.new('http://example.com/newperson') }
     before { person.stub(:save) }
 
     it 'should assign the attributes' do
@@ -122,18 +122,18 @@ describe Tripod::Persistence do
       transaction = Tripod::Persistence::Transaction.new
 
       unsaved_person.save(transaction: transaction)
-      saved_person.write_predicate('http://pred2', 'blah')
+      saved_person.write_predicate('http://example.com/pred2', 'blah')
       saved_person.save(transaction: transaction)
 
       # nothing should have changed yet.
       lambda {Person.find(unsaved_person.uri)}.should raise_error(Tripod::Errors::ResourceNotFound)
-      Person.find(saved_person.uri).read_predicate('http://pred2').first.to_s.should == RDF::URI.new('http://obj2').to_s
+      Person.find(saved_person.uri).read_predicate('http://example.com/pred2').first.to_s.should == RDF::URI.new('http://example.com/obj2').to_s
 
       transaction.commit
 
       # things should have changed now.
       lambda {Person.find(unsaved_person.uri)}.should_not raise_error()
-      Person.find(saved_person.uri).read_predicate('http://pred2').first.should == 'blah'
+      Person.find(saved_person.uri).read_predicate('http://example.com/pred2').first.should == 'blah'
 
     end
 
@@ -143,7 +143,7 @@ describe Tripod::Persistence do
       unsaved_person.stub(:graph_uri).and_return(nil) # force a failure
       unsaved_person.save(transaction: transaction).should be_false
 
-      saved_person.write_predicate('http://pred2', 'blah')
+      saved_person.write_predicate('http://example.com/pred2', 'blah')
       saved_person.save(transaction: transaction).should be_true
 
       transaction.commit
@@ -155,7 +155,7 @@ describe Tripod::Persistence do
       lambda {Person.find(unsaved_person.uri)}.should raise_error(Tripod::Errors::ResourceNotFound)
 
       # saved person SHOULD be updated
-      Person.find(saved_person.uri).read_predicate('http://pred2').first.should == 'blah'
+      Person.find(saved_person.uri).read_predicate('http://example.com/pred2').first.should == 'blah'
     end
 
     it "can be aborted" do

data/spec/tripod/predicates_spec.rb

@@ -3,30 +3,30 @@ require "spec_helper"
 describe Tripod::Predicates do
 
   before do
-    @uri = 'http://ric'
-    @graph = RDF::Graph.new('http://graph')
+    @uri = 'http://example.com/ric'
+    @graph = RDF::Graph.new('http://example.com/graph')
 
     stmt = RDF::Statement.new
     stmt.subject = RDF::URI.new(@uri)
-    stmt.predicate = RDF::URI.new('http://blog')
-    stmt.object = RDF::URI.new('http://blog1')
+    stmt.predicate = RDF::URI.new('http://example.com/blog')
+    stmt.object = RDF::URI.new('http://example.com/blog1')
     @graph << stmt
 
     stmt2 = RDF::Statement.new
     stmt2.subject = RDF::URI.new(@uri)
-    stmt2.predicate = RDF::URI.new('http://blog')
-    stmt2.object = RDF::URI.new('http://blog2')
+    stmt2.predicate = RDF::URI.new('http://example.com/blog')
+    stmt2.object = RDF::URI.new('http://example.com/blog2')
     @graph << stmt2
 
     stmt3 = RDF::Statement.new
     stmt3.subject = RDF::URI.new(@uri)
-    stmt3.predicate = RDF::URI.new('http://name')
+    stmt3.predicate = RDF::URI.new('http://example.com/name')
     stmt3.object = "ric"
     @graph << stmt3
 
     # throw a random other statement (about name) in the mix!
     stmt4 = RDF::Statement.new
-    stmt4.subject = RDF::URI.new('http://name')
+    stmt4.subject = RDF::URI.new('http://example.com/name')
     stmt4.predicate = RDF::RDFS.label
     stmt4.object = "name"
     @graph << stmt4
@@ -40,10 +40,10 @@ describe Tripod::Predicates do
 
   describe "#read_predicate" do
     it 'returns the values where the predicate matches' do
-      values = person.read_predicate('http://blog')
+      values = person.read_predicate('http://example.com/blog')
       values.length.should == 2
-      values.first.should == RDF::URI('http://blog1')
-      values[1].should == RDF::URI('http://blog2')
+      values.first.should == RDF::URI('http://example.com/blog1')
+      values[1].should == RDF::URI('http://example.com/blog2')
     end
   end
 
@@ -51,15 +51,15 @@ describe Tripod::Predicates do
 
     context 'single term passed' do
       it 'replaces the values where the predicate matches' do
-        person.write_predicate('http://name', 'richard')
-        person.read_predicate('http://name').should == [RDF::Literal.new('richard')]
+        person.write_predicate('http://example.com/name', 'richard')
+        person.read_predicate('http://example.com/name').should == [RDF::Literal.new('richard')]
       end
     end
 
     context 'multiple terms passed' do
       it 'replaces the values where the predicate matches' do
-        person.write_predicate('http://name', ['richard', 'ric', 'ricardo'])
-        person.read_predicate('http://name').should == [RDF::Literal.new('richard'), RDF::Literal.new('ric'), RDF::Literal.new('ricardo')]
+        person.write_predicate('http://example.com/name', ['richard', 'ric', 'ricardo'])
+        person.read_predicate('http://example.com/name').should == [RDF::Literal.new('richard'), RDF::Literal.new('ric'), RDF::Literal.new('ricardo')]
       end
     end
 
@@ -67,22 +67,22 @@ describe Tripod::Predicates do
 
   describe '#remove_predicate' do
     it 'remnoves the values where the predicate matches' do
-      person.remove_predicate('http://blog')
-      person.read_predicate('http://blog').should be_empty
+      person.remove_predicate('http://example.com/blog')
+      person.read_predicate('http://example.com/blog').should be_empty
     end
   end
 
   describe "#append_to_predicate" do
     it 'appends values to the existing values for the predicate' do
-      person.append_to_predicate('http://name', 'rico')
-      person.read_predicate('http://name').should == [RDF::Literal.new('ric'), RDF::Literal.new('rico')]
+      person.append_to_predicate('http://example.com/name', 'rico')
+      person.read_predicate('http://example.com/name').should == [RDF::Literal.new('ric'), RDF::Literal.new('rico')]
     end
   end
 
   describe "#predicates" do
     it "returns a list of unique RDF::URIs for the predicates set on this resource" do
       person.predicates.length.should == 2
-      person.predicates.should == [RDF::URI('http://blog'), RDF::URI('http://name')]
+      person.predicates.should == [RDF::URI('http://example.com/blog'), RDF::URI('http://example.com/name')]
     end
 
 

data/spec/tripod/repository_spec.rb

@@ -7,14 +7,14 @@ describe Tripod::Repository do
     context 'uri set' do
 
       before do
-        @uri = 'http://foobar'
-        @uri2 = 'http://bazbar'
-        @graph_uri = 'http://graph'
+        @uri = 'http://example.com/foobar'
+        @uri2 = 'http://example.com/bazbar'
+        @graph_uri = 'http://example.com/graph'
 
         p1 = Person.new(@uri, @graph_uri)
-        p1.write_predicate('http://pred', RDF::URI.new('http://obj'))
-        p1.write_predicate('http://pred2', RDF::URI.new('http://obj2'))
-        p1.write_predicate('http://pred3', 'literal')
+        p1.write_predicate('http://example.com/pred', RDF::URI.new('http://example.com/obj'))
+        p1.write_predicate('http://example.com/pred2', RDF::URI.new('http://example.com/obj2'))
+        p1.write_predicate('http://example.com/pred3', 'literal')
         p1.save!
       end
 
@@ -27,7 +27,7 @@ describe Tripod::Repository do
         context 'no predicate restrictions passed' do
 
           it 'populates the repository with a graph of triples from the db' do
-            Tripod::SparqlClient::Query.should_receive(:describe).with("DESCRIBE <#{@uri}>").and_call_original
+            Tripod::SparqlClient::Query.should_receive(:query).with("DESCRIBE <#{@uri}>", "application/n-triples").and_call_original
             person.hydrate!
             person.repository.should_not be_empty
           end
@@ -43,7 +43,7 @@ describe Tripod::Repository do
             @graph << s
           end
 
-          @graph << RDF::Statement.new( 'http://anotherresource', 'http://pred', 'http://obj')
+          @graph << RDF::Statement.new( 'http://example.com/anotherresource', 'http://example.com/pred', 'http://example.com/obj')
           @graph.statements.count.should ==2 # there'll already be a statement about type in the person.
 
           person.hydrate!(:graph => @graph)

data/spec/tripod/resource_spec.rb

@@ -10,20 +10,20 @@ describe Tripod::Resource do
 
     context 'with a URI' do
       let(:person) do
-        Person.new('http://foobar')
+        Person.new('http://example.com/foobar')
       end
 
       it 'sets the uri instance variable' do
-        person.uri.should == RDF::URI.new('http://foobar')
+        person.uri.should == RDF::URI.new('http://example.com/foobar')
       end
 
       it 'sets the graph_uri instance variable from the class by default' do
-        person.graph_uri.should == RDF::URI.new('http://graph')
+        person.graph_uri.should == RDF::URI.new('http://example.com/graph')
       end
 
       context "with rdf_type specified at class level" do
         it "sets the rdf type from the class" do
-          person.rdf_type.should == ['http://person']
+          person.rdf_type.should == ['http://example.com/person']
         end
       end
 
@@ -34,11 +34,11 @@ describe Tripod::Resource do
 
     context 'with a URI and a graph URI' do
       let(:person) do
-        Person.new('http://foobar', 'http://foobar/graph')
+        Person.new('http://example.com/foobar', 'http://example.com/foobar/graph')
       end
 
       it "overrides the default graph URI with what's given" do
-        person.graph_uri.should == RDF::URI.new('http://foobar/graph')
+        person.graph_uri.should == RDF::URI.new('http://example.com/foobar/graph')
       end
     end
   end

data/spec/tripod/serialization_spec.rb

@@ -4,11 +4,11 @@ describe Tripod::Serialization do
 
   let(:person) do
 
-    p2 = Person.new('http://fred')
+    p2 = Person.new('http://example.com/fred')
     p2.name = "fred"
     p2.save!
 
-    p = Person.new('http://garry')
+    p = Person.new('http://example.com/garry')
     p.name = 'Garry'
     p.age = 30
     p.knows = p2.uri

data/spec/tripod/sparql_client_spec.rb

@@ -6,28 +6,28 @@ describe Tripod::SparqlClient do
 
     describe "Data#append" do
       it "should add the graph uri to the configured data endpoint" do
-        RestClient::Request.should_receive(:execute).with(hash_including(url: 'http://127.0.0.1:3030/tripod-test/data?graph=http://foo'))
-        Tripod::SparqlClient::Data.append('http://foo', data)
+        RestClient::Request.should_receive(:execute).with(hash_including(url: 'http://127.0.0.1:3030/tripod-test/data?graph=http://example.com/foo'))
+        Tripod::SparqlClient::Data.append('http://example.com/foo', data)
       end
 
       it "should send the data as the payload" do
         RestClient::Request.should_receive(:execute).with(hash_including(payload: data))
-        Tripod::SparqlClient::Data.append('http://foo', data)
+        Tripod::SparqlClient::Data.append('http://example.com/foo', data)
       end
 
       it "should HTTP POST the data" do
         RestClient::Request.should_receive(:execute).with(hash_including(method: :post))
-        Tripod::SparqlClient::Data.append('http://foo', data)
+        Tripod::SparqlClient::Data.append('http://example.com/foo', data)
       end
 
       context "which fails with a 400 error" do
         before do
           WebMock.enable!
-          stub_http_request(:post, 'http://127.0.0.1:3030/tripod-test/data?graph=http://foo').to_return(body: 'Error 400: Trousers missing', status: 400)
+          stub_http_request(:post, 'http://127.0.0.1:3030/tripod-test/data?graph=http://example.com/foo').to_return(body: 'Error 400: Trousers missing', status: 400)
         end
 
         it "should raise a 'parse failed' exception" do
-          lambda { Tripod::SparqlClient::Data.append('http://foo', data) }.should raise_error(Tripod::Errors::BadDataRequest)
+          lambda { Tripod::SparqlClient::Data.append('http://example.com/foo', data) }.should raise_error(Tripod::Errors::BadDataRequest)
         end
 
         after do
@@ -39,7 +39,7 @@ describe Tripod::SparqlClient do
     describe "Data#replace" do
       it "should HTTP PUT the data" do
         RestClient::Request.should_receive(:execute).with(hash_including(method: :put))
-        Tripod::SparqlClient::Data.replace('http://foo', data)
+        Tripod::SparqlClient::Data.replace('http://example.com/foo', data)
       end
     end
   end

data/spec/tripod/state_spec.rb

@@ -7,7 +7,7 @@ describe Tripod::State do
     context "when calling new on the resource" do
 
       let(:person) do
-        Person.new('http://uri', 'http://graph')
+        Person.new('http://example.com/uri', 'http://example.com/graph')
       end
 
       it "returns true" do
@@ -18,7 +18,7 @@ describe Tripod::State do
     context "when the object has been saved" do
 
       let(:person) do
-        p = Person.new('http://uri', 'http://graph')
+        p = Person.new('http://example.com/uri', 'http://example.com/graph')
         p.save
         p
       end
@@ -32,7 +32,7 @@ describe Tripod::State do
   describe "#persisted?" do
 
     let(:person) do
-      Person.new('http://uri', 'http://graph')
+      Person.new('http://example.com/uri', 'http://example.com/graph')
     end
 
     it "delegates to new_record?" do
@@ -54,7 +54,7 @@ describe Tripod::State do
   describe "destroyed?" do
 
     let(:person) do
-      Person.new('http://uri', 'http://graph')
+      Person.new('http://example.com/uri', 'http://example.com/graph')
     end
 
     context "when destroyed is true" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tripod
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -15,7 +15,7 @@ date: 2013-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
-  requirement: &70167526722900 !ruby/object:Gem::Requirement
+  requirement: &70364886263520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -23,10 +23,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70167526722900
+  version_requirements: *70364886263520
 - !ruby/object:Gem::Dependency
   name: activemodel
-  requirement: &70167526720820 !ruby/object:Gem::Requirement
+  requirement: &70364886262400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -34,10 +34,10 @@ dependencies:
         version: '3.1'
   type: :runtime
   prerelease: false
-  version_requirements: *70167526720820
+  version_requirements: *70364886262400
 - !ruby/object:Gem::Dependency
   name: equivalent-xml
-  requirement: &70167518449700 !ruby/object:Gem::Requirement
+  requirement: &70364886261680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -45,10 +45,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70167518449700
+  version_requirements: *70364886261680
 - !ruby/object:Gem::Dependency
   name: rdf
-  requirement: &70167518447940 !ruby/object:Gem::Requirement
+  requirement: &70364886260440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -56,10 +56,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70167518447940
+  version_requirements: *70364886260440
 - !ruby/object:Gem::Dependency
   name: rdf-rdfxml
-  requirement: &70167518446320 !ruby/object:Gem::Requirement
+  requirement: &70364886259940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -67,10 +67,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70167518446320
+  version_requirements: *70364886259940
 - !ruby/object:Gem::Dependency
   name: rdf-n3
-  requirement: &70167518445720 !ruby/object:Gem::Requirement
+  requirement: &70364886258140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -78,10 +78,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70167518445720
+  version_requirements: *70364886258140
 - !ruby/object:Gem::Dependency
   name: rdf-json
-  requirement: &70167518444840 !ruby/object:Gem::Requirement
+  requirement: &70364886255600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -89,10 +89,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70167518444840
+  version_requirements: *70364886255600
 - !ruby/object:Gem::Dependency
   name: json-ld
-  requirement: &70167518444020 !ruby/object:Gem::Requirement
+  requirement: &70364886254440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -100,10 +100,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70167518444020
+  version_requirements: *70364886254440
 - !ruby/object:Gem::Dependency
   name: guid
-  requirement: &70167518443180 !ruby/object:Gem::Requirement
+  requirement: &70364886240960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -111,10 +111,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70167518443180
+  version_requirements: *70364886240960
 - !ruby/object:Gem::Dependency
   name: dalli
-  requirement: &70167518442440 !ruby/object:Gem::Requirement
+  requirement: &70364886240040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -122,7 +122,7 @@ dependencies:
         version: '2.6'
   type: :runtime
   prerelease: false
-  version_requirements: *70167518442440
+  version_requirements: *70364886240040
 description: RDF ruby ORM
 email:
 - ric@swirrl.com