tripod 0.0.10 → 0.2

data/lib/tripod/repository.rb

@@ -13,10 +13,18 @@ module Tripod::Repository
   #   person.hydrate!
   #
   # @example Hydrate the resource from a passed in graph
-  #   person.hydrate!(my_graph)
+  #   person.hydrate!(:graph => my_graph)
+  #
+  # @example Only hydrate certain predicates (ignored if a graph is passde in)
+  #   person.hydrate!(:only => ["http://foo", "http://bar"])
+  #   person.hydrate!(:only => "http://foo")
+  #
   #
   # @return [ RDF::Repository ] A reference to the repository for this instance.
-  def hydrate!(graph = nil)
+  def hydrate!(opts = {})
+
+    graph = opts[:graph]
+    only_hydrate_predicates = [opts[:only]].flatten # allow
 
     # we require that the uri is set.
     raise Tripod::Errors::UriNotSet.new() unless @uri
@@ -31,7 +39,16 @@ module Tripod::Repository
         end
       end
     else
-      triples = Tripod::SparqlClient::Query::describe("DESCRIBE <#{uri}>")
+
+      unless only_hydrate_predicates && only_hydrate_predicates.any?
+        triples = Tripod::SparqlClient::Query::describe("DESCRIBE <#{uri}>")
+      else
+        query = "CONSTRUCT { <#{uri}> ?p ?o } WHERE { <#{uri}> ?p ?o . FILTER ("
+        query += only_hydrate_predicates.map { |p| "?p = <#{p.to_s}>" }.join(" || ")
+        query += ")}"
+        triples = Tripod::SparqlClient::Query::construct(query)
+      end
+
       @repository = RDF::Repository.new
       RDF::Reader.for(:ntriples).new(triples) do |reader|
         reader.each_statement do |statement|

data/lib/tripod/resource.rb

@@ -9,8 +9,12 @@ module Tripod::Resource
   include Tripod::Components
 
   included do
-    # every resource needs a graph and a uri set.
-    validates_presence_of :uri, :graph_uri
+    # every resource needs a graph set.
+    validates_presence_of :graph_uri
+    # every instance of a resource has an rdf type field, which is set at the class level
+    class_attribute :_RDF_TYPE
+    # the Graph URI is set at the class level by default also, although this can be overridden in the constructor
+    class_attribute :_GRAPH_URI
   end
 
   attr_reader :new_record
@@ -18,7 +22,6 @@ module Tripod::Resource
   attr_reader :uri
 
   # Instantiate a +Resource+.
-  # Optionsally pass a uri
   #
   # @example Instantiate a new Resource
   #   Person.new('http://swirrl.com/ric.rdf#me')
@@ -26,29 +29,17 @@ module Tripod::Resource
   # @param [ String, RDF::URI ] uri The uri of the resource.
   #
   # @return [ Resource ] A new +Resource+
-  def initialize(uri=nil, graph_uri=nil)
-    @new_record = true
-    @uri = RDF::URI(uri.to_s) if uri
-    @graph_uri = RDF::URI(graph_uri.to_s) if graph_uri
-    @repository = RDF::Repository.new
-  end
+  def initialize(uri, graph_uri=nil)
+    raise Tripod::Errors::UriNotSet.new('uri missing') unless uri
+    @uri = RDF::URI(uri.to_s)
 
-  # Set the uri for this resource
-  def uri=(new_uri)
-    if new_uri
-      @uri = RDF::URI(new_uri.to_s)
-    else
-      @uri = nil
-    end
-  end
+    graph_uri ||= self.class._GRAPH_URI if self.class._GRAPH_URI
+    raise Tripod::Errors::UriNotSet.new('graph_uri missing') unless graph_uri
+    @graph_uri = RDF::URI(graph_uri)
 
-  # Set the uri for this resource
-  def graph_uri=(new_graph_uri)
-    if new_graph_uri
-      @graph_uri = RDF::URI(new_graph_uri.to_s)
-    else
-      @graph_uri = nil
-    end
+    @repository = RDF::Repository.new
+    @new_record = true
+    self.rdf_type = self.class._RDF_TYPE if respond_to?(:rdf_type=)
   end
 
   # default comparison is via the uri
@@ -102,6 +93,14 @@ module Tripod::Resource
       other.class == Class ? self <= other : other.is_a?(self)
     end
 
+    def rdf_type(new_rdf_type)
+      field :rdf_type, RDF.type
+      self._RDF_TYPE = new_rdf_type
+    end
+
+    def graph_uri(new_graph_uri)
+      self._GRAPH_URI = new_graph_uri
+    end
   end
 
 end

data/lib/tripod/serialization.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+# This module defines behaviour for finders.
+module Tripod::Serialization
+  extend ActiveSupport::Concern
+
+  # Serialises this resource's triples to rdf/xml
+  def to_rdf
+    @repository.dump(:rdfxml)
+  end
+
+  # Serialises this resource's triples to turtle
+  def to_ttl
+    @repository.dump(:n3)
+  end
+
+  # Serialises this resource's triples to n-triples
+  def to_nt
+    @repository.dump(:ntriples)
+  end
+
+  # Serialises this resource's triples to JSON-LD
+  def to_json(opts={})
+    @repository.dump(:jsonld)
+  end
+
+end

data/lib/tripod/sparql_client.rb

@@ -26,10 +26,8 @@ module Tripod::SparqlClient
         body = e.http_body
         if body.start_with?('Error 400: Parse error:')
           # TODO: this is a SPARQL parsing exception. Do something different.
-          puts body.inspect
           raise e
         else
-          puts body.inspect
           raise e
         end
       end
@@ -68,6 +66,21 @@ module Tripod::SparqlClient
       response = self.query(query, nil, {:accept=>accept_header})
       return response.body
     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
@@ -92,10 +105,8 @@ module Tripod::SparqlClient
         body = e.http_body
         if body.start_with?('Error 400: Parse error:')
           # TODO: this is a SPARQL parsing exception. Do something different.
-          puts body.inspect
           raise e
         else
-          puts body.inspect
           raise e
         end
       end

data/lib/tripod/version.rb

@@ -1,3 +1,3 @@
 module Tripod
-  VERSION = "0.0.10"
+  VERSION = "0.2"
 end

data/spec/app/models/person.rb

@@ -2,7 +2,11 @@ class Person
 
   include Tripod::Resource
 
+  rdf_type 'http://person'
+  graph_uri 'http://graph'
+
   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

data/spec/tripod/attributes_spec.rb

@@ -1,103 +1,112 @@
 require "spec_helper"
 
 describe Tripod::Attributes do
+  describe ".read_attribute" do
+    let(:person) do
+      p = Person.new('http://barry')
+      p.name = 'Barry'
+      p
+    end
 
-  before do
-    @uri = 'http://ric'
-    @graph = RDF::Graph.new
-
-    stmt = RDF::Statement.new
-    stmt.subject = RDF::URI.new(@uri)
-    stmt.predicate = RDF::URI.new('http://blog')
-    stmt.object = RDF::URI.new('http://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')
-    @graph << stmt2
-
-    stmt3 = RDF::Statement.new
-    stmt3.subject = RDF::URI.new(@uri)
-    stmt3.predicate = RDF::URI.new('http://name')
-    stmt3.object = "ric"
-    @graph << stmt3
-  end
+    it "should read the given attribute" do
+      person[:name].should == 'Barry'
+    end
 
-  let(:person) do
-    p = Person.new(@uri)
-    p.hydrate!(@graph)
-    p
-  end
+    context "where the attribute is multi-valued" do
+      before do
+        person.aliases = ['Boz', 'Baz', 'Bez']
+      end
 
-  describe "#[]" do
-    it 'returns the values where the predicate matches' do
-      values = person['http://blog']
-      values.length.should == 2
-      values.first.should == RDF::URI('http://blog1')
-      values[1].should == RDF::URI('http://blog2')
+      it "should return an array" do
+        person[:aliases].should == ['Boz', 'Baz', 'Bez']
+      end
     end
-  end
 
-  describe "#read_attribute" do
-    it 'returns the values where the predicate matches' do
-      values = person.read_attribute('http://blog')
-      values.length.should == 2
-      values.first.should == RDF::URI('http://blog1')
-      values[1].should == RDF::URI('http://blog2')
+    context "where field is given and single-valued" do
+      let(:field) { Person.send(:field_for, :hat_type, 'http://hat', {}) }
+      before do
+        person.stub(:read_predicate).with('http://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.read_attribute(:hat_type, field)
+      end
+
+      it "should return a single value" do
+        person.read_attribute(:hat_type, field).should == 'fez'
+      end
     end
-  end
 
-  describe '#[]=' do
+    context "where field is given and is multi-valued" do
+      let(:field) { Person.send(:field_for, :hat_types, 'http://hat', {multivalued: true}) }
+      before do
+        person.stub(:read_predicate).with('http://hat').and_return(['fez', 'bowler'])
+      end
 
-    context 'single term passed' do
-      it 'replaces the values where the predicate matches' do
-        person['http://name'] = 'richard'
-        person['http://name'].should == [RDF::Literal.new('richard')]
+      it "should return an array of values" do
+        person.read_attribute(:hat_types, field).should == ['fez', 'bowler']
       end
     end
 
-    context 'multiple terms passed' do
-      it 'replaces the values where the predicate matches' do
-        person['http://name'] = ['richard', 'ric', 'ricardo']
-        person['http://name'].should == [RDF::Literal.new('richard'), RDF::Literal.new('ric'), RDF::Literal.new('ricardo')]
+    context "where there is no field with the given name" do
+      it "should raise a 'field not present' error" do
+        lambda { person.read_attribute(:hoof_size) }.should raise_error(Tripod::Errors::FieldNotPresent)
       end
     end
   end
 
-  describe '#write_attribute' do
+  describe ".write_attribute" do
+    let(:person) { Person.new('http://barry') }
+
+    it "should write the given attribute" do
+      person[:name] = 'Barry'
+      person.name.should == 'Barry'
+    end
 
-    context 'single term passed' do
-      it 'replaces the values where the predicate matches' do
-        person.write_attribute('http://name', 'richard')
-        person['http://name'].should == [RDF::Literal.new('richard')]
+    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
+    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
       end
     end
 
-    context 'multiple terms passed' do
-      it 'replaces the values where the predicate matches' do
-        person.write_attribute('http://name', ['richard', 'ric', 'ricardo'])
-        person['http://name'].should == [RDF::Literal.new('richard'), RDF::Literal.new('ric'), RDF::Literal.new('ricardo')]
+    context "where field is given" do
+      let(:field) { Person.send(:field_for, :hat_type, 'http://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'
       end
     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}) }
 
-  describe '#remove_attribute' do
-    it 'remnoves the values where the predicate matches' do
-      person.remove_attribute('http://blog')
-      person['http://blog'].should be_empty
+      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
+      end
     end
-  end
 
-  describe "append_to_attribute" do
+    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}) }
 
-    it 'appends values to the existing values for the predicate' do
-      person.append_to_attribute('http://name', 'rico')
-      person['http://name'].should == [RDF::Literal.new('ric'), RDF::Literal.new('rico')]
+      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
+      end
     end
 
+    context "where there is no field with the given name" do
+      it "should raise a 'field not present' error" do
+        lambda { person.write_attribute(:hoof_size, 'A1') }.should raise_error(Tripod::Errors::FieldNotPresent)
+      end
+    end
   end
-
 end

data/spec/tripod/fields_spec.rb

@@ -6,82 +6,32 @@ describe Tripod::Fields do
 
     let(:barry) do
       b = Person.new('http://barry')
-      b['http://name'] = 'Barry'
-      b['http://alias'] = ['Basildon', 'Baz']
-      b['http://age'] = 54
-      b['http://importantdates'] = [Date.new(2010,01,01), Date.new(2012,01,01)]
+      b.name = 'Barry'
+      b
       b
     end
 
-    context "with no options" do
-
-      it "creates a getter for the field, which accesses data for the predicate, returning a single String" do
-        barry.name.should == "Barry"
-      end
-
-      it "creates a setter for the field, which sets data for the predicate" do
-        barry.name = "Basildon"
-        barry.name.should == "Basildon"
-        barry['http://name'].should == [RDF::Literal.new("Basildon")]
-      end
-
+    it "creates a getter for the field, which accesses data for the predicate, returning a single String" do
+      barry.name.should == "Barry"
     end
 
-    context "with multivalued option" do
-
-      it "creates a getter for the field, which accesses data for the predicate, returning an array of Strings" do
-        barry.aliases.should == ['Basildon', 'Baz']
-      end
-
-      it "creates a setter for the field, which sets data for the predicate" do
-        barry.aliases = ['Basildon', 'Baz', 'B-man']
-        barry.aliases.should == ['Basildon', 'Baz', 'B-man']
-        barry['http://alias'].should == [RDF::Literal.new("Basildon"),RDF::Literal.new("Baz"),RDF::Literal.new("B-man")]
-      end
-
-      context 'with data type' do
-
-        it "creates a getter for the field, which accesses data for the predicate, returning an array of Strings" do
-          barry.important_dates.class.should == Array
-          barry.important_dates.should == ["2010-01-01Z", "2012-01-01Z"]
-        end
-
-        it "creates a setter for the field, which sets data for the predicate, using the right data type" do
-          barry.important_dates = [Date.new(2010,01,02),Date.new(2010,01,03)]
-          barry['http://importantdates'].should == [ RDF::Literal.new(Date.new(2010,01,02)), RDF::Literal.new(Date.new(2010,01,03)) ]
-          barry['http://importantdates'].map(&:datatype).should == [RDF::XSD.date,RDF::XSD.date]
-        end
-
-      end
-
+    it "creates a setter for the field, which sets data for the predicate" do
+      barry.name = "Basildon"
+      barry.name.should == "Basildon"
     end
 
-    context 'with data type' do
-
-      it "creates a getter for the field, which accesses data for the predicate, returning a single String" do
-        barry.age.should == "54"
-      end
-
-      it "creates a setter for the field, which sets data for the predicate, using the right data type" do
-        barry.age = 57
-        barry.age.should == '57'
-        barry['http://age'] = [ RDF::Literal.new(57) ]
-        barry['http://age'].first.datatype = RDF::XSD.integer
-      end
-
+    it "creates a check? method, which returns true when the value is present" do
+      barry.name?.should == true
     end
 
-    context 'with no data type specified' do
-
-      it "creates the right kind of literals when setting values." do
-        barry.name == 100 # set an integer
-        barry['http://name'] = [ RDF::Literal.new(100) ]
-        barry['http://name'].first.datatype = RDF::XSD.integer
+    context "when the value is not set" do
+      before do
+        barry.name = nil
       end
 
-
+      it "should have a check? method which returns false" do
+        barry.name?.should == false
+      end
     end
-
   end
-
 end