publisci 0.1.2

data/features/prov_dsl_steps.rb

@@ -0,0 +1,11 @@
+Given(/^the prov DSL string from file (.+)$/) do |file|
+  @dsl_string = file
+end
+
+When(/^I call Prov\.run on it$/) do
+  @turtle_string = PubliSci::Prov.run(@dsl_string)
+end
+
+Then(/^I should receive a provenance string$/) do
+  puts @turtle_string
+end

data/features/reader.feature

@@ -0,0 +1,25 @@
+Feature: generate RDF
+
+	In order to test the generators
+	I want to be able to create turtle strings from various objects
+
+	Scenario: generate turtle RDF from a Dataframe
+		Given a Dataframe generator
+		When I provide an R dataframe and the label "mr"
+			And generate a turtle string from it
+		Then the result should contain a "qb:dataSet"
+			And the result should contain some "qb:Observation"s
+
+	Scenario: generate turtle RDF from a CSV
+		Given a CSV generator
+		When I provide the reference file spec/csv/bacon.csv and the label "bacon"
+			And generate a turtle string from it
+		Then the result should contain a "qb:dataSet"
+			And the result should contain some "qb:Observation"s
+
+	Scenario: generate turtle RDF from an ARFF file
+		Given a ARFF generator
+		When I provide the file resources/weather.numeric.arff
+			And generate a turtle string from it
+		Then the result should contain a "qb:dataSet"
+			And the result should contain some "qb:Observation"s

data/features/reader_steps.rb

@@ -0,0 +1,61 @@
+require_relative '../lib/bio-publisci.rb'
+
+Given /^a (.*) generator$/ do |generator|
+	@generator = PubliSci::Readers.const_get(generator).new
+end
+
+When /^I ask for its methods$/ do
+	@methods = @generator.methods
+end
+
+When /^I provide an R (.*) and the label "(.*?)"$/ do |type, label|
+	if type == "dataframe"
+		r = Rserve::Connection.new
+		r.eval <<-EOF
+			library(qtl)
+			data(listeria)
+			mr = scanone(listeria,method="mr")
+EOF
+		rexp = r.eval 'mr'
+		@attr = rexp,label
+	else
+		raise "Unknown object #{type}"
+	end
+
+end
+
+When /^I provide the.* file (.*) and the label "(.*?)"$/ do |file, label|
+	raise "Cant find #{file}" unless File.exist? file
+	@attr = file,label
+end
+
+When /^I provide the.* file (.*) and the label "(.*?)" and the options (.*)$/ do |file, label, opts|
+  raise "Cant find #{file}" unless File.exist? file
+  @attr = file,label,eval(opts)
+end
+
+When /^I provide the.* file (\S+)$/ do |file|
+	raise "Cant find #{file}" unless File.exist? file
+	@attr = file
+end
+
+When /^generate a turtle string from it$/ do
+	@turtle_string = @generator.send :generate_n3, *@attr
+	# open('weather.ttl','w'){|f| f.write @turtle_string}
+end
+
+Then /^I should have access to a (.*) method$/ do |method|
+	@methods.include?(method).should == true
+end
+
+Then /^I should be able to call its (.*) method$/ do |method|
+	@generator.methods.include?(:"#{method}").should == true
+end
+
+Then /^the result should contain a "(.*?)"$/ do |search|
+	@turtle_string[search].should_not be nil
+end
+
+Then /^the result should contain some "(.*?)"s$/ do |search|
+	@turtle_string[search].size.should > 1
+end

data/features/store.feature

@@ -0,0 +1,27 @@
+Feature: load triples into a store
+
+	In order to query and share data
+	I want to be able load the output into a variety of store 
+
+	Scenario: Use an RDF::Graph to store data
+		Given a store of type graph
+		When I call the stores add method with the turtle file spec/turtle/bacon and an RDF::Repository
+		Then I should recieve a non-empty graph
+
+	Scenario: Use 4store to store data
+		Given a store of type fourstore
+		When I call the stores add method with the turtle file spec/turtle/bacon and the graph name "test"
+		Then I should receive an info string
+
+	Scenario: Run queries on store
+		Given a store of type fourstore
+		When I call the query method using the text in file spec/queries/integrity/1.rq
+		Then I should receive 0 results
+		When I call the query method using the text in file resources/queries/test.rq
+		Then I should receive 10 results
+
+	Scenario: Run queries on graph based store
+		Given a store of type graph
+		When I call the stores add method with the turtle file spec/turtle/bacon and an RDF::Repository
+		Then calling the query method using the text in file spec/queries/integrity/1.rq should return 0 results
+		And calling the query method using the text in file resources/queries/test.rq should return 10 results

data/features/store_steps.rb

@@ -0,0 +1,42 @@
+require_relative '../lib/bio-publisci.rb'
+
+Given /a store of type (.*?)$/ do |type|
+	@store = PubliSci::Store.new(type: :"#{type}")
+end
+
+When /^I call the stores add method with the turtle file (.*?) and an RDF::(.*?)$/ do |file,graph|
+	graph = RDF.const_get(graph).new #rescue graph
+	@graph = @store.add(file,graph)
+end
+
+When /^I call the stores add method with the turtle file (.*?) and the graph name "(.*?)"$/ do |file,graph|
+	@graph = @store.add(file,graph)
+end
+
+
+When /^I call the query method using the text in file (.*)$/ do |file|
+	query_string = IO.read(file)
+	@query_result  = @store.query(query_string)
+end
+
+Then /^calling the query method using the text in file (.*) should return (.*) results$/ do |file, num|
+	query_string = IO.read(file)
+	@store.query(query_string) #.size.should == num
+end
+
+Then /^I should recieve a non-empty graph$/ do
+	@graph.is_a?(RDF::Repository).should be true
+	@graph.size.should > 0
+end
+
+Then /^I should receive an info string$/ do
+	@graph.is_a?(String).should be true
+end
+
+Then /^I should receive (.*) results$/ do |num|
+	@query_result.size.should == num.to_i
+end
+
+# Then /^raise the result$/ do
+# 	raise "got @graph"
+# end

data/features/support/env.rb

@@ -0,0 +1,13 @@
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'bio-publisci'
+
+require 'rspec/expectations'

data/features/writer.feature

@@ -0,0 +1,14 @@
+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 PubliSci::Writers 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
+
+  Scenario: write to CSV
+    Given a CSV writer
+    When I call its from_turtle method on the file spec/turtle/bacon
+    Then I should receive a .csv file as a string

data/features/writer_steps.rb

@@ -0,0 +1,24 @@
+Given(/^a (.*) writer$/) do |type|
+  @writer = PubliSci::Writers.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
+  puts @result
+  @result.is_a?(String).should be true
+end
+
+Then(/^I should receive a \.csv file as a string$/) do
+  puts @result
+  @result.is_a?(String).should be true
+end
+

data/lib/bio-publisci.rb

@@ -0,0 +1,64 @@
+# This is temporary, just to help w/ development so I don't have to rewrite r2rdf.rb to be
+# a standard gem base yet. Also load s the files instead of require for easy reloading
+require 'tempfile'
+require 'fileutils'
+require 'csv'
+
+require 'rdf'
+require 'sparql'
+require 'sparql/client'
+require 'rdf/turtle'
+require 'rdf/rdfxml'
+require 'json/ld'
+
+require 'rserve'
+require 'rest-client'
+
+begin
+	require 'spira'
+rescue LoadError
+	puts "can't load spira; orm unavailable"
+end
+
+def load_folder(folder)
+	Dir.foreach(File.dirname(__FILE__) + "/#{folder}") do |file|
+		unless file == "." or file == ".."
+			f = File.dirname(__FILE__) + "/#{folder}/" + file
+      load f unless File.directory?(f)
+		end
+  end
+end
+
+load_folder('bio-publisci/mixins')
+
+load File.dirname(__FILE__) + '/bio-publisci/dataset/interactive.rb'
+load File.dirname(__FILE__) + '/bio-publisci/query/query_helper.rb'
+load File.dirname(__FILE__) + '/bio-publisci/parser.rb'
+load File.dirname(__FILE__) + '/bio-publisci/post_processor.rb'
+load File.dirname(__FILE__) + '/bio-publisci/r_client.rb'
+load File.dirname(__FILE__) + '/bio-publisci/analyzer.rb'
+load File.dirname(__FILE__) + '/bio-publisci/store.rb'
+load File.dirname(__FILE__) + '/bio-publisci/dataset/data_cube.rb'
+load File.dirname(__FILE__) + '/bio-publisci/dataset/dataset_for.rb'
+load File.dirname(__FILE__) + '/bio-publisci/dataset/configuration.rb'
+load File.dirname(__FILE__) + '/bio-publisci/dataset/dataset.rb'
+load File.dirname(__FILE__) + '/bio-publisci/datacube_model.rb'
+load File.dirname(__FILE__) + '/bio-publisci/output.rb'
+load File.dirname(__FILE__) + '/bio-publisci/metadata/prov/element.rb'
+load File.dirname(__FILE__) + '/bio-publisci/metadata/prov/prov.rb'
+load File.dirname(__FILE__) + '/bio-publisci/writers/base.rb'
+load File.dirname(__FILE__) + '/bio-publisci/readers/base.rb'
+
+
+load_folder('bio-publisci/dsl')
+load_folder('bio-publisci/metadata')
+load_folder('bio-publisci/metadata/prov')
+load_folder('bio-publisci/metadata/prov/model')
+load_folder('bio-publisci/readers')
+load_folder('bio-publisci/writers')
+load_folder('bio-publisci/dataset/ORM')
+# Dir.foreach(File.dirname(__FILE__) + '/generators') do |file|
+	# unless file == "." or file == ".."
+# 		load File.dirname(__FILE__) + '/generators/' + file
+# 	end
+# end

data/lib/bio-publisci/analyzer.rb

@@ -0,0 +1,57 @@
+module PubliSci
+
+  #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/datacube_model.rb

@@ -0,0 +1,111 @@
+require 'rdf/4store'
+begin
+  require 'spira'
+  module PubliSci
+    module ORM
+      # class Observation < Spira::Base
+      #   type RDF::URI.new('http://purl.org/linked-data/cube#Observation')
+      #   property :label, predicate: RDFS.label
+
+      # end
+      QB ||= RDF::Vocabulary.new(RDF::URI.new('http://purl.org/linked-data/cube#'))
+
+      class Component < Spira::Base
+        type QB.ComponentSpecification
+        property :dimension, predicate: QB.dimension # RDF::URI.new('http://purl.org/linked-data/cube#dimension')
+        property :measure, predicate: QB.measure # RDF::URI.new('http://purl.org/linked-data/cube#measure')
+      end
+
+      class DataStructureDefinition < Spira::Base
+        type QB.DataStructureDefinition
+        property :label, predicate: RDFS.label
+        has_many :component, predicate: QB.component
+      end
+
+      class DataSet < Spira::Base
+        type QB.DataSet
+        property :label, predicate: RDFS.label
+        property :structure, predicate: QB.structure
+      end
+
+      class Dimension < Spira::Base
+        type QB.DimensionProperty
+        property :range, predicate: RDFS.range
+        property :label, predicate: RDFS.label
+      end
+
+      class Measure < Spira::Base
+        type QB.MeasureProperty
+        property :label, predicate: RDFS.label
+      end
+
+
+      def load_repo(repo)
+        raise "Not an RDF::Repository - #{repo}" unless repo.is_a? RDF::Repository
+        Spira.add_repository :default, repo
+      end
+
+      # def observation
+      #   unless PubliSci::ORM.const_defined?("Observation")
+      #     obs = Class.new(Spira::Base) do
+      #       type RDF::URI.new('http://purl.org/linked-data/cube#Observation')
+
+      #       property :structure, predicate: QB.dataSet
+
+      #       ((Dimension.each.to_a | Measure.each.to_a) || []).each{|component|
+      #         property strip_uri(component.subject.to_s), predicate: component.subject
+      #       }
+      #     end
+      #     PubliSci::ORM.const_set("Observation",obs)
+      #   end
+      #   Observation
+      # end
+
+      class Observation < Spira::Base
+        type QB.Observation
+        property :label, predicate: RDFS.label
+        property :dataset, predicate: QB.dataSet
+
+        def load_properties
+          comps = dataset.as(DataSet).structure.as(DataStructureDefinition).component.map{|comp| comp.as(Component)}
+          props = comps.map{|comp| comp.dimension ? comp.dimension.as(Dimension) : comp.measure.as(Measure) }
+          props.each{|prop|
+            ss =  strip_uri(prop.subject.to_s)
+
+            self.class.property ss.to_sym, predicate: prop.subject
+          }
+        end
+
+        # for testing; DRY up eventually
+        def strip_uri(uri)
+          uri = uri.to_s.dup
+          uri[-1] = '' if uri[-1] == '>'
+          uri.to_s.split('/').last.split('#').last
+        end
+
+        # def method_missing(meth, *args, &block)
+        #         if meth.to_s =~ /^find_by_(.+)$/
+        #           run_find_by_method($1, *args, &block)
+        #         else
+        #           super # You *must* call super if you don't handle the
+        #                 # method, otherwise you'll mess up Ruby's method
+        #                 # lookup.
+        #         end
+        #       end
+      end
+
+      def reload_observation
+        PubliSci::ORM.send(:remove_const, "Observation")
+        observation
+      end
+
+      def strip_uri(uri)
+        uri = uri.to_s.dup
+        uri[-1] = '' if uri[-1] == '>'
+        uri.to_s.split('/').last.split('#').last
+      end
+    end
+  end
+rescue LoadError
+  # puts "Skipping ORM load"
+end