biointerchange 0.1.3 → 0.2.0

data/README.md

@@ -274,6 +274,12 @@ Building a new version of the Ruby vocabulary classes for GFF3, SIO, SOFA (requi
     ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-sofa> SOFA >> lib/biointerchange/sofa.rb
     echo -e "\nend" >> lib/biointerchange/sofa.rb
 
+A Geno Ontology external reference (GOxref) vocabulary can be created by directly downloading the latest version of `GO.xrf_abbs`:
+
+    echo -e "module BioInterchange\n" > lib/biointerchange/goxref.rb
+    curl ftp://ftp.geneontology.org/pub/go/doc/GO.xrf_abbs | ruby generators/GOxrefify.rb
+    echo -e "\nend" >> lib/biointerchange/goxref.rb
+
 #### Python Vocabulary Classes
 
 The source-code generation can be skipped, if none of the ontologies that are used by BioInterchange have been changed. Otherwise, the existing Python vocabulary class wrappers can be generated as follows:
@@ -282,6 +288,7 @@ The source-code generation can be skipped, if none of the ontologies that are us
     ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-gvf1o> GVF1O | ruby generators/pythonify.rb > supplemental/python/biointerchange/gvf1o.py
     ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-sio> SIO | ruby generators/pythonify.rb > supplemental/python/biointerchange/sio.py
     ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-sofa> SOFA | ruby generators/pythonify.rb > supplemental/python/biointerchange/sofa.py
+    curl ftp://ftp.geneontology.org/pub/go/doc/GO.xrf_abbs | ruby generators/GOxrefify.rb | ruby generators/pythonify.rb > supplemental/python/biointerchange/goxref.py
 
 Generate the BioInterchange Python vocabulary egg:
 
@@ -302,6 +309,7 @@ The source-code generation can be skipped, if none of the ontologies that are us
     ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-gvf1o> GVF1O | ruby generators/javaify.rb > supplemental/java/biointerchange/src/main/java/org/biointerchange/vocabulary/GVF1O.java
     ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-sio> SIO | ruby generators/javaify.rb > supplemental/java/biointerchange/src/main/java/org/biointerchange/vocabulary/SIO.java
     ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-sofa> SOFA | ruby generators/javaify.rb "http://purl.obolibrary.org/obo/" > supplemental/java/biointerchange/src/main/java/org/biointerchange/vocabulary/SOFA.java
+    curl ftp://ftp.geneontology.org/pub/go/doc/GO.xrf_abbs | ruby generators/GOxrefify.rb | ruby generators/javaify.rb > supplemental/java/biointerchange/src/main/java/org/biointerchange/vocabulary/GOXRef.java
 
 Generate the BioInterchange Java vocabulary artifact:
 
@@ -346,6 +354,15 @@ A more verbose is produced by calling `rspec` directly:
 
     bundle exec rake rdoc
 
+### Deploying on Rubygems
+
+_Note:_ Only BioInterchange package maintainers can deploy the 'biointerchange' gem on Rubygems.
+
+    bundle exec rake version:bump:(major | minor | patch)
+    bundle exec rake gemspec
+    bundle exec gem build biointerchange.gemspec
+    bundle exec gem push biointerchange-VERSION.gem
+
 ### Troubleshooting
 
 #### GCC: No such file or directory

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.2.0

data/generators/GOxrefify.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/ruby
+
+def record(id, description, uri)
+  puts "  # Returns the link-out URI for objects of \"#{description}\"."
+  puts "  def self.#{id}"
+  puts "    RDF::URI.new(\"#{uri}\")"
+  puts '  end'
+  puts ''
+end
+
+puts 'class GOXRef'
+puts ''
+
+in_record = false
+
+id = nil
+description = nil
+uri = nil
+
+STDIN.each { |line|
+  line.chomp!
+
+  if line.empty? then
+    record(id, description, uri) if uri and not uri.match(/\[.*\]/)
+    uri = nil
+    in_record = false
+  end
+
+  if line.start_with?('abbreviation:') and not in_record then
+    id = line.sub(/^abbreviation: /, '').gsub(/[-\/]/, '_')
+    in_record = true
+  end
+  
+  description = line.sub(/^database: /, '') if line.start_with?('database:') and in_record
+  uri = line.sub(/^url_syntax: /, '').sub(/\[example_id\]$/, '') if line.start_with?('url_syntax:') and in_record
+}
+
+record(id, description, uri) if uri
+
+puts 'end'
+

data/generators/rdfxml.rb

@@ -16,8 +16,10 @@ OBO_DEF = RDF::URI.new('http://purl.obolibrary.org/obo/def')
 # For handling synonyms in SIO:
 SIO_SYN = RDF::URI.new('http://semanticscience.org/resource/synonym')
 
-def makeLabel(label)
-  label.gsub(/[ '-.<>]/, '_').gsub(/\([^\)]*?\)/, '').sub(/^(\d+)/, "a_#{$1}").gsub(/^_+|_+$/, '').gsub(/_+/, '_')
+# This label conversion also appears in:
+#   +lib/biointerchange/core.rb+
+def make_safe_label(label)
+  label.gsub(/[ '-.<>\/]/, '_').gsub(/\([^\)]*?\)/, '').sub(/^(\d+)/, "a_#{$1}").gsub(/^_+|_+$/, '').gsub(/_+/, '_')
 end
 
 reader = RDF::RDFXML::Reader.open(ARGV[0])
@@ -55,7 +57,7 @@ model.keys.each { |key|
   next unless type
 
   label = entry[RDF::RDFS.label].to_s
-  next if makeLabel(label).empty?
+  next if make_safe_label(label).empty?
   uri = key.to_s
 
   # Only deal with URI sub-classes/sub-properties, whilst ignoring restrictions, etc.
@@ -84,7 +86,7 @@ model.keys.each { |key|
     set = combined_uris[label_or_synonym]
     set = [] unless set
     combined_uris[label_or_synonym] = set | [ uri ]
-    generated_labels[label_or_synonym] = makeLabel(label_or_synonym)
+    generated_labels[label_or_synonym] = make_safe_label(label_or_synonym)
   }
 
   object_properties[uri] = true if type == RDF::OWL.ObjectProperty

data/lib/biointerchange/core.rb

@@ -5,11 +5,23 @@
 # of it as a gem in your own Ruby implementation.
 module BioInterchange
 
+  ### Global behaviour settings, which can be altered programmatically or via the CLI:
+
+  # If true, then RDF::Graph's "insert" function will be overwritten so that it
+  # immediately outputs N-Triples. This reduces memory requirements (since no RDF
+  # graph is kept in memory) and performance (since no looping through an RDF graph
+  # is necessary).
+  @@skip_rdf_graph = true
+  def self.skip_rdf_graph
+    @@skip_rdf_graph
+  end
+
   # Custom Exceptions and Errors
   require 'biointerchange/exceptions'
 
   # Ontologies (besides the ones from the 'rdf' gem)
   require 'biointerchange/gff3o'
+  require 'biointerchange/goxref'
   require 'biointerchange/gvf1o'
   require 'biointerchange/sio'
   require 'biointerchange/sofa'
@@ -78,14 +90,17 @@ module BioInterchange
       opt = Getopt::Long.getopts(
         ["--help", "-h", Getopt::BOOLEAN],
         ["--debug", "-d", Getopt::BOOLEAN],  # set debug mode => print stack traces
+        ["--no_rdf_graph_optimization", "-n", Getopt::BOOLEAN], # set self.skip_rdf_graph to false
+        ["--batchsize", "-b", Getopt::OPTIONAL], # batchsize for readers/writers that support +postpone?+
         ["--input", "-i", Getopt::REQUIRED], # input file format
         ["--rdf", "-r", Getopt::REQUIRED], # output file format
-        ["--name", Getopt::OPTIONAL], # name of resourcce/tool/person
-        ["--name_id", Getopt::OPTIONAL], # uri of resource/tool/person
-        ["--date", "-t", Getopt::OPTIONAL], # date of processing/annotation
-        ["--version", "-v", Getopt::OPTIONAL], # version number of resource
+        ["--annotate_name", Getopt::OPTIONAL], # name of resourcce/tool/person
+        ["--annotate_name_id", Getopt::OPTIONAL], # uri of resource/tool/person
+        ["--annotate_date", Getopt::OPTIONAL], # date of processing/annotation
+        ["--annotate_version", Getopt::OPTIONAL], # version number of resource
         ["--file", "-f", Getopt::OPTIONAL], # file to read, will read from STDIN if not supplied
-        ["--out", "-o", Getopt::OPTIONAL] # output file, will out to STDOUT if not supplied
+        ["--out", "-o", Getopt::OPTIONAL], # output file, will out to STDOUT if not supplied
+        ["--version", "-v", Getopt::OPTIONAL] # output the version number of the gem and exit
       )
       
       if opt['help'] or not opt['input'] or not opt['rdf'] then
@@ -115,26 +130,38 @@ module BioInterchange
         puts '  Input: dbcls.catanns.json, uk.ac.man.pdfx'
         puts '  Output: rdf.bh12.sio'
         puts '  Options:'
-        puts '    -t <date>/--date <date>          : date of processing/annotation (optional)'
-        puts '    -v <version>/--version <version> : version number of resource (optional)'
-        puts '    --name <name>                    : name of resource/tool/person (required)'
-        puts '    --name_id <id>                   : URI of resource/tool/person (required)'
+        puts '    --annotate_date <date>           : date of processing/annotation (optional)'
+        puts '    --annotate_version <version>     : version number of resource (optional)'
+        puts '    --annotate_name <name>           : name of resource/tool/person (required)'
+        puts '    --annotate_name_id <id>          : URI of resource/tool/person (required)'
         puts ''
         puts 'Input-/RDF-format specific options:'
         puts '  Input: biointerchange.gff3 or biointerchange.gvf'
         puts '  Output: rdf.biointerchange.gff3 or rdf.biointerchange.gvf'
         puts '  Options:'
+        puts '    -b <size>/--batchsize <size>     : process features in batches of the given size (optional)'
         puts '    -t <date>/--date <date>          : date when the GFF3/GVF file was created (optional)'
         puts '    --name <name>                    : name of the GFF3/GVF file creator (optional)'
         puts '    --name_id <id>                   : email address of the GFF3/GVF file creator (optional)'
         puts ''
         puts 'Other options:'
+        puts '  -v / --version                     : print the Gem\'s version number and exit'
         puts '  -d / --debug                       : turn on debugging output (for stacktraces)'
         puts '  -h  --help                         : this message'
       
         exit 1
       end
       
+      # Print version number and exit:
+      if opt['version'] then
+        puts 'BioInterchange 0.1.4'
+        exit
+      end
+
+      # Turn off optimization, if requested. This will generate an RDF graph in memory and
+      # at least double memory requirements and runtime.
+      @@skip_rdf_graph = false if opt['no_rdf_graph_optimization']
+
       # Check if the input/rdf options are supported:
       if opt['input'] == 'dbcls.catanns.json' or opt['input'] == 'uk.ac.man.pdfx' then
         if opt['rdf'] == 'rdf.bh12.sio' then
@@ -158,27 +185,27 @@ module BioInterchange
         unsupported_combination
       end
       
-      opt['date'] = nil unless opt['date']
-      opt['version'] = nil unless opt['version']
-      
+      wrong_type('batchsize', 'a positive integer') if opt['batchsize'] and not opt['batchsize'].match(/^[1-9][0-9]*$/)
+
+      opt['batchsize'] = opt['batchsize'].to_i if opt['batchsize']
+
       # Generate model from file (deserialization).
       # Note: if-clauses are lexicographically ordered. 
       reader = nil
       if opt['input'] == 'biointerchange.gff3' then
-        reader = BioInterchange::Genomics::GFF3Reader.new(opt['name'], opt['name_id'], opt['date'])
+        reader = BioInterchange::Genomics::GFF3Reader.new(opt['annotate_name'], opt['annotate_name_id'], opt['annotate_date'], opt['batchsize'])
       elsif opt['input'] == 'biointerchange.gvf' then
-        reader = BioInterchange::Genomics::GVFReader.new(opt['name'], opt['name_id'], opt['date'])
+        reader = BioInterchange::Genomics::GVFReader.new(opt['annotate_name'], opt['annotate_name_id'], opt['annotate_date'], opt['batchsize'])
       elsif opt['input'] == 'dbcls.catanns.json' then
-        reader = BioInterchange::TextMining::PubannosJsonReader.new(opt['name'], opt['name_id'], opt['date'], BioInterchange::TextMining::Process::UNSPECIFIED, opt['version'])
+        reader = BioInterchange::TextMining::PubannosJsonReader.new(opt['annotate_name'], opt['annotate_name_id'], opt['annotate_date'], BioInterchange::TextMining::Process::UNSPECIFIED, opt['version'])
       elsif opt['input'] == 'uk.ac.man.pdfx' then
-        reader = BioInterchange::TextMining::PdfxXmlReader.new(opt['name'], opt['name_id'], opt['date'], BioInterchange::TextMining::Process::UNSPECIFIED, opt['version'])
+        reader = BioInterchange::TextMining::PdfxXmlReader.new(opt['annotate_name'], opt['annotate_name_id'], opt['annotate_date'], BioInterchange::TextMining::Process::UNSPECIFIED, opt['annotate_version'])
       end
     
-      model = nil
       if opt["file"]
-        model = reader.deserialize(File.new(opt["file"],'r'))
+        input_source = File.new(opt["file"],'r')
       else
-        model = reader.deserialize(STDIN)
+        input_source = STDIN
       end
     
       # Generate rdf from model (serialization).
@@ -193,7 +220,10 @@ module BioInterchange
         writer = BioInterchange::Genomics::RDFWriter.new(STDOUT) unless opt['out']
       end
       
-      writer.serialize(model)
+      begin
+        model = reader.deserialize(input_source)
+        writer.serialize(model)
+      end while reader.postponed?
 
     rescue ArgumentError => e
       $stderr.puts e.message
@@ -228,11 +258,55 @@ module BioInterchange
     }
   end
 
+  # Returns a "safe" version of a label that can be used as a Ruby method name.
+  #
+  # +label+:: string that should be converted into a "safe" string that can be used as a Ruby method name
+  def self.make_safe_label(label)
+    label.gsub(/[ '-.<>\/]/, '_').gsub(/\([^\)]*?\)/, '').sub(/^(\d+)/, "a_#{$1}").gsub(/^_+|_+$/, '').gsub(/_+/, '_')
+  end
+
 private
 
   def self.unsupported_combination
     raise ArgumentError, 'This input/output format combination is not supported.'
   end
 
+  def self.wrong_type(parameter, expected_type)
+    raise ArgumentError, "The parameter '#{parameter}' needs to be #{expected_type}."
+  end
+
+end
+
+# Overwrite RDF::Graph implementation, in case we do not want to keep
+# the complete graph in memory. If the implementing writer does not
+# set an output stream via +fast_ostream+, then fall back to the original
+# implementation.
+module RDF
+
+class Graph
+  # DO NOT keep old insert implementation due to infinite recursion caused by module loading dependencies!
+  # alias_method :graph_building_insert, :insert
+
+  # Set an output stream for writing in +insert+.
+  #
+  # +ostream+:: Output stream that is populated by +insert+, if optimization can be carried out.
+  def fast_ostream(ostream)
+    @ostream = ostream
+  end
+
+  # Alternative implementation to +insert+, which can immediately output N-Triples instead
+  # of building an in-memory graph first.
+  #
+  # +statement+:: RDF statement that should be serialized.
+  def insert(statement)
+    if BioInterchange::skip_rdf_graph and @ostream then
+      @ostream.puts(statement.to_ntriples)
+    else
+      insert_statement(statement)
+    end
+  end
+
+end
+
 end
 

data/lib/biointerchange/genomics/gff3_feature_set.rb

@@ -38,11 +38,11 @@ class GFF3FeatureSet
     @pragmas.keys
   end
 
-  # Returns an URI for this particular feature set, which is a SHA1 hash over the content's concatenated properties.
+  # Returns an URI for this particular feature set, which is a SHA1 hash over the pragma's concatenated properties.
   def uri
     clob = ''
-    contents.each { |feature|
-      clob << "#{feature.sequence_id}\t#{feature.source}\t#{feature.type}\t#{feature.start_coordinate}\t#{feature.end_coordinate}\t#{feature.score}\t#{feature.strand}\t#{feature.phase}\t#{feature.attributes.keys.map { |tag| "#{tag}=#{feature.attributes[tag]}" }.join(';')}\n"
+    pragmas.each { |pragma_name|
+      clob << "#{pragma_name}\t#{pragma(pragma_name).to_s}\n"
     }
     "biointerchange://gff3/featureset/self/#{Digest::SHA1.hexdigest(clob)}"
   end
@@ -62,6 +62,14 @@ class GFF3FeatureSet
      # TODO Should throw exception if name is not a string.
      @pragmas[name] = value
    end
+
+   # Removes all features from the set, but keeps the pragmas. This enables
+   # batched processing, since the URI for the set is only determined by the
+   # pragma statement contents.
+   def prune
+     @set.clear
+   end
+
 end
 
 end

data/lib/biointerchange/genomics/gff3_pragmas.rb

@@ -1,15 +1,15 @@
 
 module BioInterchange::Genomics
 
-# Represents a named region, which is defined by the pragma statement 'sequence-region'.
-class GFF3NamedRegion
+# Represents a named region, a.k.a. landmark, which is defined by the pragma statement 'sequence-region'.
+class GFF3Landmark
 
   # Create a new instance of a named region.
   #
   # +seqid+:: unique identifier (in the GFF3 file context) that identifies this region
   # +start_coordinate+:: genomic start coordinate of the region
   # +end_coordinate+:: genomic end coordinate of the region
-  def initialize(seqid, start_coordinate, end_coordinate)
+  def initialize(seqid, start_coordinate = nil, end_coordinate = nil)
     @seqid = seqid
     @start_coordinate = start_coordinate
     @end_coordinate = end_coordinate

data/lib/biointerchange/genomics/gff3_rdf_ntriples.rb

@@ -46,7 +46,16 @@ protected
   #
   # +model+:: an instance of +BioInterchange::Genomics::GFF3FeatureSet+
   def serialize_model(model)
+    # We record landmarks, because they can either be written when their "##sequence-region"
+    # pragma statement appears, or otherwise, when the first feature with said landmark is
+    # being serialized.
+    @landmarks = {}
+
+    # Record written variants in order to avoid writing out RDF.type multiple times.
+    @variants = {}
+
     graph = RDF::Graph.new
+    graph.fast_ostream(@ostream) if BioInterchange::skip_rdf_graph
     set_uri = RDF::URI.new(model.uri)
     graph.insert(RDF::Statement.new(set_uri, RDF.type, @base.Set))
     model.pragmas.each { |pragma_name|
@@ -57,21 +66,32 @@ protected
     }
     RDF::NTriples::Writer.dump(graph, @ostream)
     # TODO Figure out why the following is very slow. Use with 'rdf-raptor'.
+    #      Having said that, Jena's rdfcat is very good for converting formats
+    #      anyway, so perhaps it is not worth investigating the following.
     # RDF::RDFXML::Writer.dump(graph, @ostream)
   end
 
   # Serializes pragmas for a given feature set URI.
+  #
   # +graph+:: RDF graph to which the pragmas are added
   # +set_uri+:: the feature set URI to which the pragmas belong to
   # +pragma+:: an object representing a pragma statement
   def serialize_pragma(graph, set_uri, pragma)
     if pragma.kind_of?(Hash) then
-      if pragma.has_key?('gff-version') and @base == BioInterchange::GFF3O then
+      if (pragma.has_key?('attribute-method') or pragma.has_key?('data-source') or pragma.has_key?('score-method') or pragma.has_key?('source-method') or pragma.has_key?('technology-platform')) and @base == BioInterchange::GVF1O then
+        serialize_structured_attribute(graph, set_uri, pragma)
+      elsif pragma.has_key?('gff-version') and @base == BioInterchange::GFF3O then
         graph.insert(RDF::Statement.new(set_uri, @base.version, RDF::Literal.new(pragma['gff-version'], :datatype => RDF::XSD.float )))
       elsif pragma.has_key?('gff-version') and @base == BioInterchange::GVF1O then
         graph.insert(RDF::Statement.new(set_uri, @base.gff_version, RDF::Literal.new(pragma['gff-version'], :datatype => RDF::XSD.float )))
       elsif pragma.has_key?('gvf-version') and @base == BioInterchange::GVF1O then
         graph.insert(RDF::Statement.new(set_uri, @base.gvf_version, RDF::Literal.new(pragma['gvf-version'], :datatype => RDF::XSD.float )))
+      elsif pragma.has_key?('sequence-region') then
+        pragma['sequence-region'].keys.each { |seqid|
+          serialize_landmark(graph, set_uri, pragma['sequence-region'][seqid])
+        }
+      elsif pragma.has_key?('species') then
+        graph.insert(RDF::Statement.new(set_uri, @base.species, RDF::URI.new(pragma['species'])))
       end
     else
       # TODO
@@ -87,17 +107,18 @@ protected
     # TODO Make sure there is only one value in the 'ID' list.
     feature_uri = RDF::URI.new("#{set_uri.to_s}/feature/#{feature.sequence_id},#{feature.source},#{feature.type.to_s.sub(/^[^:]+:\/\//, '')},#{feature.start_coordinate},#{feature.end_coordinate},#{feature.strand},#{feature.phase}") unless feature.attributes.has_key?('ID')
     feature_uri = RDF::URI.new("#{set_uri.to_s}/feature/#{feature.attributes['ID'][0]}") if feature.attributes.has_key?('ID')
-    feature_properties = @base.feature_properties.select { |uri| @base.is_datatype_property?(uri) }[0]
+    feature_datatype_properties = @base.feature_properties.select { |uri| @base.is_datatype_property?(uri) }[0]
+    feature_object_properties = @base.feature_properties.select { |uri| @base.is_object_property?(uri) }[0]
     graph.insert(RDF::Statement.new(set_uri, @base.contains, feature_uri))
     graph.insert(RDF::Statement.new(feature_uri, RDF.type, @base.Feature))
-    graph.insert(RDF::Statement.new(feature_uri, @base.with_parent([ @base.seqid ].flatten, feature_properties)[0], RDF::Literal.new(feature.sequence_id)))
+    serialize_landmark(graph, set_uri, GFF3Landmark.new(feature.sequence_id)) unless @landmarks.has_key?(feature.sequence_id)
+    graph.insert(RDF::Statement.new(feature_uri, @base.with_parent([ @base.seqid ].flatten, feature_object_properties)[0], @landmarks[feature.sequence_id]))
     graph.insert(RDF::Statement.new(feature_uri, @base.source, RDF::Literal.new(feature.source)))
-    graph.insert(RDF::Statement.new(feature_uri, @base.type, RDF::Literal.new(feature.type)))
-    graph.insert(RDF::Statement.new(feature_uri, @base.with_parent(@base.start, feature_properties)[0], RDF::Literal.new(feature.start_coordinate)))
-    graph.insert(RDF::Statement.new(feature_uri, @base.with_parent(@base.end, feature_properties)[0], RDF::Literal.new(feature.end_coordinate)))
+    graph.insert(RDF::Statement.new(feature_uri, @base.type, feature.type))
+    graph.insert(RDF::Statement.new(feature_uri, @base.with_parent(@base.start, feature_datatype_properties)[0], RDF::Literal.new(feature.start_coordinate)))
+    graph.insert(RDF::Statement.new(feature_uri, @base.with_parent(@base.end, feature_datatype_properties)[0], RDF::Literal.new(feature.end_coordinate)))
     graph.insert(RDF::Statement.new(feature_uri, @base.score, RDF::Literal.new(feature.score))) if feature.score
-    feature_properties = @base.feature_properties.select { |uri| @base.is_object_property?(uri) }[0]
-    strand_uri = @base.with_parent(@base.strand, feature_properties)[0]
+    strand_uri = @base.with_parent(@base.strand, feature_object_properties)[0]
     case feature.strand
     when BioInterchange::Genomics::GFF3Feature::NOT_STRANDED
       graph.insert(RDF::Statement.new(feature_uri, strand_uri, @base.NotStranded))
@@ -108,13 +129,27 @@ protected
     when BioInterchange::Genomics::GFF3Feature::NEGATIVE
       graph.insert(RDF::Statement.new(feature_uri, strand_uri, @base.Negative))
     else
-      raise ArgumentException, 'Strand of feature is set to an unknown constant.'
+      raise BioInterchange::Exceptions::InputFormatError, 'Strand of feature is set to an unknown constant.'
     end
     graph.insert(RDF::Statement.new(feature_uri, @base.phase, RDF::Literal.new(feature.phase))) if feature.phase
 
     serialize_attributes(graph, set_uri, feature_uri, feature.attributes) unless feature.attributes.keys.empty?
   end
 
+  # Serializes a genomic feature landmark ("seqid").
+  #
+  # +graph+:: RDF graph to which the landmark is added
+  # +set_uri+:: the feature set URI to which the landmark belongs to
+  # +landmark+:: encapsuled landmark data
+  def serialize_landmark(graph, set_uri, landmark)
+    return if @landmarks.has_key?(landmark.seqid)
+    landmark_uri = RDF::URI.new("#{set_uri.to_s}/landmark/#{landmark.seqid}")
+    @landmarks[landmark.seqid] = landmark_uri
+    graph.insert(RDF::Statement.new(landmark_uri, @base.with_parent([ @base.id ].flatten, @base.landmark_properties)[0], RDF::Literal.new(landmark.seqid)))
+    graph.insert(RDF::Statement.new(landmark_uri, @base.with_parent([ @base.start ].flatten, @base.landmark_properties)[0], RDF::Literal.new(landmark.start_coordinate))) if landmark.start_coordinate
+    graph.insert(RDF::Statement.new(landmark_uri, @base.with_parent([ @base.end ].flatten, @base.landmark_properties)[0], RDF::Literal.new(landmark.end_coordinate))) if landmark.end_coordinate
+  end
+
   # Serializes the attributes of a feature.
   #
   # +graph+:: RDF graph to which the feature is added
@@ -123,24 +158,194 @@ protected
   # +attribtues+:: a map of tag/value pairs
   def serialize_attributes(graph, set_uri, feature_uri, attributes)
     attributes.each_pair { |tag, list|
-      if tag == 'Parent' then
+      # Check for defined tags (in alphabetical order), if not matched, serialize as generic Attribute:
+      if tag == 'Alias' then
+        list.each { |value|
+          graph.insert(RDF::Statement.new(feature_uri, @base.alias, RDF::Literal.new(value)))
+        }
+      elsif tag == 'Dbxref' then
+        feature_properties = @base.feature_properties.select { |uri| @base.is_object_property?(uri) }[0]
+        list.each { |value|
+          begin
+            if value.match(/^dbSNP(_\d+)?:rs\d+$/) then
+              graph.insert(RDF::Statement.new(feature_uri, @base.with_parent([ @base.dbxref ].flatten, feature_properties)[0], RDF::URI.new("http://www.ncbi.nlm.nih.gov/projects/SNP/snp_ref.cgi?rs=#{value.split(/:/)[1].sub(/^rs/, '')}")))
+            elsif value.match(/^COSMIC(_\d+)?:COSM\d+$/) then
+              graph.insert(RDF::Statement.new(feature_uri, @base.with_parent([ @base.dbxref ].flatten, feature_properties)[0], RDF::URI.new("http://cancer.sanger.ac.uk/cosmic/mutation/overview?id=#{value.split(/:/)[1].sub(/^COSM/, '')}")))
+            else
+              abbreviation, id = value.split(':', 2)
+              graph.insert(RDF::Statement.new(feature_uri, @base.with_parent([ @base.dbxref ].flatten, feature_properties)[0], RDF::URI.new(BioInterchange::GOXRef.send(BioInterchange.make_safe_label(abbreviation)).to_s + id)))
+            end
+          rescue NoMethodError
+            raise BioInterchange::Exceptions::InputFormatError, 'Attribute Dbxref link-out is not resolvable, i.e. the name cannot be turned into an URL.'
+          end
+        }
+      elsif tag == 'Derives_from' and @base == BioInterchange::GFF3O then
+        list.each { |value|
+          graph.insert(RDF::Statement.new(feature_uri, @base.derives_from, RDF::URI.new("#{set_uri.to_s}/feature/#{value}")))
+        }
+      elsif tag == 'Gap' and @base == BioInterchange::GFF3O then
+        graph.insert(RDF::Statement.new(feature_uri, @base.gap, RDF::Literal.new(list.join(','))))
+      elsif tag == 'ID' then
+        # Do nothing. The feature ID is the URI of the feature. It is not relevant as information anymore.
+      elsif tag == 'Is_circular' and @base == BioInterchange::GFF3O then
+        value = list.join(',')
+        graph.insert(RDF::Statement.new(feature_uri, @base.is_circular, true)) if value == 'true'
+        graph.insert(RDF::Statement.new(feature_uri, @base.is_circular, false)) if value == 'false'
+        # TODO Report invalid value.
+      elsif tag == 'Name' and @base == BioInterchange::GFF3O then
+        graph.insert(RDF::Statement.new(feature_uri, @base.name, RDF::Literal.new(list.join(','))))
+      elsif tag == 'Note' and @base == BioInterchange::GFF3O then
+        list.each { |value|
+          graph.insert(RDF::Statement.new(feature_uri, @base.note, RDF::Literal.new(value)))
+        }
+      elsif tag == 'Ontology_term' and @base == BioInterchange::GFF3O then
+        list.each { |value|
+          # TODO Sanitize values that are either not in GO xrf_abbs or need conversion to match
+          #      match their associated Ruby method.
+          namespace, accession = value.split(/:/, 2)
+          graph.insert(RDF::Statement.new(feature_uri, @base.ontology_term, RDF::URI.new("#{BioInterchange::GOXRef.send(namespace).to_s}#{accession}")))
+        }
+      elsif tag == 'Parent' then
         list.each { |parent_id|
           graph.insert(RDF::Statement.new(feature_uri, @base.parent, RDF::URI.new("#{set_uri.to_s}/feature/#{parent_id}")))
         }
+      elsif tag == 'Reference_seq' then
+        list.each { |value|
+          graph.insert(RDF::Statement.new(feature_uri, @base.reference_seq, RDF::Literal.new(value)))
+        }
+      elsif tag == 'Target' then
+        target_id, start_coordinate, end_coordinate, strand = list.join(',').split(/\s+/, 4)
+        target_datatype_properties = @base.target_properties.select { |uri| @base.is_datatype_property?(uri) }[0]
+        target_object_properties = @base.target_properties.select { |uri| @base.is_object_property?(uri) }[0]
+        target_uri = RDF::URI.new("#{feature_uri.to_s}/target/#{target_id}")
+        graph.insert(RDF::Statement.new(target_uri, RDF.type, @base.Target))
+        graph.insert(RDF::Statement.new(target_uri, @base.target_id, RDF::Literal.new(target_id)))
+        graph.insert(RDF::Statement.new(target_uri, @base.with_parent([ @base.start ].flatten, target_datatype_properties)[0], RDF::Literal.new(start_coordinate.to_i)))
+        graph.insert(RDF::Statement.new(target_uri, @base.with_parent([ @base.end ].flatten, target_datatype_properties)[0], RDF::Literal.new(end_coordinate.to_i)))
+        graph.insert(RDF::Statement.new(target_uri, @base.with_parent([ @base.end ].flatten, target_object_properties)[0], @base.Positive)) if strand and strand == '+'
+        graph.insert(RDF::Statement.new(target_uri, @base.with_parent([ @base.end ].flatten, target_object_properties)[0], @base.Negative)) if strand and strand == '-'
+        graph.insert(RDF::Statement.new(feature_uri, @base.target, target_uri))
+      elsif tag == 'Variant_seq' and @base == BioInterchange::GVF1O then
+        serialize_variant_seqs(graph, set_uri, feature_uri, list)
       else
+        # TODO Report unknown upper case letters here? That would be a spec. validation...
+        #      Well, or it would show that this implementation is incomplete. Could be either.
+        attribute_properties = @base.attribute_properties
+        attribute_properties = attribute_properties.select { |uri| @base.is_datatype_property?(uri) }[0] if attribute_properties.kind_of?(Array)
+        feature_properties = @base.feature_properties.select { |uri| @base.is_object_property?(uri) }[0]
         list.each_index { |index|
           value = list[index]
           attribute_uri = RDF::URI.new("#{feature_uri.to_s}/attribute/#{tag}") if list.size == 1
           attribute_uri = RDF::URI.new("#{feature_uri.to_s}/attribute/#{tag}-#{index + 1}") unless list.size == 1
-          graph.insert(RDF::Statement.new(feature_uri, @base.attributes, attribute_uri))
+          graph.insert(RDF::Statement.new(feature_uri, @base.with_parent([ @base.attributes ].flatten, feature_properties)[0], attribute_uri))
           graph.insert(RDF::Statement.new(attribute_uri, RDF.type, @base.Attribute))
-          graph.insert(RDF::Statement.new(attribute_uri, @base.tag, RDF::Literal.new("#{tag}")))
+          graph.insert(RDF::Statement.new(attribute_uri, @base.with_parent([ @base.tag ].flatten, attribute_properties)[0], RDF::Literal.new("#{tag}")))
           graph.insert(RDF::Statement.new(attribute_uri, RDF.value, RDF::Literal.new(value)))
         }
       end
     }
   end
 
+  # Serializes a structured attribute (given as a pragma statement), which later
+  # can be referred to from feature instances.
+  #
+  # +graph+:: RDF graph to which the structured attribute is added
+  # +set_uri+:: the feature set URI to which the structured attribute belongs to
+  # +pragma+:: a map that encapsulates the structured attribute data
+  def serialize_structured_attribute(graph, set_uri, pragma)
+    attribute_uri = RDF::URI.new("#{set_uri.to_s}/structured_attribute/#{pragma.object_id}")
+    attributes = nil
+    class_type = nil
+    if pragma.has_key?('attribute-method') then
+      attributes = pragma['attribute-method'][0]
+      class_type = @base.Method
+    elsif pragma.has_key?('data-source') then
+      attributes = pragma['data-source'][0]
+      class_type = @base.DataSource
+    elsif pragma.has_key?('score-method') then
+      attributes = pragma['score-method'][0]
+      class_type = @base.Method
+    elsif pragma.has_key?('source-method') then
+      attributes = pragma['source-method'][0]
+      class_type = @base.Method
+    elsif pragma.has_key?('technology-platform') then
+      attributes = pragma['technology-platform'][0]
+      class_type = @base.TechnologyPlatform
+    else
+      # TODO Error.
+    end
+    graph.insert(RDF::Statement.new(attribute_uri, RDF.type, class_type))
+    if class_type == @base.DataSource and attributes.has_key?('Data_type') then
+      data_type_individual = nil
+      attributes['Data_type'] = attributes['Data_type'][0] # TODO Make sure array is of length 1.
+      if attributes['Data_type'] == 'Array_CGH' then
+        data_type_individual = @base.ArrayComparativeGenomicHybridization
+      elsif attributes['Data_type'] == 'DNA_microarray' then
+        data_type_individual = @base.DNAMicroarray
+      elsif attributes['Data_type'] == 'DNA_sequence' then
+        data_type_individual = @base.DNASequence
+      elsif attributes['Data_type'] == 'RNA_sequence' then
+        data_type_individual = @base.RNASequence
+      else
+        # TODO Error.
+      end
+      graph.insert(RDF::Statement.new(attribute_uri, @base.data_type, data_type_individual))
+    elsif class_type == @base.TechnologyPlatform then
+      if attributes.has_key?('Average_coverage') then
+        graph.insert(RDF::Statement.new(attribute_uri, @base.average_coverage, RDF::Literal.new(attributes['Average_coverage'][0].to_i)))
+      end
+      if attributes.has_key?('Platform_class') then
+        graph.insert(RDF::Statement.new(attribute_uri, @base.platform_class, RDF::Literal.new(attributes['Platform_class'][0])))
+      end
+      if attributes.has_key?('Platform_name') then
+        graph.insert(RDF::Statement.new(attribute_uri, @base.platform_name, RDF::Literal.new(attributes['Platform_name'][0])))
+      end
+      if attributes.has_key?('Read_length') then
+        graph.insert(RDF::Statement.new(attribute_uri, @base.read_length, RDF::Literal.new(attributes['Read_length'][0].to_i)))
+      end
+      if attributes.has_key?('Read_pair_span') then
+        graph.insert(RDF::Statement.new(attribute_uri, @base.read_pair_span, RDF::Literal.new(attributes['Read_pair_span'][0].to_i)))
+      end
+      if attributes.has_key?('Read_type') then
+        read_type_individual = nil
+        attributes['Read_type'] = attributes['Read_type'][0] # TODO Make sure array is of length 1.
+        if attributes['Read_type'] == 'fragment' then
+          read_type_individual = @base.Fragment
+        elsif attributes['Read_type'] == 'pair' then
+          read_type_individual = @base.Pair
+        else
+          # TODO Error.
+        end
+        graph.insert(RDF::Statement.new(attribute_uri, @base.read_type, read_type_individual))
+      end
+    end
+    structuredpragma_properties = @base.structuredpragma_properties.select { |uri| @base.is_object_property?(uri) }[0]
+    attributes.keys.each { |tag|
+      if tag.match(/^[a-z]/) then
+        custom_attribute_uri = RDF::URI.new("#{attribute_uri.to_s}/attribute/#{tag}")
+        graph.insert(RDF::Statement.new(custom_attribute_uri, RDF.type, @base.StructuredAttribute))
+        graph.insert(RDF::Statement.new(custom_attribute_uri, @base.with_parent([ @base.tag ].flatten, @base.structuredattribute_properties)[0], tag))
+        graph.insert(RDF::Statement.new(custom_attribute_uri, RDF.value, RDF::Literal.new(attributes[tag].join(','))))
+        graph.insert(RDF::Statement.new(attribute_uri, @base.with_parent([ @base.attributes ].flatten, structuredpragma_properties)[0], custom_attribute_uri))
+      end
+    }
+  end
+
+  # Serializes a list of variant sequences.
+  #
+  # +graph+:: RDF graph to which the structured attribute is added
+  # +set_uri+:: the feature set URI to which the feature belongs to
+  # +feature_uri+:: the feature URI to the feature that is annotated with variant data
+  # +list+:: list of variant values
+  def serialize_variant_seqs(graph, set_uri, feature_uri, list)
+    list.each_index { |index|
+      value = list[index]
+      variant_uri = RDF::URI.new("#{feature_uri.to_s}/variant/#{index}")
+      graph.insert(RDF::Statement.new(variant_uri, RDF.type, @base.Variant)) unless @variants.has_key?(variant_uri.to_s)
+      @variants[variant_uri.to_s] = true
+      graph.insert(RDF::Statement.new(variant_uri, @base.variant_seq, RDF::Literal.new(value)))
+    }
+  end
 end
 
 end