bio-publisci 0.0.5 → 0.0.6

data/lib/bio-publisci/metadata/prov/model/prov_models.rb

@@ -0,0 +1,79 @@
+require 'rdf/4store'
+
+begin
+  require 'spira'
+
+module PubliSci
+  module Prov
+    module Model
+      PROV ||= RDF::Vocabulary.new(RDF::URI.new('http://www.w3.org/ns/prov#'))
+
+      class Entity < Spira::Base
+        type PROV.Entity
+        property :label, predicate: RDF::RDFS.label
+        property :wasGeneratedBy, predicate: PROV.wasGeneratedBy
+        has_many :wasAttributedTo, predicate: PROV.wasAttributedTo
+        has_many :wasDerivedFrom, predicate: PROV.wasDerivedFrom
+        has_many :qualifiedAssociation, predicate: PROV.qualifiedAssociation
+
+        def organization
+          wasAttributedTo.map{|src|
+            if Agent.for(src).actedOnBehalfOf
+              Agent.for(Agent.for(src).actedOnBehalfOf).label
+            end
+          }
+        end
+      end
+
+      class Agent < Spira::Base
+        type PROV.Agent
+        type PROV.Organization
+        type PROV.SoftwareAgent
+        type PROV.Person
+        property :label, predicate: RDF::RDFS.label
+        property :wasGeneratedBy, predicate: PROV.wasGeneratedBy
+        property :foaf_name, predicate: RDF::FOAF.name
+        property :foaf_given, predicate: RDF::FOAF.givenName
+        property :name, predicate: PROV.actedOnBehalfOf
+        property :actedOnBehalfOf, predicate: PROV.actedOnBehalfOf
+
+        def name
+          foaf_given || foaf_name
+        end
+      end
+
+      class Activity < Spira::Base
+        type PROV.Activity
+        property :label, predicate: RDF::RDFS.label
+        has_many :generated, predicate: PROV.generated
+        has_many :used, predicate: PROV.used
+        has_many :wasAssociatedWith, predicate: PROV.wasAssociatedWith
+        has_many :qualifiedAssociation, predicate: PROV.qualifiedAssociation
+      end
+
+
+      class Association < Spira::Base
+        type PROV.Association
+        property :label, predicate: RDF::RDFS.label
+        property :agent, predicate: PROV.agent
+        property :hadPlan, predicate: PROV.plan
+      end
+
+      class Derivation < Spira::Base
+        type PROV.Derivation
+        property :label, predicate: RDF::RDFS.label
+        property :agent, predicate: PROV.agent
+        property :hadPlan, predicate: PROV.plan
+      end
+
+      class Plan < Spira::Base
+        type PROV.Plan
+        property :label, predicate: RDF::RDFS.label
+        property :comment, predicate: RDF::RDFS.comment
+      end
+    end
+  end
+end
+rescue LoadError
+  # puts "spira not installed, ORM unavailable"
+end

data/lib/bio-publisci/metadata/prov/plan.rb

@@ -15,7 +15,7 @@ module Prov
     end
 
     def to_n3
-      str = "<#{subject}> a prov:Plan, prov:Entity ;\n"
+      str = "<#{subject}> a prov:Plan ;\n"
       if steps
         str << "\trdfs:comment (\"#{steps.join('" "')}\") ;\n"
       end

data/lib/bio-publisci/metadata/prov/prov.rb

@@ -49,7 +49,7 @@ module PubliSci
     end
 
     def self.associations
-      registry[:associations] ||= []
+      registry[:associations] ||= {}
     end
 
     def self.plans

data/lib/bio-publisci/metadata/prov/role.rb

@@ -0,0 +1,40 @@
+module PubliSci
+  module Prov
+    class Role
+      # attr_writer :comment
+
+      include Prov::Element
+
+      def comment(str=nil)
+        if str
+          @comment = str
+        else
+          @comment
+        end
+      end
+
+      # def steps(steps=nil)
+      #   if steps
+      #     if File.exist? steps
+      #       steps = Array[IO.read(steps).split("\n")]
+      #     end
+      #     @steps = Array[steps]
+      #   else
+      #     @steps
+      #   end
+      # end
+
+      def to_n3
+        str = "<#{subject}> a prov:Role ;\n"
+        str << "\trdfs:comment \"#{comment}\" ;\n" if comment
+        add_custom(str)
+
+        str << "\trdfs:label \"#{__label}\" .\n\n"
+      end
+
+      def to_s
+        subject
+      end
+    end
+  end
+end

data/lib/bio-publisci/metadata/prov/usage.rb

@@ -0,0 +1,64 @@
+module PubliSci
+  module Prov
+    class Usage
+      include Prov::Element
+
+      def __label
+        @__label ||= Time.now.nsec.to_s(32)
+      end
+
+      def entity(entity=nil)
+        basic_keyword(:entity,:entities,entity)
+      end
+
+      def had_role(*args, &block)
+        if block_given?
+          p = Prov::Role.new
+          p.instance_eval(&block)
+          p.__label=args[0]
+          @role = p
+          # puts p.class
+          Prov.register(args[0], p)
+        elsif args.size == 0
+          if @role.is_a? Symbol
+            raise "UnknownRole: #{@role}" unless (Prov.registry[:role]||={})[@role]
+            @role = Prov.registry[:role][@role]
+          end
+          @role
+        elsif args.size == 1
+          unless (Prov.registry[:role]||={})[args[0]]
+            p = Prov::Role.new
+            p.__label=args[0]
+            @role = p
+            Prov.register(args[0], p)
+          end
+        else
+          name = args.shift
+          args = Hash[*args]
+          p = Prov::Role.new
+
+          p.__label=name
+          p.subject args[:subject]
+          (args.keys - [:subject]).map{|k|
+            raise "Unkown Role setting #{k}" unless try_auto_set(p,k,args[k])
+          }
+          @role = p
+          Prov.register(name, p)
+        end
+      end
+      alias_method :role, :had_role
+
+      def to_n3
+        str = "<#{subject}> a prov:Usage ;\n"
+        str << "\tprov:entity <#{entity}> ;\n"
+        str << "\tprov:hadRole <#{had_role}> ;\n" if had_role
+        str[-2] = ".\n"
+        str
+      end
+
+      def to_s
+        subject
+      end
+    end
+  end
+end

data/lib/bio-publisci/mixins/custom_predicate.rb

@@ -1,10 +1,14 @@
 module PubliSci
   module CustomPredicate
     def has(predicate, object)
-      predicate = RDF::Resource(predicate) if RDF::Resource(predicate).valid?
-      obj = RDF::Resource(object)
-      obj = RDF::Literal(object) unless obj.valid?
-      ((@custom ||= {})[predicate] ||= []) << obj
+      if object.is_a? Symbol
+        obj = object
+      else
+        predicate = RDF::Resource(predicate) if RDF::Resource(predicate).valid?
+        obj = RDF::Resource(object)
+        obj = RDF::Literal(object) unless obj.valid?
+      end
+        ((@custom ||= {})[predicate] ||= []) << obj
     end
     alias_method :set, :has
 
@@ -17,6 +21,14 @@ module PubliSci
         custom.map{|k,v|
           pk = k.respond_to?(:to_base) ? k.to_base : k
           v.map{|vv|
+            if vv.is_a? Symbol
+
+              deref = Prov.registry.values.map{|h|
+                h[vv] if vv
+              }.reject{|x| x==nil}
+              raise "Unknown Element #{vv}" unless deref.size > 0
+              vv = RDF::Resource(deref.first)
+            end
             str << "\t#{pk} #{vv.to_base} ;\n"
           }
         }

data/lib/bio-publisci/mixins/dereferencable.rb

@@ -0,0 +1,34 @@
+module PubliSci
+  module Prov
+    module Dereferencable
+      def dereference
+        self.map{|x|
+          if x.is_a? Symbol
+            raise "Unknown#{method.capitalize}: #{x}" unless Prov.registry[method.to_sym][x]
+            Prov.registry[method.to_sym][x]
+          else
+            x
+          end
+        }
+      end
+
+      def method
+        raise "must be overridden"
+      end
+
+      def [](index)
+        self.dereference.fetch(index)
+        # if self.fetch(index).is_a? Symbol
+        #   raise "UnknownEntity: #{self.fetch(index)}" unless Prov.entities[self.fetch(index)]
+        #   Prov.entities[self.fetch(index)]
+        # else
+        #   self.fetch(index)
+        # end
+      end
+
+      def map_(&blk)
+        self.dereference.map(&blk)
+      end
+    end
+  end
+end

data/lib/bio-publisci/parser.rb

@@ -38,13 +38,13 @@ module R2RDF
       h
     end
 
-		def create_graph(string)
-			f = Tempfile.new('graph')
+		def load_string(string,repo=RDF::Repository.new)
+			f = Tempfile.new('repo')
 			f.write(string)
 			f.close
-			graph = RDF::Graph.load(f.path, :format => :ttl)
+			repo.load(f.path, :format => :ttl)
 			f.unlink
-			graph
+			repo
 		end
 
 		def get_ary(query_results,method='to_s')

data/spec/prov/activity_spec.rb

@@ -0,0 +1,74 @@
+require_relative '../../lib/bio-publisci.rb'
+include PubliSci::Prov::DSL
+include PubliSci::Prov
+
+describe PubliSci::Prov::Activity do
+
+  before(:each) do
+    @evaluator = PubliSci::Prov::DSL::Singleton.new
+  end
+
+  it "can generate activity fields from symbol" do
+    a = activity :name
+    a.is_a?(Activity).should be true
+    a.subject.should == "http://rqtl.org/ns/activity/name"
+  end
+
+  it "can specify fields manually" do
+    a = activity :name, subject: "http://example.org/name"
+    a.subject.should == "http://example.org/name"
+  end
+
+  it "can be created with a block" do
+    e = entity :data
+    a = activity :ag do
+      subject "http://things.com/stuff"
+      generated :data
+    end
+    a.is_a?(Activity).should be true
+    a.subject.should == "http://things.com/stuff"
+  end
+
+  it "lazy loads other objects" do
+    a = activity :ag do
+      subject "http://things.com/stuff"
+      generated :data
+    end
+    e = entity :data
+
+    a.generated[0].should == e
+  end
+
+  it "raises an exception when used does not refer to an entity" do
+    a = activity :name, used: :some_data
+    expect {a.used[0]}.to raise_error
+  end
+
+  it "raises an exception when generated does not refer to an entity" do
+    a = activity :name, generated: :other_data
+    expect {a.generated[0]}.to raise_error
+  end
+
+  it "lazy loads generated relationships" do
+    a = activity :act, generated: :data
+    e = entity :data
+
+    a.generated[0].should == e
+  end
+
+  it "lazy loads used relationships" do
+    a = activity :act, generated: :data, used: :other_data
+    e = entity :data
+    f = entity :other_data
+
+    a.used[0].should == f
+  end
+
+  # it "lazy loads other objects, so declaration order doesn't usually matter" do
+  #   a = activity :name, on_behalf_of: :other
+  #   b = activity :other
+
+  #   a.on_behalf_of.should == b
+  # end
+
+end

data/spec/prov/agent_spec.rb

@@ -0,0 +1,55 @@
+require_relative '../../lib/bio-publisci.rb'
+include PubliSci::Prov::DSL
+include PubliSci::Prov
+
+describe PubliSci::Prov::Agent do
+
+  before(:each) do
+    @evaluator = PubliSci::Prov::DSL::Singleton.new
+  end
+
+  it "can generate agent fields from symbol" do
+    a = agent :name
+    a.is_a?(Agent).should be true
+    a.subject.should == "http://rqtl.org/ns/agent/name"
+  end
+
+  it "can specify fields manually" do
+    a = agent :name, subject: "http://example.org/name"
+    a.subject.should == "http://example.org/name"
+  end
+
+  it "can be created with a block" do
+    a = agent :ag do
+      subject "http://things.com/stuff"
+      name "Mr Person"
+    end
+    a.is_a?(Agent).should be true
+    a.subject.should == "http://things.com/stuff"
+    a.name.should == "Mr Person"
+  end
+
+  it "can be given a type corresponding to a subclass of prov:Agent" do
+    a = agent :name, type: "software"
+    a.type.should == :software
+    a.to_n3["prov:SoftwareAgent"].should_not be nil
+  end
+
+  it "can be created using the organization helper" do
+    a = organization :group
+    a.type.should == :organization
+  end
+
+  it "raises an exception when on_behalf_of does not refer to an agent" do
+    a = agent :name, on_behalf_of: :other
+    expect {a.on_behalf_of[0]}.to raise_error
+  end
+
+  it "lazy loads other objects, so declaration order doesn't usually matter" do
+    a = agent :name, on_behalf_of: :other
+    b = agent :other
+
+    a.on_behalf_of.should == b
+  end
+
+end

data/spec/prov/association_spec.rb

@@ -0,0 +1,56 @@
+require_relative '../../lib/bio-publisci.rb'
+include PubliSci::Prov
+include PubliSci::Prov::DSL
+
+describe PubliSci::Prov::Association do
+  before(:each) do
+    @ev = PubliSci::Prov::DSL::Singleton.new
+  end
+
+  it "can create simple associations" do
+    e = @ev.entity :name
+    f = @ev.agent :other
+    g = @ev.activity :do_things, generated: :name, associated_with: :other
+    g.associated_with[0].should == f
+    @ev.generate_n3["prov:wasAssociatedWith"].size.should > 0
+  end
+
+  it "creates qualified associations when a block is passed" do
+    e = @ev.entity :name
+    f = @ev.agent :other
+    p = @ev.plan :the_plan
+    g = @ev.activity :do_things do
+      generated :name
+      associated_with do
+        agent :other
+        plan :the_plan
+      end
+    end
+    g.associated_with.first.agent.should == f
+    @ev.generate_n3["prov:wasAssociatedWith"].size.should > 0
+    @ev.generate_n3["prov:qualifiedAssociation"].size.should > 0
+  end
+
+  # it "raises an exception when derivation does not refer to an entity" do
+  #   e = entity :name, derived_from: :dataset
+  #   expect {e.derived_from[0]}.to raise_error
+  # end
+
+  # it "raises an exception when attribution does not refer to an agent" do
+  #   e = entity :name, attributed_to: :person
+  #   expect {e.attributed_to[0]}.to raise_error
+  # end
+
+  # it "raises an exception when generated_by does not refer to an activity" do
+  #   e = entity :name, generated_by: :act
+  #   expect {e.generated_by[0]}.to raise_error
+  # end
+
+  # it "lazy loads other objects, so declaration order doesn't usually matter" do
+  #   e = entity :name, derived_from: :other
+  #   f = entity :other
+
+
+  #   e.derived_from[0].should == f
+  # end
+end