biointerchange 0.1.0 → 0.1.2

data/.travis.yml

@@ -4,9 +4,9 @@ rvm:
   - 1.9.3
   - jruby-19mode # JRuby in 1.9 mode
   - rbx-19mode
-#  - 1.8.7
-#  - jruby-18mode # JRuby in 1.8 mode
-#  - rbx-18mode
+  - 1.8.7
+  - jruby-18mode # JRuby in 1.8 mode
+  - rbx-18mode
 
 # uncomment this line if your project needs to run something other than `rake`:
 # script: bundle exec rspec spec

data/Gemfile

@@ -5,12 +5,13 @@ source "http://rubygems.org"
 gem "rdf", ">= 0.3.4.1"
 gem "json", ">= 1.6.4"
 gem "getopt", ">= 1.4.1"
+gem "addressable", ">= 2.3.2"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
   gem "rspec", "~> 2.8.0"
-  gem "bundler", "~> 1.2.1"
+  gem "bundler", ">= 1.1.5"
   gem "jeweler", "~> 1.8.4"
   gem "bio", ">= 1.4.2"
   gem "rdoc", "~> 3.12"

data/README.md

@@ -1,7 +1,7 @@
 BioInterchange
 ==============
 
-[![Build Status](https://secure.travis-ci.org/joejimbo/bioruby-biointerchange.png)](http://travis-ci.org/joejimbo/bioruby-biointerchange)
+[![Build Status](https://secure.travis-ci.org/BioInterchange/BioInterchange.png?branch=master)](https://travis-ci.org/BioInterchange/BioInterchange)
 
 BioInterchange is a tool for generating interchangable RDF from non-RDF data sources.
 
@@ -16,7 +16,10 @@ Supported RDF output formats:
 
 Ontologies used in the RDF output:
 
+* [Generic Feature Format Version 3 Ontology](http://www.biointerchange.org/ontologies.html) (GFF3O)
+* [Genome Variation Format Version 1 Ontology](http://www.biointerchange.org/ontologies.html) (GVF1O)
 * [Semanticscience Integrated Ontology](http://code.google.com/p/semanticscience/wiki/SIO) (SIO)
+* [Sequence Ontology Feature Annotation](http://www.sequenceontology.org/index.html) (SOFA)
 
 Usage
 -----
@@ -24,7 +27,7 @@ Usage
 Four interfaces to BioInterchange are available:
 
 1.  command-line tool-suite
-2.  Ruby API/Ruby gem
+2.  API (Ruby gem, Python egg)
 3.  RESTful web-service
 4.  interactive web-site
 
@@ -53,7 +56,9 @@ Output formats:
 *  `rdf.bh12.sio`
 
 
-### Ruby API/Ruby gem
+### Application Programming Interface
+
+#### Ruby
 
 The Ruby gem is under active development, so the following may or may not work out of the box.
 
@@ -63,6 +68,120 @@ To use BioInterchange in your Ruby projects, include the following line in your
 
     require 'biointerchange'
 
+#### Python
+
+Currently, there are only wrappers to the vocabularies of the ontologies that are used by
+BioInterchange available.
+
+To install the BioInterchange egg, run:
+
+    sudo easy_install rdflib
+    sudo easy_install http://www.biointerchange.org/eggs/biointerchange-0.1.2-py2.7.egg
+
+Usage examples:
+
+    import biointerchange
+    from biointerchange import *
+    
+    # Get the URI of an ontology term by label:
+    GFF3O.seqid()
+    
+    # Ambiguous labels will return an array of URIs:
+    # "start" can refer to a sub-property of "feature_properties" or "target_properties"
+    GFF3O.start()
+    # "feature_properties" can be either a datatype or object property
+    GFF3O.feature_properties()
+    
+    # Use build-in method "is_datatype_property" to resolve ambiguity:
+    # (Note: there is exactly one item in the result set, so the selection of the first item is acceptable.)
+    feature_properties = filter(lambda uri: GFF3O.is_datatype_property(uri), GFF3O.feature_properties())[0]
+    
+    # Use build-in method "with_parent" to pick properties based on their context:
+    GFF3O.with_parent(GFF3O.start(), feature_properties)
+
+#### Java
+
+Only vocabulary wrapper classes are provided for the Java API. In order to make use of the RDF generation features in BioInterchange, either use the Ruby implementation or connect Java to BioInterchange's web-services.
+
+To use the BioInterchange artifact, set-up add the following to your Maven POM file:
+
+    <repositories>
+      <repository>
+        <id>biointerchange</id>
+        <name>BioInterchange</name>
+        <url>http://www.biointerchange.org/artifacts</url>
+      </repository>
+    </repositories>
+     
+    <dependencies>
+      <dependency>
+        <groupId>org.biointerchange</groupId>
+        <artifactId>vocabularies</artifactId>
+        <version>0.1.2</version>
+      </dependency>
+    </dependencies>
+
+Usage examples:
+
+    package org.biointerchange;
+    
+    import com.hp.hpl.jena.rdf.model.*;
+    import com.hp.hpl.jena.vocabulary.*;
+    import org.apache.commons.collections.CollectionUtils;
+    import org.apache.commons.collections.Predicate;
+    
+    import java.util.Set;
+    
+    import org.biointerchange.vocabulary.*;
+    
+    /**
+     * Demo on how to make use of BioInterchange's vocabulary classes.
+     *
+     * @author Joachim Baran
+     */
+    public class App 
+    {
+        public static void main(String[] args) {
+            Resource seqid = GFF3O.seqid();
+            System.out.println("'seqid' property:");
+            printResource(seqid);
+            
+            System.out.println("'start' properties:");
+            Set<Resource> start = GFF3O.start();
+            for (Resource startSynonym : start)
+                printResource(startSynonym);
+            
+            System.out.println("'feature_properties' properties:");
+            Set<Resource> featureProperties = GFF3O.feature_properties();
+            for (Resource featurePropertiesSynonym : featureProperties)
+                printResource(featurePropertiesSynonym);
+            
+            System.out.println("'feature_properties' properties, which are a datatype property:");
+            CollectionUtils.filter(featureProperties, new Predicate() {
+                public boolean evaluate(Object o) {
+                    return GFF3O.isDatatypeProperty((Resource)o);
+                }
+            });
+            for (Resource featurePropertiesSynonym : featureProperties)
+                printResource(featurePropertiesSynonym);
+            
+            System.out.println("'start' property with parent datatype property 'feature_properties':");
+            Set<Resource> startUnderDatatypeFeatureProperties = GFF3O.withParent(start, featureProperties.iterator().next());
+            for (Resource startSynonym : startUnderDatatypeFeatureProperties)
+                printResource(startSynonym);
+        }
+        
+        private static void printResource(Resource resource) {
+            System.out.println("    " + resource.toString());
+            System.out.println("        Namespace:                            " + resource.getNameSpace());
+            System.out.println("        Local name:                           " + resource.getLocalName());
+            System.out.println("        Jena Property (rather than Resource): " + (resource instanceof Property));
+            System.out.println("        Ontology class:                       " + GFF3O.isClass(resource));
+            System.out.println("        Ontology object property:             " + GFF3O.isObjectProperty(resource));
+            System.out.println("        Ontology datatype property:           " + GFF3O.isDatatypeProperty(resource));
+        }
+    }
+
 ### RESTful Web-Service
 
 TODO
@@ -78,13 +197,34 @@ This section is only relevant if you are building newer versions of BioInterchan
 
 Note that the following set-up only works with Ruby 1.9.2p290 or newer.
 
+### Prerequisites
+
+Software requirements:
+
+* Ruby 1.9.2p290 or newer
+* Bundler gem 1.1.5 or newer
+* Rake gem 0.8.7 or newer
+
+With Ruby installed, the following commands install the additional packages:
+
+    sudo gem install bundler
+    sudo gem install rake
+    bundle
+
+The last step, `bundle`, will install gem dependencies of BioInterchange automatically.
+
+### Building Vocabulary Classes
+
 Building a new version of the Ruby vocabulary classes for GFF3, SIO, SOFA (requires that the OBO files are saves as RDF/XML using [Protege](http://protege.stanford.edu)):
 
     sudo gem install rdf
     sudo gem install rdf-rdfxml
-    echo -e "module BioInterchange\n" > lib/biointerchange/gff3.rb
-    ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-gff3> GFF3 >> lib/biointerchange/gff3.rb
-    echo -e "\nend" >> lib/biointerchange/gff3.rb
+    echo -e "require 'rdf'\nmodule BioInterchange\n" > lib/biointerchange/gff3o.rb
+    ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-gff3o> GFF3O >> lib/biointerchange/gff3o.rb
+    echo -e "\nend" >> lib/biointerchange/gff3o.rb
+    echo -e "module BioInterchange\n" > lib/biointerchange/gvf1o.rb
+    ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-gvf1o> GVF1O >> lib/biointerchange/gvf1o.rb
+    echo -e "\nend" >> lib/biointerchange/gvf1o.rb
     echo -e "module BioInterchange\n" > lib/biointerchange/sio.rb
     ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-sio> SIO >> lib/biointerchange/sio.rb
     echo -e "\nend" >> lib/biointerchange/sio.rb
@@ -92,6 +232,50 @@ 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
 
+#### 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:
+
+    ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-gff3o> GFF3O | ruby generators/pythonify.rb > supplemental/python/biointerchange/gff3o.py
+    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
+
+Generate the BioInterchange Python vocabulary egg:
+
+    cd supplemental/python
+    python setup.py bdist_egg
+
+##### Required Python Library
+
+The vocabulary wrapper makes used of RDFLib, which does not install automatically with the egg.
+
+*  (RDFLib)[https://github.com/RDFLib/rdflib]
+
+#### Java 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 Java vocabulary class wrappers can be generated as follows:
+
+    ruby generators/rdfxml.rb <path-to-rdf/xml-version-of-gff3o> GFF3O | ruby generators/javaify.rb > supplemental/java/biointerchange/src/main/java/org/biointerchange/vocabulary/GFF3O.java
+    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
+
+Generate the BioInterchange Java vocabulary artifact:
+
+    cd supplemental/java/biointerchange
+    mvn package
+
+##### Required Java Packages
+
+The following Java packages will automatically install alongside BioInterchange's Maven artifact:
+
+* (Jena Core)[http://mvnrepository.com/artifact/org.apache.jena/jena-core]
+* (Apache Commons Collections)[http://mvnrepository.com/artifact/org.apache.directory.studio/org.apache.commons.collections]
+* (SLF4J)[http://mvnrepository.com/artifact/org.slf4j/slf4j-api]
+* (Xerces)[http://mvnrepository.com/artifact/xerces/xerces]
+* (JUnit)[http://mvnrepository.com/artifact/junit/junit]
+
 ### Gem Bundling/Installing
 
     sudo bundle exec rake install
@@ -106,6 +290,7 @@ BioInterchange uses unit testing using [RSpec](http://rspec.info), where the uni
 
 Using bundler, a quick check can be carried out using:
 
+    bundle update
     bundle exec rake spec
 
 A more verbose is produced by calling `rspec` directly:
@@ -129,7 +314,6 @@ This can be solved by executing:
 
     sudo ln -s /usr/bin/llvm-gcc-4.2 /usr/bin/gcc-4.2
 
-
 Contributors
 ------------
 
@@ -139,6 +323,7 @@ In alphabetical order of the last name:
 * [Kevin B. Cohen](http://compbio.ucdenver.edu/Hunter_lab/Cohen/index.shtml)
 * [Geraint Duck](http://www.cs.man.ac.uk/~duckg)
 * [Michel Dumontier](http://dumontierlab.com)
+* [Jin-Dong Kim](http://www.bioontology.org/Jin-Dong_Kim)
 
 Cite
 ----

data/Rakefile

@@ -20,7 +20,7 @@ Jeweler::Tasks.new do |gem|
   gem.summary = %Q{An open source framework for transforming heterogeneous data formats into RDF.}
   gem.description = %Q{BioInterchange is a Ruby gem, command-line tool, web-service for turning heterogeneous data formats such as JSON, XML, GFF3, etc., into RDF."}
   gem.email = "joachim.baran@gmail.com"
-  gem.authors = ["Joachim Baran", "Kevin B. Cohen", "Geraint Duck", "Michel Dumontier"]
+  gem.authors = ["Joachim Baran", "Kevin B. Cohen", "Geraint Duck", "Michel Dumontier", "Jin-Dong Kim"]
   gem.executable = 'biointerchange'
   # dependencies defined in Gemfile
 end

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.2

data/examples/vocabulary.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'biointerchange'
+
+include BioInterchange
+
+# Get the URI of an ontology term by label:
+GFF3O.seqid()
+
+# Ambiguous labels will return an array of URIs:
+# "start" can refer to a sub-property of "feature_properties" or "target_properties"
+GFF3O.start()
+# "feature_properties" can be either a datatype or object property
+GFF3O.feature_properties()
+
+# Use build-in method "is_datatype_property" to resolve ambiguity:
+# (Note: there is exactly one item in the result set, so the selection of the first item is acceptable.)
+feature_properties = GFF3O.feature_properties().select { |uri| GFF3O.is_datatype_property(uri) }[0]
+
+# Use build-in method "with_parent" to pick properties based on their context:
+GFF3O.with_parent(GFF3O.start(), feature_properties)
+

data/generators/javaify.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/ruby
+
+private_scope = false
+java_class = nil
+namespace = nil
+comment = nil
+
+if ARGV.length == 1 then
+  namespace = ARGV[0]
+end
+
+cls = ''
+
+puts 'package org.biointerchange.vocabulary;'
+puts ''
+puts 'import java.util.Arrays;'
+puts 'import java.util.Map;'
+puts 'import java.util.HashMap;'
+puts 'import java.util.HashSet;'
+puts 'import java.util.Set;'
+puts 'import com.hp.hpl.jena.rdf.model.Property;'
+puts 'import com.hp.hpl.jena.rdf.model.Resource;'
+puts 'import com.hp.hpl.jena.rdf.model.ResourceFactory;'
+puts 'import org.apache.commons.collections.CollectionUtils;'
+puts 'import org.apache.commons.collections.Predicate;'
+puts ''
+
+STDIN.each { |line|
+  line.chomp!
+
+  if line.match('http://') then
+    if line.match(/http:\/\/[^'")]+#[^'")]+/) then
+      namespace = line.scan(/http:\/\/[^'")]+/)[0].sub(/(#).*$/, '\1') unless namespace
+    else
+      namespace = line.scan(/http:\/\/[^'")]+/)[0].sub(/\/[^\/]+$/, '/') unless namespace
+    end
+    if line.match("#{namespace}\w+") then
+      line.gsub!(namespace, '') unless line.strip.start_with?('#')
+    end
+  end
+
+  if line.start_with?('class') then
+    java_class = line.sub(/^.* /, '')
+    transduction = "public class #{java_class} {"
+  elsif line.strip.start_with?('def ') then
+    leading_spaces = line.gsub(/[^ ].*$/, '')
+    transduction = ''
+    if comment then
+      transduction << "#{("/**\n *" + comment).gsub(/^/, "#{leading_spaces}")}\n#{leading_spaces} */\n"
+      comment = nil
+    end
+    transduction << "  public static #{line.sub('?', '').sub(/self\./, '').sub(/ *def\ /, '')}"
+    method_name = transduction.sub(/^.*public static /m, '').sub(/(\(.*)?$/, '')
+    transduction.sub!("public static #{method_name}", "public static _#{method_name}_") if method_name.match(/^(true|false|class|public|private|static|return|if|while|do|clone|equals|toString|hashCode)$/)
+    variables = transduction.scan(/^\s*public static \w+\((.+)\)$/)
+    variables = variables[0][0].split(',').map { |variable| variable.strip } if variables.length > 0
+    if method_name == 'is_object_property' then
+      transduction.sub!(/public static .*$/, "public static boolean isObjectProperty(Resource #{variables[0]})")
+    elsif method_name == 'is_datatype_property' then
+      transduction.sub!(/public static .*$/, "public static boolean isDatatypeProperty(Resource #{variables[0]})")
+    elsif method_name == 'is_class' then
+      transduction.sub!(/public static .*$/, "public static boolean isClass(Resource #{variables[0]})")
+    elsif method_name == 'is_named_individual' then
+      transduction.sub!(/public static .*$/, "public static boolean isNamedIndividual(Resource #{variables[0]})")
+    elsif method_name == 'with_parent' then
+      transduction.sub!(/public static .*$/, "public static Set<Resource> withParent(Set<Resource> #{variables[0]}, final Resource #{variables[1]})")
+    elsif method_name == 'has_parent' then
+      transduction.sub!(/public static .*$/, "public static boolean hasParent(Resource #{variables[0]}, Resource #{variables[1]})")
+    else
+      if transduction.match(/\/\*\*[^E]*Either:.*Or:/m) or transduction.match(/\/\*\*[^A]*Ambiguous label\./) then
+        transduction.sub!(/public static /, 'public static Set<Resource> ')
+      else
+        transduction.sub!(/public static /, 'public static Resource ')
+      end
+    end
+    transduction << '()' unless transduction.end_with?(")")
+    transduction << ' {'
+  elsif line.strip.start_with?('#') then
+    unless comment then
+      comment = line.strip.sub(/^# ?/, ' ')
+    else
+      comment << "\n#{line.strip.gsub(/^# ?/, ' * ').gsub(/\+([^+]+)\+::/, '@param \1')}"
+    end
+    transduction = nil
+  elsif line.strip.start_with?('end') then
+    transduction = line.sub(/end/, '}')
+  elsif line.strip.start_with?('if ') or line.strip.start_with?('elsif') then
+    transduction = "#{line.sub(/ then$/, '').sub('elsif', 'else if').gsub('@@', '__').gsub(/RDF::URI\.new\(([^)]+)\)/, "_namespace_#{java_class}(\\1)").gsub(/(\w)\?\(/, '\1(')}".gsub(/\.has_key\(([^)]+)\)/, '.containsKey(\1)').gsub(/\[([^\]]+)\]/, '.get(\1)')
+    if transduction.match(/if ([^=]+|_namespace_[^=]+) ?== ?([^_].*|_namespace_.*)/)
+      transduction.sub!(/if ([^= ]+) ?== ?(\S+)\s+$/, 'if \1.equals(\2)')
+      transduction.sub!(/_namespace_\w+\('(\w+)'\)/, "\"#{namespace}\\1\"")
+    end
+    transduction.sub!(/\.equals\(("[^"]+")\)/, '.equals(ResourceFactory.createResource(\1))')
+    transduction.sub!(/if /, 'if (')
+    transduction.sub!(/$/, ') {')
+  elsif line.strip.start_with?('return [') then
+    transduction = line.sub(/return \[/, 'return new HashSet<Resource>(Arrays.asList(new Resource[] {').sub(/\]$/, '}));').gsub(/RDF::URI\.new\(([^)]+)\)/, "_namespace_#{java_class}(\\1)")
+  elsif line.strip.start_with?('private') then
+    private_scope = true
+    transduction = "  private static Resource _namespace_#{java_class}(String accession) {\n"
+    transduction << "    if (isClass(ResourceFactory.createResource(\"#{namespace}\" + accession))) {\n"
+    transduction << "      return ResourceFactory.createResource(\"#{namespace}\" + accession);\n"
+    transduction << "    } else {\n"
+    transduction << "      return ResourceFactory.createProperty(\"#{namespace}\" + accession);\n"
+    transduction << "    }\n"
+    transduction << "  }\n\n"
+  else
+    transduction = line.gsub('@@', '__').gsub(/RDF::URI\.new\(([^)]+)\)/, "_namespace_#{java_class}(\\1)").gsub(/(\w+)\.select ?\{ ?\|(\w+)\| ?(.*[^ ]) ?\}/, 'new HashSet<Resource>(CollectionUtils.select(\1, new Predicate() { public boolean evaluate(Object \2) { return \3; } }))').gsub(/(\w)\?\(/, '\1(').gsub('has_parent(', 'hasParent((Resource)').gsub(/\[([^\]]+)\]/, '.get(\1)')
+    transduction.gsub!('__', '__') unless line.strip.start_with?('@@')
+    transduction << ';' unless line.strip.empty?
+  end
+
+  if transduction and transduction.strip.start_with?('__') then
+    variable = transduction.scan(/__\w+/)[0]
+    map = {}
+    map = Hash[*transduction.sub(/^.* \{/, '').sub(/\};/, '').split(',').map { |assignment| assignment.split('=>').map { |kv| kv.strip } }.flatten.map { |function| if function.match(/'\w+'/) then "#{namespace}#{function.scan(/'\w+'/)[0].gsub(/'/, '')}" else nil end }.compact ] if transduction.match(/\{\s*\S+.*\}/)
+    transduction = "  private static Map<Resource, Resource> #{variable} = _init_#{variable}();\n\n"
+    transduction << "  private static Map<Resource, Resource> _init_#{variable}() {\n"
+    transduction << "    Map<Resource, Resource> map = new HashMap<Resource, Resource>();\n\n"
+    map.each_pair { |key, value| transduction << "    map.put(ResourceFactory.createResource(\"#{key}\"), ResourceFactory.createResource(\"#{value}\"));\n" }
+    transduction << "\n"
+    transduction << "    return map;\n"
+    transduction << "  }\n"
+  end
+
+  cls << "#{transduction}\n".gsub(/'/, '"') if transduction
+
+}
+
+puts cls
+