dyntask-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: db4c0169535bb6a981d671d2999d4938811c6062
+  data.tar.gz: 8aea8a1e1c10fbbb6f98f89deb365d0fa405d50a
+SHA512:
+  metadata.gz: 79fa4901c10d0d8192f79df1c4d0aeb53c33a540069dd0b68f630d8a70845d38440254fd9bee5e85642f8793e23711c9c58d6d31d567b68834ffb45c646b8478
+  data.tar.gz: 0fd0be9b9cd04407abb840ad4b41247ff1dcb89807d0488d802b9783b52fd2de3c3ed1866c589a922125d906c0ebe05d731d43664a7009326d79fbc36f6540c6

data/bin/dyntask-init

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'trollop'
+require 'pathname'
+require 'dyntask/task_mngr'
+require 'fileutils'
+
+VERSION='0.1.0'
+
+options = Trollop::options do
+  version "dyntask-init version #{VERSION}"
+  banner <<-EOS
+dyntask-init executes the dynamic task file.
+Usage:
+   dyntask-init [--force] '<name>' '<working_dir>:<list_of_comma_separated_tasks>' ['<working_dir_2>:<list_of_comma_separated_tasks_2>' ...]
+   dyntask-init '<name>'
+   dyntask-init --force --rm '<name>'
+Options:
+EOS
+  opt :force, "force is used to rewrite on an existing file", :short => 'f', :type => :boolean, :default => false
+  opt :rm, "remove an existing file", :type => :boolean, :default => false
+end
+
+Trollop::die Trollop::educate if(ARGV.size == 0)
+
+if ARGV[0] == "pandoc-extra"
+	case ARGV[1]
+	when "ls"
+		if File.directory? DynTask.cfg_pandoc[:extra_dir]
+			puts `/usr/bin/env bash -c 'ls #{DynTask.cfg_pandoc[:extra_dir]}'`
+		end
+	when "dir"
+		if options[:force] and options[:rm]
+			FileUtils.rm(DynTask.cfg_pandoc[:extra_etc])
+		elsif ARGV[2] and (File.directory? ARGV[2] or options[:force])
+			File.open(DynTask.cfg_pandoc[:extra_etc],"w") do |f|
+				f << ARGV[2]
+			end
+		end
+		puts "Config file #{DynTask.cfg_pandoc[:extra_etc]} is "+ ( (File.exist? DynTask.cfg_pandoc[:extra_etc]) ? "" : "not ") +"created."
+		puts "Current pandoc extra installations are located at #{DynTask.cfg_pandoc(true)[:extra_dir]}, "+((File.exist? DynTask.cfg_pandoc[:extra_dir]) ? "an " : "a non-") +"existing directory."
+		
+	when "wget"
+		## Stuff!
+		p [:extra_dir,DynTask.cfg_pandoc[:extra_dir]]
+		FileUtils.mkdir_p DynTask.cfg_pandoc[:extra_dir]
+		curdir=Dir.pwd
+      	Dir.chdir DynTask.cfg_pandoc[:extra_dir]
+      	version="3.1.0"
+      	puts "Installing reveal-js-#{version}"
+      	system("/usr/bin/env bash -c 'wget -O revealjs.tgz https://github.com/hakimel/reveal.js/archive/#{version}.tar.gz && tar xzvf revealjs.tgz && rm revealjs.tgz'") 
+      	puts "Installing s5-11"
+      	system("/usr/bin/env bash -c 'wget -O s5.zip http://meyerweb.com/eric/tools/s5/v/1.1/s5-11.zip && mkdir -p s5-tmp && unzip -d s5-tmp s5.zip && mv s5-tmp/ui s5-ui && rm s5.zip && rm -fr s5-tmp'")
+      	Dir.chdir curdir
+
+	end
+	exit
+end
+
+
+
+if ARGV.size == 1 and ARGV[0]=="ls"
+	Dir[File.join(DynTask.cfg_dir[:etc],"tasks","**/*")].each do |f|
+		puts "#{File.basename(f)}: #{File.read(f)}"
+	end
+	exit
+end
+
+etc_tasks=File.join(DynTask.cfg_dir[:etc],"tasks",ARGV[0])
+
+if ARGV.size==1
+	if options[:rm] and options[:force]
+		require 'fileutils'
+		FileUtils.rm etc_tasks
+	end
+else
+	if File.exists? etc_tasks and !options[:force]
+		puts "Error: file #{etc_tasks} already exist. Use --force or -f to modify this file!"
+		exit
+	else
+		require 'fileutils'
+		FileUtils.mkdir_p File.dirname(etc_tasks)
+		dyntask_tasks=ARGV[1..-1].join(" ")
+		File.open(etc_tasks,"w") do |f|
+			f << dyntask_tasks
+		end
+	end
+end
+
+puts "#{etc_tasks} contains: #{File.read(etc_tasks)}" if File.exists? etc_tasks

data/bin/dyntask-reader

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'trollop'
+require 'pathname'
+require 'dyntask'
+
+VERSION='0.1.0'
+
+options = Trollop::options do
+  version "dyntask-reader version #{VERSION}"
+  banner <<-EOS
+dyntask-reader executes the dynamic task file.
+Usage:
+   dyntask-reader '<dyntask file>'
+Options:
+EOS
+
+end
+
+Trollop::die Trollop::educate if(ARGV.size == 0)
+
+filename=Pathname.new(ARGV[-1]).expand_path.to_s
+
+#p filename
+DynTask.read_tasks(filename)

data/bin/dyntask-server

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'filewatcher'
+require 'trollop'
+require 'pathname'
+require 'thread'
+require 'dyntask'
+
+options = Trollop::options do
+  version "dyntask-server based on filewatcher, version #{FileWatcher.VERSION} by Thomas Flemming 2015"
+  banner <<-EOS
+dyntask-server scans the filesystem and executes shell commands when files changes.
+Usage:
+  dyntask-server [--restart] '<command type>'
+Comment: 
+  when file ~/.dyntask_workdir exists and contains a valid directory name, this becomes the working directory to watch unless -w option is provided at command line.
+Options:
+EOS
+  opt :dontwait, "Do not wait for filesystem updates before running", :short => 'd', :type => :boolean, :default => false
+  opt :restart, "Restart process when filesystem is updated", :short => 'r', :type => :boolean, :default => false
+  opt :list, "Print name of files being watched"
+  opt :interval, "Interval to scan filesystem.", :short => 'i', :type => :float, :default => 0.5
+  opt :spinner, "Show an ascii spinner", :short => 's', :type => :boolean, :default => false
+end
+
+Trollop::die Trollop::educate if(ARGV.size == 0)
+
+tasks_to_watch = []
+ARGV[0..-1].each do |a|
+  if !(a.include? ",") and File.exists? (etc_tasks=File.join(DynTask.cfg_dir[:etc],"tasks",a))
+    tasks_to_watch += File.read(etc_tasks).strip.split(/\s+/)
+  else
+    tasks_to_watch << a
+  end
+end
+
+
+# root working directory
+# dyntask_root=nil
+# if options[:workdir] != "" 
+#   dyntask_root=options[:workdir].sub("~",ENV["HOME"])
+# else
+#   etc_work_dir=File.join(DynTask.cfg_dir[:etc],"workdir")
+#   dyntask_root=File.read(etc_work_dir).strip.sub("~",ENV["HOME"]) if File.exists? etc_work_dir
+# end
+
+# unless dyntask_root
+#   puts "Working directory unset!\n Use: option -w with dyntask-server\n  or\n Launch: dyntask-init -w <WORKING DIRECTORY> to set default working directory!"
+#   exit
+# end
+# unless File.exists? dyntask_root
+#   puts "Stop: #{dyntask_root} is not a directory!"
+#   exit
+# end
+
+#puts "Root directory is #{dyntask_root}"
+
+if tasks_to_watch.empty?
+  puts "Stop: no tasks to serve!\n Launch: dyntask-init <NAME> <WORKDIR>:<LIST OF COMMA SEPARATED TASKS> to set of tasks to be called by <NAME>!"
+  exit
+end
+
+files_to_watch=[]
+tasks_to_watch.each do |e| 
+  workdir,tasks=e.split(":")
+  workdir=workdir.sub("~",ENV["HOME"])
+  tasks.split(",").each do |t|
+    files_to_watch << File.join(workdir,"**/*" +DynTask::TaskMngr::TASK_EXT+t) #if DynTask::TaskMngr::TASKS.include? file
+  end
+end
+
+files_to_watch.uniq!
+
+puts "Tasks watched: #{files_to_watch}"
+
+def restart(child_pid, env, cmd)
+  Process.kill(9,child_pid)
+  Process.wait(child_pid)
+rescue Errno::ESRCH
+  # already killed
+ensure
+  child_pid = Process.spawn({}, cmd)
+end
+
+if(options[:restart])
+  rd, wr = IO.pipe
+  child_pid = nil
+end
+
+begin
+  ##p files
+  fw = FileWatcher.new(files_to_watch, options[:list], options[:dontwait], options[:spinner])
+  task_mngr=DynTask::TaskMngr.new
+  fw.watch(options[:interval]) do |filename, event| 
+    cmd=nil
+    if([:changed,:new].include? event)
+      path = Pathname.new(filename).realpath.to_s
+      cmd = "dyntask-reader "+path
+
+      if(options[:restart])
+        if(child_pid == nil)
+          child_pid = Process.spawn({}, cmd)
+        else
+          child_id = restart(child_pid, {}, cmd)
+        end
+      else
+        begin
+          p "cmd: <#{cmd}>"
+          pid = Process.spawn({}, cmd)
+          Process.wait()
+        rescue SystemExit, Interrupt
+          exit(0)
+        end
+      end
+    end
+  end
+rescue SystemExit, Interrupt
+  fw.finalize
+end

data/bin/dyntask-writer

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'trollop'
+require 'pathname'
+require 'dyntask'
+
+VERSION='0.1.0'
+
+options = Trollop::options do
+  version "dyntask-writer version #{VERSION}"
+  banner <<-EOS
+dyntask-writer creates a dynamic task file.
+Usage:
+   dyntask-writer '<dyntask file>' ['<dyntask file2>' ...]
+Options:
+EOS
+
+end
+
+Trollop::die Trollop::educate if(ARGV.size == 0)
+task_basename=Pathname.new(ARGV[0]).expand_path.to_s
+ARGV[1..-1].each do |task|
+	cmd,*opts=task.split(",")
+	task2={cmd: cmd}
+	opts.each{|o|
+		key,*value=o.split("=")
+		value=value.join("=")
+		#p [:value,value]
+		
+		begin
+			task2[key.to_sym]=Object.class_eval(value)
+		rescue Exception
+			task2[key.to_sym]=value
+		end
+	}
+	[:source,:target].each {|t| 
+		task2[t]=Pathname.new(task2[t]).expand_path.to_s if task2[t] and !(task2[t] =~ /^\%/) 
+	}
+	p [:added,task2]
+	DynTask.add_task(task2)
+end
+ 
+DynTask.save_tasks(task_basename)

data/lib/dyntask/task_mngr.rb

@@ -0,0 +1,365 @@
+# encoding: UTF-8
+require 'dyndoc-software'
+require 'dyndoc-converter'
+require "fileutils"
+
+module DynTask
+
+  @@task_mngr=nil
+
+  def self.add_task(task)
+    @@task_mngr ||= DynTask::TaskMngr.new
+    @@task_mngr.add_task(task)
+  end
+
+  def self.save_tasks(task_basename)
+    return unless @@task_mngr
+    @@task_mngr.save_tasks(task_basename)
+  end
+
+  def self.read_tasks(task_filename)
+    @@task_mngr ||= DynTask::TaskMngr.new
+    @@task_mngr.load_user_task_plugins
+    @@task_mngr.read_tasks(task_filename)
+  end
+
+  @@cfg_dir=nil
+
+  def self.cfg_dir
+    return @@cfg_dir if @@cfg_dir
+    root=File.join(ENV["HOME"],".dyntask")
+    @@cfg_dir={
+      :root => root,
+      :etc => File.join(root,"etc"),
+      :share => File.join(root,"share"),
+      :tasks => File.join(root,"share","tasks"),
+      :plugins => File.join(root,"share","plugins")
+    }
+    @@cfg_dir
+  end
+
+  @@cfg_pandoc=nil
+
+  def self.cfg_pandoc(renew=false)
+    return @@cfg_pandoc if @@cfg_pandoc and !renew
+    @@cfg_pandoc={}
+    @@cfg_pandoc[:extra_etc]=File.join(self.cfg_dir[:etc],"pandoc_extra_dir")
+    @@cfg_pandoc[:extra_dir]=((File.exist? @@cfg_pandoc[:extra_etc]) ? File.read(@@cfg_pandoc[:extra_etc]) : File.join(self.cfg_dir[:root],"pandoc-extra")).strip
+    @@cfg_pandoc[:config_rb]=File.join(self.cfg_dir[:share],"pandoc","config.rb")
+    @@cfg_pandoc[:extra]=(File.exist? @@cfg_pandoc[:config_rb]) ? Object.class_eval(File.read(@@cfg_pandoc[:config_rb])) : {}
+    @@cfg_pandoc
+  end
+
+  def self.wait_for_file(filename,wait_loop_number = 20, wait_loop_time = 0.5,verbose=false)
+    cpt=0
+    while !File.exists? filename and cpt < wait_loop_number
+      p "wait: #{cpt}"
+      sleep wait_loop_time
+      cpt+=1
+    end
+    ## return succeed
+    File.exists? filename
+  end
+
+  class TaskMngr
+
+    # TODO: to put outside to be extended by users!
+    TASKS=["pdflatex","pandoc","png","dyn","sh"]
+    TASK_EXT=".task_"
+
+    def initialize
+      init_tasks
+    end
+
+     def init_tasks
+      @tasks=[]
+    end
+
+    ## Comment on writing task:
+    ## task is just a ruby hash containing at least :cmd key to describe the
+    ## command type. Other keys are for completing the task related to command :cmd
+    ## However, :source and :target are recommanded keynames for describing source and target filename
+
+    ## possibly add condition to check before applying command+options
+    def add_task(task)
+      @tasks << task
+    end
+
+    def save_tasks(task_basename)
+      task_filename=task_basename+TASK_EXT+@tasks[0][:cmd].to_s
+      File.open(task_filename,"w") do |f|
+        f << @tasks.inspect
+      end 
+    end
+
+    def write_tasks(task_basename,tasks)
+      @tasks=tasks
+      save_tasks(task_basename)
+    end
+
+    ## maybe to maintain only one task, remove current task when the new one is created
+    def read_tasks(task_filename)
+      @task_filename=task_filename
+      @workdir=File.dirname(@task_filename)
+      @tasks=Object.class_eval(File.read(@task_filename))
+      ##p @tasks
+      if @tasks.length>=1
+        @task=@tasks.shift #first task to deal with
+        ##p @task
+        make_task
+        if @tasks.length>=1
+          dirname=File.dirname(task_filename)
+          basename=File.basename(task_filename,".*")
+          task_basename=File.join(dirname,basename)
+          save_tasks(task_basename)
+        end
+        # remove since it is executed!
+        FileUtils.rm(task_filename)
+      end
+    end
+
+    ## if option to not remove taskfiles, this is a clean!
+    def task_clean_taskfiles(task_filename)
+      dirname=File.dirname(task_filename)
+      basename=File.basename(task_filename,TASK_EXT+"*")
+      
+      Dir[File.join(dirname,basename+TASK_EXT+"*")].each do |f|
+        FileUtils.rm(f)
+      end
+    end
+
+    def load_user_task_plugins
+      Dir[File.join(DynTask.cfg_dir[:plugins],"*.rb")].each {|lib| require lib} if File.exists? DynTask.cfg_dir[:plugins] 
+    end
+
+    def info_file(filename)
+      return {} unless filename
+      filename=File.join(@workdir,filename[1..-1]) if filename =~ /^\%/
+
+      ##p [:info_file,filename]
+
+      res = {
+        dirname: File.dirname(filename),
+        extname: File.extname(filename),
+        basename: File.basename(filename,".*")
+      }
+      res[:filename]=res[:basename]+res[:extname]
+      res[:full_filename]=File.join(res[:dirname],res[:filename])
+      res
+    end
+
+    def make_task
+
+      ## 
+      @source=@task[:source] ? info_file(@task[:source]) : info_file(@task_filename)
+      #p [:info,@task[:source]]
+      
+      #p [:source,@source]
+      @basename=@source[:basename]
+      @extname=@source[:extname]
+      @dirname=@source[:dirname]
+      @filename=@source[:filename]
+
+      @target=info_file(@task[:target]) if @task[:target]
+       
+      cd_new
+
+      ## This is a rule, if a @task contains both :source and :content
+      ## then save the file @task[:source] with this content @task[:content]
+      ## This is useful when delegating a next task in some dropbox-like environment: task and source are synchronized!
+      if @task[:content] and @task[:source]
+        #p [:content,@source[:filename]]
+        File.open(@source[:filename],"w") do |f|
+          f << @task[:content]
+        end
+      end
+
+      method("make_"+@task[:cmd].to_s).call
+
+      # case @task[:cmd].to_s
+      # when "sh"
+      #   make_sh
+      # when "dyn"
+      #   make_dyn
+      # when "pdflatex"
+      #   make_pdf
+      # when "pandoc"
+      #   make_pandoc
+      # when "png"
+      #   make_png
+      # end
+
+      cd_old
+        
+    end
+
+    def cd_new
+      @curdir=Dir.pwd
+      Dir.chdir(@workdir)
+    end
+
+    def cd_old
+      Dir.chdir(@curdir)
+    end
+
+    # make sh
+
+    def make_sh
+      shell_opts=@task[:shell_opts] || ""
+      script_opts=@task[:script_opts] || ""
+      `sh #{shell_opts} #{source[:filename]} #{script_opts}`
+    end
+
+    # make dyn
+
+    def make_dyn
+      opts = @task[:options] || ""
+      p [:dyn_cmd,"dyn #{opts} #{@filename}"]
+      `dyn #{opts} #{@filename}`
+    end
+
+    # make dyn-cli
+
+    def make_dyn_cli
+      p [:dyn_cmd_cli,"dyn-cli #{@filename} #{@target[:filename]} "]
+      `dyn-cli #{@filename} #{@target[:filename]}`
+    end
+
+    # make pdf
+
+    def make_pdflatex
+      #p [:task,@task]
+      nb_pass = @task[:nb_pass] || 1
+      echo_mode=@task[:echo] || false
+
+      ## Just in case of synchronisation delay!
+      wait_time=@task[:wait_loop_time] || 0.5
+      wait_nb=@task[:wait_loop_nb] || 20
+      ok=DynTask.wait_for_file(@basename+".tex",wait_nb,wait_time)
+
+      if ok
+        nb_pass.times {|i| make_pdflatex_pass(echo_mode) }
+      else
+        puts "Warning: no way to apply pdflatex since #{@basename+'.tex'} does not exist!"
+      end
+    end
+
+    # make pdflatex
+
+    def make_pdflatex_pass(echo_mode=false)
+      unless File.exists? @basename+".tex"
+        msg="No pdflatex #{@basename} in #{@dirname} since file does not exist!"
+        print "\n==> "+msg
+      end
+      if File.read(@basename+".tex").empty?
+        msg="No pdflatex #{@basename} in #{@dirname} since empty file!"
+        print "\n==> "+msg
+        ###$dyn_logger.write("ERROR pdflatex: "+msg+"\n") unless Dyndoc.cfg_dyn[:dyndoc_mode]==:normal
+        return ""
+      end
+      print "\n==> #{Dyndoc.pdflatex} #{@basename} in #{@dirname}"
+
+      out=`#{Dyndoc.pdflatex} -halt-on-error -file-line-error -interaction=nonstopmode #{@basename}`
+      out=out.b if RUBY_VERSION >= "1.9" #because out is not necessarily utf8 encoded  
+      out=out.split("\n")
+      puts out if echo_mode
+      if out[-2].include? "Fatal error"
+        #if Dyndoc.cfg_dyn[:dyndoc_mode]==:normal
+        #  print " -> NOT OKAY!!!\n==> "
+        #  puts out[-4...-1]
+        #  raise SystemExit 
+        #end
+      else 
+        print " -> OKAY!!!\n"
+        ###@cfg[:created_docs] << @basename+".pdf" #( @dirname.empty? ? "" : @dirname+"/" ) + @basename+".pdf"
+      end
+    end
+
+    # make pandoc
+
+    def make_pandoc
+
+      cfg_pandoc = DynTask.cfg_pandoc[:extra]
+
+      format_doc,format_output=@task[:filter].split("2")
+      #
+      p [format_doc.to_s , format_output.to_s]
+      append_doc= @task[:append_doc] || ""
+      cmd_pandoc_options,pandoc_file_output,pandoc_file_input=[],"",nil
+      case @task[:filter]
+      when "md2odt"
+        cmd_pandoc_options = cfg_pandoc["md2odt"] || []
+        pandoc_file_output=@basename+append_doc+".odt"
+      when "md2docx"
+        cmd_pandoc_options= cfg_pandoc["md2docx"] || ["-s","-S"]
+        pandoc_file_output=@basename+append_doc+".docx"
+      when "tex2docx"
+        pandoc_file_input=@filename
+        cmd_pandoc_options= cfg_pandoc["tex2docx"] || ["-s"]
+        pandoc_file_output=@basename+append_doc+".docx"
+      when "md2beamer"
+        cmd_pandoc_options= cfg_pandoc["md2beamer"] || ["-t","beamer"]
+        pandoc_file_output=@basename+append_doc+".pdf"
+      when "md2dzslides"
+        cmd_pandoc_options= cfg_pandoc["md2dzslides"] || ["-s","--mathml","-i","-t","dzslides"]
+        pandoc_file_output=@basename+append_doc+".html"
+      when "md2slidy"
+        cmd_pandoc_options= cfg_pandoc["md2slidy"] || ["-s","--webtex","-i","-t","slidy"]
+        pandoc_file_output=@basename+append_doc+".html"  
+      when "md2s5"
+        cmd_pandoc_options= cfg_pandoc["md2s5"] || ["-s","--self-contained","--webtex","-i","-t","s5"]
+        pandoc_file_output=@basename+append_doc+".html"
+      when "md2revealjs"
+        cmd_pandoc_options= cfg_pandoc["md2revealjs"] || ["-s","--self-contained","--webtex","-i","-t","revealjs"]
+        pandoc_file_output=@basename+append_doc+".html"
+      when "md2slideous"
+        cmd_pandoc_options=["-s","--mathjax","-i","-t","slideous"]
+        pandoc_file_output=@basename+append_doc+".html"
+      end
+     
+      opts=cmd_pandoc_options #OBSOLETE NOW!: +["-o",pandoc_file_output]
+    
+      output=if pandoc_file_input
+        opts << pandoc_file_input
+        Dyndoc::Converter.pandoc(nil,opts.join(" "))
+      else
+        @content=@task[:content]
+        #
+        p [:make_pandoc_content, opts.join(" "),@content]
+        Dyndoc::Converter.pandoc(@content,opts.join(" "))
+      end
+
+      if pandoc_file_output
+        File.open(pandoc_file_output,"w") do |f|
+          f << output
+        end
+      end
+  
+    end
+
+
+
+    # make png
+
+    def make_png
+      make_dvipng
+    end
+
+    # make latex and dvipng 
+
+    def make_dvipng
+        system "latex #{@basename}.tex"
+        print "\nlatex #{@basename}.tex -> ok\n"
+        system "dvipng --nogssafer #{@basename}.dvi -o #{@basename}.png"
+        print "\ndvipng --nogssafer #{@basename}.dvi -o #{@basename}.png -> ok\n"
+    end
+
+    # make ttm
+    
+    def make_ttm
+#puts "make_ttm:begin"
+      Dyndoc::Converter.ttm(File.read(@task[:filename]))
+    end
+
+  end
+end

data/lib/dyntask.rb

@@ -0,0 +1 @@
+require 'dyntask/task_mngr'

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: dyntask-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- CQLS
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-21 00:00:00.000000000 Z
+dependencies: []
+description: |2
+    Managing dyndoc tasks.
+email: rdrouilh@gmail.com
+executables:
+- dyntask-server
+- dyntask-reader
+- dyntask-writer
+- dyntask-init
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dyntask.rb
+- lib/dyntask/task_mngr.rb
+- bin/dyntask-server
+- bin/dyntask-reader
+- bin/dyntask-writer
+- bin/dyntask-init
+homepage: http://cqls.upmf-grenoble.fr
+licenses:
+- MIT
+- GPL-2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- none
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: dyntask system
+test_files: []