rbbt-util 5.44.1 → 6.0.3

data/lib/rbbt/util/tar.rb

@@ -1,117 +1,119 @@
-require 'rubygems/package'
-require 'zlib'
-require 'fileutils'
- 
-# SOURCE: https://gist.github.com/sinisterchipmunk/1335041
-# Adapted for Rbbt 
-
-module Misc
-  # Creates a tar file in memory recursively
-  # from the given path.
-  #
-  # Returns a StringIO whose underlying String
-  # is the contents of the tar file.
-  def self.tar(path, tarfile = nil)
-    tarfile ||= StringIO.new("")
-
-    Gem::Package::TarWriter.new(tarfile) do |tar|
-      Dir[File.join(path, "**/*")].each do |file|
-        mode = File.stat(file).mode
-        relative_file = file.sub /^#{Regexp::escape path}\/?/, ''
-
-        if File.directory?(file)
-          tar.mkdir relative_file, mode
-        else
-          tar.add_file relative_file, mode do |tf|
-            File.open(file, "rb") { |f| tf.write f.read }
-          end
-        end
-      end
-    end
-
-    tarfile.rewind
-
-    tarfile
-  end
-
-  def self.tarize(path, gz = nil)
-    gz ||= StringIO.new('wb')
-
-    tar =  Misc.in_dir(path) do self.tar('.') end
-
-    tar.rewind
-
-    string = tar.string
-
-    z = Zlib::GzipWriter.new(gz)
-    z.write string
-    z.close
-
-    gz.reopen('read')
-    gz.rewind
-
-
-    gz
-  end
-
-  def self.tarize(path)
-    Misc.in_dir(path) do
-      CMD.cmd("tar cvfz - '.'", :pipe => true)
-    end
-  end
-
-  # gzips the underlying string in the given StringIO,
-  # returning a new StringIO representing the 
-  # compressed file.
-  def self.gzip(tarfile)
-    gz = StringIO.new("")
-    z = Zlib::GzipWriter.new(gz)
-    z.write tarfile.string
-    z.close # this is necessary!
-
-    # z was closed to write the gzip footer, so
-    # now we need a new StringIO
-    StringIO.new gz.string
-  end
-
-  # un-gzips the given IO, returning the
-  # decompressed version as a StringIO
-  def self.ungzip(tarfile)
-    z = Zlib::GzipReader.new(tarfile)
-    unzipped = StringIO.new(z.read)
-    z.close
-    unzipped
-  end
-
-  def self._untar_cmd(io, destination)
-    FileUtils.mkdir_p destination unless File.exist? destination
-    CMD.cmd_log("tar xvf - -C '#{destination}'", :in => io)
-    nil
-  end
-
-  # untars the given IO into the specified
-  # directory
-  def self.untar(io, destination)
-    io = io.find if Path === io
-    if String === io and File.exist?(io)
-      Open.open(io) do |f|
-        untar(f, destination)
-      end
-    else
-      return _untar_cmd(io, destination)
-    end
-  end
-end
-
-
-### Usage Example: ###
-#
-# include Util::Tar
+require_relative '../refactor'
+Rbbt.require_instead 'scout/misc/filesystem'
+#require 'rubygems/package'
+#require 'zlib'
+#require 'fileutils'
 # 
-# io = tar("./Desktop")   # io is a TAR of files
-# gz = gzip(io)           # gz is a TGZ
-# 
-# io = ungzip(gz)         # io is a TAR
-# untar(io, "./untarred") # files are untarred
+## SOURCE: https://gist.github.com/sinisterchipmunk/1335041
+## Adapted for Rbbt 
+#
+#module Misc
+#  # Creates a tar file in memory recursively
+#  # from the given path.
+#  #
+#  # Returns a StringIO whose underlying String
+#  # is the contents of the tar file.
+#  def self.tar(path, tarfile = nil)
+#    tarfile ||= StringIO.new("")
+#
+#    Gem::Package::TarWriter.new(tarfile) do |tar|
+#      Dir[File.join(path, "**/*")].each do |file|
+#        mode = File.stat(file).mode
+#        relative_file = file.sub /^#{Regexp::escape path}\/?/, ''
+#
+#        if File.directory?(file)
+#          tar.mkdir relative_file, mode
+#        else
+#          tar.add_file relative_file, mode do |tf|
+#            File.open(file, "rb") { |f| tf.write f.read }
+#          end
+#        end
+#      end
+#    end
+#
+#    tarfile.rewind
+#
+#    tarfile
+#  end
+#
+#  def self.tarize(path, gz = nil)
+#    gz ||= StringIO.new('wb')
+#
+#    tar =  Misc.in_dir(path) do self.tar('.') end
+#
+#    tar.rewind
+#
+#    string = tar.string
+#
+#    z = Zlib::GzipWriter.new(gz)
+#    z.write string
+#    z.close
+#
+#    gz.reopen('read')
+#    gz.rewind
+#
+#
+#    gz
+#  end
+#
+#  def self.tarize(path)
+#    Misc.in_dir(path) do
+#      CMD.cmd("tar cvfz - '.'", :pipe => true)
+#    end
+#  end
+#
+#  # gzips the underlying string in the given StringIO,
+#  # returning a new StringIO representing the 
+#  # compressed file.
+#  def self.gzip(tarfile)
+#    gz = StringIO.new("")
+#    z = Zlib::GzipWriter.new(gz)
+#    z.write tarfile.string
+#    z.close # this is necessary!
+#
+#    # z was closed to write the gzip footer, so
+#    # now we need a new StringIO
+#    StringIO.new gz.string
+#  end
+#
+#  # un-gzips the given IO, returning the
+#  # decompressed version as a StringIO
+#  def self.ungzip(tarfile)
+#    z = Zlib::GzipReader.new(tarfile)
+#    unzipped = StringIO.new(z.read)
+#    z.close
+#    unzipped
+#  end
+#
+#  def self._untar_cmd(io, destination)
+#    FileUtils.mkdir_p destination unless File.exist? destination
+#    CMD.cmd_log("tar xvf - -C '#{destination}'", :in => io)
+#    nil
+#  end
+#
+#  # untars the given IO into the specified
+#  # directory
+#  def self.untar(io, destination)
+#    io = io.find if Path === io
+#    if String === io and File.exist?(io)
+#      Open.open(io) do |f|
+#        untar(f, destination)
+#      end
+#    else
+#      return _untar_cmd(io, destination)
+#    end
+#  end
+#end
+#
+#
+#### Usage Example: ###
+##
+## include Util::Tar
+## 
+## io = tar("./Desktop")   # io is a TAR of files
+## gz = gzip(io)           # gz is a TGZ
+## 
+## io = ungzip(gz)         # io is a TAR
+## untar(io, "./untarred") # files are untarred
+##
 #
-

data/lib/rbbt/util/tmpfile.rb

@@ -1,67 +1,69 @@
-require 'fileutils'
-
-module TmpFile
-
-  TMPDIR = "/tmp/#{ENV['USER']}/tmpfiles" 
-  FileUtils.mkdir_p TMPDIR unless File.exist? TMPDIR
-
-  def self.tmpdir=(tmpdir)
-    TMPDIR.replace tmpdir
-    FileUtils.mkdir_p TMPDIR unless File.exist? TMPDIR
-  end
-
-  def self.tmpdir
-    TMPDIR
-  end
-
-
-  # Creates a random file name, with the given suffix and a random number
-  # up to +max+
-  def self.random_name(s = "tmp-", max = 1_000_000_000)
-    n = rand(max)
-    s + n.to_s
-  end
-
-  # Creates a random filename in the temporary directory
-  def self.tmp_file(s = "tmp-", max=1_000_000_000, dir = TMPDIR)
-    File.expand_path(File.join(dir, random_name(s, max)))
-  end
-
-  def self.with_file(content = nil, erase = true, options = {})
-    options, content, erase = content, nil, true if Hash === content
-    options, erase = erase, true if Hash === erase 
-
-    prefix = options[:prefix] || "tmp-"
-    tmpdir = options[:tmpdir] || TMPDIR
-    max = options[:max] || 1_000_000_000
-    tmpfile = tmp_file prefix, max, tmpdir
-    if options[:extension]
-      tmpfile += ".#{options[:extension]}"
-    end
-
-    if IO === content
-      Misc.consume_stream(content, false, tmpfile)
-    else
-      File.open(tmpfile, 'w') do |f| f.write content end if content != nil
-    end
-
-    result = yield(tmpfile)
-
-    FileUtils.rm_rf tmpfile if File.exist?(tmpfile) and erase
-
-    result
-  end
-
-  def self.with_dir(erase = true, options = {})
-    prefix = options[:prefix] || "tmpdir-"
-    tmpdir = tmp_file prefix
-
-    FileUtils.mkdir_p tmpdir
-
-    result = yield(tmpdir)
-
-    FileUtils.rm_rf tmpdir if File.exist?(tmpdir) and erase
-
-    result
-  end
-end
+require_relative '../refactor'
+Rbbt.require_instead 'scout/tmpfile'
+#require 'fileutils'
+#
+#module TmpFile
+#
+#  TMPDIR = "/tmp/#{ENV['USER']}/tmpfiles" 
+#  FileUtils.mkdir_p TMPDIR unless File.exist? TMPDIR
+#
+#  def self.tmpdir=(tmpdir)
+#    TMPDIR.replace tmpdir
+#    FileUtils.mkdir_p TMPDIR unless File.exist? TMPDIR
+#  end
+#
+#  def self.tmpdir
+#    TMPDIR
+#  end
+#
+#
+#  # Creates a random file name, with the given suffix and a random number
+#  # up to +max+
+#  def self.random_name(s = "tmp-", max = 1_000_000_000)
+#    n = rand(max)
+#    s + n.to_s
+#  end
+#
+#  # Creates a random filename in the temporary directory
+#  def self.tmp_file(s = "tmp-", max=1_000_000_000, dir = TMPDIR)
+#    File.expand_path(File.join(dir, random_name(s, max)))
+#  end
+#
+#  def self.with_file(content = nil, erase = true, options = {})
+#    options, content, erase = content, nil, true if Hash === content
+#    options, erase = erase, true if Hash === erase 
+#
+#    prefix = options[:prefix] || "tmp-"
+#    tmpdir = options[:tmpdir] || TMPDIR
+#    max = options[:max] || 1_000_000_000
+#    tmpfile = tmp_file prefix, max, tmpdir
+#    if options[:extension]
+#      tmpfile += ".#{options[:extension]}"
+#    end
+#
+#    if IO === content
+#      Misc.consume_stream(content, false, tmpfile)
+#    else
+#      File.open(tmpfile, 'w') do |f| f.write content end if content != nil
+#    end
+#
+#    result = yield(tmpfile)
+#
+#    FileUtils.rm_rf tmpfile if File.exist?(tmpfile) and erase
+#
+#    result
+#  end
+#
+#  def self.with_dir(erase = true, options = {})
+#    prefix = options[:prefix] || "tmpdir-"
+#    tmpdir = tmp_file prefix
+#
+#    FileUtils.mkdir_p tmpdir
+#
+#    result = yield(tmpdir)
+#
+#    FileUtils.rm_rf tmpdir if File.exist?(tmpdir) and erase
+#
+#    result
+#  end
+#end

data/lib/rbbt/util/version.rb

@@ -1,3 +1,5 @@
+require 'scout/path'
+require 'scout/indiferent_hash'
 module Rbbt
   VERSIONS = IndiferentHash.setup({})
 

data/lib/rbbt/workflow/refactor/entity.rb

@@ -0,0 +1,11 @@
+module TSV
+  annotation :entity_options, :entity_templates
+
+  def entity_options
+    @entity_options ||= {}
+  end
+
+  def entity_templates
+    @entity_templates ||= {}
+  end
+end

data/lib/rbbt/workflow/refactor/export.rb

@@ -0,0 +1,66 @@
+module Workflow
+
+  annotation :asynchronous_exports, :synchronous_exports, :exec_exports, :stream_exports
+
+  def asynchronous_exports
+    @asynchronous_exports ||= []
+  end
+
+  def synchronous_exports
+    @synchronous_exports ||= []
+  end
+
+  def exec_exports
+    @exec_exports ||= []
+  end
+
+  def stream_exports
+    @exec_exports ||= []
+  end
+
+
+  def all_exports
+    asynchronous_exports + synchronous_exports + exec_exports + stream_exports
+  end
+
+  alias task_exports all_exports
+
+  def unexport(*names)
+    names = names.collect{|n| n.to_s} + names.collect{|n| n.to_sym}
+    names.uniq!
+    exec_exports.replace exec_exports - names if exec_exports
+    synchronous_exports.replace synchronous_exports - names if synchronous_exports
+    asynchronous_exports.replace asynchronous_exports - names if asynchronous_exports
+    stream_exports.replace stream_exports - names if stream_exports
+  end
+  
+  def export_exec(*names)
+    unexport *names
+    exec_exports.concat names
+    exec_exports.uniq!
+    exec_exports
+  end
+
+  def export_synchronous(*names)
+    unexport *names
+    synchronous_exports.concat names
+    synchronous_exports.uniq!
+    synchronous_exports
+  end
+
+  def export_asynchronous(*names)
+    unexport *names
+    asynchronous_exports.concat names
+    asynchronous_exports.uniq!
+    asynchronous_exports
+  end
+
+  def export_stream(*names)
+    unexport *names
+    stream_exports.concat names
+    stream_exports.uniq!
+    stream_exports
+  end
+
+  alias export export_asynchronous
+end

data/lib/rbbt/workflow/refactor/inputs.rb

@@ -0,0 +1,24 @@
+class Step
+  def self.save_inputs(inputs, input_types, dir)
+    inputs.collect do |name,value|
+      next if value.nil?
+      type = input_types[name]
+      type = type.to_s if type
+
+      Task.save_input(dir, name, type, value)
+      name
+    end.compact.any?
+  end
+end
+
+module Workflow
+  def self.load_inputs(dir, names, types)
+    inputs = IndiferentHash.setup({})
+    names.zip(types) do |name, type|
+      filename = File.join(directory, name.to_s) 
+      value = Task.load_input_from_file(filename, name, type)
+      inputs[name] = value unless value.nil?
+    end
+    inputs
+  end
+end

data/lib/rbbt/workflow/refactor/recursive.rb

@@ -0,0 +1,64 @@
+module Workflow
+  def rec_inputs(task_name)
+    tasks[task_name].recursive_inputs.collect{|name, _| name }
+  end
+
+  def rec_input_types(task_name)
+    tasks[task_name].recursive_inputs.inject({}) do |acc,l|
+      name, type, desc, default, options = l
+      acc.merge!(name => type) unless acc.include?(name)
+      acc
+    end
+  end
+
+
+  def rec_input_descriptions(task_name)
+    tasks[task_name].recursive_inputs.inject({}) do |acc,l|
+      name, type, desc, default, options = l
+      acc.merge!(name => desc)  unless desc.nil? || acc.include?(name)
+      acc
+    end
+  end
+
+  def rec_input_defaults(task_name)
+    tasks[task_name].recursive_inputs.inject({}) do |acc,l|
+      name, type, desc, default, options = l
+      acc.merge!(name => default)  unless default.nil? || acc.include?(name)
+      acc
+    end
+  end
+
+  def rec_input_options(task_name)
+    tasks[task_name].recursive_inputs.inject({}) do |acc,l|
+      name, type, desc, default, options = l
+      acc.merge!(name => options) unless options.nil? unless acc.include?(name)
+      acc
+    end
+  end
+
+
+  def rec_input_use(task_name)
+    input_use = {}
+    task = self.tasks[task_name]
+    task.inputs.each do |name,_| 
+      input_use[name] ||= {} 
+      input_use[name][self] ||= []
+      input_use[name][self] << task_name
+    end
+
+    task.deps.inject(input_use) do |acc,p|
+      workflow, task_name = p
+      next if task_name.nil?
+      workflow.rec_input_use(task_name).each do |name,uses|
+        acc[name] ||= {}
+        uses.each do |workflow, task_names|
+          acc[name][workflow] ||= []
+          acc[name][workflow].concat(task_names)
+        end
+      end
+      acc
+    end if task.deps
+
+    input_use
+  end
+end

data/lib/rbbt/workflow/refactor/task_info.rb

@@ -0,0 +1,65 @@
+require_relative 'export'
+require_relative 'recursive'
+module Workflow
+  def task_info(name)
+    name = name.to_sym
+    task = tasks[name]
+    raise "No '#{name}' task in '#{self.to_s}' Workflow" if task.nil?
+    id = File.join(self.to_s, name.to_s)
+    @task_info ||= {}
+    @task_info[id] ||= begin 
+                         description = task.description
+                         result_description = task.result_description
+                         result_type = task.result_type
+
+                         inputs = rec_inputs(name).uniq
+                         input_types = rec_input_types(name)
+                         input_descriptions = rec_input_descriptions(name)
+                         input_use = rec_input_use(name)
+                         input_defaults = rec_input_defaults(name)
+                         input_options = rec_input_options(name)
+                         extension = task.extension
+                         export = case
+                                  when (synchronous_exports.include?(name.to_sym) or synchronous_exports.include?(name.to_s))
+                                    :synchronous
+                                  when (asynchronous_exports.include?(name.to_sym) or asynchronous_exports.include?(name.to_s))
+                                    :asynchronous
+                                  when (exec_exports.include?(name.to_sym) or exec_exports.include?(name.to_s))
+                                    :exec
+                                  when (stream_exports.include?(name.to_sym) or stream_exports.include?(name.to_s))
+                                    :stream
+                                  else
+                                    :none
+                                  end
+
+                         dependencies = tasks[name].deps
+                         { :id => id,
+                           :description => description,
+                           :export => export,
+                           :inputs => inputs,
+                           :input_types => input_types,
+                           :input_descriptions => input_descriptions,
+                           :input_defaults => input_defaults,
+                           :input_options => input_options,
+                           :input_use => input_use,
+                           :result_type => result_type,
+                           :result_description => result_description,
+                           :dependencies => dependencies,
+                           :extension => extension
+                         }
+                       end
+  end
+end
+
+module Task
+  def result_description
+    ""
+  end
+
+  def result_type
+    @returns
+  end
+
+end
+
+