publisci 0.1.2

data/examples/visualization/prov_viz.rb

@@ -0,0 +1,140 @@
+require 'bio-publisci'
+require 'graphviz'
+
+def entity_node(label)
+  ent = @g.add_nodes(label)
+  ent.color = "#F3F781"
+  ent.style = "filled"
+  ent
+end
+
+def agent_node(label)
+  ag = @g.add_nodes(label)
+  ag.color = "#FE9A2E"
+  ag.style = "filled"
+	ag.shape = "box"
+	ag
+end
+
+def activity_node(label)
+	act = @g.add_nodes(label)
+	act.color = "#5858FA"
+	act.style = "filled"
+	act.shape = "box"
+	act
+end
+
+def generic_node(label)
+  act = @g.add_nodes(label)
+  # act.color = "#5858FA"
+  # act.style = "filled"
+  act.shape = "box"
+  act
+end
+
+def make_edges(from_obj,to_class,predicate)
+  # from_class.enum_for.to_a.map{|from_obj|
+    raise "Unknown From Node: #{from_obj.subject}" unless @nodemap[from_obj.subject]
+    relation = from_obj.send(predicate)
+    if relation
+      if relation.is_a? Array
+        relation.map{|r|
+        other = to_class.for(r)
+        raise "Unknown To Node: #{other.subject}" unless @nodemap[other.subject]
+          @g.add_edges(@nodemap[from_obj.subject],@nodemap[other.subject]).label=predicate.to_s
+        }
+      else
+        other = to_class.for(relation)
+        raise "Unknown To Node: #{other.subject}" unless @nodemap[other.subject]
+        @g.add_edges(@nodemap[from_obj.subject],@nodemap[other.subject]).label=predicate.to_s
+      end
+    end
+  # }
+end
+
+@nodemap={}
+@g = GraphViz.new(:G, type: :digraph)
+infile = ARGV[0] || 'primer.prov'
+runner = PubliSci::Prov::DSL::Instance.new
+runner.instance_eval(IO.read(infile),infile)
+repo = runner.to_repository
+Spira.add_repository :default, repo
+
+include PubliSci::Prov::Model
+
+Entity.enum_for.to_a.map{|e|
+  @nodemap[e.subject]=entity_node(e.label)
+}
+
+Agent.enum_for.to_a.map{|agent|
+  @nodemap[agent.subject]=agent_node(agent.label)
+}
+
+Activity.enum_for.to_a.map{|act|
+  @nodemap[act.subject]=activity_node(act.label)
+}
+
+Association.enum_for.to_a.map{|association|
+  @nodemap[association.subject]=generic_node(association.label)
+}
+
+Plan.enum_for.to_a.map{|plan|
+  @nodemap[plan.subject]=generic_node(plan.label)
+}
+
+
+# Derivation.enum_for.to_a.map{|deriv|
+#   @nodemap[deriv.subject]=generic_node(deriv.label)
+# }
+
+Entity.enum_for.to_a.map{|e|
+  attribs ={
+    "wasAttributedTo" => Agent,
+    "wasGeneratedBy" => Activity,
+    "wasDerivedFrom" => Entity,
+  }
+  attribs.each{|predicate,range| make_edges(e,range,predicate)}
+}
+
+Activity.enum_for.to_a.map{|act|
+  attribs ={
+    "generated" => Entity,
+    "used" => Entity,
+    "wasAssociatedWith" => Agent,
+    "qualifiedAssociation" => Agent,
+  }
+  attribs.each{|predicate,range| make_edges(act,range,predicate)}
+}
+
+Agent.enum_for.to_a.map{|agent|
+  attribs = {
+    "actedOnBehalfOf" => Agent
+  }
+  attribs.each{|predicate,range| make_edges(agent,range,predicate)}
+}
+
+Association.enum_for.to_a.map{|assoc|
+  attribs ={
+    "agent" => Agent,
+    "hadPlan" => Plan
+  }
+  attribs.each{|predicate,range| make_edges(assoc,range,predicate)}
+}
+
+# Association.enum_for.to_a.map{|assoc|
+#   attribs ={
+#     "agent" => Agent
+#     "hadPlan" => Plan
+#   }
+#   attribs.each{|predicate,range| make_edges(assoc,range,predicate)}
+# }
+
+# Derivation.enum_for.to_a.map{|assoc|
+#   attribs ={
+#     "agent" => Entity
+#   }
+#   attribs.each{|predicate,range| make_edges(assoc,range,predicate)}
+# }
+
+@g.output(png: "out.png")
+begin `eog out.png` rescue nil end

data/examples/visualization/viz.rb

@@ -0,0 +1,35 @@
+require 'graphviz'
+
+def entity_node(label)
+  ent = @g.add_nodes(label)
+  ent.color = "#F3F781"
+  ent.style = "filled"
+  ent
+end
+
+def agent_node(label)
+  ag = @g.add_nodes(label)
+  ag.color = "#FE9A2E"
+  ag.style = "filled"
+	ag.shape = "box"
+	ag
+end
+
+def activity_node(label)
+  act = @g.add_nodes(label)
+  act.color = "#5858FA"
+  act.style = "filled"
+  act.shape = "box"
+  act
+end
+
+@g = GraphViz.new(:G, type: :digraph)
+g = @g
+
+ent_n = entity_node("entity") #g.add_nodes("entity")
+ag_n = activity_node("activity")
+
+g.add_edges(ent_n,ag_n).label="attributed"
+
+g.output(png: "out.png")
+`eog out.png`

data/features/create_generator.feature

@@ -0,0 +1,21 @@
+Feature: create generators
+
+	In order to check that objects conform to a common interface
+	I want to be able to call a generate method on various classes
+
+	Scenario: create a Dataframe generator
+		Given a Dataframe generator
+		Then I should be able to call its generate_n3 method
+
+	Scenario: create a CSV generator
+		Given a CSV generator
+		Then I should be able to call its generate_n3 method
+
+	Scenario: create a RMatrix generator
+		Given a RMatrix generator
+		Then I should be able to call its generate_n3 method
+
+	Scenario: create a RCross generator
+		Given a RCross generator
+		Then I should be able to call its generate_n3 method
+

data/features/integration.feature

@@ -0,0 +1,12 @@
+Feature: Integrate with other GSOC projects
+
+  In order to leverage the data sharing and comprehension power of RDF
+  I want to integrate my code with that of other GSOC students
+
+  Scenario: Integrate with Ruby Mining
+    Given a CSV generator
+    When I provide the reference file spec/csv/moar_bacon.csv and the label "moar_bacon" and the options {dimensions:["producer","pricerange"]}
+    And generate a turtle string from it
+    Given a ARFF writer
+    When I call its from_turtle method on the turtle string
+    Then I should be able to cluster the result and print statistics

data/features/integration_steps.rb

@@ -0,0 +1,10 @@
+Then(/^I should be able to cluster the result and print statistics$/) do
+  pending
+  # f=Tempfile.open('arff'); f.write @result; f.close
+  # clustering = Weka::Clusterer::SimpleKMeans::Base
+  # clustering.set_options "-N 5"
+  # clustering.set_data(Core::Parser::parse_ARFF(f.path))
+  # f.unlink
+  # clustered = clustering.new
+  # puts clustered
+end

data/features/metadata.feature

@@ -0,0 +1,37 @@
+Feature: Receive metadata as user input or extract from data sources
+
+  In order to publish and share data about my datasets
+  I want to be able to attach metadata
+
+  Scenario: Attach basic DC Terms info
+    Given a class which includes the Metadata module
+    When I call its basic method with the hash {var: "example", title: "example dataset", creator: "Will Strinz", description: "an example dataset", date: "1-10-2010"}
+    Then I should receive a metadata string
+
+  Scenario: Auto Generate some fields
+    Given a class which includes the Metadata module
+    When I call its basic method with the hash {var: "example", title: "example dataset", description: "an example dataset"}
+    Then I should receive a metadata string
+
+  Scenario: Generate process information
+    Given a class which includes the Metadata module
+    And the source object {resource: 'http://example.org/software/R/var/ex', software:'http://r-project.org', process: 'spec/resource/example.Rhistory'}
+    And the rdf dataset {resource:'http://example.org/data'}
+    When I call its provenance method with the source object and the rdf object
+    Then I should receive a metadata string
+
+  Scenario: Generate organizational provenance information
+    Given a class which includes the Metadata module
+    And the source object {resource: 'http://example.org/software/R/var/ex', author: 'http://example.org/people/jrs', author_name: "J Random Scientist", organization: 'http://example.org/org/science', organization_name: "The League of Science" }
+    And the rdf dataset {resource:'http://example.org/data', author: 'http://gsocsemantic.wordpress.com/me', author_name: "Will Strinz", organization: 'http://sciruby.com/'}
+    When I call its provenance method with the source object and the rdf object
+    Then I should receive a metadata string
+
+  Scenario: Generate a provenance chain
+    Given a class which includes the Metadata module
+    And the source object {resource: 'http://example.org/software/R/var/ex', software:'http://r-project.org'}
+    And the rdf dataset {resource:'http://example.org/data'}
+    And the chain object {resource: 'http://example.org/lab_results/1', author: 'http://example.org/people/brl', author_name: "B Random Labtech"}
+    And the chain object {resource: 'http://example.org/field_work/1', author: 'http://example.org/people/arn', organization: 'http://example.org/org/science'}
+    When I call its provenance method with the source object, the rdf object, and the chain
+    Then I should receive a metadata string

data/features/metadata_steps.rb

@@ -0,0 +1,40 @@
+Given(/^a class which includes the Metadata module$/) do
+
+  @klass = Class.new {include PubliSci::Metadata::Generator}
+end
+
+Given(/^the source object (\{.+\})$/) do |fields|
+  @original = eval(fields)
+end
+
+Given(/^the rdf dataset (\{.+\})$/) do |fields|
+  @rdf = eval(fields)
+end
+
+Given(/^the chain object (\{.+\})$/) do |fields|
+  (@chain ||= []) << eval(fields)
+end
+
+When(/^I call its provenance method with the source object, the rdf object, and the chain$/) do
+  @response = @klass.new.provenance(@original, @rdf, @chain)
+end
+
+
+When(/^I call its provenance method with the source object and the rdf object$/) do
+  @response = @klass.new.provenance(@original, @rdf, nil)
+end
+
+When(/^I call its basic method with the hash (\{.+\})$/) do |fields|
+  fields = eval(fields)
+  @response = @klass.new.basic(fields)
+end
+
+When(/^I call its provenance method with the hash (\{.+\})$/) do |fields|
+  fields = eval(fields)
+  @response = @klass.new.provenance(fields)
+end
+
+Then(/^I should receive a metadata string$/) do
+  @response.is_a?(String).should be true
+  puts @response
+end

data/features/orm.feature

@@ -0,0 +1,60 @@
+Feature: generate data using ORM
+	
+	In order to make the generator simpler and more accessible to ruby users
+	I want to implement an ORM (OTM? OGM?) to assist creation of datacube objects
+
+	Scenario: build data cube and export turtle
+		Given an ORM::DataCube entitled "cats"
+		When I add a "size" dimension
+		And I add a "breed" dimension
+		And I add a "fluffiness" measure
+		And I add the observation {size: "big", breed: "American Shorthair", fluffiness: 100}
+		And I add the observation {size: "huge", breed: "Maine Coon", fluffiness: 9001}
+		And I add the observation {size: "little", breed: "American Shorthair", fluffiness: 15}
+    Then the to_n3 method should return a string
+
+  Scenario: load from turtle string
+  	Given a turtle string from file spec/turtle/bacon
+  	When I call the ORM::DataCube class method load on it
+  	Then I should receive an ORM::DataCube object
+    And the to_n3 method should return a string
+
+  Scenario: load from endpoint
+  	Given the URI string "http://localhost:8080"
+  	When I call the ORM::DataCube class method load on it
+  	Then I should receive an ORM::DataCube object
+    And the to_n3 method should return a string
+
+  Scenario: raise error when unknown components are used
+    Given an ORM::DataCube entitled "animals"
+    When I add a "robustness" dimension
+    And I add a "species" measure
+    And I add the observation {species: "Balaenoptera musculus", robustness: 25}
+    And I add the observation {species: "Hypsibius dujardini", robustness: 9001}
+    Then the to_n3 method should return a string
+    When I add the observation {species: "Deinococcus radiodurans", robustness: 350, chunkiness: 9}
+    Then the to_n3 method should raise error UnknownProperty ["chunkiness"]
+
+  Scenario: raise error when components are missing
+    Given an ORM::DataCube entitled "animals"
+    When I add a "robustness" dimension
+    And I add a "species" measure
+    And I add the observation {species: "Felis catus"}
+    Then the to_n3 method should raise error MissingValues for ["robustness"]
+
+  Scenario: raise error when components are missing
+    Given an ORM::DataCube entitled "animals" with the following options: 
+    | key | value |
+    | :validate_each | true |
+    When I add a "robustness" dimension
+    And I add a "species" measure
+    Then adding the observation {species: "Caenorhabditis elegans"} should raise error MissingValues for ["robustness"]
+
+  Scenario: add metadata
+    Given an ORM::DataCube entitled "meta"
+    When I add a "robustness" dimension
+    And I add a "species" measure
+    And I add the observation {species: "Hypsibius dujardini", robustness: 9001}
+    And I call the cubes add_publisher method with the arguments "Moss Piglets Unlimited", "http://mosspiglet.org/"
+		Then the to_n3 method should return a string with a "dct:publisher"
+

data/features/orm_steps.rb

@@ -0,0 +1,74 @@
+require_relative '../lib/bio-publisci.rb'
+
+Given /^an ORM::DataCube entitled "(.*?)"$/ do |name|
+	@cube = PubliSci::DataSet::ORM::DataCube.new(name: name)
+end
+
+Given /^an ORM::DataCube entitled "(.*?)" with the following options:$/ do |name, opts|
+	options_hash = {name: name}
+	opts.hashes.map{|hash|
+		k = hash["key"]
+		k = k[1..-1].to_sym if k[0] == ":"
+
+		v = hash["value"]
+		v = v[1..-1].to_sym if k[0] == ":"
+
+		v = true if v =="true"
+		v = false if v =="false"
+
+		options_hash[k] = v
+	}
+	@cube = PubliSci::DataSet::ORM::DataCube.new(options_hash)
+end
+
+Given(/^a turtle string from file (.*)$/) do |file|
+	@string = IO.read(file)
+end
+
+Given(/^the URI string "(.*?)"$/) do |uri|
+  @string = uri
+end
+
+When(/^I call the ORM::DataCube class method load on it$/) do
+  @cube = PubliSci::DataSet::ORM::DataCube.load(@string)
+end
+
+When /^I add a "(.*?)" dimension$/ do |dim|
+	@cube.add_dimension(dim)
+end
+
+When /^I add a "(.*?)" measure$/ do |meas|
+	@cube.add_measure(meas)
+end
+
+When /^I add the observation (.*)$/ do |obs|
+	data = eval(obs)
+	# obs.split(',').map{|entry| data[entry.chomp.strip.split(':')[0].to_s] = eval(entry.chomp.strip.split(':')[1])}
+	@cube.add_observation(data)
+end
+
+When /^adding the observation (.*) should raise error (.*)$/ do |obs,err|
+	data = eval(obs)
+	expect { @cube.add_observation(data) }.to raise_error(err)
+end
+
+When /^I call the cubes (.*) method with the arguments (.*)$/ do |method,args|
+  eval("args = #{args}")
+  @cube.send(method.to_sym, *args)
+end
+
+Then /^the to_n3 method should return a string$/ do
+	@cube.to_n3.is_a?(String).should be true
+end
+
+Then /^the to_n3 method should raise error (.*?)$/ do |err|
+	expect { @cube.to_n3 }.to raise_error(err)
+end
+
+Then /^the to_n3 method should return a string with a "(.*?)"$/ do |search|
+	@cube.to_n3[search].should_not be nil
+end
+
+Then(/^I should receive an ORM::DataCube object$/) do
+  @cube.is_a?(PubliSci::DataSet::ORM::DataCube).should == true
+end

data/features/prov_dsl.feature

@@ -0,0 +1,14 @@
+Feature: Receive metadata as user input or extract from data sources
+
+  To generate clean provenance strings through a friendly interface
+  I want to use a DSL for the PROV ontology
+
+  Scenario: Generate based on example for w3.org
+    Given the prov DSL string from file examples/primer-full.prov
+    When I call Prov.run on it
+    Then I should receive a provenance string
+
+  Scenario: Generate from file
+    Given the prov DSL string from file examples/prov_dsl.prov
+    When I call Prov.run on it
+    Then I should receive a provenance string