bio-publisci 0.0.3 → 0.0.4

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

@@ -0,0 +1,159 @@
+module PubliSci
+  module Prov
+    module DSL
+
+      include PubliSci::Vocabulary
+
+      class Singleton
+        include Prov::DSL
+
+        def initialize
+          Prov.registry.clear
+        end
+      end
+
+      def self.included(mod)
+        Prov.registry.clear
+      end
+
+      def agent(name,args={}, &block)
+        if block_given?
+          a = Prov::Agent.new
+          a.instance_eval(&block)
+          a.__label=name
+          Prov.register(name, a)
+        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])
+          }
+
+
+          Prov.register(name, a)
+        end
+      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
+      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
+      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
+      end
+
+      def generate_n3(abbreviate = false)
+        entities = Prov.entities.values.map(&:to_n3).join
+        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]
+
+        str = "#{entities}#{agents}#{activities}#{plans}#{associations}#{derivations}"
+
+        if abbreviate
+          abbreviate_known(str)
+        else
+          str
+        end
+      end
+
+      def return_objects
+        Prov.registry
+      end
+
+      # def vocabulary(url)
+      #   raise "InvalidVocabulary: #{url} is not a valid URI" unless RDF::Resource(url).valid?
+      #   RDF::Vocabulary.new(url)
+      # end
+
+      private
+      def try_auto_set(object,method,args)
+        if object.methods.include? method
+          object.send(method,args)
+          true
+        else
+          false
+        end
+      end
+
+      def abbreviate_known(turtle)
+        ttl = turtle.dup
+        %w{activity assoc agent plan entity derivation}.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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module PubliSci
+  module 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 __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"
+        else
+          raise "MissingSubject: No automatic subject generation for #{self}"
+        end
+
+        "#{Prov.base_url}/#{category}/#{__label}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+module PubliSci
+  module Prov
+    class Entity
+      class Derivations < Array
+        def [](index)
+          if self.fetch(index).is_a? Symbol
+              Prov.entities[self.fetch(index)]
+          else
+            self.fetch(index)
+          end
+        end
+      end
+
+      include Prov::Element
+
+      def source(s=nil)
+        if s
+          (@sources ||= []) << s
+        else
+          @sources
+        end
+      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
+      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
+      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
+
+      # def derived_from[](entity)
+      #   if @derived_from && @derived_from[entity]
+      #     if entity.is_a? Symbol
+      #       Prov.entities[entity]
+      #     else
+      #       entity
+      #     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]
+
+            if der.is_a? Derivation
+              str << "\tprov:wasDerivedFrom <#{der.entity}> ;\n"
+              str << "\tprov:qualifiedDerivation <#{der.subject}> ;\n"
+            else
+              str << "\tprov:wasDerivedFrom <#{der}> ;\n"
+            end
+          }
+        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)
+      end
+
+      def to_s
+        subject
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module PubliSci
+module Prov
+  class Plan
+    include Prov::Element
+
+    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:Plan, prov:Entity ;\n"
+      if steps
+        str << "\trdfs:comment (\"#{steps.join('" "')}\") ;\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/prov.rb

@@ -0,0 +1,76 @@
+module PubliSci
+  module Prov
+    def self.register(name,object)
+      # puts "register #{name} #{object} #{associations.size}"
+      name = name.to_sym if name
+      if object.is_a? Agent
+        sub = :agents
+      elsif object.is_a? Entity
+        sub = :entities
+      elsif object.is_a? Activity
+        sub = :activities
+      elsif object.is_a? Association
+        sub = :associations
+      elsif object.is_a? Plan
+        sub = :plans
+      else
+        sub = object.class.to_s.split('::').last.downcase.to_sym
+        # raise "UnknownElement: unkown object type for #{object}"
+      end
+      if name
+        (registry[sub] ||= {})[name] = object
+      else
+        (registry[sub] ||= []) << object
+      end
+    end
+
+    def self.registry
+      @registry ||= {}
+    end
+
+    def self.run(string)
+      if File.exists? string
+        DSL::Singleton.new.instance_eval(IO.read(string),string)
+      else
+        DSL::Singleton.new.instance_eval(string)
+      end
+    end
+
+    def self.agents
+      registry[:agents] ||= {}
+    end
+
+    def self.entities
+      registry[:entities] ||= {}
+    end
+
+    def self.activities
+      registry[:activities] ||= {}
+    end
+
+    def self.associations
+      registry[:associations] ||= []
+    end
+
+    def self.plans
+      registry[:plans] ||= {}
+    end
+
+    def self.base_url
+      @base_url ||= "http://rqtl.org/ns"
+    end
+
+    def self.base_url=(url)
+      @base_url = url
+    end
+
+    def self.prefixes
+      <<-EOF
+@prefix prov: <http://www.w3.org/ns/prov#> .
+@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix foaf: <http://xmlns.com/foaf/0.1/> .
+      EOF
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+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
+    end
+    alias_method :set, :has
+
+    def custom
+      @custom
+    end
+
+    def add_custom(str)
+      if custom
+        custom.map{|k,v|
+          pk = k.respond_to?(:to_base) ? k.to_base : k
+          v.map{|vv|
+            str << "\t#{pk} #{vv.to_base} ;\n"
+          }
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module PubliSci
+  module Vocabulary
+    def vocabulary(url)
+      raise "InvalidVocabulary: #{url} is not a valid URI" unless RDF::Resource(url).valid?
+      RDF::Vocabulary.new(url)
+    end
+  end
+end

data/lib/bio-publisci/output.rb

@@ -0,0 +1,27 @@
+module R2RDF
+  module Reader
+    module Output
+      def output(string, options={},append=false)
+        options[:type] = [:string] unless options[:type]
+        base = options[:file_base]
+        name = options[:file_name]
+        types = Array(options[:type])
+
+        if types.include? :print
+          puts string
+        end
+
+        if types.include? :file
+          raise "no file specified output" unless name
+
+          method = append ? 'a' : 'w'
+          open("#{base}#{name}", method) { |f| f.write str }
+        end
+
+        if types.include? :string
+          string
+        end
+      end
+    end
+  end
+end

data/lib/bio-publisci/parser.rb

@@ -1,12 +1,21 @@
 module R2RDF
 	module Parser
 
+    def is_uri?(string)
+      RDF::Resource(string).valid?
+    end
+
     def sanitize(array)
       #remove spaces and other special characters
+      array = Array(array)
       processed = []
       array.map{|entry|
         if entry.is_a? String
-          processed << entry.gsub(/[\s\.]/,'_')
+          if is_uri? entry
+            processed << entry.gsub(/[\s]/,'_')
+          else
+            processed << entry.gsub(/[\s\.]/,'_')
+          end
         else
           processed << entry
         end
@@ -16,7 +25,7 @@ module R2RDF
 
     def sanitize_hash(h)
       mappings = {}
-      h.keys.map{|k| 
+      h.keys.map{|k|
         if(k.is_a? String)
           mappings[k] = k.gsub(' ','_')
         end
@@ -74,9 +83,9 @@ module R2RDF
 
     	if shorten_uris
 	    	newh= {}
-	    	h.map{|k,v| 
+	    	h.map{|k,v|
 	    		newh[strip_uri(k)] ||= {}
-	    		v.map{|kk,vv| 
+	    		v.map{|kk,vv|
 	    			newh[strip_uri(k)][strip_uri(kk)] = strip_uri(vv)
 	    		}
 	    	}
@@ -88,12 +97,12 @@ module R2RDF
 
     def to_resource(obj, options)
       if obj.is_a? String
-        obj = "<#{obj}>" if obj =~ /^http:\/\//
-          
+        obj = "<#{obj}>" if is_uri? obj
+
         #TODO decide the right way to handle missing values, since RDF has no null
         #probably throw an error here since a missing resource is a bigger problem
         obj = "NA" if obj.empty?
-        
+
         #TODO  remove special characters (faster) as well (eg '?')
         obj.gsub(' ','_').gsub('?','')
       elsif obj == nil && options[:encode_nulls]
@@ -108,7 +117,7 @@ module R2RDF
 
     def to_literal(obj, options)
       if obj.is_a? String
-        # Depressing that there's no more elegant way to check if a string is 
+        # Depressing that there's no more elegant way to check if a string is
         # a number...
         if val = Integer(obj) rescue nil
           val

data/lib/bio-publisci/readers/csv.rb

@@ -5,15 +5,17 @@ module R2RDF
 			include R2RDF::Interactive
 
       def automatic(file=nil,dataset_name=nil,options={},interactive=true)
-        #to do 
+        #to do
+        # puts "f #{file} \n ds #{dataset_name} opts #{options}"
+
         unless file || !interactive
           puts "Input file?"
           file = gets.chomp
         end
-        
+
         raise "CSV reader needs an input file" unless file && file.size > 0
 
-        
+
         unless dataset_name
           if interactive
             dataset_name = interact("Dataset name?","#{File.basename(file).split('.').first}"){|sel| File.basename(file).split('.').first }
@@ -21,7 +23,7 @@ module R2RDF
             dataset_name = File.basename(file).split('.').first
           end
         end
-        
+
 
         categories = ::CSV.read(file)[0]
 
@@ -31,9 +33,9 @@ module R2RDF
         end
 
         unless options[:measures] || !interactive
-          meas = categories - ((options[:dimensions] || []) | [categories[0]])
+          meas = categories - (options[:dimensions] || [categories[0]])
           selection = interact("Measures?",meas,meas){|s| nil}
-          options[:measures] = Array(selection) unless options[:measures] == nil
+          options[:measures] = Array(selection) unless selection == nil
         end
 
         generate_n3(file,dataset_name,options)
@@ -76,7 +78,7 @@ module R2RDF
 				}
 				tmp = @data.dup
 				tmp.shift
-				
+
 				tmp.map{|row|
 					row.each_with_index{|entry,i|
 						obs[@data[0][i]] << entry

data/lib/bio-publisci/readers/dataframe.rb

@@ -1,17 +1,18 @@
 module R2RDF
 		module Reader
 		class Dataframe
-			include R2RDF::Dataset::DataCube
-		
+      include R2RDF::Dataset::DataCube
+			include R2RDF::Reader::Output
+
 			# def initialize(var)
 			# 	@var = var
 			# end
-			
+
 			def generate_n3(rexp, var, options={})
 				@rexp = rexp
-				@options = options
-
-				generate(measures, dimensions, codes, observation_data, observation_labels, var, options)
+        options[:type] ||= :string
+        @options = options
+				output(generate(measures, dimensions, codes, observation_data, observation_labels, var, options), options)
 			end
 
 			def dimensions
@@ -21,7 +22,7 @@ module R2RDF
 					[@options[:row_label]]
 				else
 					["refRow"]
-				end	
+				end
 			end
 
 			def codes
@@ -31,7 +32,7 @@ module R2RDF
 					[@options[:row_label]]
 				else
 					["refRow"]
-				end	
+				end
 			end
 
 			def measures