publisci 0.1.2

data/spec/ORM/data_cube_orm_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../../lib/bio-publisci.rb'
+
+describe PubliSci::ORM do
+
+  it "should load and save a turtle file without loss of information in old ORM" do
+    pending("pending rewrite of abbreviaton method to account for base_url")
+    ref = IO.read(File.dirname(__FILE__) + '/../turtle/bacon')
+    cube = PubliSci::DataSet::ORM::DataCube.load(ref, {skip_metadata: true, generator_options: {label_column: 0}})
+    cube.abbreviate_known(cube.to_n3).should == ref
+    # cube.to_n3.should == ref
+  end
+
+  it "should load properties for Observation object" do
+    ev = PubliSci::DSL::Instance.new
+    r = ev.instance_eval do
+      data do
+        object 'spec/csv/bacon.csv'
+      end
+
+      to_repository
+    end
+    Spira.add_repository :default, r
+
+    PubliSci::ORM::Observation.count.should > 0
+
+    PubliSci::ORM::Observation.first.load_properties
+    fi = PubliSci::ORM::Observation.first
+    fi.chunkiness.should_not be nil
+    fi.deliciousness.should_not be nil
+
+  end
+
+end

data/spec/ORM/prov_model_spec.rb

@@ -0,0 +1,72 @@
+require_relative '../../lib/bio-publisci.rb'
+include PubliSci::Prov::DSL
+# include PubliSci::Prov
+
+describe PubliSci::Prov::Model do
+  it "can be loaded from" do
+    ev = PubliSci::Prov::DSL::Instance.new
+    r = ev.instance_eval do
+      entity :datathing
+
+      activity :process, generated: :datathing
+
+      to_repository
+    end
+
+    Spira.add_repository :default, r
+    PubliSci::Prov::Model::Entity.first.should_not be nil
+  end
+
+  context "has useful methods built in to models" do
+    it "can reverse chain associated activities for agents" do
+      ev = PubliSci::Prov::DSL::Instance.new
+
+      ag = ev.instance_eval do
+        agent :some_dudette
+      end
+
+      act = ev.instance_eval do
+        entity :datathing
+
+        activity :process, generated: :datathing, wasAssociatedWith: :some_dudette
+      end
+
+      r = ev.instance_eval do
+        to_repository
+      end
+
+
+      # z= ev.instance_eval do
+      #   generate_n3
+      # end
+
+      Spira.add_repository :default, r
+      model_agent = PubliSci::Prov::Model::Agent.first
+      ag.subject.should == model_agent.subject
+      acts =  model_agent.activities
+      acts.first.subject.should == act.subject
+    end
+
+    it "can dump all types for Entities" do
+      ev = PubliSci::Prov::DSL::Instance.new
+
+      qb = RDF::Vocabulary.new(RDF::URI.new('http://purl.org/linked-data/cube#'))
+
+      r = ev.instance_eval do
+        agent :some_dudette
+
+        entity :datathing do
+          has RDF.type, qb.DataSet
+        end
+
+        activity :process, generated: :datathing, wasAssociatedWith: :some_dudette
+
+        to_repository
+      end
+
+      Spira.add_repository :default, r
+      PubliSci::Prov::Model::Entity.first.all_types.should == %w{http://www.w3.org/ns/prov#Entity http://purl.org/linked-data/cube#DataSet}
+      PubliSci::Prov::Model::Entity.first.has_data?.should == true
+    end
+  end
+end

data/spec/analyzer_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../lib/bio-publisci.rb'
+
+describe PubliSci::Analyzer do
+	class Ana
+		include PubliSci::Analyzer
+	end
+
+	before(:all) do
+		@analyzer = Ana.new
+
+		@measures = ['chunkiness','deliciousness']
+		@dimensions = ['producer', 'pricerange']
+		@labels = %w(hormel newskies whys)
+		@data =
+		{
+			"producer" =>      ["hormel","newskies",  "whys"],
+			"pricerange" =>    ["low",   "medium",    "nonexistant"],
+			"chunkiness"=>     [1,         6,          9001],
+			"deliciousness"=>  [1,         9,          6]
+		}
+	end
+
+	it "should run a basic validation" do
+		newdata = []
+
+		@data.keys.size.times{|i|
+			obs = {}
+			@data.map{|k,v|
+				obs[k] = v[i]
+			}
+			newdata << obs
+		}
+
+		@analyzer.check_integrity(newdata, @measures, @dimensions)
+	end
+end

data/spec/bnode_spec.rb

@@ -0,0 +1,66 @@
+require_relative '../lib/bio-publisci.rb'
+
+
+describe "DataCube Node Generation" do
+
+  context "with Plain Old Ruby objects" do
+    #define a temporary class to use module methods
+    before(:all) do
+      class Gen
+        include PubliSci::Dataset::DataCube
+      end
+
+      @generator = Gen.new
+      @measures = ['chunkiness','deliciousness']
+      @dimensions = ['producer', 'pricerange']
+      @codes = @dimensions #all dimensions coded for the tests
+      @labels = %w(hormel newskies whys)
+      @data =
+      {
+        "producer" =>      ["hormel","newskies",  "whys"],
+        "pricerange" =>    ["low",   "medium",    "nonexistant"],
+        "chunkiness"=>     [1,         6,          9001],
+        "deliciousness"=>  [1,         9,          6]
+      }
+    end
+
+    it "represents nested arrays using blank nodes" do
+      newdata = Hash[@data.map{|k,v| [k,v.first] }]
+      newdata.keys.each{|k| newdata[k] =[[["a", "rdf:Property"],["<http://semanticscience.org/resource/SIO_000300>", newdata[k]]]] }
+      observations = @generator.observations(@measures, [], [], newdata, @labels[0], "bacon")
+      observations.is_a?(Array).should == true
+      # puts observations.first.class
+      observations.first.is_a?(String).should == true
+      # puts observations
+      # observations.first[%r{\[ a rdf:Property  ;\n<http://semanticscience.org/resource/SIO_000300> 1  \n \]}].should_not be nil
+    end
+
+    it "can nest arrays to some depth" do
+      newdata = Hash[@data.map{|k,v| [k,v.first] }]
+      newdata.keys.each{|k| 
+        if ["producer","chunkiness"].include? k
+          newdata[k] = [
+          [
+            ["a", "rdf:MacGuffin"] ,
+            [
+              "<http://semanticscience.org/resource/SIO_000300>", 
+              [
+                ["a", "rdf:Absurdity"],
+                [ 'rdf:value', newdata[k] ] 
+              ]
+            ]
+          ]]
+
+        end
+      }
+
+      observations = @generator.observations(@measures, @dimensions, [], newdata, @labels[0], "bacon")
+      observations.is_a?(Array).should == true
+      observations.first.is_a?(String).should == true
+      # observations.first.count('[').should == 4
+      # observations.first.count(']').should == 4
+
+      # observations.first[%r{\[ a rdf:Property ;\n <http://semanticscience.org/resource/SIO_000300> 1 \]}].should_not be nil
+    end
+  end
+end

data/spec/csv/bacon.csv

@@ -0,0 +1,4 @@
+producer,pricerange,chunkiness,deliciousness
+hormel,low,1,1
+newskies,medium,6,9
+whys,nonexistant,9001,6

data/spec/csv/moar_bacon.csv

@@ -0,0 +1,11 @@
+producer,pricerange,chunkiness,deliciousness
+hormel,low,1,1
+oscar_mayer,low,6,3
+newskies,medium,2,5
+hormel,low,2,2
+DArtagnan,medium,6,9
+oscar_mayer,low,5,4
+hormel,low,2,1
+farmland,high,6,9
+newskies,medium,6,9
+whys,nonexistant,9001,6

data/spec/data_cube_spec.rb

@@ -0,0 +1,169 @@
+# require_relative '../lib/r2rdf/data_cube.rb'
+# require_relative '../lib/r2rdf/generators/dataframe.rb'
+# require_relative '../lib/r2rdf/r_client.rb'
+# require_relative '../lib/r2rdf/r_builder.rb'
+# require_relative '../lib/r2rdf/generators/csv.rb'
+
+require_relative '../lib/bio-publisci.rb'
+
+
+describe PubliSci::Dataset::DataCube do
+
+	context "with Plain Old Ruby objects" do
+		#define a temporary class to use module methods
+		before(:all) do
+			class Gen
+				include PubliSci::Dataset::DataCube
+			end
+
+			@generator = Gen.new
+			@measures = ['chunkiness','deliciousness']
+			@dimensions = ['producer', 'pricerange']
+			@codes = @dimensions #all dimensions coded for the tests
+			@labels = %w(hormel newskies whys)
+			@data =
+			{
+				"producer" =>      ["hormel","newskies",  "whys"],
+				"pricerange" =>    ["low",   "medium",    "nonexistant"],
+				"chunkiness"=>     [1,         6,          9001],
+				"deliciousness"=>  [1,         9,          6]
+			}
+		end
+
+		it "should have correct output according to the reference file" do
+
+			turtle_string = @generator.generate(@measures, @dimensions, @codes,	@data, @labels, 'bacon')
+			ref = IO.read(File.dirname(__FILE__) + '/turtle/bacon')
+      turtle_string.should == ref
+		end
+
+		context "with missing values" do
+
+			before(:all) do
+				@missing_data = Marshal.load(Marshal.dump(@data))
+				missingobs = {
+					"producer" =>      "missingbacon",
+					"pricerange" =>    "unknown",
+					"chunkiness"=>     nil,
+					"deliciousness"=>  nil,
+				}
+				missingobs.map{|k,v| @missing_data[k] << v}
+			end
+
+			it "skips observations with missing values by default" do
+				turtle_string = @generator.generate(@measures, @dimensions, @codes,	@missing_data, @labels + ["missingbacon"], 'bacon')
+        turtle_string[/.*obsmissingbacon.*\n/].should_not be nil
+        turtle_string[/\S+obsmissingbacon.*prop:chunkiness.*\n\n/m].should be nil
+      end
+
+      it "includes observations with missing values if flag is set" do
+        turtle_string = @generator.generate(@measures, @dimensions, @codes, @missing_data, @labels + ["missingbacon"], 'bacon',{encode_nulls: true})
+        turtle_string[/.*obsmissingbacon.*\n/].should_not be nil
+  			turtle_string[/\S+obsmissingbacon.*prop:chunkiness.*\n\n/m].should_not be nil
+			end
+
+		end
+
+		it 'generates prefixes' do
+				prefixes = @generator.prefixes('bacon')
+				prefixes.is_a?(String).should == true
+			end
+
+			it 'generates data structure definition' do
+				dsd = @generator.data_structure_definition(@measures, @dimensions, @codes, "bacon")
+				dsd.is_a?(String).should == true
+			end
+
+			it 'generates dataset' do
+				dsd = @generator.dataset("bacon")
+				dsd.is_a?(String).should == true
+			end
+
+			it 'generates component specifications' do
+				components = @generator.component_specifications(@measures , @dimensions, @codes, "bacon")
+				components.is_a?(Array).should == true
+				components.first.is_a?(String).should == true
+			end
+
+			it 'generates dimension properties' do
+				dimensions = @generator.dimension_properties(@dimensions,@codes,"bacon")
+				dimensions.is_a?(Array).should == true
+				dimensions.first.is_a?(String).should == true
+			end
+
+			it 'generates measure properties' do
+				measures = @generator.measure_properties(@measures, "bacon")
+				measures.is_a?(Array).should == true
+				measures.first.is_a?(String).should == true
+			end
+
+			it 'generates observations' do
+				#measures, dimensions, codes, var, observation_labels, data, options={}
+
+				observations = @generator.observations(@measures, @dimensions, @codes, @data, @labels, "bacon")
+				observations.is_a?(Array).should == true
+				observations.first.is_a?(String).should == true
+			end
+
+      it "coerces single values into arrays" do
+        newdata = Hash[@data.map{|k,v| [k,v.first] }]
+        observations = @generator.observations(@measures, @dimensions, @codes, newdata, @labels[0], "bacon")
+        observations.is_a?(Array).should == true
+        observations.first.is_a?(String).should == true
+      end
+  end
+
+
+  context "under official integrity constraints" do
+    before(:all) do
+      @graph = RDF::Graph.load(File.dirname(__FILE__) + '/turtle/reference', :format => :ttl)
+      @checks = {}
+      Dir.foreach(File.dirname(__FILE__) + '/queries/integrity') do |file|
+        if file.split('.').last == 'rq'
+          @checks[file.split('.').first] = IO.read(File.dirname(__FILE__) + '/queries/integrity/' + file)
+        end
+      end
+    end
+
+    it 'obeys IC-1, has a unique dataset for each observation' do
+      SPARQL.execute(@checks['1'], @graph).first.should be_nil
+    end
+
+    it 'obeys IC-2, has a unique data structure definition of each dataset' do
+      SPARQL.execute(@checks['2'], @graph).first.should be_nil
+    end
+
+    it 'obeys IC-3, has a measure property specified for each dataset' do
+      SPARQL.execute(@checks['3'], @graph).first.should be_nil
+    end
+
+    it 'obeys IC-4, specifies a range for all dimensions' do
+      SPARQL.execute(@checks['4'], @graph).first.should be_nil
+    end
+
+    it 'obeys IC-5, every dimension with range skos:Concept must have a qb:codeList' do
+      SPARQL.execute(@checks['5'], @graph).first.should be_nil
+    end
+
+    it 'obeys IC-11, has a value for each dimension in every observation' do
+      SPARQL.execute(@checks['11'], @graph).first.should be_nil
+    end
+
+    ## currently locks up. possible bug in SPARQL gem parsing?
+    ## works fine as a raw query
+    # it 'obeys IC-12, has do duplicate observations' do
+    #   SPARQL.execute(@checks['12'], @graph).first.should be_nil
+    # end
+
+    it 'obeys IC-14, has a value for each measure in every observation' do
+      SPARQL.execute(@checks['14'], @graph).first.should be_nil
+    end
+
+    it 'obeys IC-19, all codes for each codeList are included' do
+      SPARQL.execute(@checks['19_1'], @graph).first.should be_nil
+      ## second query for IC-19 uses property paths that aren't as easy to
+      ## convert to sparql 1.0, so for now I've left it out
+      # SPARQL.execute(@checks['19_2'], @graph).first.should be_nil
+    end
+  end
+end

data/spec/dataset_for_spec.rb

@@ -0,0 +1,77 @@
+require_relative '../lib/bio-publisci.rb'
+
+describe PubliSci::Dataset do
+  it "should use sio:has_value for unknown string types" do
+    pending("pending refactor dataset_for to handle raw remote files better")
+    turtle_string = PubliSci::Dataset.for('http://www.biostat.wisc.edu/~kbroman/D3/cistrans/data/probe_data/probe497638.json',false)
+    (turtle_string =~ /hasValue/).should_not be nil
+    # open('ttl.ttl','w'){|f| f.write turtle_string}
+    repo = RDF::Repository.new
+
+    f = Tempfile.new(['repo','.ttl'])
+    f.write(turtle_string)
+    f.close
+    repo.load(f.path, :format => :ttl)
+    f.unlink
+
+    repo.size.should > 0
+  end
+
+  it "can convert arff files" do
+    turtle_string = PubliSci::Dataset.for('resources/weather.numeric.arff',false)
+    turtle_string.should == IO.read('spec/turtle/weather')
+  end
+
+  describe ".register_reader" do
+    it "can register readers to be used by Dataset.for" do
+      PubliSci::Dataset.reader_registry.clear
+      expect { PubliSci::Dataset.for('resources/maf_example.maf') }.to raise_error
+      PubliSci::Dataset.register_reader('.maf',PubliSci::Readers::MAF)
+      file = PubliSci::Dataset.for('resources/maf_example.maf')
+      str = IO.read(file)
+      File.delete(file.path)
+      str.size.should > 0
+      (str =~ /qb:Observation/).should_not be nil
+    end
+  end
+
+  context 'with a csv file' do
+    before(:all) do
+      @file = File.dirname(__FILE__) + '/csv/bacon.csv'
+    end
+
+    it "should load with no prompts if all details are specified" do
+      turtle_string = PubliSci::Dataset.for(@file,{dimensions:["producer"],measures:["pricerange"]},false)
+      (turtle_string =~ /qb:Observation/).should_not be nil
+    end
+
+    it "will download remote files" do
+      turtle_string = PubliSci::Dataset.for('https://raw.github.com/wstrinz/bioruby-publisci/master/spec/csv/bacon.csv',false)
+      (turtle_string =~ /prop:pricerange/).should_not be nil
+      (turtle_string =~ /prop:producer/).should_not be nil
+    end
+
+    it "will request user input if not provided" do
+      gen = PubliSci::Readers::CSV.new
+      gen.stub(:gets).and_return('pricerange,producer')
+      gen.stub(:puts)
+      turtle_string = gen.automatic(@file,nil,{measures:["chunkiness"]})
+      (turtle_string =~ /prop:pricerange/).should_not be nil
+      (turtle_string =~ /prop:producer/).should_not be nil
+    end
+
+    it "will try to guess if told not to be interactive" do
+      turtle_string = PubliSci::Dataset.for(@file,false)
+      (turtle_string =~ /prop:pricerange/).should_not be nil
+      (turtle_string =~ /prop:producer/).should_not be nil
+    end
+
+    it "will attempt to load remote file if given URI" do
+      loc = 'https://raw.github.com/wstrinz/bioruby-publisci/master/spec/csv/bacon.csv'
+      turtle_string = PubliSci::Dataset.for(loc,false)
+      (turtle_string =~ /prop:pricerange/).should_not be nil
+      (turtle_string =~ /prop:producer/).should_not be nil
+    end
+  end
+
+end