publisci 0.1.2

data/lib/bio-publisci/dsl/metadata_dsl.rb

@@ -0,0 +1,85 @@
+module PubliSci
+  class Metadata
+    module DSL
+
+      class Instance
+        include Metadata::DSL
+
+        def initialize
+          Metadata.registry.clear
+        end
+      end
+
+      def var(name=nil)
+        set_or_get('var',name)
+      end
+      alias_method :dataset, :var
+
+      def creator(id=nil)
+        set_or_get('creator',id)
+      end
+      alias_method :name, :creator
+
+      def description(desc=nil)
+        set_or_get('description',desc)
+      end
+
+      def title(desc=nil)
+        set_or_get('title',desc)
+      end
+
+      def topic(sub=nil)
+        add_or_get('topic',sub)
+      end
+
+      def publishers(pub=nil,&block)
+        if block_given?
+          p = Publisher.new
+          p.instance_eval(&block)
+          @publishers ||= [] << p
+          p
+        else
+          add_or_get('publishers',pub)
+        end
+      end
+      alias_method :publisher, :publishers
+
+      def generate_n3
+        opts = {}
+        %w{var creator description title}.each{|field|
+          opts[field.to_sym] = send(field.to_sym) if send(field.to_sym)
+        }
+        opts[:subject] = topic if topic
+        publishers.each{|pub|
+          opts[:publishers] ||= [] << {label: pub.label, uri: pub.uri}
+        } if publishers
+        gen = Class.new {include PubliSci::Metadata::Generator}
+
+        gen.new.basic(opts)
+      end
+
+      private
+      def set_or_get(var,input=nil)
+        ivar = instance_variable_get("@#{var}")
+
+        if input
+          instance_variable_set("@#{var}", input)
+        else
+          ivar
+        end
+      end
+
+      def add_or_get(var,input)
+        ivar = instance_variable_get("@#{var}")
+
+        if input
+          instance_variable_set("@#{var}", []) unless ivar
+          instance_variable_get("@#{var}") << input
+          instance_variable_get("@#{var}")
+        else
+          ivar
+        end
+      end
+    end
+  end
+end

data/lib/bio-publisci/dsl/prov_dsl.rb

@@ -0,0 +1,143 @@
+module PubliSci
+  class Prov
+    module DSL
+
+      include PubliSci::Vocabulary
+
+      class Instance
+        include Prov::DSL
+        def initialize
+          Prov.registry.clear
+          Prov.reset_settings
+        end
+      end
+
+      def self.included(mod)
+        Prov.registry.clear
+        Prov.reset_settings
+      end
+
+      # def configure(&block)
+      #   Prov.configuration.instance_eval(&block)
+      # end
+
+      def configure
+        yield Prov.configuration
+      end
+
+      def named_element(name,element_class,args={},&block)
+        el = element_class.new
+        el.__label=name
+        if block_given?
+          el.instance_eval(&block)
+          Prov.register(name,el)
+        else
+          args.keys.map{|k|
+            raise "Unkown #{element_class} setting #{k}" unless try_auto_set(el,k,args[k])
+          }
+          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)
+        named_element(name,Prov::Entity,args,&block)
+      end
+      alias_method :data, :entity
+
+      def plan(name, args={}, &block)
+        named_element(name,Prov::Plan,args,&block)
+      end
+
+      def activity(name,args={}, &block)
+        named_element(name,Prov::Activity,args,&block)
+      end
+
+      def base_url(url)
+        Prov.base_url=url
+      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.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}#{usages}#{roles}"
+
+        if abbreviate
+          abbreviate_known(str)
+        else
+          str
+        end
+      end
+
+      def settings
+        Prov.configuration
+      end
+
+      def return_objects
+        Prov.registry
+      end
+
+      def to_repository(turtle_string=(Prov.prefixes+generate_n3))
+        repo = settings.repository
+        case repo
+        when :in_memory
+          repo = RDF::Repository.new
+        when :fourstore
+          repo = RDF::FourStore::Repository.new('http://localhost:8080')
+        end
+        f = Tempfile.new(['repo','.ttl'])
+        f.write(turtle_string)
+        f.close
+        repo.load(f.path, :format => :ttl)
+        f.unlink
+        repo
+      end
+
+      def output
+        cfg = Prov.configuration
+        case cfg.output
+        when :generate_n3
+          generate_n3(cfg.abbreviate)
+        when :to_repository
+          raise "not implemented yet"
+        end
+      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 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
+  end
+end

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

@@ -0,0 +1,323 @@
+class String
+  def unindent
+    gsub /^#{self[/\A\s*/]}/, ''
+  end
+end
+
+module PubliSci
+  class Metadata
+    module Generator
+      include PubliSci::Parser
+
+      def defaults
+      {
+        encode_nulls: false,
+        base_url: "http://www.rqtl.org",
+      }
+      end
+
+      def basic(fields)
+        #TODO don't assume base dataset is "ns:dataset-var",
+        #make it just "var", and try to make that clear to calling classes
+
+        fields[:var] = sanitize([fields[:var]]).first
+
+        unless fields[:creator]
+          if ENV['USER']
+            fields[:creator] = ENV['USER']
+          elsif ENV['USERNAME']
+            fields[:creator] = ENV['USERNAME']
+          end
+        end
+
+        fields[:date] = Time.now.strftime("%Y-%m-%d") unless fields[:date]
+
+        #TODO some of these should probably be resources, eg dct:creator, or put under DC namespace
+        str = <<-EOF.unindent
+        ns:dataset-#{fields[:var]} rdfs:label "#{fields[:title]}";
+          dct:title "#{fields[:title]}";
+          dct:creator "#{fields[:creator]}";
+          rdfs:comment "#{fields[:description]}";
+          dct:description "#{fields[:description]}";
+          dct:issued "#{fields[:date]}"^^xsd:date.
+        EOF
+
+        end_str = ""
+
+        if fields[:subject] && fields[:subject].size > 0
+          str << "  dct:subject"
+          fields[:subject].each{|subject|
+            sub = RDF::Resource(subject)
+            sub = RDF::Literal(subject) unless sub.valid?
+
+            str << " " + sub.to_base + ",\n"
+          }
+          str[-2] = ";"
+        end
+
+        if fields[:publishers]
+          fields[:publishers].map{|publisher|
+            raise "No URI for publisher #{publisher}" unless publisher[:uri]
+            raise "No label for publisher #{publisher}" unless publisher[:label]
+            str << "  dct:publisher <#{publisher[:uri]}> ;\n"
+            end_str << "<#{publisher[:uri]}> a org:Organization, foaf:Agent;\n  rdfs:label \"#{publisher[:label]}\" .\n\n"
+          }
+          str[-2] = '.'
+        end
+
+        str + "\n" + end_str
+      end
+
+      def provenance(original, triplified, chain, options={})
+        #TODO: should either add a prefixes method or replace some with full URIs
+        raise "MissingOriginal: must specify a provenance source" unless original && original[:resource]
+
+        #TODO include file type etc, or create a separate method for it
+
+        str = <<-EOF.unindent
+          <#{original[:resource]}> a prov:Entity ;
+            prov:wasGeneratredBy ns:activity-1 .
+
+          ns:activity-1 a prov:Activity ;
+            prov:generated <#{original[:resource]}> .
+
+        EOF
+
+        if original[:software]
+          original_assoc_id = Time.now.nsec.to_s(32)
+
+
+          str << <<-EOF.unindent
+            <#{original[:software]}> a prov:Entity.
+
+            ns:activity-1 prov:qualifiedAssociation ns:assoc-1_#{original_assoc_id} .
+
+            ns:assoc-1_#{original_assoc_id} a prov:Assocation ;
+              prov:entity <#{original[:software]}> .
+
+          EOF
+
+          if original[:process]
+            original[:process] = IO.read(original[:process]) if File.exist? original[:process]
+
+            steps = '"' + original[:process].split("\n").join('" "') + '"'
+            str << <<-EOF.unindent
+              ns:assoc-1_#{original_assoc_id} prov:hadPlan ns:plan-1.
+
+              ns:plan-1 a prov:Plan ;
+                rdfs:comment (#{steps});
+
+            EOF
+          end
+        end
+
+        if original[:author]
+          str << "<#{original[:author]}> a prov:Agent, prov:Person .\n"
+          str << "ns:activity-1 prov:wasAssociatedWith <#{original[:author]}> .\n"
+
+          str << "<#{original[:author]}> foaf:givenName \"#{original[:author_name]}\" .\n" if original[:author_name]
+
+          if original[:organization]
+            str << "<#{original[:author]}> prov:actedOnBehalfOf <#{original[:organization]}> .\n\n"
+            str << "<#{original[:organization]}> a prov:Agent, prov:Organization.\n"
+            if original[:organization_name]
+              str << "<#{original[:organization]}> foaf:name \"#{original[:organization_name]}\" .\n\n"
+            else
+              str << "\n"
+            end
+          else
+            str << "\n"
+          end
+        end
+
+        if triplified
+          triples_assoc_id = Time.now.nsec.to_s(32)
+
+          str << <<-EOF.unindent
+            <#{triplified[:resource]}> a prov:Entity;
+              prov:wasGeneratredBy ns:activity-0 .
+
+            </ns/R2RDF> a prov:Agent, prov:SoftwareAgent ;
+              rdfs:label "Semantic Publishing Toolkit" .
+
+            ns:activity-0 a prov:Activity ;
+              prov:qualifiedAssociation ns:assoc-0_#{triples_assoc_id};
+              prov:generated <#{triplified[:resource]}> ;
+              prov:used <#{original[:resource]}> .
+
+            ns:assoc-0_#{triples_assoc_id} a prov:Assocation ;
+              prov:entity </ns/R2RDF>;
+              prov:hadPlan ns:plan-0.
+
+            ns:plan-0 a prov:Plan ;
+              rdfs:comment "generation of <#{triplified[:resource]}> by R2RDF gem" .
+
+          EOF
+
+          if triplified[:author]
+            str << "<#{triplified[:author]}> a prov:Agent, prov:Person .\n"
+
+            str << "<#{triplified[:author]}> foaf:givenName \"#{triplified[:author_name]}\" .\n" if triplified[:author_name]
+
+            if triplified[:organization]
+              str << "<#{triplified[:author]}> prov:actedOnBehalfOf <#{triplified[:organization]}> .\n\n"
+              str << "<#{triplified[:organization]}> a prov:Agent, prov:Organization.\n"
+              if triplified[:organization_name]
+                str << "<#{triplified[:organization]}> foaf:name \"#{triplified[:organization_name]}\" .\n\n"
+              else
+                str << "\n"
+              end
+            else
+              str << "\n"
+            end
+          end
+        end
+
+        if chain
+          str << "ns:activity-1 prov:used <#{chain.first[:resource]}> .\n"
+          str << "<#{original[:resource]}> prov:wasDerivedFrom <#{chain.first[:resource]}> .\n\n"
+          chain.each_with_index{ |src,i|
+            if i == chain.size-1
+              str << activity(src[:resource],nil,src)
+            else
+              str << activity(src[:resource],chain[i+1][:resource],src)
+            end
+          }
+        end
+
+        str
+      end
+
+      def activity(entity, used, options={})
+        assoc_id = Time.now.nsec.to_s(32)
+        activity_id = Time.now.nsec.to_s(32)
+        plan_id = Time.now.nsec.to_s(32)
+
+        raise "NoEntityGiven: activity generation requires a subject entity" unless entity
+
+        entity_str = <<-EOF.unindent
+          <#{entity}> a prov:Entity ;
+            prov:wasGeneratredBy ns:activity-a_#{activity_id} ;
+        EOF
+
+        activity_str = <<-EOF.unindent
+          ns:activity-a_#{activity_id} a prov:Activity ;
+            prov:generated <#{entity}> ;
+        EOF
+
+        if used
+          entity_str << "\tprov:wasDerivedFrom <#{used}> . \n\n"
+          activity_str << "\tprov:used <#{used}> . \n\n"
+        else
+          entity_str[-2] = ".\n"
+          activity_str[-2] = ".\n"
+        end
+
+        activity_str << <<-EOF.unindent
+          ns:activity-a_#{activity_id} prov:qualifiedAssociation ns:assoc-s_#{assoc_id} .
+
+          ns:assoc-s_#{assoc_id} a prov:Assocation .
+
+        EOF
+
+        if options[:software]
+
+          activity_str << <<-EOF.unindent
+            <#{options[:software]}> a prov:Entity .
+
+            ns:assoc-s_#{assoc_id} prov:agent <#{options[:software]}> .
+          EOF
+
+          if options[:process]
+            options[:process] = IO.read(options[:process]) if File.exist? options[:process]
+
+            steps = '"' + options[:process].split("\n").join('" "') + '"'
+            activity_str << <<-EOF.unindent
+              ns:assoc-s_#{assoc_id} prov:hadPlan ns:plan-p_#{plan_id}.
+
+              ns:plan-p_#{plan_id} a prov:Plan ;
+                rdfs:comment (#{steps});
+            EOF
+          end
+        end
+
+        if options[:author]
+          entity_str << "<#{options[:author]}> a prov:Agent, prov:Person .\n"
+          entity_str << "<#{options[:author]}> foaf:givenName \"#{options[:author_name]}\" .\n" if options[:author_name]
+
+          activity_str << "ns:activity-a_#{activity_id} prov:wasAssociatedWith <#{options[:author]}> .\n"
+          activity_str << "ns:assoc-s_#{assoc_id} prov:agent <#{options[:author]}> .\n"
+
+          if options[:organization]
+            entity_str << "<#{options[:organization]}> a prov:Agent, prov:Organization .\n"
+            activity_str << "<#{options[:author]}> prov:actedOnBehalfOf <#{options[:organization]}> .\n\n"
+            if options[:organization_name]
+              entity_str << "<#{options[:organization]}> foaf:name \"#{options[:organization_name]}\" .\n\n"
+            end
+          else
+            activity_str << "\n"
+            # entity_str << "\n"
+          end
+        end
+
+        entity_str + "\n" + activity_str
+      end
+
+      def process(id, step_string, software_resource, software_var, options={})
+        #TODO a better predicate for the steplist than rdfs:comment
+        # and make sure it looks good.
+        steps = '"' + step_string.split("\n").join('" "') + '"'
+        assoc_id = Time.now.nsec.to_s(32)
+        str = <<-EOF.unindent
+          ns:activity-#{id} a prov:Activity ;
+            prov:qualifiedAssociation ns:assoc-#{assoc_id} ;
+            prov:used </ns/dataset/#{software_var}#var>.
+
+          ns:assoc-#{id}_#{assoc_id} a prov:Assocation ;
+            prov:entity <#{software_resource}>;
+            prov:hadPlan ns:plan-#{id}.
+
+          ns:plan-#{id} a prov:Plan ;
+            rdfs:comment (#{steps});
+
+        EOF
+
+      end
+
+      def r2rdf_metadata
+        str <<-EOF.unindent
+        <#{options[:base_url]}/ns/R2RDF> a foaf:Agent;
+          foaf:name "R2RDF Semantic Web Toolkit";
+          org:memberOf <http://sciruby.com/>
+        EOF
+      end
+
+      def org_metadata
+        str <<-EOF.unindent
+          <http://sciruby.com/> a org:Organization, prov:Organization;
+            skos:prefLabel "SciRuby";
+            rdfs:description "A Project to Build and Improve Tools for Scientific Computing in Ruby".
+        EOF
+      end
+
+      def metadata_help(topic=nil)
+        if topic
+          puts "This should display help information for #{topic}, but there's none here yet :("
+        else
+          puts <<-EOF.unindent
+          Available metadata fields:
+          (Field)         (Ontology)                              (Description)
+
+          publishers      dct/foaf/org        The Organization/s responsible for publishing the dataset
+          subject         dct                 The subject of this dataset. Use resources when possible
+          var             dct                 The name of the datset resource (used internally)
+          creator         dct                 The person or process responsible for creating the dataset
+          description     dct/rdfs            A descriptions of the dataset
+          issued          dct                 The date of issuance for the dataset
+
+          EOF
+        end
+      end
+    end
+  end
+end