publisci 0.1.2

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

@@ -0,0 +1,5 @@
+module PubliSci
+  class Metadata
+    extend PubliSci::Registry
+  end
+end

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

@@ -0,0 +1,25 @@
+begin
+  require 'spira'
+  module PubliSci
+    class Metadata
+      module Model
+        PROV ||= RDF::Vocabulary.new(RDF::URI.new('http://www.w3.org/ns/prov#'))
+        QB ||= RDF::Vocabulary.new(RDF::URI.new('http://purl.org/linked-data/cube#'))
+        DCT ||= RDF::Vocabulary.new(RDF::URI.new('http://purl.org/dc/terms/'))
+
+
+        class Meta < Spira::Base
+          type PROV.Entity
+          type QB.DataSet
+          property :label, predicate: RDF::RDFS.label
+          property :comment, predicate: RDF::RDFS.comment
+          property :description, predicate: DCT.description
+          property :creator, predicate: DCT.creator
+          property :issued, predicate: DCT.issued
+        end
+      end
+    end
+  end
+rescue LoadError
+  # puts "spira not installed, ORM unavailable"
+end

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

@@ -0,0 +1,88 @@
+module PubliSci
+class Prov
+  class Activity
+    include Prov::Element
+    class Associations < Array
+      include PubliSci::Prov::Dereferencable
+      def method
+        :agents
+      end
+    end
+
+    class Generations < Array
+      include PubliSci::Prov::Dereferencable
+      def method
+        :entities
+      end
+    end
+
+    class Usages < Array
+      include PubliSci::Prov::Dereferencable
+      def method
+        :entities
+      end
+    end
+
+    def generated(entity=nil)
+      if entity.is_a? Entity
+        entity.generated_by self
+      elsif Prov.entities[entity]
+        Prov.entities[entity].generated_by self
+      end
+      basic_list(:generated,:entities,Generations,entity)
+    end
+
+    def associated_with(agent=nil, &block)
+      block_list(:associated,:associations,Association,Associations,agent,&block)
+    end
+    alias_method :wasAssociatedWith, :associated_with
+
+    def used(entity=nil, &block)
+      block_list(:use,:usages,Usage,Usages,entity, &block)
+    end
+
+    def to_n3
+      str = "<#{subject}> a prov:Activity ;\n"
+
+      if generated
+        str << "\tprov:generated "
+        generated.dereference.map{|src|
+          str << "<#{src}>, "
+        }
+        str[-2]=" "
+        str[-1]=";\n"
+      end
+
+      if used
+        used.dereference.map{|u|
+          if u.is_a? Usage
+            str << "\tprov:used <#{u.entity}> ;\n"
+            str << "\tprov:qualifiedUsage <#{u}> ;\n"
+          else
+            str << "\tprov:used <#{u}> ;\n"
+          end
+        }
+      end
+
+      if associated_with
+        associated_with.dereference.map{|assoc|
+          if assoc.is_a? Association
+            str << "\tprov:wasAssociatedWith <#{assoc.agent}> ;\n"
+            str << "\tprov:qualifiedAssociation <#{assoc}> ;\n"
+          else
+            str << "\tprov:wasAssociatedWith <#{assoc}> ;\n"
+          end
+        }
+      end
+
+      add_custom(str)
+
+      str << "\trdfs:label \"#{__label}\" .\n\n"
+    end
+
+    def to_s
+      subject
+    end
+  end
+end
+end

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

@@ -0,0 +1,100 @@
+module PubliSci
+  class Prov
+    class Agent
+      include Prov::Element
+      attr_accessor :organization
+      attr_accessor :behalf_of
+
+      def type(t=nil)
+        if t
+          @type = t.to_sym
+        else
+          @type
+        end
+      end
+
+      def type=(t)
+        @type = t.to_sym
+      end
+
+      def name(name=nil)
+        if name
+          @name = name
+        else
+          @name
+        end
+      end
+
+      def name=(name)
+        @name = name
+      end
+
+      def organization(organization=nil)
+        basic_keyword(:organization,:agents,organization)
+        # if organization
+        #   @organization = organization
+        # elsif @organization.is_a? Symbol
+        #   raise "UnknownAgent: #{@organization}" unless Prov.agents[@organization]
+        #   @organization = Prov.agents[@organization]
+        # else
+        #   @organization
+        # end
+      end
+
+      # def organization=(organization)
+      #   @organization = organization
+      # end
+
+      def on_behalf_of(other_agent=nil)
+        basic_keyword(:behalf_of,:agents,other_agent)
+        # if other_agent
+        #   @behalf_of = other_agent
+        # elsif @on_behalf_of.is_a? Symbol
+        #   raise "UnknownAgent: #{@on_behalf_of}" unless Prov.agents.has_key?(@on_behalf_of)
+        #   @behalf_of = Prov.agents[@on_behalf_of]
+        # else
+        #   @behalf_of
+        # end
+
+        # @behalf_of
+      end
+      alias_method :worked_for, :on_behalf_of
+
+      def to_n3
+        str = "<#{subject}> a"
+        if type
+          case type.to_sym
+          when :software
+            str << " prov:SoftwareAgent ;\n"
+          when :person
+            str << " prov:Person ;\n"
+          when :organization
+            str << " prov:Organization ;\n"
+          end
+        else
+          str << " prov:Agent ;\n"
+        end
+
+        if name
+          if type && type.to_sym == :person
+            str << "\tfoaf:givenName \"#{name}\" ;\n"
+          else
+            str << "\tfoaf:name \"#{name}\" ;\n"
+          end
+        end
+
+        if on_behalf_of
+          str << "\tprov:actedOnBehalfOf <#{on_behalf_of}> ;\n"
+        end
+
+        add_custom(str)
+
+        str << "\trdfs:label \"#{__label}\" .\n\n"
+      end
+
+      def to_s
+        subject
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+module PubliSci
+class Prov
+  class Association
+    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)
+      basic_keyword(:agent,:agents,agent)
+    end
+
+    def had_plan(*args, &block)
+      if block_given?
+        p = Prov::Plan.new
+        p.instance_eval(&block)
+        p.__label=args[0]
+        @plan = p
+        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 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
+        args = Hash[*args]
+        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])
+        }
+        @plan = p
+        Prov.register(name, p)
+      end
+    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 << "\trdfs:label \"#{__label}\".\n\n"
+      str
+    end
+
+    def to_s
+      subject
+    end
+  end
+end
+end

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

@@ -0,0 +1,34 @@
+module PubliSci
+  class Prov
+    class Configuration
+      def self.defaults
+        {
+          output: :generate_n3,
+          abbreviate: false,
+          repository: :in_memory,
+          repository_url: 'http://localhost:8080/'
+        }
+      end
+
+      defaults.keys.each{|k|
+        default = defaults[k]
+        define_method(k) do |input=nil|
+          var = instance_variable_get :"@#{k}"
+          if var
+            var
+          else
+            instance_variable_set :"@#{k}", default
+          end
+
+          if input
+            instance_variable_set :"@#{k}", input
+          end
+
+          instance_variable_get :"@#{k}"
+        end
+
+        attr_writer k
+      }
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module PubliSci
+  class Prov
+    class Derivation
+
+      include PubliSci::CustomPredicate
+
+    def __label
+      # raise "MissingInternalLabel: no __label for #{self.inspect}" unless @__label
+      @__label ||= Time.now.nsec.to_s(32)
+    end
+
+      def subject(sub=nil)
+        if sub
+          @subject = sub
+        else
+          @subject ||= "#{Prov.base_url}/derivation/#{Time.now.nsec.to_s(32)}"
+        end
+      end
+
+      def had_activity(activity=nil)
+        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
+        end
+      end
+      alias_method :activity, :had_activity
+
+      def entity(entity=nil)
+        if entity
+          @entity = entity
+        elsif @entity.is_a? Symbol
+          raise "UnknownEntity #{@entity}" unless Prov.entities[@entity]
+          @entity = Prov.entities[@entity]
+        else
+          @entity
+        end
+      end
+      alias_method :data, :entity
+
+      def to_n3
+        str = "<#{subject}> a prov:Derivation ;\n"
+        str << "\tprov:entity <#{entity}> ;\n" if entity
+        str << "\tprov:hadActivity <#{had_activity}> ;\n" if had_activity
+        str << "\trdfs:label \"#{__label}\".\n\n"
+
+        add_custom(str)
+
+        str
+      end
+
+      def to_s
+        subject
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+module PubliSci
+  class Prov
+    module Element
+      include PubliSci::Vocabulary
+      include PubliSci::CustomPredicate
+
+      def subject(s=nil)
+        if s
+          if s.is_a? Symbol
+            raise "subject generation from symbol not yet implemented!"
+          else
+            @subject = s
+          end
+        else
+          @subject ||= generate_subject
+        end
+      end
+
+      def subject=(s)
+        @subject = s
+      end
+
+      def subject_id
+        self.class.to_s.split('::').last.downcase
+      end
+
+      def __label=(l)
+        @__label = l
+      end
+
+      def __label
+        raise "MissingInternalLabel: no __label for #{self.inspect}" unless @__label
+        @__label
+      end
+
+      private
+      def generate_subject
+        # puts self.class == Prov::Activity
+        category = case self
+        when Agent
+          "agent"
+        when Entity
+          "entity"
+        when Activity
+          "activity"
+        when Plan
+          "plan"
+        when Association
+          "assoc"
+        else
+          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(inst.__label,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