bio-publisci 0.0.5 → 0.0.6

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

@@ -1,25 +1,16 @@
 module PubliSci
 module Prov
   class Association
-    def subject(sub=nil)
-      if sub
-        @subject = sub
-      else
-        @subject ||= "#{Prov.base_url}/assoc/#{Time.now.nsec.to_s(32)}"
-      end
+    include Prov::Element
+
+
+    def __label
+      # raise "MissingInternalLabel: no __label for #{self.inspect}" unless @__label
+      @__label ||= Time.now.nsec.to_s(32)
     end
 
     def agent(agent=nil)
-      if agent
-        # agent = Prov.agents[agent.to_sym] if agent.is_a?(String) || agent.is_a?(Symbol)
-        # raise "UnkownAgent #{ag}" unless agent
-        # puts "Warning: overwriting agent #{@agent.subject}" if @agent
-        @agent = agent
-      elsif @agent.is_a? Symbol
-        @agent = Prov.agents[@agent]
-      else
-        @agent
-      end
+      basic_keyword(:agent,:agents,agent)
     end
 
     def had_plan(*args, &block)
@@ -31,15 +22,18 @@ module Prov
         Prov.register(args[0], p)
       elsif args.size == 0
         if @plan.is_a? Symbol
+          raise "UnknownPlan: #{@plan}" unless Prov.plans[@plan]
           @plan = Prov.plans[@plan]
         end
         @plan
       elsif args.size == 1
-        if args[0].is_a? Symbol
-          raise "UnknownPlan: #{args[0]}" unless Prov.plans[args[0]]
-          @plan = Prov.plans[args[0]]
-        else
+        if Prov.plans[args[0]]
           @plan = args[0]
+        else
+          p = Prov::Plan.new
+          p.__label=args[0]
+          @plan = p
+          Prov.register(args[0], p)
         end
       else
         name = args.shift
@@ -57,10 +51,50 @@ module Prov
     end
     alias_method :plan, :had_plan
 
+    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
+        if (Prov.registry[:role]||={})[args[0]]
+          @role = args[0]
+        else
+          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:Association ;\n"
       str << "\tprov:agent <#{agent}> ;\n"
       str << "\tprov:hadPlan <#{plan}> ;\n" if plan
+      str << "\tprov:hadRole <#{role}> ;\n" if role
       str[-2] = ".\n"
       str
     end

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

@@ -16,6 +16,7 @@ module PubliSci
         if activity
           @had_activity = activity
         elsif @had_activity.is_a? Symbol
+          raise "UnknownActivity #{@had_activity}" unless Prov.activities[@had_activity]
           @had_activity = Prov.activities[@had_activity]
         else
           @had_activity
@@ -27,6 +28,7 @@ module PubliSci
         if entity
           @entity = entity
         elsif @entity.is_a? Symbol
+          raise "UnknownEntity #{@entity}" unless Prov.entities[@entity]
           @entity = Prov.entities[@entity]
         else
           @entity

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

@@ -16,97 +16,40 @@ module PubliSci
         Prov.registry.clear
       end
 
-      def agent(name,args={}, &block)
+      def named_element(name,element_class,args={},&block)
+        el = element_class.new
+        el.__label=name
         if block_given?
-          a = Prov::Agent.new
-          a.instance_eval(&block)
-          a.__label=name
-          Prov.register(name, a)
+          el.instance_eval(&block)
+          Prov.register(name,el)
         else
-          # name = args.shift
-          # args = Hash[*args]
-          a = Prov::Agent.new
-
-          a.__label=name
-
-          a.subject args[:subject]
-
-          (args.keys - [:subject]).map{|k|
-            raise "Unkown agent setting #{k}" unless try_auto_set(a,k,args[k])
+          args.keys.map{|k|
+            raise "Unkown #{element_class} setting #{k}" unless try_auto_set(el,k,args[k])
           }
-
-
-          Prov.register(name, a)
+          Prov.register(name,el)
         end
       end
 
+      def agent(name,args={}, &block)
+        named_element(name,Prov::Agent,args,&block)
+      end
+
       def organization(name,args={},&block)
         args[:type] = :organization
         agent(name,args,&block)
       end
 
       def entity(name, args={}, &block)
-        if block_given?
-          e = Prov::Entity.new
-          e.instance_eval(&block)
-          e.__label=name
-          Prov.register(name, e)
-        else
-          # name = args.shift
-          # args = Hash[*args]
-          e = Prov::Entity.new
-
-          e.__label=name
-          e.subject args[:subject]
-          (args.keys - [:subject]).map{|k|
-            raise "Unkown entity setting #{k}" unless try_auto_set(e,k,args[k])
-          }
-
-          Prov.register(name, e)
-        end
+        named_element(name,Prov::Entity,args,&block)
       end
       alias_method :data, :entity
 
       def plan(name, args={}, &block)
-        if block_given?
-          p = Prov::Plan.new
-          p.instance_eval(&block)
-          p.__label=name
-          Prov.register(name, e)
-        else
-          p = Prov::Plan.new
-
-          p.__label=name
-          p.subject args[:subject]
-          (args.keys - [:subject]).map{|k|
-            raise "Unkown plan setting #{k}" unless try_auto_set(p,k,args[k])
-          }
-
-
-          Prov.register(name, p)
-        end
+        named_element(name,Prov::Plan,args,&block)
       end
 
       def activity(name,args={}, &block)
-        if block_given?
-          act = Prov::Activity.new
-          act.instance_eval(&block)
-          act.__label=name
-          Prov.register(name, act)
-        else
-
-          act.subject args[:subject]
-
-          (args.keys - [:subject]).map{|k|
-            raise "Unkown agent setting #{k}" unless try_auto_set(act,k,args[k])
-          }
-
-          a = Prov::Activity.new
-
-          act.__label=name
-          Prov.register(name, act)
-          raise "has based activity creation not yet implemented"
-        end
+        named_element(name,Prov::Activity,args,&block)
       end
 
       def base_url(url)
@@ -118,10 +61,12 @@ module PubliSci
         agents = Prov.agents.values.map(&:to_n3).join
         activities = Prov.activities.values.map(&:to_n3).join
         plans = Prov.plans.values.map(&:to_n3).join
-        associations = Prov.associations.map(&:to_n3).join
-        derivations = Prov.registry[:derivation].map(&:to_n3).join if Prov.registry[:derivation]
+        associations = Prov.registry[:associations].values.map(&:to_n3).join if Prov.registry[:associations]
+        derivations = Prov.registry[:derivation].values.map(&:to_n3).join if Prov.registry[:derivation]
+        usages = Prov.registry[:usage].values.map(&:to_n3).join if Prov.registry[:usage]
+        roles = Prov.registry[:role].values.map(&:to_n3).join if Prov.registry[:role]
 
-        str = "#{entities}#{agents}#{activities}#{plans}#{associations}#{derivations}"
+        str = "#{entities}#{agents}#{activities}#{plans}#{associations}#{derivations}#{usages}#{roles}"
 
         if abbreviate
           abbreviate_known(str)
@@ -134,10 +79,20 @@ module PubliSci
         Prov.registry
       end
 
-      # def vocabulary(url)
-      #   raise "InvalidVocabulary: #{url} is not a valid URI" unless RDF::Resource(url).valid?
-      #   RDF::Vocabulary.new(url)
-      # end
+      def to_repository(repo=:in_memory,turtle_string=(Prov.prefixes+generate_n3))
+        case repo
+        when :in_memory
+          repo = RDF::Repository.new
+        when :fourstore
+          repo = RDF::FourStore::Repository.new('http://localhost:8080')
+        end
+        f = Tempfile.new('repo')
+        f.write(turtle_string)
+        f.close
+        repo.load(f.path, :format => :ttl)
+        f.unlink
+        repo
+      end
 
       private
       def try_auto_set(object,method,args)
@@ -151,11 +106,12 @@ module PubliSci
 
       def abbreviate_known(turtle)
         ttl = turtle.dup
-        %w{activity assoc agent plan entity derivation}.each{|element|
+        %w{activity assoc agent plan entity derivation usage role}.each{|element|
           ttl.gsub!(%r{<#{Prov.base_url}/#{element}/([\w|\d]+)>}, "#{element}:" + '\1')
         }
 
         ttl.gsub!(%r{<http://gsocsemantic.wordpress.com/([\w|\d]+)>}, 'me:\1')
+        ttl.gsub!(%r{<http://www.w3.org/ns/prov#([\w|\d]+)>}, 'prov:\1')
         ttl
       end
     end

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

@@ -20,6 +20,10 @@ module PubliSci
         @subject = s
       end
 
+      def subject_id
+        self.class.to_s.split('::').last.downcase
+      end
+
       def __label=(l)
         @__label = l
       end
@@ -41,12 +45,76 @@ module PubliSci
           "activity"
         when Plan
           "plan"
+        when Association
+          "assoc"
         else
-          raise "MissingSubject: No automatic subject generation for #{self}"
+          subject_id()
+          # raise "MissingSubject: No automatic subject generation for #{self}"
         end
 
         "#{Prov.base_url}/#{category}/#{__label}"
       end
+
+      def try_auto_set(object,method,args)
+        if object.methods.include? method
+          object.send(method,args)
+          true
+        else
+          false
+        end
+      end
+
+      def basic_keyword(var,type,identifier=nil)
+        ivar = instance_variable_get("@#{var}")
+
+        if identifier
+          instance_variable_set("@#{var}", identifier)
+        elsif ivar.is_a? Symbol
+          raise "NotRegistered: #{type}" unless Prov.registry[type]
+          raise "Unknown#{type.capitalize}: #{ivar}" unless Prov.registry[type][ivar]
+          instance_variable_set("@#{var}", Prov.registry[type][ivar])
+        else
+          ivar
+        end
+      end
+
+      def basic_list(var,type,collection_class,identifier=nil)
+
+        if identifier
+          unless instance_variable_get("@#{var}")
+            instance_variable_set("@#{var}",collection_class.new)
+          end
+          instance_variable_get("@#{var}") << identifier
+          # (@used ||= Uses.new) << identifier
+        # elsif @used
+        #   @used.map{|u| u.is_a?(Symbol) ? Prov.entities[u] : u}
+        # elsif instance_variable_get("@#{var}")
+        #   @used.dereference
+        else
+          instance_variable_get("@#{var}")
+        end
+      end
+
+      def block_list(var,type,instance_class,collection_class,name=nil,&block)
+        if block_given?
+          inst = instance_class.new
+          inst.instance_eval(&block)
+          unless instance_variable_get("@#{var}")
+            instance_variable_set("@#{var}",collection_class.new)
+          end
+          instance_variable_get("@#{var}") << inst
+          Prov.register(type,inst)
+        else
+          if name
+            unless instance_variable_get("@#{var}")
+              instance_variable_set("@#{var}",collection_class.new)
+            end
+            instance_variable_get("@#{var}") << name
+          else
+            instance_variable_get("@#{var}")
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,17 +1,18 @@
 module PubliSci
   module Prov
     class Entity
+      include Prov::Element
+
+      attr_accessor :derived_from
+      attr_accessor :attributed_to
+
       class Derivations < Array
-        def [](index)
-          if self.fetch(index).is_a? Symbol
-              Prov.entities[self.fetch(index)]
-          else
-            self.fetch(index)
-          end
+        include PubliSci::Prov::Dereferencable
+        def method
+          :entities
         end
       end
 
-      include Prov::Element
 
       def source(s=nil)
         if s
@@ -22,57 +23,45 @@ module PubliSci
       end
 
       def generated_by(activity=nil)
-        if activity
-          @generated_by = activity
-        elsif @generated_by.is_a? Symbol
-          @generated_by = Prov.activities[@generated_by]
-        else
-          @generated_by
-        end
+        basic_keyword(:generated_by,:activities,activity)
       end
 
       def attributed_to(agent=nil)
-        if agent
-          @attributed_to = agent
-        elsif @attributed_to.is_a? Symbol
-          @attributed_to = Prov.agents[@attributed_to]
-        else
-          @attributed_to
-        end
+        basic_keyword(:attributed_to,:agents,agent)
+        # if agent
+        #   @attributed_to = agent
+        # elsif @attributed_to.is_a? Symbol
+        #   raise "UnknownAgent: #{@attributed_to}" unless Prov.agents[@attributed_to]
+        #   @attributed_to = Prov.agents[@attributed_to]
+        # else
+        #   @attributed_to
+        # end
       end
 
       def derived_from(entity=nil,&block)
-        if block_given?
-          deriv = Derivation.new
-          deriv.instance_eval(&block)
-          (@derived_from ||= Derivations.new) << deriv
-          Prov.register(nil,deriv)
-        else
-          if entity
-            (@derived_from ||= Derivations.new) << entity
-          else
-            @derived_from
-          end
-        end
-      end
+        block_list(:derived_from,:derivations,Derivation,Derivations,entity,&block)
+        # if block_given?
+        #   deriv = Derivation.new
+        #   deriv.instance_eval(&block)
+        #   (@derived_from ||= Derivations.new) << deriv
+        #   Prov.register(nil,deriv)
+        # else
+        #   if entity
 
-      # def derived_from[](entity)
-      #   if @derived_from && @derived_from[entity]
-      #     if entity.is_a? Symbol
-      #       Prov.entities[entity]
-      #     else
-      #       entity
-      #     end
-      #   end
-      # end
+        #     (@derived_from ||= Derivations.new) << entity
+        #   else
+        #     @derived_from
+        #   end
+        # end
+      end
 
       def to_n3
         str = "<#{subject}> a prov:Entity ;\n"
         str << "\tprov:wasGeneratedBy <#{generated_by}> ;\n" if generated_by
         str << "\tprov:wasAttributedTo <#{attributed_to}> ;\n" if attributed_to
         if derived_from
-          derived_from.map{|der|
-            der = Prov.entities[der] if der.is_a?(Symbol) && Prov.entities[der]
+          derived_from.size.times.each{|k|
+            der = derived_from[k] # if der.is_a?(Symbol) && Prov.entities[der]
 
             if der.is_a? Derivation
               str << "\tprov:wasDerivedFrom <#{der.entity}> ;\n"
@@ -83,11 +72,6 @@ module PubliSci
           }
         end
 
-        # if custom
-        #   @custom.map{|k,v|
-        #     str << "\t<#{k.to_s}> <#{v.to_s}> ;\n"
-        #   }
-        # end
         add_custom(str)
 
         str << %Q(\trdfs:label "#{__label}" .\n\n)