rdf-trig 0.0.1

data/lib/rdf/trig/reader.rb

@@ -0,0 +1,118 @@
+require 'rdf/trig/meta'
+require 'rdf/turtle'
+
+module RDF::TriG
+  ##
+  # A parser for the TriG
+  #
+  # Leverages the Turtle reader
+  class Reader < RDF::Turtle::Reader
+    format Format
+    include RDF::TriG::Meta
+
+    # String terminals
+    terminal(nil,                  %r([\{\}\(\),.;\[\]a]|\^\^|@base|@prefix|true|false)) do |reader, prod, token, input|
+      case token.value
+      when 'a'             then input[:resource] = RDF.type
+      when 'true', 'false' then input[:resource] = RDF::Literal::Boolean.new(token.value)
+      else                      input[:string] = token.value
+      end
+    end
+    terminal(:LANGTAG,              LANGTAG) do |reader, prod, token, input|
+      input[:lang] = token.value[1..-1]
+    end
+
+    # Productions
+    # [3g] graph defines the basic creation of context
+    production(:graph) do |reader, phase, input, current, callback|
+      current[:context] = nil
+    end
+    
+    # [4g] graphIri
+    # Normally, just returns the IRIref, but if called from [3g], also
+    # sets the context for triples defined within that graph
+    production(:graphIri) do |reader, phase, input, current, callback|
+      # If input contains set_graph_iri, use the returned value to set @context
+      if phase == :finish
+        callback.call(:trace, "graphIri", lambda {"Set graph context to #{current[:resource]}"})
+        input[:context] = current[:resource]
+      end
+    end
+    
+    # [12] object ::= IRIref | blank | literal
+    production(:object) do |reader, phase, input, current, callback|
+      next unless phase == :finish
+      if input[:object_list]
+        # Part of an rdf:List collection
+        input[:object_list] << current[:resource]
+      else
+        callback.call(:trace, "object", lambda {"current: #{current.inspect}"})
+        callback.call(:statement, "object", input[:subject], input[:predicate], current[:resource], input[:context])
+      end
+    end
+
+    # [16] collection ::= "(" object* ")"
+    production(:collection) do |reader, phase, input, current, callback|
+      if phase == :start
+        current[:object_list] = []  # Tells the object production to collect and not generate statements
+      else
+        # Create an RDF list
+        bnode = reader.bnode
+        objects = current[:object_list]
+        list = RDF::List.new(bnode, nil, objects)
+        list.each_statement do |statement|
+          # Spec Confusion, referenced section "Collection" is missing from the spec.
+          # Anicdodal evidence indicates that some expect each node to be of type rdf:list,
+          # but existing Notation3 and Turtle tests (http://www.w3.org/2001/sw/DataAccess/df1/tests/manifest.ttl) do not.
+          next if statement.predicate == RDF.type && statement.object == RDF.List
+          callback.call(:statement, "collection", statement.subject, statement.predicate, statement.object, input[:context])
+        end
+        bnode = RDF.nil if list.empty?
+
+        # Return bnode as resource
+        input[:resource] = bnode
+      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)
+      @callback = block
+
+      parse(@input, START.to_sym, @options.merge(:branch => BRANCH,
+                                                 :first => FIRST,
+                                                 :follow => FOLLOW)
+      ) do |context, *data|
+        loc = data.shift
+        case context
+        when :statement
+          add_statement(loc, RDF::Statement.from(data))
+        when :trace
+          debug(loc, *data)
+        end
+      end
+    rescue RDF::LL1::Parser::Error => e
+      debug("Parsing completed with errors:\n\t#{e.message}")
+      raise RDF::ReaderError, e.message if validate?
+    end
+    
+    ##
+    # Iterates the given block for each RDF quad in the input.
+    #
+    # @yield  [subject, predicate, object, context]
+    # @yieldparam [RDF::Resource] subject
+    # @yieldparam [RDF::URI]      predicate
+    # @yieldparam [RDF::Value]    object
+    # @yieldparam [RDF::URI]      context
+    # @return [void]
+    def each_quad(&block)
+      each_statement do |statement|
+        block.call(*statement.to_quad)
+      end
+    end
+  end # class Reader
+end # module RDF::Turtle

data/lib/rdf/trig/version.rb

@@ -0,0 +1,18 @@
+module RDF::TriG::VERSION
+  VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "VERSION")
+  MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chop.split(".")
+
+  STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
+
+  ##
+  # @return [String]
+  def self.to_s()   STRING end
+
+  ##
+  # @return [String]
+  def self.to_str() STRING end
+
+  ##
+  # @return [Array(Integer, Integer, Integer)]
+  def self.to_a() STRING.split(".") end
+end

data/lib/rdf/trig/writer.rb

@@ -0,0 +1,190 @@
+require 'rdf/turtle'
+
+module RDF::TriG
+  ##
+  # A TriG serialiser
+  #
+  # Note that the natural interface is to write a whole repository at a time.
+  # Writing statements or Triples will create a repository to add them to
+  # and then serialize the repository.
+  #
+  # @example Obtaining a TriG writer class
+  #   RDF::Writer.for(:trig)         #=> RDF::TriG::Writer
+  #   RDF::Writer.for("etc/test.trig")
+  #   RDF::Writer.for(:file_name      => "etc/test.trig")
+  #   RDF::Writer.for(:file_extension => "trig")
+  #   RDF::Writer.for(:content_type   => "application/trig")
+  #
+  # @example Serializing RDF repo into an TriG file
+  #   RDF::TriG::Writer.open("etc/test.trig") do |writer|
+  #     writer << repo
+  #   end
+  #
+  # @example Serializing RDF statements into an TriG file
+  #   RDF::TriG::Writer.open("etc/test.trig") do |writer|
+  #     repo.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
+  # @example Serializing RDF statements into an TriG string
+  #   RDF::TriG::Writer.buffer do |writer|
+  #     repo.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
+  # The writer will add prefix definitions, and use them for creating @prefix definitions, and minting QNames
+  #
+  # @example Creating @base and @prefix definitions in output
+  #   RDF::TriG::Writer.buffer(:base_uri => "http://example.com/", :prefixes => {
+  #       nil => "http://example.com/ns#",
+  #       :foaf => "http://xmlns.com/foaf/0.1/"}
+  #   ) do |writer|
+  #     repo.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
+  # @author [Gregg Kellogg](http://kellogg-assoc.com/)
+  class Writer < RDF::Turtle::Writer
+    format RDF::TriG::Format
+    
+    class ContextFilteredRepo
+      include RDF::Queryable
+
+      def initialize(repo, context)
+        @repo = repo
+        @context = context
+      end
+      
+      # Filter statements in repository to those having the specified context
+      # Returns each statement having the specified context, `false` for default context
+      # @yield statement
+      # @yieldparam [RDF::Statement] statement
+      # @return [void]
+      # @see [RDF::Queryable]
+      def each
+        @repo.each_statement do |st|
+          case @context
+          when false
+            yield st if !st.context
+          else
+            yield st if st.context == @context
+          end
+        end
+      end
+      
+      ##
+      # Proxy Repository#query_pattern
+      # @see RDF::Repository#query_pattern
+      def query_pattern(pattern, &block)
+        pattern.context = @context || false
+        @repo.send(:query_pattern, pattern, &block)
+      end
+    end
+
+    ##
+    # Initializes the TriG writer instance.
+    #
+    # @param  [IO, File] output
+    #   the output stream
+    # @param  [Hash{Symbol => Object}] options
+    #   any additional options
+    # @option options [Encoding] :encoding     (Encoding::UTF_8)
+    #   the encoding to use on the output stream (Ruby 1.9+)
+    # @option options [Boolean]  :canonicalize (false)
+    #   whether to canonicalize literals when serializing
+    # @option options [Hash]     :prefixes     (Hash.new)
+    #   the prefix mappings to use (not supported by all writers)
+    # @option options [#to_s]    :base_uri     (nil)
+    #   the base URI to use when constructing relative URIs
+    # @option options [Integer]  :max_depth      (3)
+    #   Maximum depth for recursively defining resources, defaults to 3
+    # @option options [Boolean]  :standard_prefixes   (false)
+    #   Add standard prefixes to @prefixes, if necessary.
+    # @option options [String]   :default_namespace (nil)
+    #   URI to use as default namespace, same as prefixes[nil]
+    # @yield  [writer] `self`
+    # @yieldparam  [RDF::Writer] writer
+    # @yieldreturn [void]
+    # @yield  [writer]
+    # @yieldparam [RDF::Writer] writer
+    def initialize(output = $stdout, options = {}, &block)
+      super do
+        # Set both @repo and @graph to a new repository.
+        # When serializing a context, @graph is changed
+        # to a ContextFilteredRepo
+        @repo = @graph = RDF::Repository.new
+        if block_given?
+          case block.arity
+            when 0 then instance_eval(&block)
+            else block.call(self)
+          end
+        end
+      end
+    end
+
+    ##
+    # Outputs the TriG representation of all stored triples.
+    #
+    # @return [void]
+    # @see    #write_triple
+    def write_epilogue
+      @max_depth = @options[:max_depth] || 3
+      @base_uri = RDF::URI(@options[:base_uri])
+
+      reset
+
+      debug {"\nserialize: repo: #{@repo.size}"}
+
+      preprocess
+      start_document
+
+      order_contexts.each do |ctx|
+        debug {"context: #{ctx.inspect}"}
+        reset
+        @depth = 2
+
+        if ctx
+          @output.write("\n#{format_value(ctx)} {")
+        else
+          @output.write("\n{")
+        end
+
+        # Restrict view to the particular context
+        @graph = ContextFilteredRepo.new(@repo, ctx)
+
+        # Pre-process statements again, but in the specified context
+        @graph.each {|st| preprocess_statement(st)}
+        order_subjects.each do |subject|
+          unless is_done?(subject)
+            statement(subject)
+          end
+        end
+
+        @output.puts("}")
+      end
+    end
+
+    protected
+    # Order contexts for output
+    def order_contexts
+      debug("order_contexts") {repo.contexts.to_a.inspect}
+      contexts = repo.contexts.to_a.sort
+      
+      # include default context, if necessary
+      contexts.unshift(nil) unless repo.query(:context => false).to_a.empty?
+      
+      contexts
+    end
+
+    # Perform any statement preprocessing required. This is used to perform reference counts and determine required
+    # prefixes.
+    # @param [Statement] statement
+    def preprocess_statement(statement)
+      super
+      get_pname(statement.context) if statement.has_context?
+    end
+  end
+end

metadata

@@ -0,0 +1,221 @@
+--- !ruby/object:Gem::Specification 
+name: rdf-trig
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Gregg Kellogg
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-22 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rdf
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 3
+        - 4
+        version: 0.3.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdf-turtle
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 1
+        - 1
+        version: 0.1.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: open-uri-cached
+  prerelease: false
+  requirement: &id003 !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: *id003
+- !ruby/object:Gem::Dependency 
+  name: spira
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 0
+        - 12
+        version: 0.0.12
+  type: :development
+  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: 27
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rdf-isomorphic
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 3
+        - 4
+        version: 0.3.4
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rdf-n3
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 3
+        - 5
+        version: 0.3.5
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rdf-spec
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 3
+        - 4
+        version: 0.3.4
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 6
+        - 0
+        version: 0.6.0
+  type: :development
+  version_requirements: *id009
+description: RDF::TriG is an TriG reader/writer for the RDF.rb library suite.
+email: public-rdf-ruby@w3.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- AUTHORS
+- README.markdown
+- History
+- UNLICENSE
+- VERSION
+- lib/rdf/trig/format.rb
+- lib/rdf/trig/meta.rb
+- lib/rdf/trig/reader.rb
+- lib/rdf/trig/version.rb
+- lib/rdf/trig/writer.rb
+- lib/rdf/trig.rb
+homepage: http://github.com/gkellogg/rdf-trig
+licenses: 
+- Public Domain
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 53
+      segments: 
+      - 1
+      - 8
+      - 1
+      version: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rdf-trig
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: TriG reader/writer for Ruby.
+test_files: []
+
+has_rdoc: false