publisci 0.1.2

data/lib/bio-publisci/writers/csv.rb

@@ -0,0 +1,31 @@
+module PubliSci
+  module Writers
+    class CSV < Base
+      def build_csv(data,components=nil)
+        unless components
+          components = data.values.map(&:keys).uniq
+        end
+        str = components.join(',') + "\n"
+        data.map {|d| str << Hash[d[1]].values.join(',') + "\n" }
+        str[-1]=""
+        str
+      end
+
+      def from_turtle(turtle_file, verbose=false)
+        puts "loading #{turtle_file}" if verbose
+        repo = RDF::Repository.load(turtle_file)
+        puts "loaded #{repo.size} statements into temporary repo" if verbose
+
+        dims = dimensions(repo)
+        meas = measures(repo)
+        data = observations(repo)
+        build_csv(data, (dims | meas))
+      end
+
+      def from_store(repo,dataSet=nil, variable_out=nil, verbose=false)
+        data = observations(repo,dataSet,true)
+        build_csv(data)
+      end
+    end
+  end
+end

data/lib/bio-publisci/writers/dataframe.rb

@@ -0,0 +1,81 @@
+module PubliSci
+  module Writers
+    module Dataframe
+
+    def framestring(name,vectors)
+      framestr = "#{name} = data.frame("
+      vectors.map{ |k,v| framestr << k + '=' + k +','}
+      framestr[-1] = ')'
+      framestr
+    end
+
+    def get_vectors(variable_name, helper, repo)
+      column_names = helper.get_ary(helper.execute(helper.property_names(variable_name), repo)).flatten.map{|n| n.gsub(' Component','')}
+      vectors = {}
+      column_names.map{|n|
+        vectors[n] = helper.get_ary(helper.execute(helper.property_values(variable_name,n),repo),'to_f').flatten unless n == "refRow"
+      }
+      vectors
+    end
+
+    def create_dataframe(name, connection, rows, vectors)
+      connection.assign('rows', rows)
+      vectors.map{ |k,v|
+        connection.assign(k,v)
+      }
+      connection.eval(framestring(name,vectors))
+      connection.eval("row.names(#{name}) <- rows")
+      connection.eval(name)
+    end
+
+    def save_workspace(connection, loc)
+      connection.eval "save.image(#{loc})"
+    end
+
+    def get_rownames(variable, helper, repo)
+      rows = helper.get_ary(helper.execute(helper.row_names(variable), repo)).flatten
+    end
+
+  end
+
+  class Builder
+    include PubliSci::Writers::Dataframe
+
+
+    def from_turtle(turtle_file, connection, variable_in=nil, variable_out=nil, verbose=true, save=true)
+      unless variable_in && variable_out
+        puts "no variable specified. Simple inference coming soon" if verbose
+        return
+      end
+      puts "loading #{turtle_file}" if verbose
+      repo = RDF::Repository.load(turtle_file)
+      puts "loaded #{repo.size} statements into temporary repo" if verbose
+      # connection = Rserve::Connection.new
+      query = PubliSci::QueryHelper.new
+      rows = get_rownames(variable_in, query, repo)
+      puts "frame has #{rows.size} rows" if verbose
+
+      vectors = get_vectors(variable_in, query, repo)
+      puts "got vectors of size #{vectors.first.last.size}" if verbose && vectors.first
+
+      create_dataframe(variable_out, connection, rows, vectors)
+      save_workspace(connection, connection.eval('getwd()').to_ruby) if save
+    end
+
+    def from_store(endpoint_url,connection,variable_in=nil, variable_out=nil, verbose=true, save=true)
+      unless variable_in && variable_out
+        puts "no variable specified. Simple inference coming soon" if verbose
+        return
+      end
+      puts "connecting to endpoint at #{endpoint_url}" if verbose
+      sparql = SPARQL::Client.new(endpoint_url)
+      # client = PubliSci::Client.new
+      query = PubliSci::QueryHelper.new
+
+      rows = query.get_ary(sparql.query(query.row_names(variable_in))).flatten
+
+    end
+
+    end
+  end
+end

data/lib/bio-publisci/writers/json.rb

@@ -0,0 +1,18 @@
+module PubliSci
+  module Writers
+    class JSON < Base
+      def build_json(data)
+        data.values.to_json
+      end
+
+      def from_turtle(file,select_dataset=nil,shorten_url=true)
+        rb = turtle_to_ruby(file,select_dataset,shorten_url)
+        build_json(rb[:data])
+      end
+
+      def from_store(file,select_dataset=nil,shorten_url=true)
+        build_json(repo_to_ruby(file,select_dataset,shorten_url)[:data])
+      end
+    end
+  end
+end

data/lib/r2rdf.rb

@@ -0,0 +1,226 @@
+require 'rserve'
+require 'rdf/4store'
+Dir[File.dirname(__FILE__) + '/vocabs/*.rb'].each {|file| require file }
+
+class QTL2RDF
+
+  attr_accessor :port_4s
+
+  def initialize(dir='.')
+    @dir = File.absolute_path(dir)
+    @R = Rserve::Connection.new()
+    if File.exist?(dir + "/.RData")
+      # puts "loading workspace #{dir}/.RData"
+      @R.eval("load('#{dir}/.RData')")
+    end
+
+    if File.exist?(dir + "/.Rhistory")
+      # puts "loading history #{dir}/.Rhistory"
+      @R.eval("loadhistory('#{dir}/.Rhistory')")
+    end
+
+    @port_4s = 8080
+  end
+
+  def load_workspace(dir=@dir,file='.RData')
+    path = File.join(File.absolute_path(dir),file)
+      if File.exist?(path)
+        # puts "loading workspace #{dir}/.RData"
+        @R.eval("load('#{path}')")
+      else
+        puts "Couldn't find #{path}"
+      end
+  end
+
+  def load_history(dir=@dir,file='.Rhistory')
+    path = File.join(File.absolute_path(dir),file)
+    if File.exist?(path)
+      # puts "loading history #{dir}/.Rhistory"
+      @R.eval("loadhistory('#{path}')")
+    else
+      puts "Couldn't find #{path}"
+    end
+  end
+
+  def dump_dataframe(var)
+    h = {}
+    h[var] = {"attr" => {}, "rows"=>{}}
+
+    x = @R.eval(var)
+
+    x.attr.payload.keys.map{ |a|
+      h[var]["attr"][a] = x.attr.payload[a].to_ruby
+    }
+
+    rownames = x.attr.payload["row.names"].to_ruby
+    colnames = x.payload.keys
+    rownames.each_with_index.map{ |row,i|
+      rh = {}
+      colnames.map{ |col|
+        rh[col] = x.payload[col].to_a[i].to_f
+      }
+      h[var]["rows"][row] = rh
+    }
+
+    h
+  end
+
+  def dump(var)
+    x = @R.eval(var)
+    if x.attr
+      # if x.attr.payload["class"].to_a.include? 'data.frame'
+        dump_dataframe var
+      # end
+    else
+      if x.list?
+        type = x.payload.class.to_s.split("::").last # seems hacky, but probably only temporary
+        value = x.payload.map(&:payload).flatten
+      elsif x.payload.size == 1
+        type = x.class.to_s.split("::").last 
+        value = x.payload.first
+      else
+        type = x.class.to_s.split("::").last 
+        value = x.payload
+      end
+      {var => {"attr"=>{"class" => type}, :value => value}}
+    end
+  end
+
+  def triples_for(h)
+    statements = []
+    base_n = RDF::Node.new
+    attr_n = RDF::Node.new
+    vocab = RDF::Vocabulary.new('http://www.placeholder.com/rqtl#')
+    base_uri = RDF::URI.new('http://www.placeholder.com/')
+    var = h.keys.first
+
+    statements << RDF::Statement.new(base_n, RDF::DC.title, RDF::Literal.new(var))
+
+    if h[var].is_a? Hash
+      if(h[var]["attr"])
+        statements << RDF::Statement.new(base_n, vocab.attributes, attr_n)
+        h[var]["attr"].map{ |k,v| statements << RDF::Statement.new(attr_n, vocab[k], RDF::Literal.new(v)) }
+      end
+
+      if h[var]["rows"]
+        h[var]["rows"].map{ |k,v|
+          row_uri = base_uri.join("row#{k}")
+          statements << RDF::Statement.new(row_uri, vocab.row_of, base_n)
+          statements << RDF::Statement.new(row_uri, RDF::DC.title, k)
+          num = 1 # maybe container support exists in RDF.rb?
+          v.map { |j,u|
+            n = RDF::Node.new
+            statements << RDF::Statement.new(n, vocab.entry_of, row_uri)
+            statements << RDF::Statement.new(n, RDF::DC.title, j)
+            statements << RDF::Statement.new(n, RDF::DC.title, j)
+            statements << RDF::Statement.new(n, vocab["_#{num}"], RDF::Literal.new(u))
+            num += 1
+          }
+        }
+      end
+
+      if h[var].has_key? :value        
+        statements << RDF::Statement.new(base_n, vocab.has_value, RDF::Literal.new(h[var][:value]))
+      end
+    else
+      statements << RDF::Statement.new(base_n, vocab.has_value, RDF::Literal.new(h[var]))
+    end
+    statements
+  end
+
+  #get n3 for a dataframe using datacube vocabulary
+  #still needs range for measures and dimensions, sdmx-dimension equivalent for rows
+  def n3_for(h)
+    str = <<-EOF
+@prefix : <http://www.rqtl.org/ns/#> .
+@prefix qb: <http://purl.org/linked-data/cube#> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix prop: <http://www.rqtl.org/dc/properties/> .
+@prefix cs: <http://www.rqtl.org/dc/cs/> .
+
+    EOF
+    #@prefix sdmx-measure: <http://purl.org/linked-data/sdmx/2009/measure#>
+    var = h.keys.first
+    names = h[var]["attr"]["names"]
+
+    #generate data structure definition
+    str << ":dsd-#{var} a qb:DataStructureDefinition ;\n"
+    str << "\tqb:component cs:refRow ,\n"
+    names.map{ |n|
+      str << "\t\tcs:#{n} ,\n\n"
+    }
+    str[-3]="."
+
+    #generate component specifications
+    str << "cs:refRow a qb:ComponentSpecification ;\n\trdfs:label \"Component Specification for Row\" ;\n\tqb:dimension prop:refRow .\n\n"
+    names.map{ |n|
+      str << "cs:#{n} a qb:ComponentSpecification ;\n\trdfs:label \"Component Specification for #{n}\" ;\n\tqb:measure prop:#{n} .\n\n"
+    }
+
+    #generate dataset definition
+    str << ":dataset-#{var} a qb:DataSet ;\n\trdfs:label \"#{var}\"@en ;\n\tqb:structure :dsd-#{var} .\n\n"
+
+    #add DimensionProperty for row
+    str << <<-EOF
+:refRow a rdf:Property, qb:DimensionProperty ;
+\trdfs:label "Row"@en .
+
+    EOF
+
+    #generate MeasureProperties
+    names.map{ |n|
+      str << ":#{n} a rdf:Property, qb:MeasureProperty ;\n\trdfs:label \"#{n}\"@en .\n\n"
+    }
+
+    #add observations
+    h[var]["rows"].map{|k,v|
+      str << ":obs#{k} a qb:Observation ;\n\tqb:dataSet :dataset-#{var} ;\n\tprop:refRow :#{k} ;\n"
+      v.map{|l,w|
+        str << "\tprop:#{l} #{w} ;\n"
+      }
+      str << "\t.\n\n"
+    }
+
+    #add row property definitions
+    h[var]["rows"].map{|k,v|
+      str << ":#{k} a prop:refRow ;\n\trdfs:label \"#{k}\" .\n\n"
+    }
+
+    str
+  end
+
+  def statements_for(string,type=:turtle)
+    statements = []
+    RDF::Reader.for(:turtle).new(string) do |reader|
+      reader.each_statement do |statement|
+        # puts statement.inspect
+        statements << statement
+      end
+    end
+    statements
+  end
+
+  def turtletype_for(value)
+    #use for providing ranges to better define data (later)
+  end
+
+  def load_statements(statements)
+    #maybe a better way than inserting statements one at a time?
+    repo = RDF::FourStore::Repository.new("http://localhost:#{@port_4s}")
+    statements.each{|s| repo.insert(s)}
+  end
+
+  def to_store(var, parse_type=:turtle)
+    load_statements(triples_for(dump(var))) if parse_type==:ntriples
+    
+    #TODO: this doesn't work (needs to be converted to statments or 
+    # a way of inserting raw strings needs to be figured out.
+    load_statements(n3_for(dump(var))) if parse_type==:turtle
+  end
+
+  def vars
+    @R.eval("ls()").payload
+  end
+
+end

data/lib/template_bak.rb

@@ -0,0 +1,12 @@
+# Please require your code below, respecting the naming conventions in the
+# bioruby directory tree.
+#
+# For example, say you have a plugin named bio-plugin, the only uncommented
+# line in this file would be 
+#
+#   require 'bio/bio-plugin/plugin'
+#
+# In this file only require other files. Avoid other source code.
+
+require 'bio-publisci/publisci.rb'
+

data/lib/template_bak/publisci.rb

@@ -0,0 +1,3 @@
+
+module BioPublisci
+end

data/lib/vocabs/cc.rb

@@ -0,0 +1,18 @@
+module RDF
+  ##
+  # Creative Commons (CC) vocabulary.
+  #
+  # @see http://creativecommons.org/ns
+  class CC < Vocabulary("http://creativecommons.org/ns#")
+    property :attributionName
+    property :attributionURL
+    property :deprecatedOn
+    property :jurisdiction
+    property :legalcode
+    property :license
+    property :morePermissions
+    property :permits
+    property :prohibits
+    property :requires
+  end
+end

data/lib/vocabs/cert.rb

@@ -0,0 +1,13 @@
+module RDF
+  ##
+  # W3 Authentication Certificates (CERT) vocabulary.
+  #
+  # @see   http://www.w3.org/ns/auth/cert#
+  # @since 0.2.0
+  class CERT < Vocabulary("http://www.w3.org/ns/auth/cert#")
+    property :decimal
+    property :hex
+    property :identity
+    property :public_key
+  end
+end

data/lib/vocabs/dc.rb

@@ -0,0 +1,63 @@
+module RDF
+  ##
+  # Dublin Core (DC) vocabulary.
+  #
+  # @see http://dublincore.org/schemas/rdfs/
+  class DC < Vocabulary("http://purl.org/dc/terms/")
+    property :abstract
+    property :accessRights
+    property :accrualMethod
+    property :accrualPeriodicity
+    property :accrualPolicy
+    property :alternative
+    property :audience
+    property :available
+    property :bibliographicCitation
+    property :conformsTo
+    property :contributor
+    property :coverage
+    property :created
+    property :creator
+    property :date
+    property :dateAccepted
+    property :dateCopyrighted
+    property :dateSubmitted
+    property :description
+    property :educationLevel
+    property :extent
+    property :format
+    property :hasFormat
+    property :hasPart
+    property :hasVersion
+    property :identifier
+    property :instructionalMethod
+    property :isFormatOf
+    property :isPartOf
+    property :isReferencedBy
+    property :isReplacedBy
+    property :isRequiredBy
+    property :isVersionOf
+    property :issued
+    property :language
+    property :license
+    property :mediator
+    property :medium
+    property :modified
+    property :provenance
+    property :publisher
+    property :references
+    property :relation
+    property :replaces
+    property :requires
+    property :rights
+    property :rightsHolder
+    property :source
+    property :spatial
+    property :subject
+    property :tableOfContents
+    property :temporal
+    property :title
+    property :type
+    property :valid
+  end
+end