bio-publisci 0.0.7 → 0.0.8

data/lib/bio-publisci/dataset/ORM/observation.rb

@@ -1,18 +1,20 @@
 module PubliSci
-		module ORM
-			class Observation
-				attr_accessor :data
-				def initialize(data={})
-					@data = data
-				end
+  module DataSet
+    module ORM
+        class Observation
+          attr_accessor :data
+          def initialize(data={})
+            @data = data
+          end
 
-				def method_missing(name, args)
-					#get entry of data hash
-				end
+          def method_missing(name, args)
+            #get entry of data hash
+          end
 
-				def respond_to_missing?(method, *)
+          def respond_to_missing?(method, *)
 
-				end
-			end
-	end
+          end
+        end
+    end
+  end
 end

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

@@ -121,7 +121,7 @@ module PubliSci
         base = options[:base_url]
         <<-EOF.unindent
         @base <#{base}/ns/dc/> .
-        @prefix ns:    <#{base}/ns/dataset/#{var}#> .
+        @prefix ns:    <#{base}/ns/dataset/#{var}/> .
         @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#> .
@@ -342,7 +342,6 @@ module PubliSci
           lists << str
         }
 
-
         lists
       end
 
@@ -357,12 +356,13 @@ module PubliSci
           else
             refcode = code[0]
           end
+          # puts data[refcode].uniq
           data[refcode].uniq.each_with_index{|value,i|
             unless value == nil && !options[:encode_nulls]
             concepts << <<-EOF.unindent
               #{to_resource(value,options)} a skos:Concept, #{code[2]};
                 skos:topConceptOf #{code[1]} ;
-                skos:prefLabel "#{strip_uri(data[refcode][i])}" ;
+                skos:prefLabel "#{strip_uri(value)}" ;
                 skos:inScheme #{code[1]} .
 
             EOF

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

@@ -17,7 +17,7 @@ module PubliSci
           elsif File.basename(object)[0] == '.' && File.basename(object).count('.') == 1
             extension = File.basename(object)
           else
-            raise "Can't load file #{object}; type inference not yet implemented"
+            raise "Can't load file #{object}; file type inference not yet implemented"
           end
 
           case extension
@@ -25,11 +25,17 @@ module PubliSci
             r_object(object, options, ask_on_ambiguous)
           when /.csv/i
             PubliSci::Reader::CSV.new.automatic(object,nil,options,ask_on_ambiguous)
+          else
+            false
           end
-        elsif object =~ %r{http[s]://.+}
-          self.for(download(object).path, options, ask_on_ambiguous)
+        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
+          # raise res
+          # self.for_remote(object)
         else
-          raise "Unable to find reader for File or String #{object}"
+          raise "Unable to find reader for String '#{object}'"
+          # TODO: better handling of missing readers; need this way for raw strings for now
+          # false
         end
       elsif object.is_a? Rserve::REXP
         r_object(object, options, ask_on_ambiguous)
@@ -38,6 +44,12 @@ 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
@@ -45,6 +57,15 @@ 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

data/lib/bio-publisci/dsl/dataset_dsl.rb

@@ -15,7 +15,7 @@ module PubliSci
       # end
 
       def object(file=nil)
-        set_or_get('object',file)
+        add_or_get('object',file)
       end
       alias_method :source, :object
 
@@ -61,7 +61,9 @@ module PubliSci
         if options
           opts = opts.merge(options)
         end
-        Dataset.for(object,opts,interact)
+        object().map{|obj|
+          Dataset.for(obj,opts,interact)
+        }.join("\n")
       end
 
       private

data/lib/bio-publisci/dsl/dsl.rb

@@ -2,6 +2,9 @@ module PubliSci
   module DSL
     attr_reader :base_url
 
+    class Instance
+      include PubliSci::DSL
+    end
     # Use to set base url for whole script; helps when referring to dataset
     # resources from metadata and
     def base_url=(url)

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

@@ -39,7 +39,7 @@ module PubliSci
           dct:creator "#{fields[:creator]}";
           rdfs:comment "#{fields[:description]}";
           dct:description "#{fields[:description]}";
-          dct:issued "#{fields[:date]}"^^xsd:date;
+          dct:issued "#{fields[:date]}"^^xsd:date.
         EOF
 
         end_str = ""

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

@@ -0,0 +1,27 @@
+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.
+
+      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
+# rescue LoadError
+#   puts "spira not installed, ORM unavailable"
+# end

data/lib/bio-publisci/metadata/prov/activity.rb

@@ -35,6 +35,7 @@ class Prov
     def associated_with(agent=nil, &block)
       block_list(:associated,:associations,Association,Associations,agent,&block)
     end
+    alias_method :wasAssociatedWith, :associated_with
 
     def used(entity=nil, &block)
       block_list(:use,:usages,Usage,Usages,entity, &block)

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

@@ -23,6 +23,20 @@ module PubliSci
             end
           }
         end
+
+        def all_types
+          me = self.subject
+          type_query = RDF::Query.new do
+            pattern [me, RDF.type, :type]
+          end
+
+          type_query.execute(self.class.repository).map{|t| t[:type]}
+        end
+
+        def has_data?
+          all_types.include?('http://purl.org/linked-data/cube#DataSet')
+        end
+
       end
 
       class Agent < Spira::Base
@@ -31,15 +45,28 @@ module PubliSci
         type PROV.SoftwareAgent
         type PROV.Person
         property :label, predicate: RDF::RDFS.label
-        property :wasGeneratedBy, predicate: PROV.wasGeneratedBy
         property :foaf_name, predicate: RDF::FOAF.name
         property :foaf_given, predicate: RDF::FOAF.givenName
-        property :name, predicate: PROV.actedOnBehalfOf
         property :actedOnBehalfOf, predicate: PROV.actedOnBehalfOf
 
+
         def name
           foaf_given || foaf_name
         end
+
+        def name=(name)
+          foaf_given = name
+          foaf_name = name
+
+        end
+
+        def activities
+          #should do this in a SPARQL query instead
+          Activity.enum_for.map{|act|
+            subj = subject()
+            act if act.wasAssociatedWith.any?{|assoc| assoc == subj}
+          }.reject{|x| x==nil}
+        end
       end
 
       class Activity < Spira::Base
@@ -56,6 +83,10 @@ module PubliSci
         property :label, predicate: RDF::RDFS.label
         property :agent, predicate: PROV.agent
         property :hadPlan, predicate: PROV.hadPlan
+
+        def activity
+          Activity.each.to_a.select{|act| act.qualifiedAssociation.include? self}
+        end
       end
 
       class Derivation < Spira::Base

data/lib/bio-publisci/query/query_helper.rb

@@ -47,7 +47,7 @@ module PubliSci
       sparql.query(string)
     end
 
-    def execute_from_file(file,store,type=:fourstore)
+    def execute_from_file(file,store,type=:fourstore,substitutions={})
       if File.exist?(file)
         string = IO.read(file)
       elsif File.exist?(File.dirname(__FILE__) + '/../../../resources/queries/' + file)
@@ -57,6 +57,10 @@ module PubliSci
       else
         raise "couldn't find query for #{file}"
       end
+
+      substitutions.map{|k,v|
+        string = string.gsub(k,v)
+      }
     	execute(string, store, type)
     end
 

data/lib/bio-publisci/readers/arff.rb

@@ -2,14 +2,14 @@ module PubliSci
 		module Reader
 		class ARFF
 			include PubliSci::Dataset::DataCube
+
 			def generate_n3(arff, options={})
 				arff = IO.read(arff) if File.exist? arff
 				options[:no_labels] = true # unless options[:no_labels] == nil
 				@options = options
 				comps =  components(arff)
 				obs = data(arff, comps.keys)
-				repl = generate(comps.reject{|c| comps[c][:codes]}.keys, comps.select{|c| comps[c][:codes]}.keys, comps.select{|c| comps[c][:codes]}.keys, obs, (1..obs.first[1].size).to_a, relation(arff), options)
-
+				generate(comps.reject{|c| comps[c][:codes]}.keys, comps.select{|c| comps[c][:codes]}.keys, comps.select{|c| comps[c][:codes]}.keys, obs, (1..obs.first[1].size).to_a, relation(arff), options)
 			end
 
 			def relation(arff)
@@ -44,44 +44,6 @@ module PubliSci
 				}
 				h
 			end
-
-		# 	def coded_dimensions
-		# 		if @options[:codes]
-		# 			@options[:codes]
-		# 		elsif @options[:row_label]
-		# 			[@options[:row_label]]
-		# 		else
-		# 			["refRow"]
-		# 		end
-		# 	end
-
-		# 	def measures
-		# 		if @options[:dimensions]
-		# 			if @options[:measures]
-		# 				@options[:measures] - @options[:dimensions]
-		# 			else
-		# 				# @rexp.payload.names - @options[:dimensions]
-		# 			end
-		# 		else
-		# 			@options[:measures] # || @rexp.payload.names
-		# 		end
-		# 	end
-
-		# 	def observation_labels
-		# 		# row_names = @rexp.attr.payload["row.names"].to_ruby
-	 #   #    row_names = (1..@rexp.payload.first.to_ruby.size).to_a unless row_names.first
-	 #   #    row_names
-		# 	end
-
-		# 	def observation_data
-
-		# 		# data = {}
-		# 		# @rexp.payload.names.map{|name|
-		# 		# 	data[name] = @rexp.payload[name].to_ruby
-		# 		# }
-		# 		# data[@options[:row_label] || "refRow"] = observation_labels()
-		# 		# data
-		# 	end
 		end
 	end
 end

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

@@ -1,5 +1,5 @@
 module PubliSci
-		module Reader
+	module Reader
 		class Dataframe
       include PubliSci::Dataset::DataCube
 			include PubliSci::Reader::Output

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

@@ -1,9 +1,9 @@
 module PubliSci
-  module Writer
-    class ARFF
-      include PubliSci::Query
-      include PubliSci::Parser
-      include PubliSci::Analyzer
+  module Writers
+    class ARFF < Base
+      # include PubliSci::Query
+      # include PubliSci::Parser
+      # include PubliSci::Analyzer
 
       def build_arff(relation, attributes, data, source)
         str = <<-EOS
@@ -31,34 +31,60 @@ EOS
         repo = RDF::Repository.load(turtle_file)
         puts "loaded #{repo.size} statements into temporary repo" if verbose
 
-        dims = execute_from_file("dimensions.rq",repo,:graph).to_h.map{|d| [d[:dimension].to_s, d[:label].to_s]}
-        meas = execute_from_file("measures.rq",repo,:graph).to_h.map{|m| [m[:measure].to_s, m[:label].to_s]}
-        relation = execute_from_file("dataset.rq",repo,:graph).to_h.first[:label].to_s
-        codes = execute_from_file("codes.rq",repo,:graph).to_h.map{|e| e.values.map(&:to_s)}.inject({}){|h,el|
-          (h[el.first]||=[]) << el.last; h
-        }
+        dims = dimensions(repo)
+        meas = measures(repo)
+        data = observations(repo)
+
+        relation = dataSet(repo)
+        codes = codes(repo)
 
-        data = observation_hash(execute_from_file("observations.rq",repo,:graph), true)
         attributes = {}
+
         (dims | meas).map{|component|
-          attributes[component[1]] = case recommend_range(data.map{|o| o[1][component[1]]})
+          attributes[component] = case recommend_range(data.map{|o| o[1][component]})
             when "xsd:int"
               "integer"
             when "xsd:double"
               "real"
             when :coded
               if dims.include? component
-                "{#{codes[component[1]].join(',')}}"
+                "{#{codes[component].join(', ')}}"
               else
                 "string"
               end
             end
         }
+
         build_arff(relation, attributes, data, turtle_file)
       end
 
-      def from_store(endpoint_url,variable_in=nil, variable_out=nil, verbose=false)
-        raise "not implemented yet"
+      def from_store(repo, dataset=nil, title=nil, verbose=false)
+        # data = observation_hash(execute_from_file("observations.rq",repo,:graph,{"%{dataSet}"=>"<#{dataSet}>"}), true)
+
+        dims = dimensions(repo,dataset)
+        meas = measures(repo,dataset)
+        data = observations(repo,dataset)
+        codes = codes(repo,dataset)
+        attributes = {}
+
+        (dims | meas).map{|component|
+          attributes[component] = case recommend_range(data.map{|o| o[1][component]})
+            when "xsd:int"
+              "integer"
+            when "xsd:double"
+              "real"
+            when :coded
+              if dims.include? component
+                "{#{codes[component].join(', ')}}"
+              else
+                "string"
+              end
+            end
+        }
+
+        dataset = dataSet(repo) unless dataset
+        title = dataset unless title
+        build_arff(title,attributes,data,dataset)
       end
     end
   end

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

@@ -0,0 +1,77 @@
+module PubliSci
+  module Writers
+    class Base
+      include PubliSci::Query
+      include PubliSci::Parser
+      include PubliSci::Analyzer
+
+      def handle_input(input)
+        if input.is_a? String
+          if File.exist? input
+            RDF::Repository.load(input)
+          else
+            raise "UnkownStringInput: #{input}"
+          end
+        elsif input.is_a? RDF::Repository
+          input
+        else
+          raise "UnkownInput: #{input}, #{input.class}"
+        end
+      end
+
+      def dimensions(input, data_set=nil, select=:label)
+        repo = handle_input(input)
+
+        if data_set
+          dims = execute_from_file("dimensions.rq",repo,:graph,{"?dataSet"=>"<#{data_set}>"})
+        else
+          dims = execute_from_file("dimensions.rq",repo,:graph)
+        end
+
+        dims.to_h.map{|d| d[select].to_s}
+      end
+
+      def measures(input, data_set=nil, select=:label)
+        repo = handle_input(input)
+
+        if data_set
+          meas = execute_from_file("measures.rq",repo,:graph,{"?dataSet"=>"<#{data_set}>"})
+        else
+          meas = execute_from_file("measures.rq",repo,:graph)
+        end
+
+        meas.to_h.map{|d| d[select].to_s}
+      end
+
+      def observations(input, data_set = nil, shorten_url = true)
+        repo = handle_input(input)
+
+        if data_set
+          obs = execute_from_file("observations.rq",repo,:graph,{"?dataSet"=>"<#{data_set}>"})
+        else
+          obs = execute_from_file("observations.rq",repo,:graph)
+        end
+
+        observation_hash(obs,shorten_url)
+      end
+
+      def dataSet(input, select = :label)
+        repo = handle_input(input)
+
+        execute_from_file("dataset.rq",repo,:graph).to_h.first[select].to_s
+      end
+
+      def codes(input, data_set = nil, select = :label)
+        repo = handle_input(input)
+        if data_set
+          codes = execute_from_file("codes.rq",repo,:graph,{"?dataSet"=>"<#{data_set}>"}).to_h
+        else
+          codes = execute_from_file("codes.rq",repo,:graph).to_h
+        end
+        codes.map{|c| c.values.map(&:to_s)}.inject({}){|h,el|
+          (h[el.first]||=[]) << el.last; h
+        }
+      end
+    end
+  end
+end