sasquatch 0.0.1

data/README

@@ -0,0 +1,57 @@
+Sasquatch - A DSL for the Talis Platform
+==============================
+
+Sasquatch makes it easy to add/delete/replace resources and triples on the Talis Platform using RDF.rb.
+
+Example:
+
+  store = Sasquatch::Store.new(storename, {:username=>u, :password=>p}) # authentication is optional
+  
+  resource = store.describe("http://example.org/1")
+  => #<RDF::Graph:0x81467e78(<>)>
+  
+  resources = store.describe_multi(['http://example.org/1', 'http://example.org/2'])
+  => #<RDF::Graph:0x8100fd58(<>)>
+
+  store.delete_uri('http://example.org/1')
+  
+  => true
+  
+  store.delete_uris(['http://example.org/2', 'http://example.org/3'])
+  
+  => true
+  
+  Because ChangeSets are somewhat cumbersome, there are methods to replace triples or resources wholesale:
+  
+  store.replace(resources) # where 'resources' is an RDF::Graph, array of RDF::Statements or RDF::RDFObjects::Resource
+  
+  This will replace all of the subjects with what is sent.  Pass a boolean true to make it a versioned changeset.
+  
+  There is also:
+  
+  store.replace_triple(old_triple, new_triple)
+  
+  where old_triple and new_triple are RDF::Statements
+  
+  and
+  
+  store.replace_triples
+  
+  which takes a Hash where the keys are the old triples and the values are the new triples.
+  
+  search = store.search("italy")
+  => [#<RDF::URI:0x80f92484(http://id.loc.gov/authorities/sh89006665#concept)>, #<RDF::URI:0x80f90df0(http://lcsubjects.org/subjects/sh89006665#concept)>, #<RDF::URI:0x80f9042c(http://id.loc.gov/authorities/sh2004008861#concept)>, #<RDF::URI:0x80f8f5e0(http://id.loc.gov/authorities/sh2006002475#concept)>, #<RDF::URI:0x80f8e974(http://id.loc.gov/authorities/sh86005484#concept)>, #<RDF::URI:0x80f8d31c(http://lcsubjects.org/subjects/sh2004008861#concept)>, #<RDF::URI:0x80f8c548(http://lcsubjects.org/subjects/sh2006002475#concept)>, #<RDF::URI:0x80f8b29c(http://lcsubjects.org/subjects/sh86005484#concept)>, #<RDF::URI:0x80f8a48c(http://id.loc.gov/authorities/sh85069035#concept)>, #<RDF::URI:0x80f88f38(http://lcsubjects.org/subjects/sh85069035#concept)>]
+  
+  #search returns a Sasquatch::SearchResult, which is sort of a glorified array.
+  
+  To get the next page of search results, use SearchResult#next, to get the previous, use SearchResult#previous
+  
+  You can access the search result graph at SearchResult#graph
+  
+  Because it is really an array of URIs, you can chain it into other Store methods:
+  
+  store.delete_uris(store.search('italy'))
+  
+  => true
+  
+  etc.

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/sasquatch.rb

@@ -0,0 +1,16 @@
+require 'httparty'
+require 'cgi'
+require 'rdf'
+require 'rdf/ntriples'
+require 'rdf/json'
+require 'sparql/client'
+require 'json'
+module Sasquatch
+  require File.dirname(__FILE__) + '/sasquatch/http_party'
+  require File.dirname(__FILE__) + '/sasquatch/store'
+  require File.dirname(__FILE__) + '/sasquatch/rdf'    
+  require File.dirname(__FILE__) + '/sasquatch/changeset'      
+  require File.dirname(__FILE__) + '/sasquatch/rss10'  
+  require File.dirname(__FILE__) + '/sasquatch/search_result'   
+  require File.dirname(__FILE__) + '/sasquatch/sparql_builder'         
+end

data/lib/sasquatch/changeset.rb

@@ -0,0 +1,66 @@
+module RDF
+  module Talis
+    class Changeset < RDF::Vocabulary('http://purl.org/vocab/changeset/schema#')
+      property :removal
+      property :addition
+      property :creatorName
+      property :createdDate
+      property :subjectOfChange
+      property :changeReason
+      property :ChangeSet
+      property :precedingChangeSet
+    end
+
+    class Bigfoot < RDF::Vocabulary('http://schemas.talis.com/2006/bigfoot/configuration#')
+      property :jobType
+      property :ResetDataJob
+      property :startTime
+      property :JobRequest
+    end
+
+    class TalisDir < RDF::Vocabulary('http://schemas.talis.com/2005/dir/schema#')
+      property :etag
+    end
+  end
+end
+
+module Sasquatch
+  class Changeset
+    attr_reader :resource, :statements, :subject_of_change
+    def initialize(subject_of_change, resource=nil)
+      @resource = RDF::Node.new unless resource
+      @subject_of_change = subject_of_change
+      @statements = []
+      @statements.concat [RDF::Statement.new(@resource, RDF.type, RDF::Talis::Changeset.ChangeSet),
+       RDF::Statement.new(@resource, RDF::Talis::Changeset.changeReason, "Generated in Platform Party"),
+       RDF::Statement.new(@resource, RDF::Talis::Changeset.createdDate, Time.now),
+       RDF::Statement.new(@resource, RDF::Talis::Changeset.subjectOfChange, subject_of_change)]
+    end
+    
+    def remove_statements(stmts)
+      stmts = [stmts] if stmts.is_a?(RDF::Statement)
+      stmts.each do |stmt|
+        raise ArgumentError unless stmt.subject == @subject_of_change        
+        @statements.concat changeset_statement(stmt, :removal)
+      end
+    end
+    
+    def add_statements(stmts)
+      stmts = [stmts] if stmts.is_a?(RDF::Statement)
+      stmts.each do |stmt|
+        next unless stmt
+        raise ArgumentError unless stmt.subject == @subject_of_change        
+        @statements.concat changeset_statement(stmt, :addition)
+      end
+    end
+        
+    def changeset_statement(stmt, action)
+      s = RDF::Node.new
+      [RDF::Statement.new(@resource, RDF::Talis::Changeset.send(action), s),
+        RDF::Statement.new(s, RDF.type, RDF.to_rdf+"Statement"),
+        RDF::Statement.new(s, RDF.subject, stmt.subject),
+        RDF::Statement.new(s, RDF.predicate, stmt.predicate),
+        RDF::Statement.new(s, RDF.object, stmt.object)]
+    end      
+  end
+end

data/lib/sasquatch/http_party.rb

@@ -0,0 +1,12 @@
+module HTTParty
+  class Request
+    def auth_headers
+      credentials[:headers]
+    end
+    def setup_digest_auth
+      if auth_headers
+        @raw_request.digest_auth(username, password, {'www-authenticate' => auth_headers})
+      end
+    end    
+  end
+end

data/lib/sasquatch/rdf.rb

@@ -0,0 +1,31 @@
+module RDF
+  class Statement
+    def to_ntriples
+      RDF::Writer.for(:ntriples).buffer do |writer|
+        writer << self          
+      end      
+    end
+  end
+  
+  class Graph
+    attr_reader :requested_resource
+    def to_ntriples
+      RDF::Writer.for(:ntriples).buffer do |writer|
+        self.statements.each do |statement|
+          writer << statement
+        end
+      end      
+    end    
+    def set_requested_resource(uri)
+      @requested_resource = uri
+    end
+    
+    def requested_resource
+      if self.respond_to?(:"[]") # in case rdf-rdfobjects is available
+        self[@requested_resource]
+      else
+        RDF::URI.intern(@requested_resource)
+      end
+    end
+  end    
+end

data/lib/sasquatch/rss10.rb

@@ -0,0 +1,18 @@
+
+module RDF
+  module RSS10
+     require File.dirname(__FILE__) + '/rss10/format'
+     require File.dirname(__FILE__) + '/rss10/reader'     
+    # require 'rdf/n3/vocab'
+    # require 'rdf/n3/patches/array_hacks'
+    # require 'rdf/n3/patches/graph_properties'
+    # autoload :Meta, 'rdf/n3/reader/meta'
+    # autoload :Parser, 'rdf/n3/reader/parser'
+    # autoload :Reader, 'rdf/n3/reader'
+    # autoload :VERSION, 'rdf/n3/version'
+    # autoload :Writer, 'rdf/n3/writer'
+    # 
+    # def self.debug?; @debug; end
+    # def self.debug=(value); @debug = value; end
+  end
+end

data/lib/sasquatch/rss10/format.rb

@@ -0,0 +1,12 @@
+module RDF::RSS10
+
+  class Format < RDF::Format
+    #content_type 'application/xml', :extension => :rss
+    #content_type 'application/rdf+xml', :extension => :rss
+    content_encoding 'utf-8'
+
+    reader { RDF::RSS10::Reader }
+    writer { RDF::RSS10::Writer }
+  end
+end
+

data/lib/sasquatch/rss10/reader.rb

@@ -0,0 +1,226 @@
+module RDF::RSS10
+  class Reader < RDF::Reader
+    require 'nokogiri'
+    # copied indiscriminately from gkellogg's rdf/xml parser
+
+    def initialize(input = $stdin, options = {}, &block)
+      super do
+        
+        @base_uri = uri(options[:base_uri]) if options[:base_uri]
+            
+        @doc = case input
+        when Nokogiri::XML::Document then input
+        else Nokogiri::XML.parse(input, @base_uri.to_s)
+        end
+        
+        raise RDF::ReaderError, "Synax errors:\n#{@doc.errors}" if !@doc.errors.empty? && validate?
+        raise RDF::ReaderError, "Empty document" if (@doc.nil? || @doc.root.nil?) && validate?
+
+        block.call(self) if block_given?
+      end
+    end    
+    ##
+     # Iterates the given block for each RDF statement in the input.
+     #
+     # @yield [statement]
+     # @yieldparam [RDF::Statement] statement
+     # @return [void]
+     def each_statement(&block)
+       # Block called from add_statement
+       @callback = block
+
+       root = @doc.root
+
+
+       rdf_nodes = root.xpath("/rdf:RDF", "rdf" => RDF.to_uri.to_s)
+       statements = []
+       rdf_nodes.each do |node|
+
+
+         root.xpath("//rss:channel", "rss"=>RDF::RSS.to_s).each do |channel|
+           if channel.attribute('about')
+             channel_uri = RDF::URI.intern(channel.attribute('about').value)
+           else
+             channel_uri = RDF::Node.new
+           end
+           statements << RDF::Statement.new(channel_uri, RDF.type, RDF::RSS.channel)
+           channel.children.each do |elem|
+             unless elem.name == 'items'
+               if elem.children.length == 1 && elem.children.first.is_a?(Nokogiri::XML::Text)
+                 statements << RDF::Statement.new(channel_uri, RDF::URI.intern(elem.namespace.href + elem.name), literal(elem.children.first))
+               elsif elem.attribute('resource')
+                 statements << RDF::Statement.new(channel_uri, RDF::URI.intern(elem.namespace.href + elem.name), RDF::URI.intern(elem.attribute('resource').value))
+               end
+             else
+               stmt = RDF::Statement.new(:subject=>channel_uri, :predicate=>RDF::URI.intern(elem.namespace.href + elem.name))
+               elem.children.each do |list|
+                 if list.attribute('about')
+                   list_uri = RDF::URI.intern(list.attribute('about').value)
+                 else
+                   list_uri = RDF::Node.new
+                 end
+
+                 stmt.object = list_uri
+                 statements << stmt
+                 list_type = RDF::URI.intern(list.namespace.href + list.name)
+                 unless list_type == RDF.Description
+                   statements << RDF::Statement.new(:subject=>list_uri, :predicate=>RDF.type, :object=>list_type)
+                 end
+                 list.children.each do |li|
+                   stmt = RDF::Statement.new(:subject=>list_uri, :predicate=>RDF::URI.intern(li.namespace.href + li.name))
+                   if li.attribute('resource')
+                     stmt.object = RDF::URI.intern(li.attribute('resource').value)
+                   elsif li.children.length == 1 && li.children.first.is_a?(Nokogiri::XML::Text)
+                     stmt.object = literal(li.children.first)
+                   end
+                   statements << stmt if stmt.object
+                 end
+               end
+             end
+           end
+         end
+         root.xpath("/rdf:RDF/rss:item", "rdf"=>RDF.to_uri.to_s, "rss"=>RDF::RSS.to_s).each do |item|
+           if item.attribute('about')
+             item_uri = RDF::URI.intern(item.attribute('about').value)
+           else
+             item_uri = RDF::Node.new
+           end
+           statements.concat statements_from_element(item, item_uri)
+         end
+
+
+       end
+       statements.each do |stmt |
+         yield stmt
+       end   
+       statements.to_enum    
+     end
+     
+     def statements_from_element(elem, resource)
+       child_elements = {}
+       statements = []
+       elem.children.each do |el|
+         if el.attribute_with_ns('resource', RDF.to_uri.to_s)
+           statements << RDF::Statement.new(:subject=>resource, :predicate=>RDF::URI.intern(el.namespace.href+el.name), :object=>RDF::URI.intern(el.attribute_with_ns('resource', RDF.to_uri.to_s).value))
+         elsif all_text_nodes?(el.children)
+           statements << RDF::Statement.new(:subject=>resource, :predicate=>RDF::URI.intern(el.namespace.href+el.name),:object=>literal(el.children.first))
+         else
+           el.children.each do |e|
+             if e.attribute_with_ns('about', RDF.to_uri.to_s)
+               c = RDF::URI.intern(e.attribute_with_ns('about', RDF.to_uri.to_s).value)
+               statements << RDF::Statement.new(:subject=>resource, :predicate=>RDF::URI.intern(el.namespace.href+el.name), :object=>c)  
+               child_elements[c] = e
+               e_type = RDF::URI.intern(e.namespace.href + e.name)
+               unless e_type == RDF.Description || RDF::RSS.item
+                 statements << RDF::Statement.new(:subject=>c, :predicate=>RDF.type, :object=>e_type)
+               end
+             elsif has_child_elements?(e)   
+               c = RDF::Node.new         
+               statements << RDF::Statement.new(:subject=>resource, :predicate=>RDF::URI.intern(el.namespace.href+el.name), :object=>c)  
+               child_elements[c] = e
+               e_type = RDF::URI.intern(e.namespace.href + e.name)
+               unless e_type == RDF.Description || RDF::RSS.item
+                 statements << RDF::Statement.new(:subject=>c, :predicate=>RDF.type, :object=>e_type)
+               end
+             end               
+           end
+         end
+       end
+       child_elements.each_pair do |r,e|
+         statements.concat statements_from_element(e, r)
+       end
+       statements
+     end
+     
+     def all_text_nodes?(nodes)
+       all_text = true
+       nodes.each {|n| all_text = false unless n.is_a?(Nokogiri::XML::Text)}
+       all_text
+     end
+     
+     def has_child_elements?(elem)
+       children = false
+       elem.each {|e| children = true if e.is_a?(Nokogiri::XML::Element)}
+       children
+     end
+     
+     def literal(txt)
+       options = {}
+       if txt.attribute('lang')
+         options[:language] = txt.attribute('lang').value.to_sym
+       end
+       if txt.attribute_with_ns('datatype', RDF.to_uri.to_s)
+         options[:datatype] = RDF::URI.intern(txt.attribute_with_ns('datatype', RDF.to_uri.to_s).value)
+       end
+       RDF::Literal.new(txt.inner_text, options)       
+     end
+     
+     def parse_children(elem, stmt)
+       old_stmt = nil
+       statements = []
+       if elem.attribute_with_ns("about", RDF.to_uri.to_s)
+         old_stmt = stmt
+         stmt = RDF::Statement.new(:subject=>elem.attribute_with_ns("about", RDF.to_uri.to_s).value)
+         type_object = RDF::URI.intern(elem.namespace.href+elem.name)
+         unless type_object == RDF.Description || type_object == RDF::RSS.item
+           stmt.predicate = RDF.type
+           stmt.object = type_object
+           statements << stmt
+           stmt = RDF::Statement.new
+           stmt.subject = RDF::URI.intern(elem.attribute_with_ns('about', RDF.to_uri.to_s).value)
+         end
+       end         
+       elem.children.each do |el|
+         next if el.is_a?(Nokogiri::XML::Text)
+         if el.attribute_with_ns('resource', RDF.to_uri.to_s) || el.attribute('resource')
+           if el.attribute_with_ns('resource', RDF.to_uri.to_s)
+             stmt.object = RDF::URI.intern(el.attribute_with_ns('resource', RDF.to_uri.to_s).value)
+           else
+             stmt.object = RDF::URI.intern(el.attribute('resource').value)
+           end
+           stmt.predicate = RDF::URI.intern(el.namespace.href+el.name)
+           statements << stmt.dup
+           stmt = RDF::Statement.new(:subject=>stmt.subject)
+         elsif el.children.length == 1 && el.children.first.is_a?(Nokogiri::XML::Text)
+           stmt.predicate = RDF::URI.intern(el.namespace.href+el.name)
+           options = {}
+           txt = el.children.first
+           if txt.attribute('lang')
+             options[:language] = txt.attribute('lang').value.to_sym
+           end
+           if txt.attribute_with_ns('datatype', RDF.to_uri.to_s)
+             options[:datatype] = RDF::URI.intern(txt.attribute_with_ns('datatype', RDF.to_uri.to_s).value)
+           end
+           stmt.object = RDF::Literal.new(txt.inner_text, options)
+           statements << stmt.dup
+           stmt = RDF::Statement.new(:subject=>stmt.subject)
+         else
+           stmt_found = false
+           el.children.each do |child|
+             next unless child.is_a?(Nokogiri::XML::Element)
+             stmt.predicate = RDF::URI.intern(el.namespace.href+el.name)
+             if child.attribute_with_ns("about", RDF.to_uri.to_s)
+               stmt.object = RDF::URI.intern(child.attribute_with_ns("about", RDF.to_uri.to_s).value)
+               statements << stmt.dup
+               stmt = RDF::Statement.new(:subject=>stmt.subject)
+               stmt_found = true
+             else
+               stmt.object = RDF::Node.new
+               statements << stmt.dup
+               stmt = RDF::Statement.new(:subject=>stmt.subject)
+               stmt_found = true
+             end               
+           end
+           puts "#{el.name}: #{el.inspect}" unless stmt_found
+         end
+             
+         #puts "#{el.name}: #{el.class.name}"
+         statements.concat parse_children(el, stmt) unless el.children.empty?
+       end
+       if old_stmt
+         stmt = old_stmt
+       end
+       statements
+     end
+   end
+ end

data/lib/sasquatch/search_result.rb

@@ -0,0 +1,87 @@
+module Sasquatch
+  class SearchResult < Array
+    attr_reader :graph, :total_results, :max_results, :start_index, :search_context
+    
+    def initialize
+      @results = []
+    end
+    
+    def self.new_from_query(graph, options, store)
+      search_result = self.new
+      search_result.graph = graph
+      search_result.search_context={:store=>store, :options=>options}
+      search_result.parse_graph
+      search_result
+    end
+    
+    def graph=(g)
+      @graph = g
+    end
+    
+    def search_context=(sc)
+      @search_context=sc
+    end
+    
+    def parse_graph
+      return unless @graph
+      @graph.query(:predicate=>RDF::URI.intern("http://a9.com/-/spec/opensearch/1.1/totalResults")).each do |stmt|
+        @total_results = stmt.object.value.to_i
+      end
+      @total_results ||= 0
+      @graph.query(:predicate=>RDF::URI.intern("http://a9.com/-/spec/opensearch/1.1/startIndex")).each do |stmt|
+        @start_index = stmt.object.value.to_i
+      end
+      @start_index ||= 0 
+      @graph.query(:predicate=>RDF::URI.intern("http://a9.com/-/spec/opensearch/1.1/itemsPerPage")).each do |stmt|
+        @max_results = stmt.object.value.to_i
+      end
+      @max_results ||= 0    
+      
+      set_results       
+    end
+    
+    def set_results
+      channel_uri = nil
+      @graph.query(:predicate=>RDF.type, :object=>RDF::RSS.channel).each do |channel|
+        channel_uri = channel.subject
+      end
+      return unless channel_uri
+      seq_uri = nil
+      @graph.query(:subject=>channel_uri, :predicate=>RDF::RSS.items).each do |items|
+        seq_uri = items.object
+      end
+      return unless seq_uri
+      @graph.query(:subject=>seq_uri).each do |li|
+        if li.predicate.to_s =~ /http:\/\/www\.w3\.org\/1999\/02\/22-rdf-syntax-ns#_(\d)+$/
+          (ns,idx) = li.predicate.to_s.split("#_")
+          idx = (idx.to_i - 1)
+          self[idx] = li.object
+        end
+      end
+    end
+    
+    def previous
+      if @start_index == 0
+        nil
+      else
+        o = {}
+        o[:offset] = @start_index - @max_results
+        o[:offset] = 0 if o[:offset] < 0
+        o[:sort] = @search_context[:options][:sort]
+        o[:max] = @max_results
+        @search_context[:store].search(@search_context[:options][:query][:query],o)
+      end
+    end
+    def next
+      if (@start_index + self.count) >= @total_results
+        nil
+      else
+        o = {}
+        o[:offset] = @start_index + @max_results
+        o[:sort] = @search_context[:options][:sort]
+        o[:max] = @max_results
+        @search_context[:store].search(@search_context[:options][:query][:query],o)
+      end
+    end    
+  end
+end

data/lib/sasquatch/sparql_builder.rb

@@ -0,0 +1,120 @@
+module Sasquatch
+  class SparqlBuilder < SPARQL::Client::Query
+    attr_reader :store, :variables
+    
+    def self.init(store, *variables)
+      options = variables.last.is_a?(Hash) ? variables.pop : {}
+      self.new(store, options).set_variables(*variables)
+    end
+    def initialize(store, options={}, &block)
+      @store = store
+
+      super(:sparql, options, &block)
+    end
+    
+    def sparql
+      @form = "CHANGEME"
+      self
+    end
+    
+    def set_variables(*vars)
+      @variables = vars
+      self
+    end
+    def describe!(graph=:default)
+      describe
+      execute(graph)
+    end
+    
+    def describe
+      @form = :describe
+      @values = *@variables.flatten.map { |var|
+        [var, var.is_a?(RDF::URI) ? var : RDF::Query::Variable.new(var)]
+      }      
+      self
+    end
+    
+    def select!(graph=:default)
+      select
+      execute(graph)
+    end
+    
+    def select
+      @form = :select
+      @values = @variables.flatten.map { |var| [var, RDF::Query::Variable.new(var)] }
+      self
+    end
+    
+    def ask!(graph=:default)      
+      ask
+      execute(graph)
+    end    
+    
+    def ask
+      @form = :ask
+      self
+    end
+    
+    def construct!(graph=:default)
+      construct
+      execute(graph)
+    end
+    
+    def construct
+      @form = :construct
+      options[:template] = build_patterns(*@variables)
+      self
+    end
+    
+    def execute(graph)
+      @store.send(:"sparql_#{@form}", self.to_s, graph)
+    end
+    
+    ##
+    # Returns the string representation of this query.
+    #
+    # @return [String]
+    def to_s
+      buffer = [form.to_s.upcase]
+      case form
+        when :select, :describe
+          buffer << 'DISTINCT' if options[:distinct]
+          buffer << 'REDUCED' if options[:reduced]
+          buffer << (values.empty? ? '*' : values.map { |v| serialize_value(v[1]) }.join(' '))
+        when :construct
+          buffer << '{'
+          buffer += serialize_patterns(options[:template])
+          buffer << '}'
+      end
+
+      buffer << "FROM #{serialize_value(options[:from])}" if options[:from]
+
+      unless (patterns.empty? && (options[:optionals].nil? || options[:optionals].empty?)) && form == :describe
+        buffer << 'WHERE {'
+        buffer += serialize_patterns(patterns)
+        if options[:optionals]
+          options[:optionals].each do |patterns|
+            buffer << 'OPTIONAL {'
+            buffer += serialize_patterns(patterns)
+            buffer << '}'
+          end
+        end
+        if options[:filters]
+          buffer += options[:filters].map { |filter| "FILTER(#{filter})" }
+        end
+        buffer << '}'
+      end
+
+      if options[:order_by]
+        buffer << 'ORDER BY'
+        buffer += options[:order_by].map { |var| var.is_a?(String) ? var : "?#{var}" }
+      end
+
+      buffer << "OFFSET #{options[:offset]}" if options[:offset]
+      buffer << "LIMIT #{options[:limit]}" if options[:limit]
+      options[:prefixes].reverse.each {|e| buffer.unshift("PREFIX #{e}") } if options[:prefixes]
+
+      buffer.join(' ')
+    end    
+  end
+end

data/lib/sasquatch/store.rb

@@ -0,0 +1,302 @@
+module Sasquatch
+  class Store
+    include HTTParty
+    default_timeout 30
+    
+    attr_reader :store_name, :last_response, :sparql_clients
+    def initialize(storename, options={})
+      self.class.base_uri "http://api.talis.com/stores/#{storename}"
+      @store_name = storename
+      if options[:username]
+        set_credentials(options[:username], options[:password])
+      end
+
+    end
+    
+    def set_credentials(username, password)
+      @auth = {:username => username, :password => password}
+      @auth[:headers] = self.get("/snapshots", {}).headers['www-authenticate']
+    end
+    
+    def describe(uri)
+      options = {:query=>{:about=>uri, :output=>"ntriples"}}
+      @last_response = get("/meta", options)
+      graph = parse_ntriples(@last_response.body)
+      graph.set_requested_resource(uri)
+      graph
+    end
+    
+    def describe_multi(uris)
+      sparql = "DESCRIBE "
+      uris.each {|uri| sparql << "<#{uri}> "}
+      options = {:query=>{:query=>sparql, :output=>"ntriples"}}
+      @last_response = get("/services/sparql", options)
+      graph = parse_ntriples(@last_response.body)
+      graph      
+    end
+    
+    def augment(uri, pattern=:cbd)
+      graph = augment_multi([uri], pattern)
+      graph.set_requested_resource(uri)
+      graph
+    end
+    
+    def augment_multi(uris, pattern=:cbd)
+      sparql = "DESCRIBE ?o "
+      i = 1
+      where = []
+      uris.each do |uri| 
+        sparql << "<#{uri}> "
+        where << "{<#{uri}> ?p ?o . }"
+        i += 1
+      end
+      sparql << "\nWHERE\n{ #{where.join(" UNION ")}  }"
+      options = {:body=>{:query=>sparql, :output=>"ntriples"}}
+      @last_response = post("/services/sparql", options)
+      graph = parse_ntriples(@last_response.body)
+      graph
+    end      
+    
+    def get(path, options)
+      self.class.get(path, options)      
+    end
+    
+    def post(path, options)
+      self.class.post(path, options)
+    end
+    
+    def save(graph_statement_or_resource, graph_name=nil)
+      path = "/meta"
+      path << "/graphs/#{graph_name}" if graph_name
+      options = {:headers=>{"Content-Type"=> "text/turtle"}, :body=>graph_statement_or_resource.to_ntriples, :digest_auth=>@auth}
+      @last_response = post(path, options )      
+      if @last_response.response.code == "204"
+        true
+      else
+        false
+      end
+    end
+    
+    def search(query, options={})
+      accept = self.class.headers['Accept']
+      self.class.headers 'Accept' => 'application/json'
+      path = "/items"
+      opts = {:query=>options}
+      opts[:query][:query] = query
+      @last_response = get(path, opts)
+      #graph = parse_rss10(@last_response.body)
+      graph = parse_json(@last_response.body)      
+      self.class.headers 'Accept' => accept
+      SearchResult.new_from_query(graph, opts, self)
+    end
+    
+    def remove_triple(stmt, versioned=false)
+      remove_triples([stmt], versioned, creator)
+    end
+    
+    def remove_triples(stmts, versioned=false)
+      changesets = {}
+      stmts.each do |stmt|
+        changesets[stmt.subject] ||= Changeset.new(stmt.subject)
+        changesets[stmt.subject].remove_statements(stmt)
+      end
+      graph = RDF::Graph.new
+      changesets.each_pair do |uri, changeset|
+        changeset.statements.each do |stmt|
+          graph << stmt
+        end
+      end
+      send_changeset(graph, versioned, creator)   
+    end
+    
+    def replace_triple(old_stmt, new_stmt, versioned=false)
+      replace_triples({old_triple=>new_triple}, versioned, creator)
+    end
+
+    ##
+    # takes a Hash in form of {old_statement=>replacement_statement}
+    #
+    def replace_triples(changes, versioned=false, creator="sasquatch.rb")
+      changesets = {}
+      changes.each_pair do |old_stmt, new_stmt|
+        changesets[old_stmt.subject] ||= Changeset.new(old_stmt.subject)
+        changesets[old_stmt.subject].remove_statements(*old_stmt)
+        changesets[new_stmt.subject] ||= Changeset.new(new_stmt.subject)
+        changesets[new_stmt.subject].remove_statements(*new_stmt)        
+      end
+      graph = RDF::Graph.new
+      changesets.each_pair do |uri, changeset|
+        changeset.statements.each do |stmt|
+          graph << stmt
+        end
+      end
+      send_changeset(graph, versioned, creator)   
+    end 
+    
+    def replace(graph_statements_or_resource, versioned=false, creator="sasquatch.rb")
+      uris = case graph_statements_or_resource.class.name
+      when "RDF::Graph"
+        subjects = []
+        graph_statements_or_resource.each_subject {|s| subjects << s}
+        subjects
+      when "Array"
+        subjects = []
+        graph_statements_or_resource.each_subject {|s| subjects << s}
+        subjects.uniq
+      else
+        # This should only work for rdf-rdfobjects Resources
+        if graph_statements_or_resource.respond_to?(:predicates)
+          [graph_statements_or_resource.to_s]
+        end
+      end
+      raise ArgumentError unless uris
+      current_graph = describe_multi(uris)
+      changesets = {}
+      current_graph.each_statement.each do |stmt|
+        changesets[stmt.subject] ||= Changeset.new(stmt.subject)
+        changesets[stmt.subject].remove_statements(stmt)
+      end
+      replacements = case graph_statements_or_resource.class.name
+      when "Array" then graph_statements_or_resource
+      else
+        graph_statements_or_resource.statements
+      end
+      replacements.each do |stmt|
+        changesets[stmt.subject] ||= Changeset.new(stmt.subject)
+        changesets[stmt.subject].add_statements(stmt)        
+      end
+      graph = RDF::Graph.new
+      changesets.each do |uri, changeset|
+        changeset.statements.each do |stmt|
+          graph << stmt
+        end
+      end
+      send_changeset(graph, versioned, creator)
+    end
+    
+    def send_changeset(graph, versioned=false, creator="sasquatch.rb")
+      path = "/meta"
+      path << "/changesets" if versioned
+
+      graph.query(:predicate=>RDF.type, :object=>RDF::Talis::Changeset.ChangeSet).each_subject do |cs|
+        graph << [cs, RDF::Talis::Changeset.creatorName, creator]
+      end
+        
+      options = {:headers=>{"Content-Type"=> "application/vnd.talis.changeset+turtle"}, :body=>graph.to_ntriples, :digest_auth=>@auth}
+      @last_response = post(path, options )      
+      if !versioned && @last_response.response.code =~ /^20[0-9]$/
+        true
+      elsif versioned && @last_response.response.code =~ /20[012]/
+        true
+      else
+        false
+      end      
+    end
+    
+    def delete_uri(uri, versioned=false, creator="sasquatch.rb")
+      delete_uris([uri], versioned, creator)
+    end
+    
+    def delete_uris(uris, versioned=false, creator="sasquatch.rb")
+      current_graph = describe_multi(uris)
+      changesets = []
+      uris.each do |uri|
+        u = RDF::URI.intern(uri)
+        cs = Changeset.new(u)
+        cs.remove_statements(current_graph.query(:subject=>u))
+        changesets << cs
+      end
+      graph = RDF::Graph.new
+      changesets.each do |changeset|
+        changeset.statements.each do |stmt|
+          graph << stmt
+        end
+      end
+      send_changeset(graph, versioned, creator)
+    end
+    
+    def sparql(*variables)
+      SparqlBuilder.init(self,variables) 
+    end
+    
+    def sparql_describe(query, graph=:default)
+      path = "/services/sparql"
+      unless graph == :default
+        path << "/graphs/#{graph}"
+      end
+      options = {:query=>{:query=>query, :output=>'ntriples'}}
+      @last_response = get(path, options)
+      graph = parse_ntriples(@last_response.body)
+      graph      
+    end
+    
+    alias :sparql_construct :sparql_describe 
+    
+    def sparql_select(query, graph=:default)
+      path = "/services/sparql"
+      unless graph == :default
+        path << "/graphs/#{graph}"
+      end
+      options = {:query=>{:query=>query, :output=>'json'}}
+      @last_response = get(path, options)
+      SPARQL::Client.parse_json_bindings(@last_response.body) || false
+    end
+    
+    alias :sparql_ask :sparql_select
+
+    def access_status
+      accept = self.class.headers['Accept']
+      self.class.headers 'Accept' => 'application/json'
+      path = "/config/access-status"
+      @last_response = get(path, {})
+      graph = parse_json(@last_response.body)      
+      self.class.headers 'Accept' => accept      
+      graph
+    end
+    
+    def read_only?
+      access_status.query(:predicate=>RDF::URI.intern('http://schemas.talis.com/2006/bigfoot/configuration#accessMode')).each do |stmt|
+        return true if stmt.object == RDF::URI.intern("http://schemas.talis.com/2006/bigfoot/statuses#read-only")
+      end
+      return false
+    end
+    
+    def status_message
+      access_status.query(:predicate=>RDF::URI.intern('http://schemas.talis.com/2006/bigfoot/configuration#statusMessage')).each do |stmt|
+        return stmt.object.value
+      end
+      nil
+    end
+    
+    def parse_ntriples(body)
+      read_graph(body, :ntriples)
+    end
+    
+    def parse_json(body)
+      read_graph(body, :json)
+    end
+        
+    def parse_rss10(body)      
+      read_graph(body, :rss10)
+    end
+    
+    def read_graph(data, format)
+      graph = RDF::Graph.new
+      RDF::Reader.for(format).new(data) do |reader|
+        reader.each_statement do |statement|
+          graph << statement
+        end
+      end
+      graph      
+    end
+    
+    # Parse the response body however you like
+    class Parser::Simple < HTTParty::Parser
+      def parse
+        body
+      end
+    end
+
+    parser Parser::Simple    
+  end  
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification 
+name: sasquatch
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ross Singer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-01 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 0
+        - 7
+        - 4
+        version: 0.7.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdf
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 0
+        - 3
+        - 1
+        version: 0.3.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rdf-json
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 3
+        - 0
+        version: 0.3.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sparql-client
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 0
+        - 0
+        - 9
+        version: 0.0.9
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  version_requirements: *id005
+description: A highly opinionated Ruby client for the Talis Platform using HTTParty and RDF.rb
+email: ross.singer@talis.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- VERSION
+- lib/sasquatch/changeset.rb
+- lib/sasquatch/http_party.rb
+- lib/sasquatch/rdf.rb
+- lib/sasquatch/rss10/format.rb
+- lib/sasquatch/rss10/reader.rb
+- lib/sasquatch/rss10.rb
+- lib/sasquatch/search_result.rb
+- lib/sasquatch/sparql_builder.rb
+- lib/sasquatch/store.rb
+- lib/sasquatch.rb
+has_rdoc: false
+homepage: http://github.com/rsinger/sasquatch
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A highly opinionated Ruby client for the Talis Platform.
+test_files: []
+