publisci 0.1.2

data/lib/bio-publisci/mixins/dereferencable.rb

@@ -0,0 +1,34 @@
+module PubliSci
+  class Prov
+    module Dereferencable
+      def dereference
+        self.map{|x|
+          if x.is_a? Symbol
+            raise "Unknown#{method.capitalize}: #{x}" unless Prov.registry[method.to_sym][x]
+            Prov.registry[method.to_sym][x]
+          else
+            x
+          end
+        }
+      end
+
+      def method
+        raise "must be overridden"
+      end
+
+      def [](index)
+        self.dereference.fetch(index)
+        # if self.fetch(index).is_a? Symbol
+        #   raise "UnknownEntity: #{self.fetch(index)}" unless Prov.entities[self.fetch(index)]
+        #   Prov.entities[self.fetch(index)]
+        # else
+        #   self.fetch(index)
+        # end
+      end
+
+      def map_(&blk)
+        self.dereference.map(&blk)
+      end
+    end
+  end
+end

data/lib/bio-publisci/mixins/registry.rb

@@ -0,0 +1,27 @@
+module PubliSci
+  module Registry
+    def register(name,object)
+      # puts "register #{name} #{object} #{associations.size}"
+      name = name.to_sym if name
+      if symbol_for(object)
+        sub = symbol_for(object)
+      else
+        sub = object.class.to_s.split('::').last.downcase.to_sym
+      end
+      if name
+        (registry[sub] ||= {})[name] = object
+      else
+        (registry[sub] ||= []) << object
+      end
+    end
+
+    def registry
+      @registry ||= {}
+    end
+
+    #should be overridden
+    def symbol_for(object)
+      false
+    end
+  end
+end

data/lib/bio-publisci/mixins/vocabulary.rb

@@ -0,0 +1,8 @@
+module PubliSci
+  module Vocabulary
+    def vocabulary(url)
+      raise "InvalidVocabulary: #{url} is not a valid URI" unless RDF::Resource(url).valid?
+      RDF::Vocabulary.new(url)
+    end
+  end
+end

data/lib/bio-publisci/output.rb

@@ -0,0 +1,27 @@
+module PubliSci
+  module Readers
+    module Output
+      def output(string, options={},append=false)
+        options[:type] = [:string] unless options[:type]
+        base = options[:file_base]
+        name = options[:file_name]
+        types = Array(options[:type])
+
+        if types.include? :print
+          puts string
+        end
+
+        if types.include? :file
+          raise "no file specified output" unless name
+
+          method = append ? 'a' : 'w'
+          open("#{base}#{name}", method) { |f| f.write str }
+        end
+
+        if types.include? :string
+          string
+        end
+      end
+    end
+  end
+end

data/lib/bio-publisci/parser.rb

@@ -0,0 +1,266 @@
+module PubliSci
+	module Parser
+
+    def is_uri?(obj)
+      RDF::Resource(obj).valid?
+    end
+
+    def sanitize(array)
+      #remove spaces and other special characters
+      array = Array(array)
+      processed = []
+      array.map{|entry|
+        if entry.is_a? String
+          if is_uri? entry
+            processed << entry.gsub(/[\s]/,'_')
+          else
+            processed << entry.gsub(/[\s]/,'_')
+          end
+        else
+          processed << entry
+        end
+      }
+      processed
+    end
+
+    def sanitize_hash(h)
+      mappings = {}
+      h.keys.map{|k|
+        if(k.is_a? String)
+          mappings[k] = k.gsub(' ','_')
+        end
+      }
+
+      h.keys.map{|k|
+        h[mappings[k]] = h.delete(k) if mappings[k]
+      }
+
+      h
+    end
+
+		def load_string(string,repo=RDF::Repository.new)
+			f = Tempfile.new('repo')
+			f.write(string)
+			f.close
+			repo.load(f.path, :format => :ttl)
+			f.unlink
+			repo
+		end
+
+		def get_ary(query_results,method='to_s')
+      query_results.map{|solution|
+        solution.to_a.map{|entry|
+          if entry.last.respond_to? method
+	          entry.last.send(method)
+	        else
+	        	entry.last.to_s
+	        end
+        }
+      }
+    end
+
+    def get_hashes(query_results,method=nil)
+    	arr=[]
+    	query_results.map{|solution|
+    		h={}
+    		solution.map{|element|
+					if method && element[1].respond_to?(method)
+					 	h[element[0]] = element[1].send(method)
+					else
+					 	h[element[0]] = element[1]
+					end
+    		}
+    		arr << h
+    	}
+    	arr
+    end
+
+    def observation_hash(query_results,shorten_uris=false,method='to_s')
+    	h={}
+    	query_results.map{|sol|
+    		(h[sol[:observation].to_s] ||= {})[sol[:property].to_s] = sol[:value].to_s
+    	}
+
+    	if shorten_uris
+	    	newh= {}
+	    	h.map{|k,v|
+	    		newh[strip_uri(k)] ||= {}
+	    		v.map{|kk,vv|
+	    			newh[strip_uri(k)][strip_uri(kk)] = strip_uri(vv)
+	    		}
+	    	}
+	    	newh
+	    else
+	    	h
+	    end
+    end
+
+    def to_resource(obj, options={})
+      if obj.is_a? String
+
+        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 '?')
+
+      elsif obj == nil && options[:encode_nulls]
+        'rdf:nil'
+      elsif obj.is_a? Numeric
+        #resources cannot be referred to purely by integer (?)
+        "n"+obj.to_s
+      else
+        obj
+      end
+    end
+
+    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...
+        if val = Integer(obj) rescue nil
+          val
+        elsif val = Float(obj) rescue nil
+          val
+        else
+          '"'+obj+'"'
+        end
+      elsif obj == nil && options[:encode_nulls]
+        #TODO decide the right way to handle missing values, since RDF has no null
+        '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] == '>'
+      uri.to_s.split('/').last.split('#').last
+    end
+
+    def strip_prefixes(string)
+      string.to_s.split(':').last
+    end
+
+	end
+end

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