bio-publisci 0.0.2 → 0.0.3

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

@@ -1,119 +1,120 @@
 module R2RDF
-	module Reader
-		class BigCross
-			include R2RDF::Dataset::DataCube
-
-			def generate_n3(client, var, outfile_base, options={})
-				meas = measures(client,var,options)
-				dim = dimensions(client,var,options)
-				codes = codes(client,var,options)
-				
-
-				#write structure
-				open(outfile_base+'_structure.ttl','w'){|f| f.write structure(client,var,options)}
-				
-				n_individuals = client.eval("length(#{var}$pheno[[1]])").payload.first
-				chromosome_list = (1..19).to_a.map(&:to_s) + ["X"]
-				chromosome_list.map{|chrom|
-					open(outfile_base+"_#{chrom}.ttl",'w'){|f| f.write prefixes(var,options)}
-					entries_per_individual = client.eval("length(#{var}$geno$'#{chrom}'$map)").to_ruby
-
-					#get genotype data (currently only for chromosome 1)
-					# => puts "#{var}$geno$'#{chrom}'"
-					geno_chr = client.eval("#{var}$geno$'#{chrom}'")
-
-					#get number of markers per individual
-
-					#write observations
-					n_individuals.times{|indi|
-						#time ||= Time.now
-						obs_data = observation_data(client,var,chrom.to_s,indi,geno_chr,entries_per_individual,options)
-						labels = labels_for(obs_data,chrom.to_s,indi)
-						open(outfile_base+"_#{chrom}.ttl",'a'){|f| observations(meas,dim,codes,obs_data,labels,var,options).map{|obs| f.write obs}}
-						puts "(#{chrom}) #{indi}/#{n_individuals}" #(#{Time.now - time})
-						#time = Time.now
-					}
-				}
-
-				#generate(measures, dimensions, codes, observation_data, observation_labels, var, options)
-			end
-
-			def structure(client,var,options={})
-				meas = measures(client,var,options)
-				dim = dimensions(client,var,options)
-				codes = codes(client,var,options)
-
-				str = prefixes(var,options)
-				str << data_structure_definition(meas,var,options)
-				str << dataset(var,options)
-    		component_specifications(meas, dim, var, options).map{ |c| str << c }
-				measure_properties(meas,var,options).map{|m| str << m}
-				
-				str
-			end
-
-			def measures(client, var, options={})
-				pheno_names = client.eval("names(#{var}$pheno)").to_ruby
-				if options[:measures]
-					(pheno_names & options[:measures]) | ["genotype","markerpos","marker"]
-				else
-					pheno_names | ["genotype","markerpos","marker"]
-				end
-				# measure_properties(measures,var,options)
-			end
-
-			def dimensions(client, var, options={})
-				# dimension_properties([""],var)
-				[]
-			end
-
-			def codes(client, var, options={})
-				[]				
-			end
-
-			def labels_for(data,chr,individual,options={})
-				labels=(((data.first.last.size*individual)+1)..(data.first.last.size*(individual+1))).to_a.map(&:to_s)
-				labels.map{|l| l.insert(0,"#{chr}_")}
-				labels
-			end
-
-			def observation_data(client, var, chr, row_individ, geno_chr, entries_per_individual, options={})
-				data = {}
-				# geno_chr = client.eval("#{var}$geno$'#{chr}'")
-				# n_individuals = client.eval("#{var}$pheno[[1]]").to_ruby.size
-				# entries_per_individual = @rexp.payload["geno"].payload[row_individ].payload["map"].payload.size * @rexp.payload["geno"].payload.names.size
-				data["chr"] = []
-				data["genotype"] = []
-				data["individual"] = []
-				data["marker"] = []
-				data["markerpos"] = []
-				client.eval("names(#{var}$pheno)").to_ruby.map{|name|
-					data[name] = []
-				}
-				# n_individuals.times{|row_individ|
-					# puts "#{row_individ}/#{n_individuals}"
-				data["individual"] << (1..entries_per_individual).to_a.fill(row_individ)
-
-				client.eval("names(#{var}$pheno)").to_ruby.map{|name|
-					data[name] << (1..entries_per_individual).to_a.fill(client.eval("#{var}$pheno").payload[name].to_ruby[row_individ])
-				}
-				# @rexp.payload["geno"].payload.names.map { |chr|
-				num_markers = geno_chr.payload.first.to_ruby.column_size
-				data["chr"] << (1..num_markers).to_a.fill(chr)
-				data["genotype"] << geno_chr.payload["data"].to_ruby.row(row_individ).to_a
-				data["marker"] << client.eval("names(#{var}$geno$'#{chr}'$map)").payload
-				data["markerpos"] << geno_chr.payload["map"].to_a
-					# }
-				# }
-				data.map{|k,v| v.flatten!}
-				data
-			end
-
-			def num_individuals(client, var, options={})
-				client.eval("#{var}$pheno").payload.first.to_ruby.size
-			end
-
-
-		end
-	end
+  module Reader
+    class BigCross
+      include R2RDF::Dataset::DataCube
+
+      def generate_n3(client, var, outfile_base, options={})
+        meas = measures(client,var,options)
+        dim = dimensions(client,var,options)
+        codes = codes(client,var,options)
+        
+
+        #write structure
+        open(outfile_base+'_structure.ttl','w'){|f| f.write structure(client,var,options)}
+        
+        n_individuals = client.eval("length(#{var}$pheno[[1]])").payload.first
+        chromosome_list = (1..19).to_a.map(&:to_s) + ["X"]
+        chromosome_list.map{|chrom|
+          open(outfile_base+"_#{chrom}.ttl",'w'){|f| f.write prefixes(var,options)}
+          entries_per_individual = client.eval("length(#{var}$geno$'#{chrom}'$map)").to_ruby
+
+          #get genotype data (currently only for chromosome 1)
+          # => puts "#{var}$geno$'#{chrom}'"
+          geno_chr = client.eval("#{var}$geno$'#{chrom}'")
+
+          #get number of markers per individual
+
+          #write observations
+          n_individuals.times{|indi|
+            #time ||= Time.now
+            obs_data = observation_data(client,var,chrom.to_s,indi,geno_chr,entries_per_individual,options)
+            labels = labels_for(obs_data,chrom.to_s,indi)
+            open(outfile_base+"_#{chrom}.ttl",'a'){|f| observations(meas,dim,codes,obs_data,labels,var,options).map{|obs| f.write obs}}
+            puts "(#{chrom}) #{indi}/#{n_individuals}" #(#{Time.now - time})
+            #time = Time.now
+          }
+        }
+
+        #generate(measures, dimensions, codes, observation_data, observation_labels, var, options)
+      end
+
+      def structure(client,var,options={})
+        meas = measures(client,var,options)
+        dim = dimensions(client,var,options)
+        codes = codes(client,var,options)
+
+        str = prefixes(var,options)
+        str << data_structure_definition(meas,dim,codes,var,options)
+        str << dataset(var,options)
+        component_specifications(meas, dim, var, options).map{ |c| str << c }
+        measure_properties(meas,var,options).map{|m| str << m}
+        
+        str
+      end
+
+      def measures(client, var, options={})
+        pheno_names = client.eval("names(#{var}$pheno)").to_ruby
+        if options[:measures]
+          (pheno_names & options[:measures]) | ["genotype","markerpos","marker"]
+        else
+          pheno_names | ["genotype","markerpos","marker"]
+        end
+        # measure_properties(measures,var,options)
+      end
+
+      def dimensions(client, var, options={})
+        # dimension_properties([""],var)
+        []
+      end
+
+      def codes(client, var, options={})
+        []        
+      end
+
+      def labels_for(data,chr,individual,options={})
+        labels=(((data.first.last.size*individual)+1)..(data.first.last.size*(individual+1))).to_a.map(&:to_s)
+        labels.map{|l| l.insert(0,"#{chr}_")}
+        labels
+      end
+
+      def observation_data(client, var, chr, row_individ, geno_chr, entries_per_individual, options={})
+        data = {}
+        # geno_chr = client.eval("#{var}$geno$'#{chr}'")
+        # n_individuals = client.eval("#{var}$pheno[[1]]").to_ruby.size
+        # entries_per_individual = @rexp.payload["geno"].payload[row_individ].payload["map"].payload.size * @rexp.payload["geno"].payload.names.size
+        data["chr"] = []
+        data["genotype"] = []
+        data["individual"] = []
+        data["marker"] = []
+        data["markerpos"] = []
+        pheno_names = client.eval("names(#{var}$pheno)").to_ruby
+        pheno_names.map{|name|
+          data[name] = []
+        }
+        # n_individuals.times{|row_individ|
+          # puts "#{row_individ}/#{n_individuals}"
+        data["individual"] << (1..entries_per_individual).to_a.fill(row_individ)
+
+        pheno_names.map{|name|
+          data[name] << (1..entries_per_individual).to_a.fill(client.eval("#{var}$pheno$#{name}").to_ruby[row_individ])
+        }
+        # @rexp.payload["geno"].payload.names.map { |chr|
+        num_markers = geno_chr.payload.first.to_ruby.column_size
+        data["chr"] << (1..num_markers).to_a.fill(chr)
+        data["genotype"] << geno_chr.payload["data"].to_ruby.row(row_individ).to_a
+        data["marker"] << client.eval("names(#{var}$geno$'#{chr}'$map)").payload
+        data["markerpos"] << geno_chr.payload["map"].to_a
+          # }
+        # }
+        data.map{|k,v| v.flatten!}
+        data
+      end
+
+      def num_individuals(client, var, options={})
+        client.eval("#{var}$pheno").payload.first.to_ruby.size
+      end
+
+
+    end
+  end
 end

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

@@ -1,7 +1,43 @@
 module R2RDF
 	module Reader
 		class CSV
-			include R2RDF::Dataset::DataCube
+      include R2RDF::Dataset::DataCube
+			include R2RDF::Interactive
+
+      def automatic(file=nil,dataset_name=nil,options={},interactive=true)
+        #to do 
+        unless file || !interactive
+          puts "Input file?"
+          file = gets.chomp
+        end
+        
+        raise "CSV reader needs an input file" unless file && file.size > 0
+
+        
+        unless dataset_name
+          if interactive
+            dataset_name = interact("Dataset name?","#{File.basename(file).split('.').first}"){|sel| File.basename(file).split('.').first }
+          else
+            dataset_name = File.basename(file).split('.').first
+          end
+        end
+        
+
+        categories = ::CSV.read(file)[0]
+
+
+        unless options[:dimensions] || !interactive
+          options[:dimensions] = Array(interact("Dimensions?",categories[0],categories))
+        end
+
+        unless options[:measures] || !interactive
+          meas = categories - ((options[:dimensions] || []) | [categories[0]])
+          selection = interact("Measures?",meas,meas){|s| nil}
+          options[:measures] = Array(selection) unless options[:measures] == nil
+        end
+
+        generate_n3(file,dataset_name,options)
+      end
 
 			def generate_n3(file, dataset_name, options={})
 				@data = ::CSV.read(file)
@@ -34,7 +70,6 @@ module R2RDF
 			end
 
 			def observation_data
-
 				obs = {}
 				@data[0].map{|label|
 					obs[label] = []

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

@@ -50,7 +50,7 @@ module R2RDF
 				codes = codes(client,var,options)
 
 				str = prefixes(var, options)
-				str << data_structure_definition(meas,outvar,options)
+				str << data_structure_definition(meas,[],codes,outvar,options)
 				str << dataset(outvar,options)
     		component_specifications(meas, dim, var, options).map{ |c| str << c }
 				measure_properties(meas,var,options).map{|m| str << m}

data/lib/bio-publisci/store.rb

@@ -1,56 +1,56 @@
 module R2RDF
   # handles connection and messaging to/from the triple store
   class Store
-  	include R2RDF::Query
+    include R2RDF::Query
 
     def defaults
-	    {
-	      type: :fourstore,
-	      url: "http://localhost:8080", #TODO port etc should eventually be extracted from URI if given
+      {
+        type: :fourstore,
+        url: "http://localhost:8080", #TODO port etc should eventually be extracted from URI if given
         replace: false
-	    }
-	  end
+      }
+    end
 
-	  def add(file,graph)
-	  	if @options[:type] == :graph
-	  		throw "please provide an RDF::Repository" unless graph.is_a? RDF::Repository
-	  		graph.load(file)
-	  		@store = graph
-	  		@store
-	  	elsif @options[:type] == :fourstore
-		  	if @options[:replace]
+    def add(file,graph)
+      if @options[:type] == :graph
+        throw "please provide an RDF::Repository" unless graph.is_a? RDF::Repository
+        graph.load(file)
+        @store = graph
+        @store
+      elsif @options[:type] == :fourstore
+        if @options[:replace]
           `curl -T #{file} -H 'Content-Type: application/x-turtle' #{@options[:url]}/data/http%3A%2F%2Frqtl.org%2F#{graph}`
         else
           `curl --data-urlencode data@#{file} -d 'graph=http%3A%2F%2Frqtl.org%2F#{graph}' -d 'mime-type=application/x-turtle' #{@options[:url]}/data/`
         end
-		  end
-	  end
+      end
+    end
 
-	  def add_all(dir, graph, pattern=nil)
-	  	pattern = /.+\.ttl/ if pattern == :turtle || pattern == :ttl 
+    def add_all(dir, graph, pattern=nil)
+      pattern = /.+\.ttl/ if pattern == :turtle || pattern == :ttl 
 
-	  	files = Dir.entries(dir) - %w(. ..)
-	  	files = files.grep(pattern) if pattern.is_a? Regexp
-	  	nfiles = files.size
-			n = 0
-			files.each{|file| puts file + " #{n+=1}/#{nfiles} files"; puts add(file,graph)}
-	  end
+      files = Dir.entries(dir) - %w(. ..)
+      files = files.grep(pattern) if pattern.is_a? Regexp
+      nfiles = files.size
+      n = 0
+      files.each{|file| puts file + " #{n+=1}/#{nfiles} files"; puts add(file,graph)}
+    end
 
     def initialize(options={})
       @options = defaults.merge(options)
     end
 
     def query(string)
-    	# execute(string, )
-			if @options[:type] == :graph
-				execute(string, @store, :graph)
-			elsif @options[:type] == :fourstore
-				execute(string, @options[:url], :fourstore)
-		  end
+      # execute(string, )
+      if @options[:type] == :graph
+        execute(string, @store, :graph)
+      elsif @options[:type] == :fourstore
+        execute(string, @options[:url], :fourstore)
+      end
     end
 
     def url
-    	@options[:url]
+      @options[:url]
     end
   end
 end

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

@@ -1,12 +1,12 @@
 module R2RDF
-	module Writer
-		class ARFF
-			include R2RDF::Query
-			include R2RDF::Parser
-			include R2RDF::Analyzer
+  module Writer
+    class ARFF
+      include R2RDF::Query
+      include R2RDF::Parser
+      include R2RDF::Analyzer
 
-			def build_arff(relation, attributes, data, source)
-				str = <<-EOS
+      def build_arff(relation, attributes, data, source)
+        str = <<-EOS
 % 1. Title: #{relation.capitalize} Database
 %
 % 2. Sources:
@@ -16,51 +16,50 @@ module R2RDF
 
 EOS
 
-				Hash[attributes.sort].map{|attribute,type|
-					str << "@ATTRIBUTE #{attribute} #{type}\n"
-				}
+        Hash[attributes.sort].map{|attribute,type|
+          str << "@ATTRIBUTE #{attribute} #{type}\n"
+        }
 
-				str << "\n@DATA\n"
-				data.map { |d| str << Hash[d[1].sort].values.join(',') + "\n" }
+        str << "\n@DATA\n"
+        data.map { |d| str << Hash[d[1].sort].values.join(',') + "\n" }
 
-				str
-			end
+        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 = get_ary(execute_from_file("dimensions.rq",repo,:graph)).flatten
-				meas = get_ary(execute_from_file("measures.rq",repo,:graph)).flatten
-				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
-				}
+      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 = 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
+        }
 
-				data = observation_hash(execute_from_file("observations.rq",repo,:graph), true)
-				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
-				}
+        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]]})
+            when "xsd:int"
+              "integer"
+            when "xsd:double"
+              "real"
+            when :coded
+              if dims.include? component
+                "{#{codes[component[1]].join(',')}}"
+              else
+                "string"
+              end
+            end
+        }
+        build_arff(relation, attributes, data, turtle_file)
+      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"
-			end
-		end
-	end
+      def from_store(endpoint_url,variable_in=nil, variable_out=nil, verbose=false)
+        raise "not implemented yet"
+      end
+    end
+  end
 end

data/lib/bio-publisci.rb

@@ -8,6 +8,8 @@ require 'sparql'
 require 'sparql/client'
 require 'rdf/turtle'
 
+# require 'bio-band'
+
 def load_folder(folder)
 	Dir.foreach(File.dirname(__FILE__) + "/#{folder}") do |file|
 		unless file == "." or file == ".."
@@ -23,6 +25,7 @@ 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_folder('bio-publisci/metadata')

data/resources/queries/code_resources.rq

@@ -0,0 +1,10 @@
+PREFIX qb:   <http://purl.org/linked-data/cube#> 
+PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> 
+PREFIX skos:  <http://www.w3.org/2004/02/skos/core#> 
+
+SELECT DISTINCT ?dimension ?dimLabel ?codeList ?class WHERE{
+  ?dimension a qb:DimensionProperty;
+    rdfs:label ?dimLabel;
+    qb:codeList ?codeList;
+    rdfs:range ?class.
+}

data/resources/queries/dimension_ranges.rq

@@ -1,8 +1,8 @@
 PREFIX qb:   <http://purl.org/linked-data/cube#> 
 PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> 
 
-SELECT DISTINCT ?dimension ?range WHERE {
-	?dim a qb:DimensionProperty;
-		rdfs:label ?dimension;
+SELECT DISTINCT ?dimension ?range ?label WHERE {
+	?dimension a qb:DimensionProperty;
+		rdfs:label ?label;
 		rdfs:range ?range.
 }

data/resources/queries/dimensions.rq

@@ -1,7 +1,7 @@
 PREFIX qb:   <http://purl.org/linked-data/cube#> 
 PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> 
 
-SELECT DISTINCT ?dimension WHERE{
-	?dim a qb:DimensionProperty;
-		rdfs:label ?dimension.		
+SELECT DISTINCT ?dimension ?label WHERE{
+	?dimension a qb:DimensionProperty;
+		rdfs:label ?label.		
 }

data/resources/queries/measures.rq

@@ -1,7 +1,7 @@
 PREFIX qb:   <http://purl.org/linked-data/cube#> 
 PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> 
 
-SELECT DISTINCT ?measure WHERE{
-	?meas a qb:MeasureProperty;
-		rdfs:label ?measure.
+SELECT DISTINCT ?measure ?label WHERE{
+	?measure a qb:MeasureProperty;
+		rdfs:label ?label.
 }

data/resources/queries/observation_labels.rq

@@ -0,0 +1,8 @@
+PREFIX qb:   <http://purl.org/linked-data/cube#> 
+PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> 
+PREFIX prop:  <http://www.rqtl.org/dc/properties/> 
+
+SELECT DISTINCT ?observation ?label WHERE{
+  ?observation a qb:Observation;
+    rdfs:label ?label.
+}

data/resources/queries/properties.rq

@@ -0,0 +1,8 @@
+SELECT DISTINCT ?comp ?label
+WHERE {
+  {?comp a qb:MeasureProperty;
+    rdfs:label ?label.}
+  UNION
+  {?comp a qb:DimensionProperty;
+    rdfs:label ?label.}
+}LIMIT 5

data/scripts/islet_mlratio.rb

@@ -0,0 +1,6 @@
+load File.dirname(__FILE__) + '/../lib/bio-publisci.rb'
+
+gen = R2RDF::Reader::RMatrix.new
+con = Rserve::Connection.new
+con.eval("load('#{ARGV[0] || './.RData'}')")
+gen.generate_n3(con, "islet.mlratio", "pheno", {measures: ["probe","individual","pheno"], no_labels: true})

data/scripts/scan_islet.rb

@@ -0,0 +1,6 @@
+load File.dirname(__FILE__) + '/../lib/bio-publisci.rb'
+
+gen = R2RDF::Reader::RMatrix.new
+con = Rserve::Connection.new
+con.eval("load('#{ARGV[0] || './.RData'}')")
+gen.generate_n3(con, "scan.islet", "scan", {measures: ["probe","marker","lod"], no_labels: true})

data/scripts/update_reference.rb

@@ -0,0 +1,20 @@
+puts "Really rewrite reference files? This could mess up the tests... [y/N]"
+exit unless gets.chomp == 'y'
+
+puts "overwriting #{File.absolute_path(File.dirname(__FILE__) + '/../spec/turtle/bacon')}"
+load File.dirname(__FILE__) + '/../lib/bio-publisci.rb'
+
+gen = R2RDF::Reader::CSV.new
+turtle_string = gen.generate_n3(File.dirname(__FILE__) + '/../spec/csv/bacon.csv','bacon',{dimensions:["producer","pricerange"], label_column:0})
+open(File.dirname(__FILE__) + '/../spec/turtle/bacon', 'w'){|f| f.write turtle_string}
+
+rcon = Rserve::Connection.new
+gen = R2RDF::Reader::Dataframe.new
+rcon.void_eval <<-EOF
+library(qtl)
+data(listeria)
+mr = scanone(listeria,method="mr")
+EOF
+rexp = rcon.eval 'mr'
+turtle_string = gen.generate_n3(rexp,'mr')
+open(File.dirname(__FILE__) + '/../spec/turtle/reference', 'w'){|f| f.write turtle_string}

data/spec/ORM/data_cube_orm_spec.rb

@@ -0,0 +1,12 @@
+require_relative '../../lib/bio-publisci.rb'
+
+describe R2RDF::Dataset::ORM::DataCube do
+
+  it "should load and save a turtle file without loss of information" do
+    ref = IO.read(File.dirname(__FILE__) + '/../turtle/bacon')
+    cube = R2RDF::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
+  
+end

data/spec/data_cube_spec.rb

@@ -68,7 +68,7 @@ describe R2RDF::Dataset::DataCube do
 			end
 
 			it 'generates data structure definition' do
-				dsd = @generator.data_structure_definition(@measures | @dimensions, "bacon")
+				dsd = @generator.data_structure_definition(@measures, @dimensions, @codes, "bacon")
 				dsd.is_a?(String).should == true
 			end