bio-publisci 0.0.8 → 0.1.0

data/lib/bio-publisci/dataset/dataset_for.rb

@@ -3,8 +3,15 @@ module PubliSci
   class Dataset
     extend PubliSci::Interactive
 
-    def self.for(object, options={}, ask_on_ambiguous=true)
+    def self.reader_registry
+      @reader_registry ||= {}
+    end
 
+    def self.register_reader(extension,klass)
+      reader_registry[extension] = klass
+    end
+
+    def self.for(object, options={}, ask_on_ambiguous=true)
       if options == false || options == true
         ask_on_ambiguous = options
         options = {}
@@ -20,13 +27,20 @@ module PubliSci
             raise "Can't load file #{object}; file type inference not yet implemented"
           end
 
-          case extension
-          when ".RData"
-            r_object(object, options, ask_on_ambiguous)
-          when /.csv/i
-            PubliSci::Reader::CSV.new.automatic(object,nil,options,ask_on_ambiguous)
+          if reader_registry.keys.include? extension
+            reader_registry[extension].new.automatic(object,options,ask_on_ambiguous)
           else
-            false
+            case extension
+            when ".RData"
+              r_object(object, options, ask_on_ambiguous)
+            when /.csv/i
+              PubliSci::Readers::CSV.new.automatic(object,nil,options,ask_on_ambiguous)
+            when /.arff/i
+              PubliSci::Readers::ARFF.new.generate_n3(object)
+            else
+              # false
+              raise "Unkown Extension #{extension}"
+            end
           end
         elsif object =~ %r{htt(p|ps)://.+}
           self.for(download(object).path, options, ask_on_ambiguous) || RDF::Statement.new(RDF::URI(object), RDF::URI('http://semanticscience.org/resource/hasValue'), IO.read(download(object).path)).to_s
@@ -44,12 +58,6 @@ module PubliSci
       end
     end
 
-    # def for_remote
-    #   addr = object
-    #   tmp = download(object)
-    #   self.for(tmp.path) || "#{addr} <http://semanticscience.org/resource/"
-    # end
-
     def self.download(uri)
       out = Tempfile.new(uri.split('/').last)
       out.write open(uri).read
@@ -57,15 +65,6 @@ module PubliSci
       out
     end
 
-    # private
-    # def self.reader_exists?(object)
-    #   if object.is_a? String
-    #     if File.exist? object
-
-    #   elsif
-    #   end
-    # end
-
     def self.r_object(object, options={}, ask_on_ambiguous=true)
       if object.is_a? String
         con = Rserve::Connection.new
@@ -80,7 +79,7 @@ module PubliSci
         r_classes = con.eval("class(#{var})").to_ruby
 
         if r_classes.include? "data.frame"
-          df = PubliSci::Reader::Dataframe.new
+          df = PubliSci::Readers::Dataframe.new
           unless options[:dimensions] || !ask_on_ambiguous
             dims = con.eval("names(#{var})").to_ruby
             puts "Which dimensions? #{dims}"
@@ -101,7 +100,7 @@ module PubliSci
           df.generate_n3(con.eval(var),var,options)
 
         elsif r_classes.include? "cross"
-          bc = PubliSci::Reader::RCross.new
+          bc = PubliSci::Readers::RCross.new
 
           unless options[:measures] || !ask_on_ambiguous
             pheno_names = con.eval("names(#{var}$pheno)").to_ruby
@@ -122,7 +121,7 @@ module PubliSci
           bc.generate_n3(con, var, base, options)
 
         elsif r_classes.include? "matrix"
-          mat = PubliSci::Reader::RMatrix.new
+          mat = PubliSci::Readers::RMatrix.new
 
           unless options[:measures] || !ask_on_ambiguous
             puts "Row label"
@@ -149,13 +148,13 @@ module PubliSci
 
           mat.generate_n3(con, var, base, options)
         else
-          raise "no PubliSci::Reader found for #{r_classes}"
+          raise "no PubliSci::Readers found for #{r_classes}"
         end
 
       elsif object.is_a? Rserve::REXP
         if object.attr.payload["class"].payload.first
 
-          df = PubliSci::Reader::Dataframe.new
+          df = PubliSci::Readers::Dataframe.new
 
           var = nil
 

data/lib/bio-publisci/metadata/metadata_model.rb

@@ -1,27 +1,25 @@
-module PubliSci
-  class Metadata
-    module Model
-      PROV ||= RDF::Vocabulary.new(RDF::URI.new('http://www.w3.org/ns/prov#'))
-      QB ||= RDF::Vocabulary.new(RDF::URI.new('http://purl.org/linked-data/cube#'))
-      DCT ||= RDF::Vocabulary.new(RDF::URI.new('http://purl.org/dc/terms/'))
-      # dct:title "#{fields[:title]}";
-      # dct:creator "#{fields[:creator]}";
-      # rdfs:comment "#{fields[:description]}";
-      # dct:description "#{fields[:description]}";
-      # dct:issued "#{fields[:date]}"^^xsd:date.
+begin
+  require 'spira'
+  module PubliSci
+    class Metadata
+      module Model
+        PROV ||= RDF::Vocabulary.new(RDF::URI.new('http://www.w3.org/ns/prov#'))
+        QB ||= RDF::Vocabulary.new(RDF::URI.new('http://purl.org/linked-data/cube#'))
+        DCT ||= RDF::Vocabulary.new(RDF::URI.new('http://purl.org/dc/terms/'))
 
-      class Meta < Spira::Base
-        type PROV.Entity
-        type QB.DataSet
-        property :label, predicate: RDF::RDFS.label
-        property :comment, predicate: RDF::RDFS.comment
-        property :description, predicate: DCT.description
-        property :creator, predicate: DCT.creator
-        property :issued, predicate: DCT.issued
+
+        class Meta < Spira::Base
+          type PROV.Entity
+          type QB.DataSet
+          property :label, predicate: RDF::RDFS.label
+          property :comment, predicate: RDF::RDFS.comment
+          property :description, predicate: DCT.description
+          property :creator, predicate: DCT.creator
+          property :issued, predicate: DCT.issued
+        end
       end
     end
   end
-end
-# rescue LoadError
-#   puts "spira not installed, ORM unavailable"
-# end
+rescue LoadError
+  # puts "spira not installed, ORM unavailable"
+end

data/lib/bio-publisci/metadata/prov/model/prov_models.rb

@@ -1,7 +1,7 @@
 require 'rdf/4store'
 
-# begin
-  # require 'spira'
+begin
+  require 'spira'
 
 module PubliSci
   class Prov
@@ -104,6 +104,6 @@ module PubliSci
     end
   end
 end
-# rescue LoadError
-#   puts "spira not installed, ORM unavailable"
-# end
+rescue LoadError
+  # puts "spira not installed, ORM unavailable"
+end

data/lib/bio-publisci/output.rb

@@ -1,5 +1,5 @@
 module PubliSci
-  module Reader
+  module Readers
     module Output
       def output(string, options={},append=false)
         options[:type] = [:string] unless options[:type]

data/lib/bio-publisci/parser.rb

@@ -1,8 +1,8 @@
 module PubliSci
 	module Parser
 
-    def is_uri?(string)
-      RDF::Resource(string).valid?
+    def is_uri?(obj)
+      RDF::Resource(obj).valid?
     end
 
     def sanitize(array)
@@ -14,7 +14,7 @@ module PubliSci
           if is_uri? entry
             processed << entry.gsub(/[\s]/,'_')
           else
-            processed << entry.gsub(/[\s\.]/,'_')
+            processed << entry.gsub(/[\s]/,'_')
           end
         else
           processed << entry
@@ -95,18 +95,24 @@ module PubliSci
 	    end
     end
 
-    def to_resource(obj, options)
+    def to_resource(obj, options={})
       if obj.is_a? String
-        obj = "<#{obj}>" if is_uri? obj
 
-        #TODO decide the right way to handle missing values, since RDF has no null
-        #probably throw an error here since a missing resource is a bigger problem
-        obj = "NA" if obj.empty?
+        if is_uri? obj
+          obj = RDF::Resource(obj).to_base unless obj[/\w+:\w/]
+        else
+
+          #TODO decide the right way to handle missing values, since RDF has no null
+          #probably throw an error here since a missing resource is a bigger problem
+          obj = "rdf:nil" if obj.empty?
+          obj=  obj.to_s.gsub(' ','_')
+        end
 
+        obj
         #TODO  remove special characters (faster) as well (eg '?')
-        obj.gsub(' ','_').gsub('?','')
+
       elsif obj == nil && options[:encode_nulls]
-        '"NA"'
+        'rdf:nil'
       elsif obj.is_a? Numeric
         #resources cannot be referred to purely by integer (?)
         "n"+obj.to_s
@@ -115,7 +121,7 @@ module PubliSci
       end
     end
 
-    def to_literal(obj, options)
+    def to_literal(obj, options={})
       if obj.is_a? String
         # Depressing that there's no more elegant way to check if a string is
         # a number...
@@ -128,12 +134,124 @@ module PubliSci
         end
       elsif obj == nil && options[:encode_nulls]
         #TODO decide the right way to handle missing values, since RDF has no null
-        '"NA"'
+        'rdf:nil'
+      else
+        obj
+      end
+    end
+
+    def is_complex?(obj)
+      obj.is_a? Array
+    end
+
+    def add_node(n,str="")
+
+      raise "need index or identifier to generate blank nodes" unless n
+      raise "need base string or blank string for blank node" unless str.is_a? String
+      if str["node"]
+        ret = str[0..-2] + "/#{n}" + ">"
+        ret
+        # str[0..-2] + "/#{n}" + ">"
       else
+        "<node/#{n}>"
+      end
+    end
+
+    def encode_value(obj,options={}, node_index=nil, node_str = "")
+      if RDF::Resource(obj).valid?
+        to_resource(obj,options)
+      elsif obj && obj.is_a?(String) && (obj[0]=="<" && obj[-1] = ">")
         obj
+      elsif obj.is_a?(Array)        
+        node_str = add_node(node_index,node_str)
+        ["#{node_str}" ] + [bnode_value(obj, node_index, node_str, options)]
+      else
+        to_literal(obj,options)
       end
     end
 
+    def bnode_value(obj, node_index, node_str, options)
+      # TODO - Implement proper recursion
+      # TODO - check if object is "a" (rdf:type) => or convert rdf:type to "a"
+      str = ""
+      subnodes = []
+      if obj.is_a?(Array) # && obj.size == 2
+        if obj.size == 2
+          if obj[0].is_a?(String)
+            if is_complex?(obj[1])
+              str << "#{to_resource(obj[0])} #{add_node(node_index,node_str)} . \n"            
+              subnodes << encode_value(obj[1], options, node_index, node_str)
+            else
+              str << "#{to_resource(obj[0])} #{encode_value(obj[1], options, node_index, node_str)} "
+            end
+          elsif obj[0].is_a?(Array) && obj[1].is_a?(Array)
+            newnode = add_node(0,node_str)
+            v1 = bnode_value(obj[0], 0, node_str, options)
+            v2 = bnode_value(obj[1], 1, node_str, options)
+
+            if v1.is_a? Array
+              subnodes << v1
+              v1 = nil
+            end
+
+            if v2.is_a? Array
+              subnodes << v2
+              v2 = nil
+            end
+
+            if v1
+              str << "#{v1} ;"
+            end
+
+            str << "\n#{v2} .\n" if v2
+          end
+        elsif obj.all?{|ent| ent.is_a? Array}
+          obj.each{|ent|
+            bn = bnode_value(ent,node_index,node_str,options)
+            if bn.is_a? String
+              str << bn + "\n"
+            else
+              str << bn[0] + "\n"
+              subnodes << bn[1]
+            end
+          }
+        end
+      else
+        raise "Invalid Structured value: #{obj}"
+      end
+
+      if subnodes.size > 0 
+        [str, subnodes.flatten].flatten
+      else
+        str
+      end
+    end
+
+    def turtle_indent(turtle_str)
+      tabs = 0
+      turtle_str.split("\n").map{|str|
+        case str[-1]
+        when "."
+          last_tabs = tabs
+          tabs = 0
+          ("  " * last_tabs) + str
+        when ";"
+          last_tabs = tabs
+          tabs = 1 if tabs == 0
+          ("  " * last_tabs) + str
+        else
+          last_tabs = tabs
+          if str.size < 2
+            tabs = 0
+          else
+            tabs += 1
+          end
+          ("  " * last_tabs) + str
+        end
+      }.join("\n")
+
+    end
+
     def strip_uri(uri)
       uri = uri.to_s.dup
       uri[-1] = '' if uri[-1] == '>'

data/lib/bio-publisci/post_processor.rb

@@ -0,0 +1,95 @@
+module PubliSci
+
+  class SADI_request
+    def self.send_request(service, turtle)
+      response = RestClient.post(service, turtle, content_type: 'text/rdf+n3', accept: 'text/rdf+n3')
+      RDF::Repository.new << RDF::Turtle::Reader.new(response)
+    end
+
+    def self.fetch_async(service,turtle)
+      gr = send_request(service,turtle)
+
+      rdfs = RDF::Vocabulary.new("http://www.w3.org/2000/01/rdf-schema#")
+      polls = RDF::Query.execute(gr) do
+        pattern [:obj, rdfs.isDefinedBy, :def]
+      end
+
+      poll_time = {}
+      polls.map(&:def).select{|res| res.to_s["?poll="]}.each{|poll_url|
+        poll_time[poll_url.to_s] = Time.now
+      }
+
+      results = []
+      until results.size == poll_time.keys.size
+        poll_url = poll_time.sort_by{|k,v| v}.first.first
+        t = Time.now
+
+        if poll_time[poll_url] > t
+          puts "no poll urls ready, sleeping #{poll_time[poll_url] - t}"
+          sleep poll_time[poll_url] - t
+        end
+
+        result = poll(poll_url)
+        if result.is_a? Fixnum
+          puts "#{poll_url} Response not ready, waiting #{result}"
+          poll_time[poll_url] = Time.now + result
+        else
+          results << result
+        end
+      end
+
+      results
+    end
+
+    def self.poll(url)
+      resp = RestClient.get(url, accept: 'text/rdf+n3'){ |response, request, result, &block|
+        if [301, 302, 307].include? response.code
+          wait = response.headers[:retry_after]
+          if wait
+            return wait.to_i
+          else
+            response.follow_redirection(request, result, &block)
+          end
+        else
+          response.return!(request, result, &block)
+        end
+      }
+      resp.body
+    end
+
+    def self.try_fetch(poll_url)
+      puts "polling #{poll_url}"
+      loop do
+        result = poll(poll_url)
+        if result.is_a? Fixnum
+          return result
+        else
+          return RDF::Repository.new << RDF::Turtle::Reader.new(result)
+        end
+      end
+    end
+  end
+
+  class PostProcessor
+
+
+    def self.process(infile,outfile,pattern)
+
+      tmp = Tempfile.new('annot_temp')
+      open(infile).each_line{|line|
+        if line[pattern]
+          line.scan(pattern).each{|loc|
+            line.sub!(pattern,yield(loc.first))
+          }
+          tmp.write(line)
+        else
+          tmp.write(line)
+        end
+      }
+
+      FileUtils.copy(tmp.path,outfile)
+
+      outfile
+    end
+  end
+end