biointerchange 0.1.0

data/lib/biointerchange/core.rb

@@ -0,0 +1,195 @@
+module BioInterchange
+
+  # Custom Exceptions and Errors
+  require 'biointerchange/exceptions'
+
+  # Ontologies (besides the ones from the 'rdf' gem)
+  require 'biointerchange/gff3'
+  require 'biointerchange/sio'
+  require 'biointerchange/sofa'
+
+  # Reader/writer interfaces
+  require 'biointerchange/reader'
+  require 'biointerchange/writer'
+
+  #
+  # TEXT MINING
+  #
+
+  # Text mining readers
+  require 'biointerchange/textmining/text_mining_reader'
+  require 'biointerchange/textmining/pubannos_json_reader'
+  require 'biointerchange/textmining/pdfx_xml_reader'
+
+  # Text mining model
+  require 'biointerchange/textmining/document'
+  require 'biointerchange/textmining/content'
+  require 'biointerchange/textmining/process'
+  
+  # Text mining writers
+  require 'biointerchange/textmining/text_mining_rdf_ntriples'
+  
+  #
+  # GENOMICS
+  #
+
+  # GFF3 reader
+  require 'biointerchange/genomics/gff3_reader'
+
+  # Feature base model
+  require 'biointerchange/genomics/gff3_feature_set'
+  require 'biointerchange/genomics/gff3_feature'
+
+  # GFF3 writer
+  require 'biointerchange/genomics/gff3_rdf_ntriples'
+  
+  #
+  # ACTUAL COMMAND LINE IMPLEMENTATION
+  #
+
+  # Option parsing 
+  require 'getopt/long'
+
+  def self.cli
+    begin
+      opt = Getopt::Long.getopts(
+        ["--help", "-h", Getopt::BOOLEAN],
+        ["--debug", "-d", Getopt::BOOLEAN],  # set debug mode => print stack traces
+        ["--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
+        ["--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
+      )
+      
+      if opt['help'] or not opt['input'] or not opt['rdf'] then
+        puts "Usage: ruby #{$0} -i <format> -r <format> [options]"
+        puts 'Supported input formats (--input <format>/-i <format>):'
+        puts '  biointerchange.gff3                : GFF3'
+        puts '  dbcls.catanns.json                 : PubAnnotation JSON'
+        puts '  uk.ac.man.pdfx                     : PDFx XML'
+        puts 'Supported output formats (--rdf <format>/-r <format>)'
+        puts '  rdf.biointerchange.gff3            : RDF N-Triples for input'
+        puts '    biointerchange.gff3'
+        puts '  rdf.bh12.sio                       : RDF N-Triples for inputs'
+        puts '    dbcls.catanns.json'
+        puts '    uk.ac.man.pdfx'
+        puts 'I/O options:'
+        puts '  -f <file>/--file <file>            : file to read; STDIN used if not supplied'
+        puts '  -o <file>/--out <file>             : output file; STDOUT used if not supplied'
+        puts 'Input-/RDF-format specific options:'
+        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 'Input-/RDF-format specific options:'
+        puts '  Input: biointerchange.gff3'
+        puts '  Output: rdf.biointerchange.gff3'
+        puts '  Options:'
+        puts '    -t <date>/--date <date>          : date when the GFF3 file was created (optional)'
+        puts '    --name <name>                    : name of the GFF3 file creator (optional)'
+        puts '    --name_id <id>                   : email address of the GFF3 file creator (optional)'
+        puts 'Other options:'
+        puts '  -d / --debug                       : turn on debugging output (for stacktraces)'
+        puts '  -h  --help                         : this message'
+      
+        exit 1
+      end
+      
+      if opt['input'] == 'dbcls.catanns.json' or opt['input'] == 'uk.ac.man.pdfx' then
+        if opt['rdf'] == 'rdf.bh12.sio' then
+          raise ArgumentError, 'Require --name and --name_id options to specify source of annotations (e.g., a manual annotators name, or software tool name) and their associated URI (e.g., email address, or webaddress).' unless opt['name'] and opt['name_id']
+        else
+          unsupported_combination
+        end
+      elsif opt['input'] == 'biointerchange.gff3' then
+        if opt['rdf'] == 'rdf.biointerchange.gff3' then
+          # Okay. No further arguments required.
+        else
+          unsupported_combination
+        end
+      else
+        unsupported_combination
+      end
+
+      
+      opt['date'] = nil unless opt['date']
+      opt['version'] = nil unless opt['version']
+      
+      # generate model from file (deserialise)
+      reader = nil
+      if opt['input'] == 'dbcls.catanns.json' then
+        reader = BioInterchange::TextMining::PubannosJsonReader.new(opt['name'], opt['name_id'], opt['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'])
+      elsif opt['input'] == 'biointerchange.gff3' then
+        reader = BioInterchange::Genomics::GFF3Reader.new(opt['name'], opt['name_id'], opt['date'])
+      end
+    
+      model = nil
+      if opt["file"]
+        model = reader.deserialize(File.new(opt["file"],'r'))
+      else
+        model = reader.deserialize(STDIN)
+      end
+    
+      # generate rdf from model (serialise)
+      writer = nil
+      if opt['rdf'] == 'rdf.bh12.sio' then
+        writer = BioInterchange::TextMining::RDFWriter.new(File.new(opt['out'], 'w')) if opt['out']
+        writer = BioInterchange::TextMining::RDFWriter.new(STDOUT) unless opt['out']
+      end
+      if opt['rdf'] == 'rdf.biointerchange.gff3' then
+        writer = BioInterchange::Genomics::RDFWriter.new(File.new(opt['out'], 'w')) if opt['out']
+        writer = BioInterchange::Genomics::RDFWriter.new(STDOUT) unless opt['out']
+      end
+      
+      writer.serialize(model)
+
+    rescue ArgumentError => e
+      $stderr.puts e.message
+      $stderr.puts e.backtrace if opt['debug']
+      exit 1
+    rescue Getopt::Long::Error => e
+      $stderr.puts e.message
+      #$stderr.puts e.backtrace if opt['debug']
+      exit 1
+    rescue BioInterchange::Exceptions::InputFormatError => e
+      $stderr.puts e.message
+      $stderr.puts e.backtrace if opt['debug']
+      exit 2
+    end
+  end
+
+  #
+  # Helper functions
+  #
+
+  # Returns the values of several named parameters.
+  #
+  # +map+:: a map of named parameters and their values
+  # +parameters+:: the names of the parameter values we are interested in
+  def self.get_parameters(map, parameters)
+    parameters.map { |parameter|
+      if parameter.instance_of? Array then
+        parameter[0].call(*BioInterchange::get_parameters(map, parameter[1..-1]))
+      else
+        map[parameter]
+      end
+    }
+  end
+
+private
+
+  def self.unsupported_combination
+    raise ArgumentError, 'This input/output format combination is not supported.'
+  end
+
+end
+

data/lib/biointerchange/exceptions.rb

@@ -0,0 +1,38 @@
+module BioInterchange::Exceptions
+
+# Top level Error class for all framework errors.
+class BioInterchangeError < StandardError
+end
+
+# Error class for issues regarding input file formats. 
+# This error class is caught at the hightest level and
+# only the error message is returned to the end user
+# (not the backtrace). This helps keep the framework
+# more user friendly. Note that this means meaningful
+# error messages are strongly encourged. 
+class InputFormatError < BioInterchangeError
+end
+
+# Top class error for errors raised only during 
+# framework implementation and extension. Once
+# such an implementation/extension is completed,
+# these errors should no longer be possible.
+# Examples include a method reciving something it 
+# can't handle. The framework does not resuce these
+# errors leaving the backtraces for help in debug.
+class ImplementationError < BioInterchangeError
+end
+
+# Implementation errors originating from readers.
+class ImplementationReaderError < ImplementationError
+end
+
+# Implementation errors originating from models.
+class ImplementationModelError < ImplementationError
+end
+
+# Implementation errors originating from writers.
+class ImplementationWriterError < ImplementationError
+end
+
+end

data/lib/biointerchange/genomics/gff3_feature.rb

@@ -0,0 +1,82 @@
+module BioInterchange::Genomics
+
+class GFF3Feature
+
+  # Constants determining the strand of the feature.
+  NOT_STRANDED = 0
+  UNKNOWN      = 1
+  POSITIVE     = 2
+  NEGATIVE     = 3
+
+  # Creates a new feature representation. A feature is described on one line of the GFF3 file.
+  #
+  # +sequence_id+:: an identifier that determines the coordinate system for the feature
+  # +source+:: a text description of the origin of this feature description
+  # +type+:: either a SOFA accession, SOFA term, or textual description (the former are URIs, the latter is a string)
+  # +start_coordinate+:: an integer denoting the start coordinate of the feature
+  # +end_coordinate+:: an integer denoting the end coordinate of the feature, which is equal or larger than the start coordinate
+  # +score+:: a floating point score
+  # +strand+:: a constant determining whether the feature is NOT_STRANDED, the strand is UNKNOWN, or the feature is on the POSITIVE or NEGATIVE strand
+  # +phase+:: an integer determining the phase of the feature, if the feature has a phase
+  # +attributes+:: a map of additional attributes associated with the feature
+  def initialize(sequence_id, source, type, start_coordinate, end_coordinate, score = nil, strand = NOT_STRANDED, phase = nil, attributes = {})
+    @sequence_id = sequence_id
+    @source = source
+    @type = type
+    @start_coordinate = start_coordinate
+    @end_coordinate = end_coordinate
+    @score = score
+    @strand = strand
+    @phase = phase
+    @attributes = attributes
+  end
+
+  # Returns the sequence ID that determines the coordinate system for the feature.
+  def sequence_id
+    @sequence_id
+  end
+
+  # Returns a textual description that determines the origin of this feature.
+  def source
+    @source
+  end
+
+  # Returns the feature type, which can either be a SOFA URI or a textual description otherwise.
+  def type
+    @type
+  end
+
+  # Returns the start coordinate of the feature. The start coordinate is equal or smaller than the end coordinate.
+  def start_coordinate
+    @start_coordinate
+  end
+
+  # Returns the end coordinate of the feature. The end coordinate is equal or larger than the start coordinate.
+  def end_coordinate
+    @end_coordinate
+  end
+
+  # Returns the score of the feature. The score is a floating point number, which ideally is an E-value or P-value.
+  def score
+    @score
+  end
+
+  # Returns the strand the feature is located on.
+  def strand
+    @strand
+  end
+  
+  # Returns the phase, if existing, for this feature.
+  def phase
+    @phase
+  end
+
+  # Returns a map of additional attributes for this feature.
+  def attributes
+    @attributes.freeze
+  end
+
+end
+
+end
+

data/lib/biointerchange/genomics/gff3_feature_set.rb

@@ -0,0 +1,37 @@
+require 'digest/sha1'
+
+module BioInterchange::Genomics
+
+class GFF3FeatureSet
+
+  # Create a new instance of a Generic Feature Format Version 3 (GFF3) feature set. A feature
+  # set can contain multiple GFF3 features.
+  def initialize
+    # Features are stored as the keys of a hash map to increase performance:
+    @set = {}
+  end
+
+  # Returns the contents of the feature set.
+  def contents
+    @set.keys
+  end
+
+  # Returns an URI for this particular feature set, which is a SHA1 hash over the content'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"
+    }
+    "biointerchange://gff3/featureset/self/#{Digest::SHA1.hexdigest(clob)}"
+  end
+
+  # Adds a feature to the feature set.
+  #
+  # +feature+:: feature instance that is added to the contents of this feature set
+  def add(feature)
+    @set[feature] = true
+  end
+
+end
+
+end

data/lib/biointerchange/genomics/gff3_rdf_ntriples.rb

@@ -0,0 +1,107 @@
+require 'rdf'
+require 'rdf/ntriples'
+require 'date'
+
+module BioInterchange::Genomics
+
+class RDFWriter
+
+  # Creates a new instance of a RDFWriter that will use the provided output stream to serialize RDF.
+  #
+  # +ostream+:: instance of an IO class or derivative that is used for RDF serialization
+  def initialize(ostream)
+    raise BioInterchange::Exceptions::ImplementationWriterError, 'The output stream is not an instance of IO or its subclasses.' unless ostream.kind_of?(IO)
+    @ostream = ostream
+  end
+
+  # Serialize a model as RDF.
+  #
+  # +model+:: a generic representation of input data that is derived from BioInterchange::Genomics::GFF3FeatureSet
+  def serialize(model)
+    if model.instance_of?(BioInterchange::Genomics::GFF3FeatureSet) then
+      serialize_model(model)
+    else
+      raise BioInterchange::Exceptions::ImplementationWriterError, 'The provided model cannot be serialized. ' +
+                           'This writer supports serialization for BioInterchange::Genomics::GFF3FeatureSet.'
+    end
+  end
+
+private
+
+  # Serializes RDF for a feature set representation.
+  #
+  # +model+:: an instance of +BioInterchange::Genomics::GFF3FeatureSet+
+  def serialize_model(model)
+    graph = RDF::Graph.new
+    set_uri = RDF::URI.new(model.uri)
+    graph.insert(RDF::Statement.new(set_uri, RDF.type, BioInterchange::GFF3.Set))
+    model.contents.each { |feature|
+      serialize_feature(graph, set_uri, feature)
+    }
+    RDF::NTriples::Writer.dump(graph, @ostream)
+  end
+
+  # Serializes a +GFF3Feature+ object for a given feature set URI.
+  #
+  # +graph+:: RDF graph to which the feature is added
+  # +set_uri+:: the feature set URI to which the feature belongs to
+  # +feature+:: a +GFF3Feature+ instance
+  def serialize_feature(graph, set_uri, feature)
+    # 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')
+    graph.insert(RDF::Statement.new(set_uri, BioInterchange::GFF3.contains, feature_uri))
+    graph.insert(RDF::Statement.new(feature_uri, RDF.type, BioInterchange::GFF3.Feature))
+    graph.insert(RDF::Statement.new(feature_uri, BioInterchange::GFF3.seqid, RDF::Literal.new(feature.sequence_id)))
+    graph.insert(RDF::Statement.new(feature_uri, BioInterchange::GFF3.source, RDF::Literal.new(feature.source)))
+    graph.insert(RDF::Statement.new(feature_uri, BioInterchange::GFF3.type, RDF::Literal.new(feature.type)))
+    graph.insert(RDF::Statement.new(feature_uri, BioInterchange::GFF3.start, RDF::Literal.new(feature.start_coordinate)))
+    graph.insert(RDF::Statement.new(feature_uri, BioInterchange::GFF3.end, RDF::Literal.new(feature.end_coordinate)))
+    graph.insert(RDF::Statement.new(feature_uri, BioInterchange::GFF3.score, RDF::Literal.new(feature.score))) if feature.score
+    case feature.strand
+    when BioInterchange::Genomics::GFF3Feature::NOT_STRANDED
+      graph.insert(RDF::Statement.new(feature_uri, BioInterchange::GFF3.strand, BioInterchange::GFF3.NotStranded))
+    when BioInterchange::Genomics::GFF3Feature::UNKNOWN
+      graph.insert(RDF::Statement.new(feature_uri, BioInterchange::GFF3.strand, BioInterchange::GFF3.UnknownStrand))
+    when BioInterchange::Genomics::GFF3Feature::POSITIVE
+      graph.insert(RDF::Statement.new(feature_uri, BioInterchange::GFF3.strand, BioInterchange::GFF3.Positive))
+    when BioInterchange::Genomics::GFF3Feature::NEGATIVE
+      graph.insert(RDF::Statement.new(feature_uri, BioInterchange::GFF3.strand, BioInterchange::GFF3.Negative))
+    else
+      raise ArgumentException, 'Strand of feature is set to an unknown constant.'
+    end
+    graph.insert(RDF::Statement.new(feature_uri, BioInterchange::GFF3.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 the attributes of a feature.
+  #
+  # +graph+:: RDF graph to which the feature is added
+  # +set_uri+:: URI of the set these attributes belong to (implicit due to feature)
+  # +feature_uri+:: the feature URI to which the attributes belong to
+  # +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
+        list.each { |parent_id|
+          graph.insert(RDF::Statement.new(feature_uri, BioInterchange::GFF3.parent, RDF::URI.new("#{set_uri.to_s}/feature/#{parent_id}")))
+        }
+      else
+        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, BioInterchange::GFF3.attributes, attribute_uri))
+          graph.insert(RDF::Statement.new(attribute_uri, RDF.type, BioInterchange::GFF3.Attribute))
+          graph.insert(RDF::Statement.new(attribute_uri, BioInterchange::GFF3.tag, RDF::Literal.new("#{tag}")))
+          graph.insert(RDF::Statement.new(attribute_uri, RDF.value, RDF::Literal.new(value)))
+        }
+      end
+    }
+  end
+
+end
+
+end
+

data/lib/biointerchange/genomics/gff3_reader.rb

@@ -0,0 +1,86 @@
+module BioInterchange::Genomics
+
+class GFF3Reader
+
+  # Creates a new instance of a Generic Feature Format Version 3 (GFF3) reader.
+  #
+  # +name+:: Optional name of the person who generated the GFF3 file.
+  # +name_uri+:: Optional e-mail address of the person who generated the GFF3 file.
+  # +date+:: Optional date of when the GFF3 file was produced.
+  def initialize(name = nil, name_uri = nil, date = nil)
+    @name = name
+    @name_uri = name_uri
+    @date = date
+  end 
+
+  # Reads a GFF3 file from the input stream and returns an associated model.
+  #
+  # +inputstream+:: an instance of class IO or String that holds the contents of a GFF3 file
+  def deserialize(inputstream)
+    if inputstream.kind_of?(IO)
+      create_model(inputstream.read)
+    elsif inputstream.kind_of?(String) then
+      create_model(inputstream)
+    else
+      raise BioInterchange::Exceptions::ImplementationReaderError, 'The provided input stream needs to be either of type IO or String.'
+    end
+  end
+
+private
+
+  def create_model(gff3)
+    feature_set = BioInterchange::Genomics::GFF3FeatureSet.new()
+    gff3.each_line { |line|
+      next if line.start_with?('#')
+
+      line.chomp!
+      seqid, source, type, start_coordinate, end_coordinate, score, strand, phase, attributes = line.split("\t")
+
+      # The type might be a SO/SOFA term, SO/SOFA accession, or other term (it stays a string then):
+      if type.match(/SO:\d+/) then
+        type = RDF::URI.new("http://purl.obolibrary.org/obo/#{type.sub(':', '_')}")
+      elsif BioInterchange::SOFA.methods.include?(type.gsub(' ', '_').to_sym)
+        type = BioInterchange::SOFA.send(type.gsub(' ', '_'))
+      end
+
+      # String to numeric value conversions:
+      start_coordinate = start_coordinate.to_i
+      stop_coordinate = stop_coordinate.to_i
+      if score == '.' then
+        score = nil
+      else
+        score = score.to_f
+      end
+
+      # Determine strandedness:
+      if strand == '?' then
+        strand = BioInterchange::Genomics::GFF3Feature::UNKNOWN
+      elsif strand == '+' then
+        strand = BioInterchange::Genomics::GFF3Feature::POSITIVE
+      elsif strand == '-' then
+        strand = BioInterchange::Genomics::GFF3Feature::NEGATIVE
+      else
+        strand = BioInterchange::Genomics::GFF3Feature::NOT_STRANDED
+      end
+
+      # Set phase, if it lies in the permissable range of values:
+      if phase == '0' or phase == '1' or phase == '2' then
+        phase = phase.to_i
+      else
+        phase = nil
+      end
+
+      temp = {}
+      attributes.split(';').map { |assignment| match = assignment.match(/([^=]+)=(.+)/) ; { match[1].strip => match[2].split(',').map { |value| value.strip } } }.map { |hash| hash.each_pair { |tag,list| temp[tag] = list } }
+      attributes = temp
+
+      feature_set.add(BioInterchange::Genomics::GFF3Feature.new(seqid, source, type, start_coordinate, end_coordinate, score, strand, phase, attributes))
+    }
+
+    feature_set
+  end
+
+end
+
+end
+

data/lib/biointerchange/gff3.rb

@@ -0,0 +1,135 @@
+module BioInterchange
+
+class GFF3
+
+    def self.strand
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0010')
+    end
+
+    def self.attributes
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0012')
+    end
+
+    def self.parent
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0014')
+    end
+
+    def self.contains
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0015')
+    end
+
+    def self.seqid
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0004')
+    end
+
+    def self.source
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0005')
+    end
+
+    def self.type
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0006')
+    end
+
+    def self.start
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0007')
+    end
+
+    def self.end
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0008')
+    end
+
+    def self.score
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0009')
+    end
+
+    def self.phase
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0011')
+    end
+
+    def self.tag
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0013')
+    end
+
+    def self.Set
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0001')
+    end
+
+    def self.Feature
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0002')
+    end
+
+    def self.Attribute
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0003')
+    end
+
+    def self.Strand
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0016')
+    end
+
+    def self.Positive
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0017')
+    end
+
+    def self.Negative
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0018')
+    end
+
+    def self.UnknownStrand
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0019')
+    end
+
+    def self.NotStranded
+      RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0020')
+    end
+
+    # Determines whether the given URI is an object property.
+    #
+    # +uri+:: URI that is tested for being an object property
+    def self.is_object_property?(uri)
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0010')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0012')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0014')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0015')
+      false
+    end
+
+    # Determines whether the given URI is a datatype property.
+    #
+    # +uri+:: URI that is tested for being a datatype property
+    def self.is_datatype_property?(uri)
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0004')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0005')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0006')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0007')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0008')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0009')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0011')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0013')
+      false
+    end
+
+    # Determines whether the given URI is a class.
+    #
+    # +uri+:: URI that is tested for being a class
+    def self.is_class?(uri)
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0001')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0002')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0003')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0016')
+      false
+    end
+
+    # Determines whether the given URI is a named individual.
+    #
+    # +uri+:: URI that is tested for being a named individual
+    def self.is_named_individual?(uri)
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0017')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0018')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0019')
+      return true if uri == RDF::URI.new('http://www.sequenceontology.org/gff3#GFF3_0020')
+      false
+    end
+
+end
+
+end