tripod 0.0.1 → 0.0.2

data/lib/tripod/resource.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+
+# module for all domain objects that need to be persisted to the database
+# as resources
+module Tripod::Resource
+
+  extend ActiveSupport::Concern
+
+  include Tripod::Components
+
+  included do
+    # every resource needs a graph and a uri set.
+    validates_presence_of :uri, :graph_uri
+  end
+
+  attr_reader :new_record
+  attr_reader :graph_uri
+  attr_reader :uri
+
+  # Instantiate a +Resource+.
+  # Optionsally pass a uri
+  #
+  # @example Instantiate a new Resource
+  #   Person.new('http://swirrl.com/ric.rdf#me')
+  #
+  # @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
+
+  # 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
+
+  # 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
+  end
+
+  # default comparison is via the uri
+  def <=>(other)
+    uri.to_s <=> uri.to_s
+  end
+
+  # performs equality checking on the uris
+  def ==(other)
+    self.class == other.class &&
+      uri.to_s == uri.to_s
+  end
+
+  # performs equality checking on the class
+  def ===(other)
+    other.class == Class ? self.class === other : self == other
+  end
+
+  # delegates to ==
+  def eql?()
+    self == (other)
+  end
+
+  def hash
+    identity.hash
+  end
+
+  # a resource is absolutely identified by it's class and id.
+  def identity
+    [ self.class, self.uri.to_s ]
+  end
+
+  # Return the key value for the resource.
+  #
+  # @example Return the key.
+  #   resource.to_key
+  #
+  # @return [ Object ] The uri of the resource or nil if new.
+  def to_key
+    (persisted? || destroyed?) ? [ uri.to_s ] : nil
+  end
+
+  def to_a
+    [ self ]
+  end
+
+  module ClassMethods
+
+    # Performs class equality checking.
+    def ===(other)
+      other.class == Class ? self <= other : other.is_a?(self)
+    end
+
+  end
+
+end
+
+# causes any hooks to be fired, if they've been setup on_load of :tripod.
+ActiveSupport.run_load_hooks(:triploid, Tripod::Resource)

data/lib/tripod/sparql_client.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+# this module is responsible for connecting to an http sparql endpoint
+module Tripod::SparqlClient
+
+  module Query
+
+
+    # Runs a +sparql+ query against the endpoint. Returns a RestClient response object.
+    #
+    # @example Run a query
+    #   Tripload::Sparql.query('SELECT * WHERE {?s ?p ?o}')
+    #
+    # @return [ RestClient::Response ]
+
+    def self.query(sparql, format='json', headers = {})
+
+      begin
+        params = { :params => {:query => sparql, :output => format } }
+        hdrs = headers.merge(params)
+        RestClient::Request.execute(
+          :method => :get,
+          :url => Tripod.query_endpoint,
+          :headers => hdrs,
+          :timeout => Tripod.timeout_seconds,
+        )
+      rescue RestClient::BadRequest => e
+        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
+    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.
+    #
+    # @param [ String ] query The query to run
+    # @param [ String ] raw_format valid formats are: 'json', 'text', 'csv', 'xml'
+    #
+    # @example Run a SELECT query
+    #   Triploid::Sparql.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
+    #  Triploid::Sparql.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
+  end
+
+  module Update
+
+    def self.update(sparql)
+
+      begin
+        RestClient::Request.execute(
+          :method => :post,
+          :url => Tripod.update_endpoint,
+          :timeout => Tripod.timeout_seconds,
+          :payload => {:update => sparql}
+        )
+        return true
+      rescue RestClient::BadRequest => e
+        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
+    end
+
+  end
+end

data/lib/tripod/state.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+# This module contains the behaviour for getting the various states through which a
+# resource can transition.
+module Tripod::State
+
+  extend ActiveSupport::Concern
+
+  attr_writer :destroyed, :new_record
+
+  # Returns true if the +Resource+ has not been persisted to the database,
+  # false if it has. This is determined by the variable @new_record
+  # and NOT if the object has an id.
+  #
+  # @example Is the resource new?
+  #   person.new_record?
+  #
+  # @return [ true, false ] True if new, false if not.
+  def new_record?
+    @new_record ||= false
+  end
+
+  # Checks if the resource has been saved to the database. Returns false
+  # if the document has been destroyed.
+  #
+  # @example Is the resource persisted?
+  #   person.persisted?
+  #
+  # @return [ true, false ] True if persisted, false if not.
+  def persisted?
+    !new_record? && !destroyed?
+  end
+
+  # Returns true if the +Resource+ has been succesfully destroyed, and false
+  # if it hasn't. This is determined by the variable @destroyed and NOT
+  # by checking the database.
+  #
+  # @example Is the resource destroyed?
+  #   person.destroyed?
+  #
+  # @return [ true, false ] True if destroyed, false if not.
+  def destroyed?
+    @destroyed ||= false
+  end
+  alias :deleted? :destroyed?
+
+end

data/lib/tripod/version.rb

@@ -1,3 +1,3 @@
 module Tripod
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/app/models/person.rb

@@ -0,0 +1,5 @@
+class Person
+
+  include Tripod::Resource
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+MODELS = File.join(File.dirname(__FILE__), "app/models")
+$LOAD_PATH.unshift(MODELS)
+
+require 'tripod'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  config.before(:each) do
+    # delete from all named graphs.
+    Tripod::SparqlClient::Update.update('
+      # delete from default graph:
+      DELETE {?s ?p ?o} WHERE {?s ?p ?o};
+      # delete from named graphs:
+      DELETE {graph ?g {?s ?p ?o}} WHERE {graph ?g {?s ?p ?o}};
+    ')
+  end
+
+end
+
+# configure any settings for testing...
+Tripod.configure do |config|
+  config.update_endpoint = 'http://127.0.0.1:3030/tripod-test/update'
+  config.query_endpoint = 'http://127.0.0.1:3030/tripod-test/sparql'
+end
+
+# Autoload every model for the test suite that sits in spec/app/models.
+Dir[ File.join(MODELS, "*.rb") ].sort.each do |file|
+  name = File.basename(file, ".rb")
+  autoload name.camelize.to_sym, name
+end

data/spec/tripod/attributes_spec.rb

@@ -0,0 +1,103 @@
+require "spec_helper"
+
+describe Tripod::Attributes do
+
+  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
+
+  let(:person) do
+    p = Person.new(@uri)
+    p.hydrate!(@graph)
+    p
+  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')
+    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')
+    end
+  end
+
+  describe '#[]=' do
+
+    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')]
+      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')]
+      end
+    end
+  end
+
+  describe '#write_attribute' do
+
+    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')]
+      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')]
+      end
+    end
+
+  end
+
+  describe '#remove_attribute' do
+    it 'remnoves the values where the predicate matches' do
+      person.remove_attribute('http://blog')
+      person['http://blog'].should be_empty
+    end
+  end
+
+  describe "append_to_attribute" do
+
+    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')]
+    end
+
+  end
+
+end

data/spec/tripod/finders_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper"
+
+describe Tripod::Finders do
+
+  let(:ric) do
+    @ric_uri = 'http://ric'
+    stmts = RDF::Graph.new
+
+    stmt = RDF::Statement.new
+    stmt.subject = RDF::URI.new(@ric_uri)
+    stmt.predicate = RDF::URI.new('http://name')
+    stmt.object = "ric"
+    stmts << stmt
+
+    stmt = RDF::Statement.new
+    stmt.subject = RDF::URI.new(@ric_uri)
+    stmt.predicate = RDF::URI.new('http://knows')
+    stmt.object = RDF::URI.new('http://bill')
+    stmts << stmt
+
+    r = Person.new(@ric_uri, 'http://people')
+    r.hydrate!(stmts)
+    r.save
+    r
+  end
+
+  let(:bill) do
+    @bill_uri = 'http://bill'
+    stmts = RDF::Graph.new
+    stmt = RDF::Statement.new
+    stmt.subject = RDF::URI.new(@bill_uri)
+    stmt.predicate = RDF::URI.new('http://name')
+    stmt.object = "bill"
+    stmts << stmt
+    b = Person.new(@bill_uri, 'http://people')
+    b.hydrate!(stmts)
+    b.save
+    b
+  end
+
+  describe '.find' do
+
+    context 'when record exists' do
+
+      it 'does not error' do
+        r = Person.find(ric.uri)
+      end
+
+      it 'hydrates and return an object' do
+        r = Person.find(ric.uri)
+        r['http://name'].should == [RDF::Literal.new("ric")]
+        r['http://knows'].should == [RDF::URI.new('http://bill')]
+      end
+
+      it 'sets the graph on the instantiated object' do
+        r = Person.find(ric.uri)
+        r.graph_uri.should_not be_nil
+        r.graph_uri.should == RDF::URI("http://people")
+      end
+
+    end
+
+    context 'when record does not exist' do
+      it 'raises not found' do
+        lambda { Person.find('http://nonexistant') }.should raise_error(Tripod::Errors::ResourceNotFound)
+      end
+    end
+
+  end
+
+end