bio-publisci 0.0.7 → 0.0.8

data/Gemfile

@@ -14,7 +14,7 @@ group :development do
   gem "bio", ">= 1.4.2"
   gem "rdoc", "~> 3.12"
   gem "spoon"
-  gem "spira"
+  gem "spira", git: "https://github.com/ruby-rdf/spira.git"
 end
 
 

data/Rakefile

@@ -21,7 +21,7 @@ Jeweler::Tasks.new do |gem|
   gem.description = %Q{A toolkit for publishing scientific results and datasets using RDF, OWL, and related technologies }
   gem.email = "wstrinz@gmail.com"
   gem.authors = ["Will Strinz"]
-  gem.version = "0.0.7"
+  gem.version = "0.0.8"
 
   # dependencies defined in Gemfile
 end

data/features/orm_steps.rb

@@ -1,7 +1,7 @@
 require_relative '../lib/bio-publisci.rb'
 
 Given /^an ORM::DataCube entitled "(.*?)"$/ do |name|
-	@cube = PubliSci::ORM::DataCube.new(name: name)
+	@cube = PubliSci::DataSet::ORM::DataCube.new(name: name)
 end
 
 Given /^an ORM::DataCube entitled "(.*?)" with the following options:$/ do |name, opts|
@@ -18,7 +18,7 @@ Given /^an ORM::DataCube entitled "(.*?)" with the following options:$/ do |name
 
 		options_hash[k] = v
 	}
-	@cube = PubliSci::ORM::DataCube.new(options_hash)
+	@cube = PubliSci::DataSet::ORM::DataCube.new(options_hash)
 end
 
 Given(/^a turtle string from file (.*)$/) do |file|
@@ -30,7 +30,7 @@ Given(/^the URI string "(.*?)"$/) do |uri|
 end
 
 When(/^I call the ORM::DataCube class method load on it$/) do
-  @cube = PubliSci::ORM::DataCube.load(@string)
+  @cube = PubliSci::DataSet::ORM::DataCube.load(@string)
 end
 
 When /^I add a "(.*?)" dimension$/ do |dim|
@@ -70,5 +70,5 @@ Then /^the to_n3 method should return a string with a "(.*?)"$/ do |search|
 end
 
 Then(/^I should receive an ORM::DataCube object$/) do
-  @cube.is_a?(PubliSci::ORM::DataCube).should == true
+  @cube.is_a?(PubliSci::DataSet::ORM::DataCube).should == true
 end

data/features/reader.feature

@@ -6,20 +6,20 @@ Feature: generate RDF
 	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 
+			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 
+			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 
+			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

@@ -41,6 +41,7 @@ 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|

data/features/writer.feature

@@ -1,9 +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::Writer object
+	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
+		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

@@ -1,5 +1,5 @@
 Given(/^a (.*) writer$/) do |type|
-  @writer = PubliSci::Writer.const_get(type).new
+  @writer = PubliSci::Writers.const_get(type).new
 end
 
 When(/^I call its from_turtle method on the file (.*)$/) do |file|
@@ -13,5 +13,12 @@ When(/^I call its from_turtle method on the turtle string$/) do
 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

@@ -34,9 +34,11 @@ 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_folder('bio-publisci/dsl')
@@ -47,7 +49,7 @@ 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 == ".."
+	# unless file == "." or file == ".."
 # 		load File.dirname(__FILE__) + '/generators/' + file
 # 	end
 # end

data/lib/bio-publisci/datacube_model.rb

@@ -2,14 +2,6 @@ require 'rdf/4store'
 
 module PubliSci
   module ORM
-
-    # class Person < Spira::Base
-    # configure :base_uri => "http://example.org/example/people"
-
-    # property :name, :predicate => FOAF.name, :type => String
-
-    # end
-
     # class Observation < Spira::Base
     #   type RDF::URI.new('http://purl.org/linked-data/cube#Observation')
     #   property :label, predicate: RDFS.label
@@ -25,13 +17,14 @@ module PubliSci
 
     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
@@ -51,20 +44,53 @@ module PubliSci
       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')
+    # 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
+    #       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)
+    #       ((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
-      Observation
+
+      # 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

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

@@ -1,238 +1,240 @@
 module PubliSci
-  module ORM
-    class DataCube
-      extend PubliSci::Dataset::DataCube
-      extend PubliSci::Analyzer
-      # extend PubliSci::Metadata
-      extend PubliSci::Query
-      extend PubliSci::Parser
-
-      include PubliSci::Dataset::DataCube
-      include PubliSci::Analyzer
-      include PubliSci::Metadata::Generator
-      include PubliSci::Query
-      include PubliSci::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
+  module DataSet
+    module ORM
+      class DataCube
+        extend PubliSci::Dataset::DataCube
+        extend PubliSci::Analyzer
+        # extend PubliSci::Metadata
+        extend PubliSci::Query
+        extend PubliSci::Parser
+
+        include PubliSci::Dataset::DataCube
+        include PubliSci::Analyzer
+        include PubliSci::Metadata::Generator
+        include PubliSci::Query
+        include PubliSci::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)
+        def self.load(graph,options={},verbose=false)
 
 
-        graph = load_string(graph) unless graph =~ /^http/
+          graph = load_string(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 = solution[:range].to_s
-          end
-          [solution[:dimension], {type: type}]
-        }]
-        puts "dimensions: #{dimensions}" if verbose
-
-        codes = execute_from_file('code_resources.rq',graph).to_h.map{|sol|
-          [sol[:dimension].to_s, sol[:codeList].to_s, sol[:class].to_s]
-        }
-        puts "codes: #{codes}" if verbose
-
-        measures = execute_from_file('measures.rq',graph).to_h.map{|m| m[:measure].to_s}
-        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)
-        observations = observation_hash(obs)
-        puts "observations: #{observations}" if verbose
-
-        # simple_observations = observation_hash(obs,true)
-
-        labels = execute_from_file('observation_labels.rq', graph)
-        labels = Hash[labels.map{|sol|
-          [sol[:observation].to_s, sol[:label].to_s]
-        }]
-
-        new_opts = {
-          measures: measures,
-          dimensions: dimensions,
-          observations: observations.values,
-          name: name,
-          labels: labels.values,
-          codes: codes
-        }
-
-        options = options.merge(new_opts)
-        puts "creating #{options}" if verbose
-        self.new(options)
-      end
+          # 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 = solution[:range].to_s
+            end
+            [solution[:dimension], {type: type}]
+          }]
+          puts "dimensions: #{dimensions}" if verbose
 
-      def parse_options(options)
-        if options[:dimensions]
-          options[:dimensions].each{|name,details|
-            add_dimension(name, details[:type] || :coded)
+          codes = execute_from_file('code_resources.rq',graph).to_h.map{|sol|
+            [sol[:dimension].to_s, sol[:codeList].to_s, sol[:class].to_s]
           }
-        end
+          puts "codes: #{codes}" if verbose
 
-        if options[:measures]
-          options[:measures].each{|m| @measures << m}
-        end
+          measures = execute_from_file('measures.rq',graph).to_h.map{|m| m[:measure].to_s}
+          puts "measures: #{measures}" if verbose
 
-        if options[:observations]
-          options[:observations].each{|obs_data| add_observation obs_data}
-        end
+          name = execute_from_file('dataset.rq',graph).to_h.first[:label]
+          puts "dataset: #{name}" if verbose
 
-        @generator_options = options[:generator_options] if options[:generator_options]
-        @options[:skip_metadata] = options[:skip_metadata] if options[:skip_metadata]
+          obs = execute_from_file('observations.rq',graph)
+          observations = observation_hash(obs)
+          puts "observations: #{observations}" if verbose
 
-        if options[:name]
-          @name = options[:name]
-        else
-          raise "No dataset name specified!"
-        end
+          # simple_observations = observation_hash(obs,true)
 
-        if options[:validate_each]
-          @options[:validate_each] = options[:validate_each]
-        end
+          labels = execute_from_file('observation_labels.rq', graph)
+          labels = Hash[labels.map{|sol|
+            [sol[:observation].to_s, sol[:label].to_s]
+          }]
 
-        if options[:labels]
-          @labels = options[:labels]
-        end
+          new_opts = {
+            measures: measures,
+            dimensions: dimensions,
+            observations: observations.values,
+            name: name,
+            labels: labels.values,
+            codes: codes
+          }
 
-        if options[:codes]
-          @codes = options[:codes]
+          options = options.merge(new_opts)
+          puts "creating #{options}" if verbose
+          self.new(options)
         end
-      end
 
-      def to_n3
+        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]
 
-        #create labels if not specified
-        unless @labels.is_a?(Array) && @labels.size == @obs.size
-          if @labels.is_a? Symbol
-            #define some automatic labeling methods
+          if options[:name]
+            @name = options[:name]
           else
-            @labels = (1..@obs.size).to_a.map(&:to_s)
+            raise "No dataset name specified!"
+          end
+
+          if options[:validate_each]
+            @options[:validate_each] = options[:validate_each]
+          end
+
+          if options[:labels]
+            @labels = options[:labels]
+          end
+
+          if options[:codes]
+            @codes = options[:codes]
           end
         end
-        data = {}
 
+        def to_n3
 
-        #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 unless @codes
-        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,
+          #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]
+            }
           }
-          # puts basic(fields,@generator_options)
-          str += "\n" + basic(fields)
+
+
+          @codes = @dimensions.map{|d,v| d if v[:type] == :coded}.compact unless @codes
+          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)
+          end
+          str
         end
-        str
-      end
 
-      def add_dimension(name, type=:coded)
-        @dimensions[name.to_s] = {type: type}
-      end
+        def add_dimension(name, type=:coded)
+          @dimensions[name.to_s] = {type: type}
+        end
 
-      def add_measure(name)
-        @measures << name
-      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 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 insert(observation)
+          @obs << observation
+        end
 
-      def publishers
-        @meta[:publishers] ||= []
-      end
+        def publishers
+          @meta[:publishers] ||= []
+        end
 
-      def publishers=(publishers)
-        @meta[:publishers] = publishers
-      end
+        def publishers=(publishers)
+          @meta[:publishers] = publishers
+        end
 
-      def subjects
-        @meta[:subject] ||= []
-      end
+        def subjects
+          @meta[:subject] ||= []
+        end
 
-      def subjects=(subjects)
-        @meta[:subject]=subjects
-      end
+        def subjects=(subjects)
+          @meta[:subject]=subjects
+        end
 
-      def add_publisher(label,uri)
-        publishers << {label: label, uri: uri}
-      end
+        def add_publisher(label,uri)
+          publishers << {label: label, uri: uri}
+        end
 
-      def add_subject(id)
-        subject << id
-      end
+        def add_subject(id)
+          subject << id
+        end
 
-      def author
-        @meta[:creator] ||= ""
-      end
+        def author
+          @meta[:creator] ||= ""
+        end
 
-      def author=(author)
-        @meta[:creator] = author
-      end
+        def author=(author)
+          @meta[:creator] = author
+        end
 
-      def description
-        @meta[:description] ||= ""
-      end
+        def description
+          @meta[:description] ||= ""
+        end
 
-      def description=(description)
-        @meta[:description] = 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
+          @meta[:date] ||= "#{Time.now.day}-#{Time.now.month}-#{Time.now.year}"
+        end
 
-      def date=(date)
-        @meta[:date] =  date
-      end
+        def date=(date)
+          @meta[:date] =  date
+        end
 
-      def to_h
-        {
-          measures: @measures,
-          dimensions: @dimensions,
-          observations: @obs.map{|o| o.data}
-        }
+        def to_h
+          {
+            measures: @measures,
+            dimensions: @dimensions,
+            observations: @obs.map{|o| o.data}
+          }
+        end
       end
     end
   end