rdf-n3 0.3.4.1 → 0.3.5

data/{README → README.markdown}

@@ -6,6 +6,10 @@ RDF::N3 is an Notation-3 parser for Ruby using the [RDF.rb][RDF.rb]  library sui
 
 Reader inspired from TimBL predictiveParser and Python librdf implementation.
 
+## Turtle deprecated
+Support for Turtle mime-types and specific format support has been deprecated from this gem,
+as Turtle is now implemented using [RDF::Turtle][RDF::Turtle].
+
 ## Features
 RDF::N3 parses [Notation-3][N3], [Turtle][Turtle] and [N-Triples][N-Triples] into statements or triples. It also serializes to Turtle.
 
@@ -94,7 +98,7 @@ Full documentation available on [RubyForge](http://rdf.rubyforge.org/n3)
 
 ### Patches
 * {Array}
-* {RDF::Graph}
+* {RDF::List}
 
 ## Resources
 * [RDF.rb][RDF.rb]
@@ -140,10 +144,11 @@ see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 * <http://github.com/gkellogg/rdf-n3>
 * <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
 
-[RDF.rb]:    http://rdf.rubyforge.org/
-[N3]:        http://www.w3.org/DesignIssues/Notation3.html "Notation-3"
-[Turtle]:    http://www.w3.org/TeamSubmission/turtle/
-[N-Triples]: http://www.w3.org/2001/sw/RDFCore/ntriples/
-[YARD]:      http://yardoc.org/
-[YARD-GS]:   http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
-[PDD]:       http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
+[RDF.rb]:     http://rdf.rubyforge.org/
+[RDF::Turtle] http://github.com/gkellogg/rdf-turtle/
+[N3]:         http://www.w3.org/DesignIssues/Notation3.html "Notation-3"
+[Turtle]:     http://www.w3.org/TeamSubmission/turtle/
+[N-Triples]:  http://www.w3.org/2001/sw/RDFCore/ntriples/
+[YARD]:       http://yardoc.org/
+[YARD-GS]:    http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
+[PDD]:        http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html

data/VERSION

@@ -1 +1 @@
-0.3.4.1
+0.3.5

data/lib/rdf/n3.rb

@@ -23,7 +23,7 @@ module RDF
     require 'rdf/n3/format'
     require 'rdf/n3/vocab'
     require 'rdf/n3/patches/array_hacks'
-    require 'rdf/n3/patches/graph_properties'
+    require 'rdf/n3/patches/list'
     autoload :Meta,    'rdf/n3/reader/meta'
     autoload :Parser,  'rdf/n3/reader/parser'
     autoload :Reader,  'rdf/n3/reader'

data/lib/rdf/n3/format.rb

@@ -4,28 +4,19 @@ module RDF::N3
   #
   # @example Obtaining an Notation3 format class
   #     RDF::Format.for(:n3)            #=> RDF::N3::Format
-  #     RDF::Format.for("etc/foaf.ttl")
   #     RDF::Format.for("etc/foaf.n3")
-  #     RDF::Format.for(:file_name      => "etc/foaf.ttl")
   #     RDF::Format.for(:file_name      => "etc/foaf.n3")
-  #     RDF::Format.for(:file_extension => "ttl")
   #     RDF::Format.for(:file_extension => "n3")
-  #     RDF::Format.for(:content_type   => "text/turtle")
   #     RDF::Format.for(:content_type   => "text/n3")
   #
   # @example Obtaining serialization format MIME types
-  #     RDF::Format.content_types      #=> {"text/turtle" => [RDF::N3::Format]}
   #     RDF::Format.content_types      #=> {"text/n3")" => [RDF::N3::Format]}
   #
   # @example Obtaining serialization format file extension mappings
-  #     RDF::Format.file_extensions    #=> {:ttl => "text/turtle"}
   #     RDF::Format.file_extensions    #=> {:n3 => "text/n3"}
   #
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   class Format < RDF::Format
-    content_type     'text/turtle',         :extension => :ttl
-    content_type     'application/turtle',  :extension => :ttl
-    content_type     'application/x-turtle',:extension => :ttl
     content_type     'text/n3',             :extension => :n3
     content_type     'text/rdf+n3',         :extension => :n3
     content_type     'application/rdf+n3',  :extension => :n3
@@ -47,30 +38,4 @@ module RDF::N3
     reader { RDF::N3::Reader }
     writer { RDF::N3::Writer }
   end
-  
-  # Alias for N3 format
-  #
-  # This allows the following:
-  #
-  # @example Obtaining an TTL format class
-  #     RDF::Format.for(:ttl)         # RDF::N3::TTL
-  #     RDF::Format.for(:ttl).reader  # RDF::N3::Reader
-  #     RDF::Format.for(:ttl).writer  # RDF::N3::Writer
-  class TTL < RDF::Format
-    reader { RDF::N3::Reader }
-    writer { RDF::N3::Writer }
-  end
-  
-  # Aliases for N3 format
-  #
-  # This allows the following:
-  #
-  # @example Obtaining an Turtle format class
-  #     RDF::Format.for(:turtle)         # RDF::N3::Turtle
-  #     RDF::Format.for(:turtle).reader  # RDF::N3::Reader
-  #     RDF::Format.for(:turtle).writer  # RDF::N3::Writer
-  class Turtle < RDF::Format
-    reader { RDF::N3::Reader }
-    writer { RDF::N3::Writer }
-  end
 end

data/lib/rdf/n3/patches/list.rb

@@ -0,0 +1,36 @@
+module RDF
+  class List
+    ##
+    # Validate the list ensuring that
+    # * rdf:rest values are all BNodes are nil
+    # * rdf:type, if it exists, is rdf:List
+    # * each subject has no properties other than single-valued rdf:first, rdf:rest
+    #   other than for the first node in the list
+    # @return [Boolean]
+    def valid?
+      li = subject
+      while li != RDF.nil do
+        rest = nil
+        firsts = rests = 0
+        @graph.query(:subject => li) do |st|
+          case st.predicate
+          when RDF.type
+            # Be tollerant about rdf:type entries, as some OWL vocabularies use it excessively
+          when RDF.first
+            firsts += 1
+          when RDF.rest
+            rest = st.object
+            return false unless rest.node? || rest == RDF.nil
+            rests += 1
+          else
+            # First node may have other properties
+            return false unless li == subject
+          end
+        end
+        return false unless firsts == 1 && rests == 1
+        li = rest
+      end
+      true
+    end
+  end
+end

data/lib/rdf/n3/reader.rb

@@ -19,6 +19,12 @@ module RDF::N3
     include Meta
     include Parser
     
+    ##
+    # Missing in 0.3.2
+    def base_uri
+      @options[:base_uri]
+    end
+
     N3_KEYWORDS = %w(a is of has keywords prefix base true false forSome forAny)
 
     ##
@@ -88,19 +94,6 @@ module RDF::N3
       sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, base_uri.to_s)
     end
 
-    ##
-    # XXX Remove when added to RDF::Reader
-    # Returns the base URI determined by this reader.
-    #
-    # @example
-    #   reader.prefixes[:dc]  #=> RDF::URI('http://purl.org/dc/terms/')
-    #
-    # @return [Hash{Symbol => RDF::URI}]
-    # @since  0.3.0
-    def base_uri
-      @options[:base_uri]
-    end
-
     ##
     # Iterates the given block for each RDF statement in the input.
     #
@@ -527,20 +520,12 @@ module RDF::N3
         end
       elsif anonnode[:pathlist]
         objects = [anonnode[:pathlist]].flatten.compact
-        last = objects.pop
-        first_bnode = bnode
-        objects.each do |object|
-          add_triple("anonnode", first_bnode, RDF.first, object)
-          rest_bnode = RDF::Node.new
-          add_triple("anonnode", first_bnode, RDF.rest, rest_bnode)
-          first_bnode = rest_bnode
-        end
-        if last
-          add_triple("anonnode", first_bnode, RDF.first, last)
-          add_triple("anonnode", first_bnode, RDF.rest, RDF.nil)
-        else
-          bnode = RDF.nil
+        list = RDF::List.new(bnode, nil, objects)
+        list.each_statement do |statement|
+          next if statement.predicate == RDF.type && statement.object == RDF.List
+          add_triple("anonnode(list)", statement.subject, statement.predicate, statement.object)
         end
+        bnode = RDF.nil if list.empty?
       end
       bnode
     end

data/lib/rdf/n3/writer.rb

@@ -1,5 +1,3 @@
-require 'rdf/n3/patches/graph_properties'
-
 module RDF::N3
   ##
   # A Turtle serialiser in Ruby
@@ -166,7 +164,7 @@ module RDF::N3
         return nil
       end
 
-      add_debug "get_qname(#{resource}), std? #{RDF::Vocabulary.each.to_a.detect {|v| uri.index(v.to_uri.to_s) == 0}}"
+      add_debug "get_qname(#{resource}), std?}"
       qname = case
       when @uri_to_qname.has_key?(uri)
         return @uri_to_qname[uri]
@@ -202,20 +200,11 @@ module RDF::N3
     # @param [Hash{String => Array<Resource>}] properties A hash of Property to Resource mappings
     # @return [Array<String>}] Ordered list of properties. Uses predicate_order.
     def sort_properties(properties)
-      properties.keys.each do |k|
-        properties[k] = properties[k].sort do |a, b|
-          a_li = a.to_s.index(RDF._.to_s) == 0 ? a.to_s.match(/\d+$/).to_s.to_i : a.to_s
-          b_li = b.to_s.index(RDF._.to_s) == 0 ? b.to_s.match(/\d+$/).to_s.to_i : b.to_s
-          
-          a_li <=> b_li
-        end
-      end
-      
       # Make sorted list of properties
       prop_list = []
       
       predicate_order.each do |prop|
-        next unless properties[prop]
+        next unless properties[prop.to_s]
         prop_list << prop.to_s
       end
       
@@ -224,7 +213,7 @@ module RDF::N3
         prop_list << prop.to_s
       end
       
-      add_debug "sort_properties: #{prop_list.to_sentence}"
+      add_debug "sort_properties: #{prop_list.join(', ')}"
       prop_list
     end
 
@@ -420,34 +409,20 @@ module RDF::N3
 
     # Checks if l is a valid RDF list, i.e. no nodes have other properties.
     def is_valid_list(l)
-      props = @graph.properties(l)
-      #add_debug "is_valid_list: #{props.inspect}"
-      return false unless props.has_key?(RDF.first.to_s) || l == RDF.nil
-      while l && l != RDF.nil do
-        #add_debug "is_valid_list(length): #{props.length}"
-        return false unless props.has_key?(RDF.first.to_s) && props.has_key?(RDF.rest.to_s)
-        n = props[RDF.rest.to_s]
-        #add_debug "is_valid_list(n): #{n.inspect}"
-        return false unless n.is_a?(Array) && n.length == 1
-        l = n.first
-        props = @graph.properties(l)
-      end
-      #add_debug "is_valid_list: valid"
-      true
+      #add_debug "is_valid_list: #{l.inspect}"
+      return RDF::List.new(l, @graph).valid?
     end
     
     def do_list(l)
-      add_debug "do_list: #{l.inspect}"
+      list = RDF::List.new(l, @graph)
+      add_debug "do_list: #{list.inspect}"
       position = :subject
-      while l do
-        p = @graph.properties(l)
-        item = p.fetch(RDF.first.to_s, []).first
-        if item
-          path(item, position)
-          subject_done(l)
-          position = :object
-        end
-        l = p.fetch(RDF.rest.to_s, []).first
+      list.each_statement do |st|
+        next unless st.predicate == RDF.first
+        add_debug " list this: #{st.subject} first: #{st.object}[#{position}]"
+        path(st.object, position)
+        subject_done(st.subject)
+        position = :object
       end
     end
     
@@ -507,13 +482,18 @@ module RDF::N3
       return if objects.empty?
 
       objects.each_with_index do |obj, i|
-        @output.write(",\n#{indent(2)}") if i > 0
+        @output.write(",\n#{indent(4)}") if i > 0
         path(obj, :object)
       end
     end
     
     def predicate_list(subject)
-      properties = @graph.properties(subject)
+      properties = {}
+      @graph.query(:subject => subject) do |st|
+        properties[st.predicate.to_s] ||= []
+        properties[st.predicate.to_s] << st.object
+      end
+
       prop_list = sort_properties(properties) - [RDF.first.to_s, RDF.rest.to_s]
       add_debug "predicate_list: #{prop_list.inspect}"
       return if prop_list.empty?
@@ -558,6 +538,7 @@ module RDF::N3
       add_debug "statement: #{subject.inspect}, s2?: #{s_squared?(subject)}"
       subject_done(subject)
       s_squared(subject) || s_default(subject)
+      @output.write("\n")
     end
     
     def is_done?(subject)

metadata

@@ -1,23 +1,22 @@
 --- !ruby/object:Gem::Specification 
 name: rdf-n3
 version: !ruby/object:Gem::Version 
-  hash: 69
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 3
-  - 4
-  - 1
-  version: 0.3.4.1
+  - 5
+  version: 0.3.5
 platform: ruby
 authors: 
-- Gregg Kellogg
+- Gregg
+- Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-07-11 00:00:00 -07:00
-default_executable: 
+date: 2011-09-04 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rdf
@@ -89,12 +88,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 21
+        hash: 23
         segments: 
         - 0
         - 3
-        - 3
-        version: 0.3.3
+        - 2
+        version: 0.3.2
   type: :development
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
@@ -114,9 +113,25 @@ dependencies:
   type: :development
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
-  name: rdf-isomorphic
+  name: rdf-turtle
   prerelease: false
   requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 0
+        - 4
+        version: 0.0.4
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rdf-isomorphic
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -128,87 +143,50 @@ dependencies:
         - 4
         version: 0.3.4
   type: :development
-  version_requirements: *id007
+  version_requirements: *id008
 - !ruby/object:Gem::Dependency 
   name: yard
   prerelease: false
-  requirement: &id008 !ruby/object:Gem::Requirement 
+  requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 7
         segments: 
         - 0
-        version: "0"
+        - 6
+        - 0
+        version: 0.6.0
   type: :development
-  version_requirements: *id008
+  version_requirements: *id009
 description: RDF::N3 is an Notation-3 and Turtle reader/writer for the RDF.rb library suite.
-email: gregg@kellogg-assoc.com
+email: public-rdf-ruby@w3.org
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- AUTHORS
-- History.md
-- README.md
-- UNLICENSE
-- VERSION
+extra_rdoc_files: []
+
 files: 
-- .yardopts
+- README.markdown
+- History.markdown
 - AUTHORS
-- History.md
-- README
-- README.md
-- Rakefile
-- UNLICENSE
 - VERSION
-- example-files/arnau-registered-vocab.rb
-- example-files/arnau-stack-overflow.ttl
-- example-files/best-buy.nt
-- example-files/dwbutler-mj.n3
-- example-files/dwbutler-mj.ttl
-- example-files/lee-reilly-list.rb
-- example-files/recipe.ttl
-- example-files/sp2b.n3
-- example.rb
-- lib/rdf/n3.rb
+- UNLICENSE
 - lib/rdf/n3/format.rb
 - lib/rdf/n3/patches/array_hacks.rb
-- lib/rdf/n3/patches/graph_properties.rb
-- lib/rdf/n3/reader.rb
-- lib/rdf/n3/reader/bnf-rules.n3
+- lib/rdf/n3/patches/list.rb
 - lib/rdf/n3/reader/meta.rb
-- lib/rdf/n3/reader/n3-selectors.n3
-- lib/rdf/n3/reader/n3.n3
 - lib/rdf/n3/reader/parser.rb
+- lib/rdf/n3/reader.rb
 - lib/rdf/n3/version.rb
 - lib/rdf/n3/vocab.rb
 - lib/rdf/n3/writer.rb
-- rdf-n3.gemspec
-- script/build_meta
-- script/console
-- script/parse
-- script/tc
-- script/yard-to-rubyforge
-- spec/.gitignore
-- spec/cwm_spec.rb
-- spec/cwm_test.rb
-- spec/format_spec.rb
-- spec/matchers.rb
-- spec/reader_spec.rb
-- spec/spec.opts
-- spec/spec_helper.rb
-- spec/swap_spec.rb
-- spec/swap_test.rb
-- spec/turtle_spec.rb
-- spec/turtle_test.rb
-- spec/writer_spec.rb
-has_rdoc: true
+- lib/rdf/n3.rb
 homepage: http://github.com/gkellogg/rdf-n3
-licenses: []
-
+licenses: 
+- Public Domain
 post_install_message: 
 rdoc_options: []
 
@@ -219,10 +197,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 53
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 8
+      - 1
+      version: 1.8.1
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
@@ -234,8 +214,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: "0"
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.5.0
+rubyforge_project: rdf-n3
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: N3/Turtle reader/writer for RDF.rb.