boson-more 0.1.0

data/lib/boson/pipe.rb

@@ -0,0 +1,156 @@
+module Boson
+  # This module passes an original command's return value through methods/commands specified as pipe options. Pipe options
+  # are processed in this order:
+  # * A :query option searches an array of objects or hashes using Pipes.query_pipe.
+  # * A :sort option sorts an array of objects or hashes using Pipes.sort_pipe.
+  # * A :reverse_sort pipe option reverses an array.
+  # * A :pipes option takes an array of commands that modify the return value using Pipes.pipes_pipe.
+  # * All user-defined pipe options (:pipe_options key in Repo.config) are processed in random order.
+  #
+  # Some points:
+  # * User-defined pipes call a command (the option's name by default). It's the user's responsibility to have this
+  #   command loaded when used. The easiest way to do this is by adding the pipe command's library to :defaults in main config.
+  # * By default, pipe commands do not modify the value their given. This means you can activate multiple pipes using
+  #   a method's original return value.
+  # * A pipe command expects a command's return value as its first argument. If the pipe option takes an argument, it's passed
+  #   on as a second argument.
+  # * When piping occurs in relation to rendering depends on the Hirb view. With the default Hirb view, piping occurs
+  #   occurs in the middle of the rendering, after Hirb has converted the return value into an array of hashes.
+  #   If using a custom Hirb view, piping occurs before rendering.
+  # * What the pipe command should expect as a return value depends on the type of command. If it's a command rendered with hirb's
+  #   tables, the return value is a an array of hashes. For everything else, it's the method's original return value.
+  #
+  # === User Pipes
+  # User pipes have the following attributes which alter their behavior:
+  # [*:pipe*] Pipe command the pipe executes when called. Default is the pipe's name.
+  # [*:env*] Boolean which enables passing an additional hash to the pipe command. This hash contains information from the first
+  #          command's input with the following keys: :args (command's arguments), :options (command's options),
+  #          :global_options (command's global options) and :config (a command's configuration hash). Default is false.
+  # [*:filter*] Boolean which has the pipe command modify the original command's output with the value it returns. Default is false.
+  # [*:no_render*] Boolean to turn off auto-rendering of the original command's final output. Only applicable to :filter enabled
+  #                pipes. Default is false.
+  # [*:solo*] Boolean to indicate this pipe can't run with other user pipes or pipes from :pipes option.
+  #           If a user calls multiple solo pipes, only the first one detected is called.
+  #
+  # == Repo Config
+  # This class adds the following key to the main repo config:
+  #
+  # [:pipe_options] Hash of options available to all option commands for piping (see Pipe). A pipe option has the
+  #                 {normal option attributes}[link:classes/Boson/OptionParser.html#M000081] and these:
+  #                 * :pipe: Specifies the command to call when piping. Defaults to the pipe's option name.
+  #                 * :filter: Boolean which indicates that the pipe command will modify its input with what it returns.
+  #                   Default is false.
+  #
+  # === User Pipes Example
+  # Let's say you want to have two commands, browser and copy, you want to make available as pipe options:
+  #    # Opens url in browser. This command already ships with Boson.
+  #    def browser(url)
+  #      system('open', url)
+  #    end
+  #
+  #    # Copy to clipboard
+  #    def copy(str)
+  #      IO.popen('pbcopy', 'w+') {|clipboard| clipboard.write(str)}
+  #    end
+  #
+  # To configure them, drop the following config in ~/.boson/config/boson.yml:
+  #   :pipe_options:
+  #     :browser:
+  #       :type: :boolean
+  #       :desc: Open in browser
+  #     :copy:
+  #       :type: :boolean
+  #       :desc: Copy to clipboard
+  #
+  # Now for any command that returns a url string, these pipe options can be turned on to execute the url.
+  #
+  # Some examples of these options using commands from {my libraries}[http://github.com/cldwalker/irbfiles]:
+  #    # Creates a gist and then opens url in browser and copies it.
+  #    $ cat some_file | boson gist -bC        # or cat some_file | boson gist --browser --copy
+  #
+  #    # Generates rdoc in current directory and then opens it in browser
+  #    irb>> rdoc '-b'    # or rdoc '--browser'
+  module Pipe
+    extend self
+
+    # Process pipes for Scientist
+    def scientist_process(object, global_opt, env={})
+      @env = env
+      [:query, :sort, :reverse_sort].each {|e| global_opt.delete(e) } unless object.is_a?(Array)
+      process_pipes(object, global_opt)
+    end
+
+    # Main method which processes all pipe commands, both default and user-defined ones.
+    def process_pipes(obj, options)
+      internal_pipes(options).each {|pipe|
+        obj = Pipes.send("#{pipe}_pipe", obj, options[pipe]) if options[pipe]
+      }
+      process_user_pipes(obj, options)
+    end
+
+    # A hash that defines user pipes in the same way as the :pipe_options key in Repo.config.
+    # This method should be called when a pipe's library is loading.
+    def add_pipes(hash)
+      pipe_options.merge! setup_pipes(hash)
+    end
+
+    #:stopdoc:
+    def internal_pipes(global_opt)
+      internals = [:query, :sort, :reverse_sort, :pipes]
+      internals.delete(:pipes) if pipes_to_process(global_opt).any? {|e| pipe(e)[:solo] }
+      internals
+    end
+
+    def pipe_options
+      @pipe_options ||= setup_pipes(Boson.repo.config[:pipe_options] || {})
+    end
+
+    def setup_pipes(hash)
+      hash.each {|k,v| v[:pipe] ||= k }
+    end
+
+    def pipe(key)
+      pipe_options[key] || {}
+    end
+
+    # global_opt can come from Hirb callback or Scientist
+    def process_user_pipes(result, global_opt)
+      pipes_to_process(global_opt).each {|e|
+        args = [pipe(e)[:pipe], result]
+        args << global_opt[e] unless pipe(e)[:type] == :boolean
+        args << get_env(e, global_opt) if pipe(e)[:env]
+        pipe_result = Boson.invoke(*args)
+        result = pipe_result if pipe(e)[:filter]
+      }
+      result
+    end
+
+    def get_env(key, global_opt)
+      { :global_options=>global_opt.merge(:delete_callbacks=>[:z_boson_pipes]),
+        :config=>(@env[:config].dup[key] || {}),
+        :args=>@env[:args],
+        :options=>@env[:options] || {}
+      }
+    end
+
+    def any_no_render_pipes?(global_opt)
+      !(pipes = pipes_to_process(global_opt)).empty? &&
+        pipes.any? {|e| pipe(e)[:no_render] }
+    end
+
+    def pipes_to_process(global_opt)
+      pipes = (global_opt.keys & pipe_options.keys)
+      (solo_pipe = pipes.find {|e| pipe(e)[:solo] }) ? [solo_pipe] : pipes
+    end
+    #:startdoc:
+
+    # Callbacks used by Hirb::Helpers::Table to search,sort and run custom pipe commands on arrays of hashes.
+    module TableCallbacks
+      # Processes boson's pipes
+      def z_boson_pipes_callback(obj, options)
+        Pipe.process_pipes(obj, options)
+      end
+    end
+  end
+end
+Hirb::Helpers::Table.send :include, Boson::Pipe::TableCallbacks

data/lib/boson/pipe_runner.rb

@@ -0,0 +1,44 @@
+module Boson
+  module PipeRunner
+    PIPE = '+'
+
+    # Splits array into array of arrays with given element
+    def self.split_array_by(arr, divider)
+      arr.inject([[]]) {|results, element|
+        (divider == element) ? (results << []) : (results.last << element)
+        results
+      }
+    end
+
+    def parse_args(args)
+      @all_args = PipeRunner.split_array_by(args, PIPE)
+      args = @all_args[0]
+      super(args).tap do |result|
+        @all_args[0] = ([result[0]] + Array(result[2])).compact
+      end
+    end
+
+    def execute_command(command, args)
+      @all_args.inject(nil) do |acc, (cmd,*args)|
+        args = translate_args(args, acc)
+        super(cmd, args)
+      end
+    end
+
+    def translate_args(args, piped)
+      args.unshift piped if piped
+      args
+    end
+
+    # Commands to executed, in order given by user
+    def commands
+      @commands ||= @all_args.map {|e| e[0]}
+    end
+  end
+
+  if defined? BinRunner
+    class BinRunner < BareRunner
+      class << self; include PipeRunner; end
+    end
+  end
+end

data/lib/boson/pipes.rb

@@ -0,0 +1,75 @@
+module Boson
+  # === Default Pipes: Search and Sort
+  # The default pipe options, :query, :sort and :reverse_sort, are quite useful for searching and sorting arrays:
+  # Some examples using default commands:
+  #   # Searches commands in the full_name field for 'lib' and sorts results by that field.
+  #   $ boson commands -q=f:lib -s=f    # or commands --query=full_name:lib --sort=full_name
+  #
+  #   # Multiple fields can be searched if separated by a ','. This searches the full_name and desc fields.
+  #   $ boson commands -q=f,d:web   # or commands --query=full_name,desc:web
+  #
+  #   # All fields can be queried using a '*'.
+  #   # Searches all library fields and then reverse sorts on name field
+  #   $ boson libraries -q=*:core -s=n -R  # or libraries --query=*:core --sort=name --reverse_sort
+  #
+  #   # Multiple searches can be joined together by ','
+  #   # Searches for libraries that have the name matching core or a library_type matching gem
+  #   $ boson libraries -q=n:core,l:gem   # or libraries --query=name:core,library_type:gem
+  #
+  # In these examples, we queried commands and examples with an explicit --query. However, -q or --query isn't necessary
+  # for these commands because they already default to it when not present. This behavior comes from the default_option
+  # attribute a command can have.
+  module Pipes
+    extend self
+
+    # Case-insensitive search an array of objects or hashes for the :query option.
+    # This option is a hash of fields mapped to their search terms. Searches are OR-ed.
+    # When searching hashes, numerical string keys in query_hash are converted to actual numbers to
+    # interface with Hirb.
+    def query_pipe(object, query_hash)
+      if object[0].is_a?(Hash)
+        query_hash.map {|field,query|
+          field = field.to_i if field.to_s[/^\d+$/]
+          object.select {|e| e[field].to_s =~ /#{query}/i }
+        }.flatten.uniq
+      else
+        query_hash.map {|field,query| object.select {|e| e.send(field).to_s =~ /#{query}/i } }.flatten.uniq
+      end
+    rescue NoMethodError
+      $stderr.puts "Query failed with nonexistant method '#{$!.message[/`(.*)'/,1]}'"
+    end
+
+    # Sorts an array of objects or hashes using a sort field. Sort is reversed with reverse_sort set to true.
+    def sort_pipe(object, sort)
+      sort_lambda = lambda {}
+      if object[0].is_a?(Hash)
+        if sort.to_s[/^\d+$/]
+          sort = sort.to_i
+        elsif object[0].keys.all? {|e| e.is_a?(Symbol) }
+          sort = sort.to_sym
+        end
+        sort_lambda = untouched_sort?(object.map {|e| e[sort] }) ? lambda {|e| e[sort] } : lambda {|e| e[sort].to_s }
+      else
+        sort_lambda = untouched_sort?(object.map {|e| e.send(sort) }) ? lambda {|e| e.send(sort) || ''} :
+          lambda {|e| e.send(sort).to_s }
+      end
+      object.sort_by &sort_lambda
+    rescue NoMethodError, ArgumentError
+      $stderr.puts "Sort failed with nonexistant method '#{sort}'"
+    end
+
+    def untouched_sort?(values) #:nodoc:
+      values.all? {|e| e.respond_to?(:<=>) } && values.map {|e| e.class }.uniq.size == 1
+    end
+
+    # Reverse an object
+    def reverse_sort_pipe(object, extra=nil)
+      object.reverse
+    end
+
+    # Pipes output of multiple commands recursively, given initial object
+    def pipes_pipe(obj, arr)
+      arr.inject(obj) {|acc,e| Boson.full_invoke(e, [acc]) }
+    end
+  end
+end

data/lib/boson/repo.rb

@@ -0,0 +1,96 @@
+%w{yaml fileutils}.each {|e| require e }
+module Boson
+  # A class for repositories. A repository has a root directory with required subdirectories config/ and
+  # commands/ and optional subdirectory lib/. Each repository has a primary config file at config/boson.yml.
+  class Repo
+    def self.commands_dir(dir) #:nodoc:
+      File.join(dir, 'commands')
+    end
+
+    attr_accessor :dir, :config
+    # Creates a repository given a root directory.
+    def initialize(dir)
+      @dir = dir
+    end
+
+    # Points to the config/ subdirectory and is automatically created when called. Used for config files.
+    def config_dir
+      @config_dir ||= FileUtils.mkdir_p(config_dir_path) && config_dir_path
+    end
+
+    def config_dir_path
+      "#{dir}/config"
+    end
+
+    # Path name of main config file. If passed true, parent directory of file is created.
+    def config_file(create_dir=false)
+      File.join((create_dir ? config_dir : config_dir_path), 'boson.yml')
+    end
+
+    # Points to the commands/ subdirectory and is automatically created when called. Used for command libraries.
+    def commands_dir
+      @commands_dir ||= (cdir = self.class.commands_dir(@dir)) && FileUtils.mkdir_p(cdir) && cdir
+    end
+
+    # A hash read from the YAML config file at config/boson.yml.
+    # {See here}[http://github.com/cldwalker/irbfiles/blob/master/boson/config/boson.yml] for an example config file.
+    # Top level config keys, library attributes and config attributes need to be symbols.
+    # ==== Config keys for all repositories:
+    # [:libraries] Hash of libraries mapping their name to attribute hashes. See Library.new for configurable attributes.
+    #               Example:
+    #               :libraries=>{'completion'=>{:namespace=>true}}
+    # [:command_aliases] Hash of commands names and their aliases. Since this is global it will be read by _all_ libraries.
+    #                    This is useful for quickly creating aliases without having to worry about placing them under
+    #                    the correct library config. For non-global aliasing, aliases should be placed under the :command_aliases
+    #                    key of a library entry in :libraries.
+    #                     Example:
+    #                      :command_aliases=>{'libraries'=>'lib', 'commands'=>'com'}
+    # [:defaults] Array of libraries to load at start up for commandline and irb. This is useful for extending boson i.e. adding your
+    #             own option types since these are loaded before any other libraries. Default is no libraries.
+    # [:bin_defaults] Array of libraries to load at start up when used from the commandline. Default is no libraries.
+    # [:add_load_path] Boolean specifying whether to add a load path pointing to the lib subdirectory/. This is useful in sharing
+    #                  classes between libraries without resorting to packaging them as gems. Defaults to false if the lib
+    #                  subdirectory doesn't exist in the boson directory.
+    #
+    # ==== Config keys specific to the main repo config ~/.boson/config/boson.yml
+    # [:error_method_conflicts] Boolean specifying library loading behavior when its methods conflicts with existing methods in
+    #                           the global namespace. When set to false, Boson automatically puts the library in its own namespace.
+    #                           When set to true, the library fails to load explicitly. Default is false.
+    # [:auto_namespace] Boolean which automatically namespaces all user-defined libraries. Be aware this can break libraries which
+    #                   depend on commands from other libraries. Default is false.
+    # [:ignore_directories] Array of directories to ignore when detecting local repositories for Boson.local_repo.
+    # [:option_underscore_search] When set, OptionParser option values (with :values or :keys) are auto aliased with underscore searching.
+    #                             Default is true. See Util.underscore_search.
+    def config(reload=false)
+      if reload || @config.nil?
+        begin
+          @config = Boson::CONFIG.dup
+          @config.merge!(YAML::load_file(config_file(true))) if File.exists?(config_file)
+        rescue ArgumentError
+          message = $!.message !~ /syntax error on line (\d+)/ ? "Error"+$!.message :
+            "Error: Syntax error in line #{$1} of config file '#{config_file}'"
+          Kernel.abort message
+        end
+      end
+      @config
+    end
+
+    # Updates main config file by passing config into a block to be modified and then saved
+    def update_config
+      yield(config)
+      write_config_file
+    end
+
+    def write_config_file #:nodoc:
+      File.open(config_file, 'w') {|f| f.write config.to_yaml }
+    end
+
+    def detected_libraries #:nodoc:
+      Dir[File.join(commands_dir, '**/*.rb')].map {|e| e.gsub(/^#{commands_dir}\/|\.rb$/, '') }
+    end
+
+    def all_libraries #:nodoc:
+      (detected_libraries + config[:libraries].keys).uniq
+    end
+  end
+end

data/lib/boson/repo_index.rb

@@ -0,0 +1,135 @@
+require 'digest/md5'
+module Boson
+  # This class provides an index for commands and libraries of a given a Repo.
+  # When this index updates, it detects library files whose md5 hash have changed and reindexes them.
+  # The index is stored with Marshal at config/index.marshal (relative to a Repo's root directory).
+  # Since the index is marshaled, putting lambdas/procs in it will break it.If an index gets corrupted,
+  # simply delete it and next time Boson needs it, the index will be recreated.
+
+  class RepoIndex
+    attr_reader :libraries, :commands, :repo
+    def initialize(repo)
+      @repo = repo
+    end
+
+    # Updates the index.
+    def update(options={})
+      libraries_to_update = !exists? ? repo.all_libraries : options[:libraries] || changed_libraries
+      read_and_transfer(libraries_to_update)
+      if options[:verbose]
+        puts !exists? ? "Generating index for all #{libraries_to_update.size} libraries. Patience ... is a bitch" :
+          (libraries_to_update.empty? ? "No libraries indexed" :
+          "Indexing the following libraries: #{libraries_to_update.join(', ')}")
+      end
+      Manager.instance.failed_libraries = []
+      unless libraries_to_update.empty?
+        Manager.load(libraries_to_update, options.merge(:index=>true))
+        unless Manager.instance.failed_libraries.empty?
+          $stderr.puts("Error: These libraries failed to load while indexing: #{Manager.instance.failed_libraries.join(', ')}")
+        end
+      end
+      write(Manager.instance.failed_libraries)
+    end
+
+    # Reads and initializes index.
+    def read
+      return if @read
+      @libraries, @commands, @lib_hashes = exists? ?
+        File.open(marshal_file, 'rb') do |f|
+          f.flock(File::LOCK_EX)
+          Marshal.load(f)
+        end : [[], [], {}]
+      delete_stale_libraries_and_commands
+      set_command_namespaces
+      @read = true
+    end
+
+    # Writes/saves current index to config/index.marshal.
+    def write(failed_libraries=[])
+      latest = latest_hashes
+      failed_libraries.each {|e| latest.delete(e) }
+      save_marshal_index Marshal.dump([Boson.libraries, Boson.commands, latest])
+    end
+
+    #:stopdoc:
+    def read_and_transfer(ignored_libraries=[])
+      read
+      existing_libraries = (Boson.libraries.map {|e| e.name} + ignored_libraries).uniq
+      libraries_to_add = @libraries.select {|e| !existing_libraries.include?(e.name)}
+      Boson.libraries += libraries_to_add
+      # depends on saved commands being correctly associated with saved libraries
+      Boson.commands += libraries_to_add.map {|e| e.command_objects(e.commands, @commands) }.flatten
+    end
+
+    def exists?
+      File.exists? marshal_file
+    end
+
+    def save_marshal_index(marshal_string)
+      binmode = defined?(File::BINARY) ? File::BINARY : 0
+      rdwr_access = File::RDWR | File::CREAT | binmode
+      # To protect the file truncing with a lock we cannot use the 'wb' options.
+      # The w option truncates the file before calling the File.open block
+      File.open(marshal_file, rdwr_access) do |f|
+        f.flock(File::LOCK_EX)
+        f.truncate 0
+        f.write(marshal_string)
+      end
+    end
+
+    def delete_stale_libraries_and_commands
+      cached_libraries = @lib_hashes.keys
+      libs_to_delete = @libraries.select {|e| !cached_libraries.include?(e.name) && e.is_a?(FileLibrary) }
+      names_to_delete = libs_to_delete.map {|e| e.name }
+      libs_to_delete.each {|e| @libraries.delete(e) }
+      @commands.delete_if {|e| names_to_delete.include? e.lib }
+    end
+
+    # set namespaces for commands
+    def set_command_namespaces
+      lib_commands = @commands.inject({}) {|t,e| (t[e.lib] ||= []) << e; t }
+      namespace_libs = @libraries.select {|e| e.namespace(e.indexed_namespace) }
+      namespace_libs.each {|lib|
+        (lib_commands[lib.name] || []).each {|e| e.namespace = lib.namespace }
+      }
+    end
+
+    def namespaces
+      nsps = @libraries.map {|e| e.namespace }.compact
+      nsps.delete(false)
+      nsps
+    end
+
+    def all_main_methods
+      @commands.reject {|e| e.namespace }.map {|e| [e.name, e.alias]}.flatten.compact + namespaces
+    end
+
+    def marshal_file
+      File.join(repo.config_dir, 'index.marshal')
+    end
+
+    def find_library(command, object=false)
+      read
+      namespace_command = command.split(NAMESPACE)[0]
+      if (lib = @libraries.find {|e| e.namespace == namespace_command })
+        object ? lib : lib.name
+      elsif (cmd = Command.find(command, @commands))
+        object ? @libraries.find {|e| e.name == cmd.lib} : cmd.lib
+      end
+    end
+
+    def changed_libraries
+      read
+      latest_hashes.select {|lib, hash| @lib_hashes[lib] != hash}.map {|e| e[0]}
+    end
+
+    def latest_hashes
+      repo.all_libraries.inject({}) {|h, e|
+        lib_file = FileLibrary.library_file(e, repo.dir)
+        h[e] = Digest::MD5.hexdigest(File.read(lib_file)) if File.exists?(lib_file)
+        h
+      }
+    end
+    #:startdoc:
+  end
+end

data/lib/boson/runner_options.rb

@@ -0,0 +1,88 @@
+require 'boson/save'
+
+module Boson
+  module RunnerOptions
+    # [:help]  Gives a basic help of global options. When a command is given the help shifts to a command's help.
+    # [:verbose] Using this along with :help option shows more help. Also gives verbosity to other actions i.e. loading.
+    # [:backtrace] Prints full backtrace on error. Default is false.
+    # [:index] Updates index for given libraries allowing you to use them. This is useful if Boson's autodetection of
+    #          changed libraries isn't picking up your changes. Since this option has a :bool_default attribute, arguments
+    #          passed to this option need to be passed with '=' i.e. '--index=my_lib'.
+    # [:load] Explicitly loads a list of libraries separated by commas. Most useful when used with :console option.
+    #         Can also be used to explicitly load libraries that aren't being detected automatically.
+    # [:pager_toggle] Toggles Hirb's pager in case you'd like to pipe to another command.
+    def init
+      super
+      Boson.verbose = true if options[:verbose]
+
+      if @options.key?(:index)
+        Index.update(:verbose=>true, :libraries=>@options[:index])
+        @index_updated = true
+      elsif !@options[:help] && @command && Boson.can_invoke?(@command)
+        Index.update(:verbose=>@options[:verbose])
+        @index_updated = true
+      end
+
+      Manager.load @options[:load], load_options if @options[:load]
+      View.toggle_pager if @options[:pager_toggle]
+    end
+
+    def default_libraries
+      libs = super
+      @options[:unload] ?  libs.select {|e| e !~ /#{@options[:unload]}/} : libs
+    end
+
+    def update_index
+      unless @index_updated
+        super
+        @index_updated = true
+      end
+    end
+
+    def verbose
+      @options[:verbose]
+    end
+
+    def abort_with(message)
+      if verbose || options[:backtrace]
+        message += "\nOriginal error: #{$!}\n  #{$!.backtrace.join("\n  ")}"
+      end
+      super(message)
+    end
+
+    def print_usage
+      super
+      if @options[:verbose]
+        Manager.load [Boson::Commands::Core]
+        puts "\n\nDEFAULT COMMANDS"
+        Boson.invoke :commands, :fields=>["name", "usage", "description"], :description=>false
+      end
+    end
+
+    def execute_option_or_command(options, command, args)
+      if options[:help]
+        autoload_command command
+        Boson.invoke(:usage, command, verbose: verbose)
+      else
+        super
+      end
+    end
+  end
+
+  if defined? BinRunner
+    class BinRunner < BareRunner
+      GLOBAL_OPTIONS.update({
+        :backtrace=>{:type=>:boolean, :desc=>'Prints full backtrace'},
+        :verbose=>{:type=>:boolean, :desc=>"Verbose description of loading libraries, errors or help"},
+        :index=>{
+          :type=>:array, :desc=>"Libraries to index. Libraries must be passed with '='.",
+          :bool_default=>nil, :values=>all_libraries, :regexp=>true, :enum=>false},
+        :pager_toggle=>{:type=>:boolean, :desc=>"Toggles Hirb's pager"},
+        :unload=>{:type=>:string, :desc=>"Acts as a regular expression to unload default libraries"},
+        :load=>{:type=>:array, :values=>all_libraries, :regexp=>true, :enum=>false,
+          :desc=>"A comma delimited array of libraries to load"}
+      })
+      extend RunnerOptions
+    end
+  end
+end