bio-publisci 0.0.1

data/features/writer.feature

@@ -0,0 +1,9 @@
+Feature: export to various formats using writers
+
+	In order to use RDF encoded data in other applications
+	I want to export domain objects using an R2RDF::Writer object
+
+	Scenario: write to ARFF format
+		Given a ARFF writer
+		When I call its from_turtle method on the file spec/turtle/bacon
+		Then I should receive a .arff file as a string

data/features/writer_steps.rb

@@ -0,0 +1,17 @@
+Given(/^a (.*) writer$/) do |type|
+  @writer = R2RDF::Writer.const_get(type).new
+end
+
+When(/^I call its from_turtle method on the file (.*)$/) do |file|
+  @result = @writer.from_turtle(file)
+end
+
+When(/^I call its from_turtle method on the turtle string$/) do
+  f=Tempfile.open('writerttl'); f.write @turtle_string; f.close
+  @result = @writer.from_turtle(f.path)
+  f.unlink
+end
+
+Then(/^I should receive a \.arff file as a string$/) do
+  @result.is_a?(String).should be true
+end

data/lib/bio-publisci/analyzer.rb

@@ -0,0 +1,57 @@
+module R2RDF
+  
+  #handles analysis of R expression to extract properties and recognize potential
+  #ambiguity
+  module Analyzer
+  	def dirty?(data)
+  		if data.is_a? Hash
+  			data.map{|k,v|
+  				return true if dirty?(k) || dirty?(v)
+  			}
+  			false
+  		elsif data.is_a? Array
+  			data.map{|datum|
+  				return true if dirty?(datum)
+  			}
+  		else 
+  			dirty_characters = [".",' ']
+  			if data.to_s.scan(/./) & dirty_characters
+  				true 
+  			else
+  				false
+  			end
+  		end
+  	end
+
+  	def recommend_range(data)
+  		classes = data.map{|d| d.class}
+  		homogenous = classes.uniq.size == 1
+  		if homogenous
+  			if classes[0] == Fixnum
+  				"xsd:int"
+  			elsif classes[0] == Float
+  				"xsd:double"
+  			elsif classes[0] == String
+  				recommend_range_strings(data)
+  			else
+  				:coded
+  			end
+  		else
+  			:coded
+  		end
+  	end
+
+  	def recommend_range_strings(data)
+  		return "xsd:int" if data.all?{|d| Integer(d) rescue nil}
+  		return "xsd:int" if data.all?{|d| Float(d) rescue nil}
+  		:coded
+  	end
+
+  	def check_integrity(obs, dimensions, measures)
+  		obs.map{|o|
+  				raise "MissingValues for #{(dimensions | measures) - o.keys}" unless ((dimensions | measures) - o.keys).empty?
+  				raise "UnknownProperty #{o.keys - (dimensions | measures)}" unless (o.keys - (dimensions | measures)).empty?
+  		}
+  	end
+  end
+end

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

@@ -0,0 +1,219 @@
+module R2RDF
+	module Dataset
+		module ORM
+			class DataCube
+				extend R2RDF::Dataset::DataCube
+				extend R2RDF::Analyzer
+				extend R2RDF::Metadata
+				extend R2RDF::Query
+				extend R2RDF::Parser
+
+				include R2RDF::Dataset::DataCube
+				include R2RDF::Analyzer
+				include R2RDF::Metadata
+				include R2RDF::Query
+				include R2RDF::Parser
+				
+				attr_accessor :labels
+				attr_accessor :dimensions
+				attr_accessor :measures
+	      attr_accessor :obs
+				attr_accessor :meta
+
+				def initialize(options={},do_parse = true)
+					@dimensions = {}
+					@measures = []
+					@obs = []
+					@generator_options = {}
+					@options = {}
+
+	        @meta = {}
+
+					parse_options options if do_parse
+				end
+
+				def self.load(graph,options={},verbose=false)
+
+          
+          graph = create_graph(graph) unless graph =~ /^http/
+
+          # puts get_hashes(execute_from_file('dimension_ranges.rq',graph))
+          dimensions = Hash[get_hashes(execute_from_file('dimension_ranges.rq',graph),"to_s").map{|solution|
+						#TODO coded properties should be found via SPARQL queries
+						if solution[:range].split('/')[-2] == "code"
+							type = :coded
+						else
+							type = strip_uri(solution[:range])
+						end
+						[strip_uri(solution[:dimension]), {type: type}]
+					}]
+					puts "dimensions: #{dimensions}" if verbose
+					measures = get_ary(execute_from_file('measures.rq',graph)).flatten
+					puts "measures: #{measures}" if verbose
+          name = execute_from_file('dataset.rq',graph).to_h.first[:label]
+          puts "dataset: #{name}" if verbose
+					obs = execute_from_file('observations.rq',graph)
+          puts "observations: #{obs}" if verbose
+          # observations = observation_hash(obs)
+          simple_observations = observation_hash(obs,true)
+
+					new_opts = {
+						measures: measures,
+						dimensions: dimensions,
+						observations: simple_observations.values,
+						name: name,
+					}
+
+					options = options.merge(new_opts)
+					puts "creating #{options}" if verbose
+					self.new(options)
+				end
+				
+				def parse_options(options)
+					if options[:dimensions]
+						options[:dimensions].each{|name,details|
+							add_dimension(name, details[:type] || :coded)
+						}
+					end
+
+					if options[:measures]
+						options[:measures].each{|m| @measures << m}
+					end
+
+					if options[:observations]
+						options[:observations].each{|obs_data| add_observation obs_data}
+					end
+
+					@generator_options = options[:generator_options] if options[:generator_options]
+					@options[:skip_metadata] = options[:skip_metadata] if options[:skip_metadata]
+
+					if options[:name]
+						@name = options[:name]
+					else
+						raise "No dataset name specified!"
+					end
+
+					if options[:validate_each]
+						@options[:validate_each] = options[:validate_each]
+					end
+				end
+
+				def to_n3
+
+					#create labels if not specified
+					unless @labels.is_a?(Array) && @labels.size == @obs.size
+						if @labels.is_a? Symbol
+							#define some automatic labeling methods
+						else
+							@labels = (1..@obs.size).to_a.map(&:to_s)
+						end
+					end
+					data = {}
+
+
+					#collect observation data
+					check_integrity(@obs.map{|o| o.data}, @dimensions.keys, @measures)
+					@obs.map{|obs|
+						(@measures | @dimensions.keys).map{ |component|
+						 (data[component] ||= []) <<  obs.data[component]
+						}
+					}
+					
+
+					codes = @dimensions.map{|d,v| d if v[:type] == :coded}.compact
+
+
+					str = generate(@measures, @dimensions.keys, codes, data, @labels, @name, @generator_options)
+					unless @options[:skip_metadata]
+		        fields = {
+		          publishers: publishers(),
+		          subject: subjects(),
+		          author: author(),
+		          description: description(),
+		          date: date(),
+		          var: @name,
+		        }
+		        # puts basic(fields,@generator_options)
+		        str += "\n" + basic(fields,@generator_options)
+	      	end
+	        str
+				end
+
+				def add_dimension(name, type=:coded)
+					@dimensions[name.to_s] = {type: type}
+				end
+
+				def add_measure(name)
+					@measures << name
+				end
+
+				def add_observation(data)
+					data = Hash[data.map{|k,v| [k.to_s, v]}]
+					obs = Observation.new(data)
+					check_integrity([obs.data],@dimensions.keys,@measures) if @options[:validate_each]
+					@obs << obs
+				end
+
+				def insert(observation)
+					@obs << observation
+				end
+
+	      def publishers
+	        @meta[:publishers] ||= []
+	      end
+
+	      def publishers=(publishers)
+	        @meta[:publishers] = publishers
+	      end
+
+	      def subjects
+	        @meta[:subject] ||= []
+	      end
+
+	      def subjects=(subjects)
+	        @meta[:subject]=subjects
+	      end
+
+	      def add_publisher(label,uri)
+	        publishers << {label: label, uri: uri}
+	      end
+
+	      def add_subject(id)
+	        subject << id
+	      end
+
+	      def author
+	        @meta[:creator] ||= ""
+	      end
+
+	      def author=(author)
+	        @meta[:creator] = author
+	      end
+
+	      def description
+	        @meta[:description] ||= ""
+	      end
+
+	      def description=(description)
+	        @meta[:description] = description
+	      end
+
+	      def date
+	        @meta[:date] ||= "#{Time.now.day}-#{Time.now.month}-#{Time.now.year}"
+	      end
+
+	      def date=(date)
+	        @meta[:date] =  date
+	      end
+
+	      def to_h
+					{
+						measures: @measures,
+						dimensions: @dimensions,
+						observations: @obs.map{|o| o.data}
+					}
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,20 @@
+module R2RDF
+	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 respond_to_missing?(method, *)
+
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,308 @@
+  #monkey patch to make rdf string w/ heredocs prettier ;)  
+  class String
+    def unindent
+      gsub /^#{self[/\A\s*/]}/, ''
+     # gsub(/^#{scan(/^\s*/).min_by{|l|l.length}}/, "")
+    end
+  end
+
+module R2RDF
+  # used to generate data cube observations, data structure definitions, etc
+  module Dataset
+    module DataCube
+      def defaults
+      {
+        type: :dataframe,
+        encode_nulls: false,
+        base_url: "http://www.rqtl.org",
+      }
+     end
+     
+     def generate(measures, dimensions, codes, data, observation_labels, var, options={})
+      dimensions = sanitize(dimensions)
+      codes = sanitize(codes)
+      measures = sanitize(measures)
+      var = sanitize([var]).first
+      data = sanitize_hash(data)
+
+      str = prefixes(var,options)
+      str << data_structure_definition((measures | dimensions), var, options)
+      str << dataset(var, options)
+      component_specifications(measures, dimensions, var, options).map{ |c| str << c }
+      dimension_properties(dimensions, codes, var, options).map{|p| str << p}
+      measure_properties(measures, var, options).map{|p| str << p}
+      code_lists(codes, data, var, options).map{|l| str << l}
+      concept_codes(codes, data, var, options).map{|c| str << c}
+      observations(measures, dimensions, codes, data, observation_labels, var, options).map{|o| str << o}
+      str
+    end
+
+      def sanitize(array)
+        #remove spaces and other special characters
+        processed = []
+        array.map{|entry|
+          if entry.is_a? String
+            processed << entry.gsub(/[\s\.]/,'_')
+          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 prefixes(var, options={})
+        var = sanitize([var]).first
+        options = defaults().merge(options)
+        base = options[:base_url]
+        <<-EOF.unindent
+        @base <#{base}/ns/dc/> .
+        @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#> .
+        @prefix prop:  <#{base}/dc/properties/> .
+        @prefix dct:   <http://purl.org/dc/terms/> .
+        @prefix xsd:   <http://www.w3.org/2001/XMLSchema#> .
+        @prefix cs:    <#{base}/dc/dataset/#{var}/cs/> .
+        @prefix code:  <#{base}/dc/dataset/#{var}/code/> .
+        @prefix class: <#{base}/dc/dataset/#{var}/class/> .
+        @prefix owl:   <http://www.w3.org/2002/07/owl#> .
+        @prefix skos:  <http://www.w3.org/2004/02/skos/core#> .
+        @prefix foaf:     <http://xmlns.com/foaf/0.1/> .
+        @prefix org:      <http://www.w3.org/ns/org#> .
+        @prefix prov:     <http://www.w3.org/ns/prov#> .
+
+        EOF
+      end
+
+      def data_structure_definition(components,var,options={})
+        var = sanitize([var]).first
+        options = defaults().merge(options)
+        str = "ns:dsd-#{var} a qb:DataStructureDefinition;\n"
+        str << "  qb:component\n"
+        components.map{|n|
+              str << "    cs:#{n} ,\n"
+        }
+        str[-2]='.'
+        str<<"\n"
+        str
+      end
+
+      def dataset(var,options={})
+        var = sanitize([var]).first
+        options = defaults().merge(options)
+        <<-EOF.unindent    
+        ns:dataset-#{var} a qb:DataSet ;
+          rdfs:label "#{var}"@en ;
+          qb:structure ns:dsd-#{var} .
+
+        EOF
+      end
+
+      def component_specifications(measure_names, dimension_names, var, options={})
+        options = defaults().merge(options)
+        specs = []
+        
+          dimension_names.map{|d|
+          specs << <<-EOF.unindent
+            cs:#{d} a qb:ComponentSpecification ;
+              rdfs:label "#{d} Component" ;
+              qb:dimension prop:#{d} .
+
+            EOF
+          }
+
+          measure_names.map{|n|
+            specs << <<-EOF.unindent
+              cs:#{n} a qb:ComponentSpecification ;
+                rdfs:label "#{n} Component" ;
+                qb:measure prop:#{n} .
+
+              EOF
+          }
+        
+        specs
+      end
+
+      def dimension_properties(dimensions, codes, var, options={})
+        options = defaults().merge(options)
+        props = []
+        
+          dimensions.map{|d|  
+            if codes.include?(d)
+              props << <<-EOF.unindent
+              prop:#{d} a rdf:Property, qb:DimensionProperty ;
+                rdfs:label "#{d}"@en ;
+                qb:codeList code:#{d.downcase} ;
+                rdfs:range code:#{d.downcase.capitalize} .
+
+              EOF
+            else
+              props << <<-EOF.unindent
+              prop:#{d} a rdf:Property, qb:DimensionProperty ;
+                rdfs:label "#{d}"@en .
+
+              EOF
+            end
+          }
+        
+        props
+      end
+
+      def measure_properties(measures, var, options={})
+        options = defaults().merge(options)
+        props = []
+        
+          measures.map{ |m|
+              
+            props <<  <<-EOF.unindent
+            prop:#{m} a rdf:Property, qb:MeasureProperty ;
+              rdfs:label "#{m}"@en .
+
+            EOF
+            }
+        
+        props
+      end
+
+      def observations(measures, dimensions, codes, data, observation_labels, var, options={})  
+        var = sanitize([var]).first
+        options = defaults().merge(options)
+        obs = []
+        observation_labels.each_with_index.map{|r, i|
+          contains_nulls = false
+          str = <<-EOF.unindent 
+          ns:obs#{r} a qb:Observation ;
+            qb:dataSet ns:dataset-#{var} ;
+          EOF
+
+          str << "  rdfs:label \"#{r}\" ;\n" unless options[:no_labels]
+          
+          dimensions.map{|d|
+            contains_nulls = contains_nulls | (data[d][i] == nil)
+            if codes.include? d
+              str << "  prop:#{d} <code/#{d.downcase}/#{data[d][i]}> ;\n"
+            else
+              str << "  prop:#{d} ns:#{to_resource(data[d][i], options)} ;\n"
+            end
+          }
+
+          measures.map{|m|
+            contains_nulls = contains_nulls | (data[m][i] == nil)
+            str << "  prop:#{m} #{to_literal(data[m][i], options)} ;\n" 
+            
+          }
+
+          str << "  .\n\n"
+          obs << str unless contains_nulls && !options[:encode_nulls]
+
+        }
+        obs
+      end
+
+      def code_lists(codes, data, var, options={})
+        options = defaults().merge(options)
+        lists = []
+        codes.map{|code|
+          str = <<-EOF.unindent
+            code:#{code.downcase.capitalize} a rdfs:Class, owl:Class;
+              rdfs:subClassOf skos:Concept ;
+              rdfs:label "Code list for #{code} - codelist class"@en;
+              rdfs:comment "Specifies the #{code} for each observation";
+              rdfs:seeAlso code:#{code.downcase} .
+
+            code:#{code.downcase} a skos:ConceptScheme;
+              skos:prefLabel "Code list for #{code} - codelist scheme"@en;
+              rdfs:label "Code list for #{code} - codelist scheme"@en;
+              skos:notation "CL_#{code.upcase}";
+              skos:note "Specifies the #{code} for each observation";
+          EOF
+          data[code].uniq.map{|value|
+            unless value == nil && !options[:encode_nulls]
+              str << "  skos:hasTopConcept <code/#{code.downcase}/#{to_resource(value,options)}> ;\n"
+            end
+          }
+          
+          str << "  .\n\n"
+          lists << str
+        }
+        
+
+        lists
+      end
+
+      def concept_codes(codes, data, var, options={})
+        options = defaults().merge(options)
+        concepts = []
+        codes.map{|code|
+          data[code].uniq.map{|value|
+            unless value == nil && !options[:encode_nulls]
+            concepts << <<-EOF.unindent
+              <code/#{code.downcase}/#{to_resource(value,options)}> a skos:Concept, code:#{code.downcase.capitalize};
+                skos:topConceptOf code:#{code.downcase} ;
+                skos:prefLabel "#{to_resource(value,options)}" ;
+                skos:inScheme code:#{code.downcase} .
+
+            EOF
+            end
+          }
+        }
+
+        concepts
+      end
+
+
+      def to_resource(obj, options)
+        if obj.is_a? String
+          #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?
+          
+          #TODO  remove special characters (faster) as well (eg '?')
+          obj.gsub(' ','_').gsub('?','')
+        elsif obj == nil && options[:encode_nulls]
+          '"NA"'
+        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
+          '"NA"'
+        else
+          obj
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module R2RDF
+	module Dataset
+		module Interactive
+			#to be called by other classes if user input is required
+			def defaults
+				{
+					load_from_file: false
+				}
+			end
+
+			def interactive(options={})
+				options = defaults.merge(options)
+				qb = {}
+
+				puts "load config from file? [y/N]"
+				if gets.chomp == "y"
+					#use yaml or DSL file to configure
+				else
+					qb[:dimensions] = dimensions()
+					qb[:measures] = measures()
+				end
+
+				puts "load data from file? [y/N]"
+				if gets.chomp == "y"
+					#attempt to load dataset from file, ask user to resolve problems or ambiguity
+				else
+				end
+				qb
+			end
+
+			def dimensions
+				puts "Enter a list of dimensions, separated by commas"
+				arr = gets.chomp.split(",")
+				dims = {}
+
+				arr.map{|dim|
+					puts "What is the range of #{dim.chomp.strip}? [:coded]"
+					type = gets.chomp
+					type = :coded if type == ":coded" || type == ""
+					dims[dim.chomp.strip] = {type: type}
+				}
+
+				dims
+			end
+
+			def measures
+				puts "Enter a list of measures, separated by commas"
+				arr = gets.chomp.split(",")
+				meas = []
+
+				arr.map{|m| meas << m.chomp.strip}
+
+				meas
+			end
+		end
+	end
+end