scout-gear 1.2.0 → 5.1.1

data/lib/scout/resource/produce/rake.rb

@@ -0,0 +1,69 @@
+require_relative '../../misc'
+require_relative '../../path'
+require 'rake'
+
+class Rake::FileTask
+  class << self
+    alias_method :old_define_task, :define_task
+  end
+
+  def self.define_task(file, *args, &block)
+    @@files ||= []
+    @@files << file
+    old_define_task(file, *args, &block)
+  end
+
+  def self.files
+    @@files
+  end
+
+  def self.clear_files
+    @@files = []
+  end
+end
+
+module ScoutRake
+  class TaskNotFound < StandardError; end
+  def self.run(rakefile, dir, task, &block)
+    old_pwd = FileUtils.pwd
+
+    Rake::Task.clear
+    Rake::FileTask.clear_files
+
+    t = nil
+    pid = Process.fork{
+      if block_given?
+        TOPLEVEL_BINDING.receiver.instance_exec &block
+      else
+        if Path.is_filename? rakefile
+          rakefile = rakefile.produce.find
+          load rakefile
+        else
+          TmpFile.with_file(rakefile) do |tmpfile|
+            load tmpfile
+          end
+        end
+      end
+
+      raise TaskNotFound if Rake::Task[task].nil?
+
+      #Misc.pre_fork
+      begin
+        Misc.in_dir(dir) do
+          Rake::Task[task].invoke
+
+          Rake::Task.clear
+          Rake::FileTask.clear_files
+        end
+      rescue Exception
+        Log.error "Error in rake: #{$!.message}"
+        Log.exception $!
+        Kernel.exit! -1
+      end
+      Kernel.exit! 0
+    }
+    Process.waitpid(pid)
+    raise "Rake failed" unless $?.success?
+
+  end
+end

data/lib/scout/resource/produce.rb

@@ -0,0 +1,246 @@
+require_relative '../open'
+require_relative '../tmpfile'
+require_relative 'produce/rake'
+
+module Resource
+  def claim(path, type, content = nil, &block)
+    if type == :rake
+      @rake_dirs ||= {}
+      @rake_dirs[path] = content || block
+    else
+      @resources ||= {}
+      @resources[path] = [type, content || block]
+    end
+  end
+
+  def rake_for(path)
+    @rake_dirs ||= {}
+    @rake_dirs.select{|dir, content|
+      Misc.path_relative_to(dir, path)
+    }.sort_by{|dir, content|
+      dir.length
+    }.last
+  end
+
+  def has_rake(path)
+    !! rake_for(path)
+  end
+
+  def run_rake(path, rakefile, rake_dir)
+    task = Misc.path_relative_to rake_dir, path
+    rakefile = rakefile.produce if rakefile.respond_to? :produce
+    rakefile = rakefile.find if rakefile.respond_to? :find
+
+    rake_dir = rake_dir.find(:user) if rake_dir.respond_to? :find
+
+    begin
+      if Proc === rakefile
+        ScoutRake.run(nil, rake_dir, task, &rakefile)
+      else
+        ScoutRake.run(rakefile, rake_dir, task)
+      end
+    rescue Rake::TaskNotFound
+      if rake_dir.nil? or rake_dir.empty? or rake_dir == "/" or rake_dir == "./"
+        raise $! 
+      end
+      task = File.join(File.basename(rake_dir), task)
+      rake_dir = File.dirname(rake_dir)
+      retry
+    end
+  end
+
+  def produce(path, force = false)
+    case
+    when @resources.include?(path)
+      type, content = @resources[path]
+    when (Path === path && @resources.include?(path.original))
+      type, content = @resources[path.original]
+    when has_rake(path)
+      type = :rake
+      rake_dir, content = rake_for(path)
+      rake_dir = Path.setup(rake_dir.dup, self.pkgdir, self)
+    else
+      if path !~ /\.(gz|bgz)$/
+        begin
+          produce(path.annotate(path + '.gz'), force)
+        rescue ResourceNotFound
+          begin
+            produce(path.annotate(path + '.bgz'), force)
+          rescue ResourceNotFound
+            raise ResourceNotFound, "Resource is missing and does not seem to be claimed: #{ self } -- #{ path } "
+          end
+        end
+      else
+        raise ResourceNotFound, "Resource is missing and does not seem to be claimed: #{ self } -- #{ path } "
+      end
+    end
+
+    if path.respond_to?(:find) 
+      final_path = force ? path.find(:default) : path.find
+    else
+      final_path = path
+    end
+
+    if type and not File.exist?(final_path) or force
+      Log.medium "Producing: (#{self.to_s}) #{ final_path }"
+      lock_filename = TmpFile.tmp_for_file(final_path, :dir => lock_dir)
+
+      Open.lock lock_filename do
+        FileUtils.rm_rf final_path if force and File.exist? final_path
+
+        if ! File.exist?(final_path) || force 
+
+          begin
+            case type
+            when :string
+              Open.sensible_write(final_path, content)
+            when :csv
+              raise "TSV/CSV Not implemented yet"
+              #require 'rbbt/tsv/csv'
+              #tsv = TSV.csv Open.open(content)
+              #Open.sensible_write(final_path, tsv.to_s)
+            when :url
+              options = {}
+              options[:noz] = true if Open.gzip?(final_path) || Open.bgzip?(final_path) || Open.zip?(final_path)
+              Open.sensible_write(final_path, Open.open(content, options))
+            when :proc
+              data = case content.arity
+                     when 0
+                       content.call
+                     when 1
+                       content.call final_path
+                     end
+              case data
+              when String, IO, StringIO
+                Open.sensible_write(final_path, data) 
+              when Array
+                Open.sensible_write(final_path, data * "\n")
+              when TSV
+                Open.sensible_write(final_path, data.dumper_stream) 
+              when TSV::Dumper
+                Open.sensible_write(final_path, data.stream) 
+              when nil
+              else
+                raise "Unkown object produced: #{Log.fingerprint data}"
+              end
+            when :rake
+              run_rake(path, content, rake_dir)
+            when :install
+              Log.debug "Installing software: #{path}"
+
+              $set_software_env = false unless File.exist? path
+              
+              software_dir = path.resource.root.software.find :user
+              helper_file = File.expand_path(Rbbt.share.install.software.lib.install_helpers.find(:lib, caller_lib_dir(__FILE__)))
+              #helper_file = File.expand_path(Rbbt.share.install.software.lib.install_helpers.find)
+
+              preamble = <<-EOF
+#!/bin/bash
+
+RBBT_SOFTWARE_DIR="#{software_dir}"
+
+INSTALL_HELPER_FILE="#{helper_file}"
+source "$INSTALL_HELPER_FILE"
+              EOF
+
+              content = content.call if Proc === content
+
+              content = if content =~ /git:|\.git$/
+                          {:git => content}
+                        else
+                          {:src => content}
+                        end if String === content and Open.remote?(content)
+
+              script_text = case content
+                            when nil
+                              raise "No way to install #{path}"
+                            when Path
+                              Open.read(content) 
+                            when String
+                              if Path.is_filename?(content) and Open.exists?(content)
+                                Open.read(content) 
+                              else
+                                content
+                              end
+                            when Hash
+                              name = content[:name] || File.basename(path)
+                              git = content[:git]
+                              src = content[:src]
+                              url = content[:url]
+                              jar = content[:jar]
+                              extra = content[:extra]
+                              commands = content[:commands]
+                              if git
+                                <<-EOF
+
+name='#{name}'
+url='#{git}'
+
+install_git "$name" "$url" #{extra}
+
+#{commands}
+                                EOF
+                              elsif src
+                                <<-EOF
+
+name='#{name}'
+url='#{src}'
+
+install_src "$name" "$url" #{extra}
+
+#{commands}
+                                EOF
+                              elsif jar
+                                <<-EOF
+
+name='#{name}'
+url='#{jar}'
+
+install_jar "$name" "$url" #{extra}
+
+#{commands}
+                                EOF
+                              else
+                                <<-EOF
+
+name='#{name}'
+url='#{url}'
+
+#{commands}
+                                EOF
+                              end
+                            end
+
+              script = preamble + "\n" + script_text
+              Log.debug "Installing software with script:\n" << script
+              CMD.cmd_log('bash', :in => script)
+
+              set_software_env(software_dir) unless $set_software_env
+              $set_software_env = true
+            else
+              raise "Could not produce #{ resource }. (#{ type }, #{ content })"
+            end
+          rescue
+            FileUtils.rm_rf final_path if File.exist? final_path
+            raise $!
+          end
+        end
+      end
+    end
+
+    # After producing a file, make sure we recheck all locations, the file
+    # might have appeared with '.gz' extension for instance
+    path.instance_variable_set("@path", {})
+
+    path
+  end
+
+end
+
+module Path
+  def produce(force = false)
+    return self if ! force && Open.exist?(self)
+    self.pkgdir.produce self if Resource === self.pkgdir
+    return self
+  end
+end

data/lib/scout/resource/scout.rb

@@ -0,0 +1,3 @@
+module Scout
+  extend Resource
+end

data/lib/scout/resource.rb

@@ -0,0 +1,37 @@
+require_relative 'log'
+require_relative 'path'
+require_relative 'resource/produce'
+
+module Resource
+  extend MetaExtension
+  extension_attr :pkgdir, :libdir, :subdir, :resources, :rake_dirs, :path_maps, :lock_dir
+
+  def self.default_lock_dir
+    Path.setup('tmp/produce_locks').find
+  end
+
+  def subdir
+    @subdir ||= ""
+  end
+
+  def lock_dir
+    @lock_dir ||= Resource.default_lock_dir
+  end
+
+  def pkgdir
+    @pkgdir ||= Path.default_pkgdir
+  end
+
+  def root
+    Path.setup(subdir, self, self.libdir, @path_maps)
+  end
+
+  def method_missing(name, prev = nil, *args)
+    if prev.nil?
+      root.send(name, *args)
+    else
+      root.send(name, prev, *args)
+    end
+  end
+end
+

data/lib/scout/simple_opt/accessor.rb

@@ -0,0 +1,54 @@
+module SOPT
+  class << self
+    attr_writer :inputs, :input_shortcuts, :input_types, :input_descriptions, :input_defaults
+  end
+
+  def self.all
+    @all ||= {}
+  end
+
+  def self.shortcuts
+    @shortcuts ||= {}
+  end
+  
+  def self.inputs 
+    @inputs ||= []
+  end
+
+  def self.input_shortcuts 
+    @input_shortcuts ||= {}
+  end
+
+  def self.input_types 
+    @input_types ||= {}
+  end
+
+  def self.input_descriptions 
+    @input_descriptions ||= {}
+  end
+
+  def self.input_defaults 
+    @input_defaults ||= {}
+  end
+
+  def self.reset
+    @shortcuts = {}
+    @all = {}
+  end
+
+  def self.delete_inputs(inputs)
+    inputs.each do |input|
+      input = input.to_s
+      self.shortcuts.delete self.input_shortcuts.delete(input)
+      self.inputs.delete input
+      self.input_types.delete input
+      self.input_defaults.delete input
+      self.input_descriptions.delete input
+    end
+  end
+
+  def self.usage
+    puts SOPT.doc
+    exit 0
+  end
+end

data/lib/scout/simple_opt/doc.rb

@@ -0,0 +1,102 @@
+require_relative '../log'
+module SOPT
+
+  class << self
+    attr_writer :command, :summary, :synopsys, :description
+  end
+
+  def self.command
+    @command ||= File.basename($0)
+  end
+
+  def self.summary
+    @summary ||= ""
+  end
+
+  def self.synopsys
+    @synopsys ||= begin
+                    "#{command} " <<
+                    inputs.collect{|name|
+                      "[" << input_format(name, input_types[name] || :string, input_defaults[name], input_shortcuts[name]).sub(/:$/,'') << "]"
+                    } * " "
+                  end
+  end
+
+  def self.description
+    @description ||= "Missing"
+  end
+
+  def self.input_format(name, type = nil, default = nil, short = nil)
+    input_str = (short.nil? or short.empty?) ? "--#{name}" : "-#{short},--#{name}"
+    input_str = Log.color(:blue, input_str)
+    extra = case type
+    when nil
+      ""
+    when :boolean
+      "[=false]" 
+    when :tsv, :text
+      "=<file|->"
+    when :array
+      "=<list|file|->"
+    else
+      "=<#{ type }>"
+    end
+    #extra << " (default: #{Array === default ? (default.length > 3 ? default[0..2]*", " + ', ...' : default*", " ): default})" if default != nil
+    extra << " (default: #{Misc.fingerprint(default)})" if default != nil
+    input_str << Log.color(:green, extra)
+  end
+
+  def self.input_doc(inputs, input_types = nil, input_descriptions = nil, input_defaults = nil, input_shortcuts = nil)
+    type = description = default = nil
+    shortcut = ""
+    seen = []
+    inputs.collect do |name|
+      next if seen.include? name
+      seen << name
+
+      type = input_types[name] unless input_types.nil?
+      description = input_descriptions[name] unless input_descriptions.nil?
+      default = input_defaults[name] unless input_defaults.nil?
+
+      name = name.to_s
+
+      case input_shortcuts
+      when nil, FalseClass
+        shortcut = nil
+      when Hash
+        shortcut = input_shortcuts[name] 
+      when TrueClass
+        shortcut = fix_shortcut(name[0], name)
+      end
+
+      type = :string if type.nil?
+      register(shortcut, name, type, description) unless self.inputs.include? name
+
+      name  = SOPT.input_format(name, type.to_sym, default, shortcut) 
+      Misc.format_definition_list_item(name, description, 80, 31, nil)
+    end * "\n"
+  end
+
+  def self.doc
+    doc =<<-EOF
+#{Log.color :magenta}#{command}(1) -- #{summary}
+#{"=" * (command.length + summary.length + 7)}#{Log.color :reset}
+
+    EOF
+
+    if synopsys and not synopsys.empty?
+      doc << Log.color(:magenta, "## SYNOPSYS") << "\n\n"
+      doc << Log.color(:blue, synopsys) << "\n\n"
+    end
+
+    if description and not description.empty?
+      doc << Log.color(:magenta, "## DESCRIPTION") << "\n\n"
+      doc << Misc.format_paragraph(description) << "\n\n"
+    end
+
+    doc << Log.color(:magenta, "## OPTIONS") << "\n\n"
+    doc << input_doc(inputs, input_types, input_descriptions, input_defaults, input_shortcuts)
+
+    doc
+  end
+end

data/lib/scout/simple_opt/get.rb

@@ -0,0 +1,57 @@
+module SOPT
+  GOT_OPTIONS= IndiferentHash.setup({})
+  def self.current_options=(options)
+    @@current_options = options
+  end
+  def self.consume(args = ARGV)
+    i = 0
+    @@current_options ||= {}
+    while i < args.length do
+      current = args[i]
+      break if current == "--"
+      if m = current.match(/--?(.+?)(?:=(.+))?$/)
+        key = $1
+        value = $2
+
+        input = inputs.include?(key)? key : shortcuts[key]
+
+        if input.nil?
+          i += 1
+          next
+        else
+          args.delete_at i
+        end
+      else
+        i += 1
+        next
+      end
+
+      if input_types[input] == :string
+        value = args.delete_at(i) if value.nil?
+        @@current_options[input] = value
+      else
+        if value.nil? and %w(F false FALSE no).include?(args[i])
+          Log.warn "Boolean values are best specified as #{current}=[true|false], not #{ current } [true|false]. Token '#{args[i]}' following '#{current}' automatically assigned as value" 
+          value = args.delete_at(i)
+        end
+        @@current_options[input] = %w(F false FALSE no).include?(value)? false : true
+      end
+    end
+
+    IndiferentHash.setup @@current_options
+    GOT_OPTIONS.merge! @@current_options
+
+    @@current_options
+  end
+  
+  def self.get(opt_str)
+    SOPT.parse(opt_str)
+    SOPT.consume(ARGV)
+  end
+
+  def self.require(options, *parameters)
+    parameters.flatten.each do |parameter|
+      raise ParameterException, "Parameter '#{ Log.color :blue, parameter }' not given" if options[parameter].nil?
+    end
+  end
+end

data/lib/scout/simple_opt/parse.rb

@@ -0,0 +1,67 @@
+module SOPT
+  def self.fix_shortcut(short, long)
+    return short unless short and shortcuts.include?(short)
+
+    current = shortcuts.select{|s,l| l == long}.collect{|s,l| s }.first
+    return current if current
+
+    chars = long.chars.to_a
+    current = [chars.shift]
+    short = current * ""
+
+    if (shortcuts.include?(short) and not shortcuts[short] == long) 
+      if long.index "-" or long.index "_"
+        parts = long.split(/[_-]/)
+        acc = parts.collect{|s| s[0] } * ""
+        return acc unless shortcuts.include? acc
+      elsif m = long.match(/(\d+)/)
+        n = m[0]
+        acc = long[0] + n
+        return acc unless shortcuts.include? acc
+      end
+    end
+
+    while shortcuts.include?(short) && shortcuts[short] != long 
+      next_letter = chars.shift
+      next_letter = chars.shift while %w(. - _).include?(next_letter)
+      return nil if next_letter.nil?
+      current << next_letter
+      short = current * ""
+    end
+
+    return nil if shortcuts.include? short
+
+    short
+  end
+
+  def self.register(short, long, asterisk, description)
+    short = fix_shortcut(short, long)
+    shortcuts[short] = long if short
+    inputs << long
+    input_shortcuts[long] = short
+    input_descriptions[long] = description
+    input_types[long] = asterisk ? :string : :boolean
+  end
+
+  def self.parse(opt_str)
+    inputs = []
+
+    if opt_str.include? "\n"
+      re = /\n+/
+    else
+      re = /:/
+    end
+
+    opt_str.split(re).each do |entry|
+      entry.strip!
+      next if entry.empty?
+      names, _sep, description = entry.partition(/\s+/)
+      short, long, asterisk = names.match(/\s*(?:-(.+))?(?:--(.+?))([*])?$/).values_at 1,2,3 
+
+      inputs << long
+      register short, long, asterisk, description
+    end
+
+    inputs
+  end
+end

data/lib/scout/simple_opt/setup.rb

@@ -0,0 +1,26 @@
+module SOPT
+
+  def self.setup(str)
+    parts = str.split(/\n\n+/)
+
+    summary = parts.shift unless parts.first =~ /^\s*\$-/
+    synopsys = parts.shift if parts.first =~ /^\s*\$/
+
+    description = []
+    while parts.first and parts.first !~ /^\s*-/
+      description << parts.shift
+    end
+    description = description * "\n\n"
+
+    options = parts.collect{|part| part.split("\n").select{|l| l=~ /^\s*-/ }  }.flatten.compact * "\n"
+
+    synopsys.sub!(/^\$\s+/,'') if synopsys
+
+    SOPT.summary = summary.strip if summary
+    SOPT.synopsys = synopsys.strip if synopsys
+    SOPT.description = description.strip if description
+    SOPT.parse options  if options
+
+    SOPT.consume
+  end
+end

data/lib/scout/simple_opt.rb

@@ -0,0 +1,5 @@
+require_relative 'simple_opt/accessor'
+require_relative 'simple_opt/parse'
+require_relative 'simple_opt/doc'
+require_relative 'simple_opt/get'
+require_relative 'simple_opt/setup'