gkellogg-reddy 0.2.1

data/lib/reddy/string_hacks.rb

@@ -0,0 +1,108 @@
+require 'iconv'
+
+class String
+  #private
+  # "Borrowed" from JSON utf8_to_json
+  RDF_MAP = {
+    "\x0" => '\u0000',
+    "\x1" => '\u0001',
+    "\x2" => '\u0002',
+    "\x3" => '\u0003',
+    "\x4" => '\u0004',
+    "\x5" => '\u0005',
+    "\x6" => '\u0006',
+    "\x7" => '\u0007',
+    "\b"  =>  '\b',
+    "\t"  =>  '\t',
+    "\n"  =>  '\n',
+    "\xb" => '\u000B',
+    "\f"  =>  '\f',
+    "\r"  =>  '\r',
+    "\xe" => '\u000E',
+    "\xf" => '\u000F',
+    "\x10" => '\u0010',
+    "\x11" => '\u0011',
+    "\x12" => '\u0012',
+    "\x13" => '\u0013',
+    "\x14" => '\u0014',
+    "\x15" => '\u0015',
+    "\x16" => '\u0016',
+    "\x17" => '\u0017',
+    "\x18" => '\u0018',
+    "\x19" => '\u0019',
+    "\x1a" => '\u001A',
+    "\x1b" => '\u001B',
+    "\x1c" => '\u001C',
+    "\x1d" => '\u001D',
+    "\x1e" => '\u001E',
+    "\x1f" => '\u001F',
+    '"'   =>  '\"',
+    '\\'  =>  '\\\\',
+    '/'   =>  '/',
+  } # :nodoc:
+
+  # Convert a UTF8 encoded Ruby string _string_ to an escaped string, encoded with
+  # UTF16 big endian characters as \U????, and return it.
+  #
+  # \\:: Backslash
+  # \':: Single quote
+  # \":: Double quot
+  # \n:: ASCII Linefeed
+  # \r:: ASCII Carriage Return
+  # \t:: ASCCII Horizontal Tab
+  # \uhhhh:: character in BMP with Unicode value U+hhhh
+  # \U00hhhhhh:: character in plane 1-16 with Unicode value U+hhhhhh
+  def rdf_escape
+    string = self + '' # XXX workaround: avoid buffer sharing
+    string.force_encoding(Encoding::ASCII_8BIT) if String.method_defined?(:force_encoding)
+    string.gsub!(/["\\\/\x0-\x1f]/) { RDF_MAP[$&] }
+    string.gsub!(/(
+                    (?:
+                      [\xc2-\xdf][\x80-\xbf]    |
+                      [\xe0-\xef][\x80-\xbf]{2} |
+                      [\xf0-\xf4][\x80-\xbf]{3}
+                    )+ |
+                    [\x80-\xc1\xf5-\xff]       # invalid
+                  )/nx) { |c|
+                    c.size == 1 and raise TypeError, "invalid utf8 byte: '#{c}'"
+                    s = Iconv.new('utf-16be', 'utf-8').iconv(c).unpack('H*')[0].upcase
+                    s.gsub!(/.{4}/n, '\\\\u\&')
+                  }
+    string.force_encoding(Encoding::UTF_8) if String.method_defined?(:force_encoding)
+    string
+  end
+  
+  # Unescape characters in strings.
+  RDF_UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+  RDF_UNESCAPE_MAP.update({
+    ?"  => '"',
+    ?\\ => '\\',
+    ?/  => '/',
+    ?b  => "\b",
+    ?f  => "\f",
+    ?n  => "\n",
+    ?r  => "\r",
+    ?t  => "\t",
+    ?u  => nil, 
+  })
+
+  # Reverse operation of escape
+  # From JSON parser
+  def rdf_unescape
+    return '' if self.empty?
+    string = self.gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
+      if u = RDF_UNESCAPE_MAP[$&[1]]
+        u
+      else # \uXXXX
+        bytes = [c[2, 2].to_i(16), c[4, 2].to_i(16)]
+        Iconv.new('utf-8', 'utf-16').iconv(bytes.pack("C*"))
+      end
+    end
+    if string.respond_to?(:force_encoding)
+      string.force_encoding(Encoding::UTF_8)
+    end
+    string
+  rescue Iconv::Failure => e
+    raise RdfException, "Caught #{e.class}: #{e}"
+  end
+end

data/lib/reddy/triple.rb

@@ -0,0 +1,144 @@
+module Reddy
+  # An RDF Triple, or statement.
+  #
+  # Statements are composed of _subjects_, _predicates_ and _objects_.
+  class Triple
+    attr_accessor :subject, :object, :predicate
+
+    ##
+    # Creates a new triple directly from the intended subject, predicate, and object.
+    #
+    # Any or all of _subject_, _predicate_ or _object_ may be nil, to create a triple patern.
+    # A patern may not be added to a graph.
+    #
+    # ==== Example
+    #   Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new) # => results in the creation of a new triple and returns it
+    #
+    # @param [URIRef, BNode] subject:: the subject of the triple
+    # @param [URIRef] predicate:: the predicate of the triple
+    # @param [URIRef, BNode, Literal, TypedLiteral] object:: the object of the triple
+    # @return [Triple]:: An array of the triples (leaky abstraction? consider returning the graph instead)
+    # @raise [Error]:: Checks parameter types and raises if they are incorrect.
+    #
+    # @author Tom Morris
+    def initialize (subject, predicate, object)
+      @subject   = self.class.coerce_subject(subject)
+      @predicate = self.class.coerce_predicate(predicate)
+      @object    = self.class.coerce_object(object)
+      @patern = subject.nil? || predicate.nil? || object.nil?
+    end
+
+    def is_patern?
+      @patern
+    end
+    
+    # Serialize Triple to N-Triples
+    def to_ntriples
+      raise RdfException.new("Can't serialize patern triple") if is_patern?
+      @subject.to_ntriples + " " + @predicate.to_ntriples + " " + @object.to_ntriples + " ."
+    end
+    
+    def to_s; self.to_ntriples; end
+    
+    def inspect
+      [@subject, @predicate, @object, @patern].inspect
+    end
+
+    # Is the predicate of this statment rdf:type?
+    def is_type?
+      @predicate.to_s == "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
+    end
+
+    # Two triples are equal if their of their subjects, predicates and objects are equal.
+    # Or self or other is a patern and subject, predicate, object matches
+    def eql? (other)
+      other.is_a?(Triple) &&
+      (other.subject == self.subject || other.subject.nil? || self.subject.nil?) &&
+      (other.predicate == self.predicate || other.predicate.nil? || self.predicate.nil?) &&
+      (other.object == self.object || other.object.nil? || self.object.nil?)
+    end
+
+    alias_method :==, :eql?
+
+    # Clone triple, keeping references to literals and URIRefs, but cloning BNodes
+    def clone
+      raise RdfException.new("Can't clone patern triple") if is_patern?
+      s = subject.is_a?(BNode) ? subject.clone : subject
+      p = predicate.is_a?(BNode) ? predicate.clone : predicate
+      o = object.is_a?(BNode) ? object.clone : object
+      Triple.new(subject, predicate, object)
+    end
+    
+    # For indexes
+    def hash
+      [subject, predicate, object].hash
+    end
+    
+    protected
+
+    # Coerce a subject to the appropriate Reddy type.
+    # 
+    # @param[URI, URIRef, String] subject:: If a String looks like a URI, a URI is created, otherwise a BNode.
+    # @raise[InvalidSubject]:: If subject can't be intuited.
+    def self.coerce_subject(subject)
+      case subject
+      when Addressable::URI
+        URIRef.new(subject.to_s)
+      when URIRef, BNode
+        subject
+      when nil
+        subject
+      when /^\w+:\/\/\S+/ # does it smell like a URI?
+        URIRef.new subject
+      else
+        raise InvalidSubject, "Subject is not of a known class (#{subject.class}: #{subject.inspect})"
+      end
+    end
+
+    # Coerce a predicate to the appropriate Reddy type.
+    # 
+    # @param[URI, URIRef, String] subject:: If a String looks like a URI, a URI is created
+    # @raise[InvalidSubject]:: If subject can't be predicate.
+    def self.coerce_predicate(predicate)
+      case predicate
+      when Addressable::URI
+        URIRef.new(predicate.to_s)
+      when URIRef
+        predicate
+      when String
+        URIRef.new predicate
+      when nil
+        predicate
+      else
+        raise InvalidPredicate, "Predicate should be a URI"
+      end
+    rescue ParserException => e
+      raise InvalidPredicate, "Couldn't make a URIRef: #{e.message}"
+    end
+
+    # Coerce a object to the appropriate Reddy type.
+    # 
+    # @param[URI, URIRef, String, Integer, Float, BNode, Literal] object:: If a String looks like a URI, a URI is created, otherwise an untyped Literal.
+    # @raise[InvalidSubject]:: If subject can't be predicate.
+    def self.coerce_object(object)
+      case object
+      when Addressable::URI
+        URIRef.new(object.to_s)
+      when String
+        if object.to_s =~ /^\w+:\/\/\S+/ # does it smell like a URI?
+          URIRef.new(object.to_s)
+        else
+          Literal.untyped(object)
+        end
+      when Integer, Float
+        Literal.build_from(object)
+      when URIRef, BNode, Literal
+        object
+      when nil, regexp
+        object
+      else
+        raise InvalidObject, "#{object.class}: #{object.inspect} is not a valid object"
+      end
+    end
+  end
+end

data/lib/reddy/uriref.rb

@@ -0,0 +1,95 @@
+require 'net/http'
+
+module Reddy
+  class URIRef
+    attr_accessor :uri
+    
+    # Create a URIRef from a URI  or a fragment and a URI
+    #
+    # ==== Example
+    #   u = URIRef.new("http://example.com")
+    #   u = URIRef.new("foo", u) => "http://example.com/foo"
+    # 
+    def initialize (*args)
+      args.each {|s| test_string(s)}
+      if args.size == 1
+        @uri = Addressable::URI.parse(args[0].to_s)
+      else
+        @uri = Addressable::URI.join(*args.map{|s| s.to_s}.reverse)
+      end
+      if @uri.relative?
+        raise ParserException, "<" + @uri.to_s + "> is a relative URI"
+      end
+      if !@uri.to_s.match(/^javascript/).nil?
+        raise ParserException, "Javascript pseudo-URIs are not acceptable"
+      end
+      
+      # Unique URI through class hash to ensure that URIRefs can be easily compared
+      @@uri_hash ||= {}
+      @@uri_hash[@uri.to_s] ||= @uri.freeze
+      @uri = @@uri_hash[@uri.to_s]
+    end
+    
+    # Create a URI, either by appending a fragment, or using the input URI
+    def + (input)
+      input_uri = Addressable::URI.parse(input.to_s)
+      return URIRef.new(input_uri, self.to_s)
+    end
+    
+    def short_name
+      if @uri.fragment()
+        return @uri.fragment()
+      elsif @uri.path.split("/").last.class == String and @uri.path.split("/").last.length > 0
+        return @uri.path.split("/").last
+      else
+        return false
+      end
+    end
+  
+    def eql?(other)
+      @uri.to_s == other.to_s
+    end
+    alias_method :==, :eql?
+  
+    # Needed for uniq
+    def hash; to_s.hash; end
+  
+    def to_s
+      @uri.to_s
+    end
+  
+    def to_ntriples
+      "<" + @uri.to_s + ">"
+    end
+  
+    # Output URI as QName using URI binding
+    def to_qname(uri_binding = {})
+      uri_base = @uri.to_s
+      sn = short_name.to_s
+      uri_base = uri_base[0, uri_base.length - sn.length]
+      if uri_binding.has_key?(uri_base)
+        "#{uri_binding[uri_base]}:#{sn}"
+      else
+        raise ParserException, "Couldn't find QName for #{@uri}"
+      end
+    end
+    
+    # Output URI as resource reference for RDF/XML
+    def xml_args
+      [{"rdf:resource" => @uri.to_s}]
+    end
+    
+    def test_string (string)
+      string.to_s.each_byte do |b|
+        if b >= 0 and b <= 31
+          raise ParserException, "URI '#{string}' must not contain control characters"
+        end
+      end
+    end
+
+#    def load_graph
+#      get = Net::HTTP.start(@uri.host, @uri.port) {|http| [:xml, http.get(@uri.path)] }
+#      return Reddy::RdfXmlParser.new(get[1].body, @uri.to_s).graph if get[0] == :xml
+#    end
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/reddy.rb'}"
+puts "Loading reddy gem"
+exec "#{irb} #{libs} --simple-prompt"

data/spec/bnode_spec.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+describe "Blank nodes" do
+  before(:all) { @context = {} }
+  
+  describe "which have custom identifiers" do
+    subject { BNode.new("foo", @context) }
+  
+    it "should return identifier" do
+      subject.identifier.should =~ /foo/
+      subject.to_s.should =~ /foo/
+    end
+
+    it "should be rejected if they are not acceptable" do
+      b = BNode.new("4cake", @context)
+      b.identifier.should_not =~ /4cake/
+    end
+
+    it "should be expressible in NT syntax" do
+      subject.to_ntriples.should =~ /foo/
+    end
+
+    it "should be able to determine equality" do
+      other = BNode.new(subject.to_s, @context)
+      should == other
+    end
+
+    it "should be able to determine inequality" do
+      other = URIRef.new('http://somehost.com/wherever.xml')
+      should_not == other
+    end
+
+    it "should resource hash for RDF/XML named bnode" do
+      subject.xml_args.should == [{"rdf:nodeID" => subject.to_s}]
+    end
+  end
+
+  describe "which has a blank identifier" do
+    subject { BNode.new("", @context) }
+    it "should not be the same as an anonymous identifier" do should_not == BNode.new end
+    it "should be the same as another blank identifier" do should == BNode.new("", @context) end
+  end
+
+  describe "which are anonymous" do
+    subject { BNode.new(@graph)}
+    it "should not be equivalent to another anonymous node" do
+      should_not == BNode.new
+    end
+    
+    it "should be equivalent it's clone" do
+      should == subject.clone
+    end
+    
+    it "should create resource hash for RDF/XML anonymous bnode" do
+      b = BNode.new
+      b.xml_args.should == [{"rdf:nodeID" => b.identifier}]
+    end
+  end
+end

data/spec/conjunctive_graph_spec.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "ConjunctiveGraph" do
+  before(:each) do
+    @ex = Namespace.new("http://example.org/", "ex")
+    @identifier = URIRef.new("http://store.identifier")
+    @store = MemoryStore.new(@identifier)
+  end
+  
+  subject { ConjunctiveGraph.new(:store => @store)}
+  
+  it "should should have same identifier as store" do
+    subject.identifier.should == @identifier
+  end
+  
+  it "should have a default context" do
+    subject.default_context.should be_a(Graph)
+    subject.default_context.identifier.should == @identifier
+    subject.default_context.store.should == @store
+  end
+  
+  it "should add triples to default context" do
+    t = Triple.new(@ex.a, @ex.b, @ex.c)
+    subject.add(t)
+    
+    count = 0
+    subject.triples do |t, ctx|
+      t.should == t
+      ctx.should == @identifier
+      count += 1
+    end
+    count.should == 1
+  end
+  
+  it "should retrieve triples from all contexts" do
+    g = Graph.new(:store => @store)
+    t = Triple.new(@ex.a, @ex.b, @ex.c)
+    g.add(t)
+    
+    count = 0
+    subject.triples do |t, ctx|
+      t.should == t
+      ctx.should == g.identifier
+      count += 1
+    end
+    count.should == 1
+  end
+  
+  it "should parse into new context" do
+    n3_string = "<http://example.org/> <http://xmlns.com/foaf/0.1/name> \"Gregg Kellogg\" . "
+    graph = subject.parse(n3_string, "http://foo.bar", :type => :n3)
+    graph.identifier.should == "http://foo.bar"
+    subject.size.should == 1
+    t = subject.triples.first
+    t.subject.to_s.should == "http://example.org/"
+    t.predicate.to_s.should == "http://xmlns.com/foaf/0.1/name"
+    t.object.to_s.should == "Gregg Kellogg"
+  end
+end