rubycom 0.3.2 → 0.4.0

data/lib/rubycom/commands.rb

@@ -1,63 +0,0 @@
-module Rubycom
-  module Commands
-
-    # Retrieves the singleton methods in the given base and included Modules
-    #
-    # @param [Module] base the module which invoked 'include Rubycom'
-    # @param [Boolean] all if true recursively search for included modules' commands, if false return only top level commands
-    # @return [Hash] a Hash of Symbols representing the command methods in the given base and it's included modules (if all=true)
-    def self.get_commands(base, all=true)
-      return {} if base.nil? || !base.respond_to?(:singleton_methods) || !base.respond_to?(:included_modules)
-      {
-          base.name.to_sym => {
-              commands: base.singleton_methods(true).select { |sym| ![:included, :extended].include?(sym) },
-              inclusions: base.included_modules.select { |mod|
-                ![:Rubycom].include?(mod.name.to_sym)
-              }.map { |mod|
-                all ? self.get_commands(mod) : mod.name.to_sym
-              }
-          }
-      }
-    end
-
-    # Discovers the commands specified in the given base without considering the commands contained in sub-modules
-    #
-    # @param [Module] base the base Module to search
-    # @return [Array] a list of command name symbols which are defined in the given Module
-    def self.get_top_level_commands(base)
-      return {} if base.nil? || !base.respond_to?(:singleton_methods) || !base.respond_to?(:included_modules)
-      excluded_commands = [:included, :extended]
-      excluded_modules = [:Rubycom]
-      base.singleton_methods(true).select { |sym| !excluded_commands.include?(sym) } +
-          base.included_modules.select { |mod| !excluded_modules.include?(mod.name.to_sym) }.map { |mod| mod.name.to_sym }.flatten
-    end
-
-    # Discovers the commands specified in the given base and included Modules
-    #
-    # @param [Module] base the base Module to search
-    # @return [Hash] a set of command name symbols mapped to containing Modules
-    def self.index_commands(base)
-      excluded_commands = [:included, :extended]
-      excluded_modules = [:Rubycom]
-      Hash[base.singleton_methods(true).select { |sym| !excluded_commands.include?(sym) }.map { |sym|
-        [sym, base]
-      }].merge(
-          base.included_modules.select { |mod| !excluded_modules.include?(mod.name.to_sym) }.map { |mod|
-            self.index_commands(mod)
-          }.reduce(&:merge) || {}
-      )
-    end
-
-    # Looks up the commands which will be available on the given base Module and returns the longest command name
-    # Used in arranging the command list format
-    #
-    # @param [Module] base the base Module to look up
-    # @return [String] the longest command name which will show in a list of commands for the given base Module
-    def self.get_longest_command_name(base)
-      return '' if base.nil?
-      self.get_commands(base, false).map { |_, mod_hash|
-        mod_hash[:commands] + mod_hash[:inclusions].flatten }.flatten.max_by(&:size) or ''
-    end
-
-  end
-end

data/lib/rubycom/documentation.rb

@@ -1,212 +0,0 @@
-require "#{File.dirname(__FILE__)}/commands.rb"
-
-module Rubycom
-  module Documentation
-
-    # Retrieves the summary for each command method in the given Module
-    #
-    # @param [Module] base the module which invoked 'include Rubycom'
-    # @return [String] the summary for each command method in the given Module
-    def self.get_summary(base)
-      Commands.get_top_level_commands(base).each_with_index.map { |sym, index|
-        "#{"Commands:\n" if index == 0}" << self.get_command_summary(base, sym, self.get_separator(sym, Commands.get_longest_command_name(base).length))
-      }.reduce(:+) or "No Commands found for #{base}."
-    end
-
-    # Creates a separator with the appropriate spacing to line up a command/description pair in a command list
-    #
-    # @param [Symbol] sym
-    # @param [Integer] spacer_length
-    # @return [String] a spaced separator String for use in a command/description list
-    def self.get_separator(sym, spacer_length=0)
-      [].unshift(" " * (spacer_length - sym.to_s.length)).join << "  -  "
-    end
-
-    # Retrieves the summary for the given command_name
-    #
-    # @param [Module] base the module which invoked 'include Rubycom'
-    # @param [String] command_name the command to retrieve usage for
-    # @return [String] a summary of the given command_name
-    def self.get_command_summary(base, command_name, separator = '  -  ')
-      raise CLIError, "Can not get usage for #{command_name} with base: #{base||"nil"}" if base.nil? || !base.respond_to?(:included_modules)
-      return 'No command specified.' if command_name.nil? || command_name.length == 0
-      if base.included_modules.map { |mod| mod.name.to_sym }.include?(command_name.to_sym)
-        desc = self.get_module_doc(command_name)
-      else
-        raise CLIError, "Invalid command for #{base}, #{command_name}" unless base.public_methods.include?(command_name.to_sym)
-        desc = self.get_doc(base.public_method(command_name.to_sym))[:desc].join("\n") rescue ""
-      end
-      (desc.nil?||desc=='nil'||desc.length==0) ? "#{command_name}\n" : self.get_formatted_summary(command_name, desc, separator)
-    end
-
-    # Arranges the given command_name and command_description with the separator in a standard format
-    #
-    # @param [String] command_name the command format
-    # @param [String] command_description the description for the given command
-    # @param [String] separator optional separator to use
-    def self.get_formatted_summary(command_name, command_description, separator = '  -  ')
-      width = 95
-      prefix = command_name.to_s.split(//).map { " " }.join + separator.split(//).map { " " }.join
-      line_width = width - prefix.length
-      description_msg = command_description.gsub(/(.{1,#{line_width}})(?: +|$)\n?|(.{#{line_width}})/, "#{prefix}"+'\1\2'+"\n")
-      "#{command_name}#{separator}#{description_msg.lstrip}"
-    end
-
-    # Retrieves the usage description for the given Module with a list of command methods
-    #
-    # @param [Module] base the module which invoked 'include Rubycom'
-    # @return [String] the usage description for the module with a list of command methods
-    def self.get_usage(base)
-      return '' if base.nil? || !base.respond_to?(:included_modules)
-      return '' if Commands.get_top_level_commands(base).size == 0
-      "Usage:\n    #{base} <command> [args]\n\n" << self.get_summary(base)
-    end
-
-    # Retrieves the usage description for the given command_name
-    #
-    # @param [Module] base the module which invoked 'include Rubycom'
-    # @param [String] command_name the command to retrieve usage for
-    # @param [Array] args the remaining args other than the command_name, used of sub-command look-ups
-    # @return [String] the detailed usage description for the given command_name
-    def self.get_command_usage(base, command_name, args=[])
-      raise CLIError, "Can not get usage for #{command_name} with base: #{base||"nil"}" if base.nil? || !base.respond_to?(:included_modules)
-      return 'No command specified.' if command_name.nil? || command_name.length == 0
-      if base.included_modules.map { |mod| mod.name.to_sym }.include?(command_name.to_sym)
-        if args.empty?
-          self.get_usage(eval(command_name.to_s))
-        else
-          self.get_command_usage(eval(command_name.to_s), args[0], args[1..-1])
-        end
-      else
-        raise CLIError, "Invalid command for #{base}, #{command_name}" unless base.public_methods.include?(command_name.to_sym)
-        m = base.public_method(command_name.to_sym)
-        method_doc = self.get_doc(m) || {}
-
-        msg = "Usage: #{m.name}#{self.get_param_usage(m)}\n"
-        msg << "Parameters:\n    " unless m.parameters.empty?
-        msg << "#{method_doc[:param].join("\n    ")}\n" unless method_doc[:param].nil?
-        msg << "Returns:\n    " unless method_doc[:return].nil?
-        msg << "#{method_doc[:return].join("\n    ")}\n" unless method_doc[:return].nil?
-        msg
-      end
-    end
-
-    # Discovers the given Method's parameters and uses them to build a formatted usage string
-    #
-    # @param [Method] method the Method object to generate usage for
-    def self.get_param_usage(method)
-      return "" if method.parameters.nil? || method.parameters.empty?
-      Arguments.get_param_definitions(method).group_by { |_, hsh|
-        hsh[:type]
-      }.map { |key, val_arr|
-        vals = Hash[*val_arr.flatten]
-        {
-            key => if key == :opt
-                     vals.map { |param, val_hsh| "-#{param.to_s}=#{val_hsh[:default]}" }
-                   elsif key == :req
-                     vals.keys.map { |param| " <#{param.to_s}>" }
-                   else
-                     vals.keys.map { |param| " [&#{param.to_s}]" }
-                   end
-        }
-      }.reduce(&:merge).map { |type, param_arr|
-        if type == :opt
-          " [#{param_arr.join("|")}]"
-        else
-          param_arr.join
-        end
-      }.join
-    end
-
-    # Retrieves the given module's documentation from it's source code
-    #
-    # @param [String] base_name
-    # @return [String] the documentation text from the top of the specified module
-    def self.get_module_doc(base_name)
-      begin
-        mod_const = Kernel.const_get(base_name.to_sym)
-        File.read(mod_const.public_method(mod_const.singleton_methods().first).source_location.first).split(//).reduce("") { |str, c|
-          unless str.gsub("\n", '').gsub(/\s+/, '').include?("module#{mod_const}")
-            str << c
-          end
-          str
-        }.split("\n").select { |line| line.strip.match(/^#/) && !line.strip.match(/^#!/) }.map { |line| line.strip.gsub(/^#+/, '') }.join("\n")
-      rescue
-        ""
-      end
-    end
-
-    # Retrieves the given method's documentation from it's source code
-    #
-    # @param [Method] method the Method who's documentation should be retrieved
-    # @return [Hash] a Hash representing the given Method's documentation, documentation parsed as follows:
-    #                :desc = the first general method comment lines,
-    #                :word = each @word comment (i.e.- a line starting with @param will be saved as :param => ["line"])
-    def self.get_doc(method)
-      method.comment.split("\n").map { |line|
-        line.gsub(/#\s*/, '') }.group_by { |doc|
-        if doc.match(/^@\w+/).nil?
-          :desc
-        else
-          doc.match(/^@\w+/).to_s.gsub('@', '').to_sym
-        end
-      }.map { |key, val|
-        Hash[key, val.map { |val_line| val_line.gsub(/^@\w+/, '').lstrip }.select { |line| line != '' }]
-      }.reduce(&:merge)
-    end
-
-    # @return [String] the usage message for Rubycom's default commands
-    def self.get_default_commands_usage()
-      <<-END.gsub(/^ {6}/,'')
-
-      Default Commands:
-      help                 - prints this help page
-      job                  - run a job file
-      register_completions - setup bash tab completion
-      tab_complete         - print a list of possible matches for a given word
-      END
-    end
-
-    # @return [String] the usage message for Rubycom's job runner
-    def self.get_job_usage(base)
-      <<-END.gsub(/^ {6}/,'')
-      Usage: #{base} job <job_path>
-      Parameters:
-        [String] job_path the path to the job yaml to be run
-      Details:
-      A job yaml is any yaml file which follows the format below.
-        * The env: key shown below is optional
-        * The steps: key must contain a set of numbered steps as shown
-        * The desc: key shown below is an optional context for the job's log output
-          * Other than cmd: there may be as many keys in a numbered command as you choose
-      ---
-      env:
-        test_msg: Hello World
-        test_arg: 123
-        working_dir: ./test
-      steps:
-        1:
-          desc: Run test command with environment variable
-          test_context: Some more log context
-          cmd: ruby env[working_dir]/test.rb test_command env[test_msg]
-        2:
-          cmd: ls env[working_dir]
-      END
-    end
-
-    def self.get_register_completions_usage(base)
-      <<-END.gsub(/^ {6}/,'')
-      Usage: #{base} register_completions
-      END
-    end
-
-    def self.get_tab_complete_usage(base)
-      <<-END.gsub(/^ {6}/,'')
-      Usage: #{base} tab_complete <word>
-      Parameters:
-        [String] word the word or partial word to find matches for
-      END
-    end
-
-  end
-end

data/test/rubycom/arguments_test.rb

@@ -1,289 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../lib/rubycom/arguments.rb"
-
-require "#{File.dirname(__FILE__)}/util_test_module.rb"
-require "#{File.dirname(__FILE__)}/util_test_composite.rb"
-require "#{File.dirname(__FILE__)}/util_test_no_singleton.rb"
-
-require 'test/unit'
-
-class ArgumentsTest < Test::Unit::TestCase
-
-  def test_parse_arg_string
-    test_arg = "test_arg"
-    result = Rubycom::Arguments.parse_arg(test_arg)
-    expected = {rubycom_non_opt_arg: "test_arg"}
-    assert_equal(expected, result)
-  end
-
-  def test_parse_arg_fixnum
-    test_arg = "1234512415435"
-    result = Rubycom::Arguments.parse_arg(test_arg)
-    expected = {rubycom_non_opt_arg: 1234512415435}
-    assert_equal(expected, result)
-  end
-
-  def test_parse_arg_float
-    test_arg = "12345.67890"
-    result = Rubycom::Arguments.parse_arg(test_arg)
-    expected = {rubycom_non_opt_arg: 12345.67890}
-    assert_equal(expected, result)
-  end
-
-  def test_parse_arg_timestamp
-    time = Time.new
-    test_arg = time.to_s
-    result = Rubycom::Arguments.parse_arg(test_arg)
-    expected = {rubycom_non_opt_arg: time}
-    assert_equal(expected[:rubycom_non_opt_arg].to_i, result[:rubycom_non_opt_arg].to_i)
-  end
-
-  def test_parse_arg_datetime
-    time = Time.new("2013-05-08 00:00:00 -0500")
-    date = Date.new(time.year, time.month, time.day)
-    test_arg = date.to_s
-    result = Rubycom::Arguments.parse_arg(test_arg)
-    expected = {rubycom_non_opt_arg: date}
-    assert_equal(expected, result)
-  end
-
-  def test_parse_arg_array
-    test_arg = ["1", 2, "a", 'b']
-    result = Rubycom::Arguments.parse_arg(test_arg.to_s)
-    expected = {rubycom_non_opt_arg: test_arg}
-    assert_equal(expected, result)
-  end
-
-  def test_parse_arg_hash
-    time = Time.new.to_s
-    test_arg = ":a: \"#{time}\""
-    result = Rubycom::Arguments.parse_arg(test_arg.to_s)
-    expected = {rubycom_non_opt_arg: {a: time}}
-    assert_equal(expected, result)
-  end
-
-  def test_parse_arg_hash_group
-    test_arg = ":a: [1,2]\n:b: 1\n:c: test\n:d: 1.0\n:e: \"2013-05-08 23:21:52 -0500\"\n"
-    result = Rubycom::Arguments.parse_arg(test_arg.to_s)
-    expected = {rubycom_non_opt_arg: {:a => [1, 2], :b => 1, :c => "test", :d => 1.0, :e => "2013-05-08 23:21:52 -0500"}}
-    assert_equal(expected, result)
-  end
-
-  def test_parse_arg_yaml
-    test_arg = {:a => ["1", 2, "a", 'b'], :b => 1, :c => "test", :d => "#{Time.now.to_s}"}
-    result = Rubycom::Arguments.parse_arg(test_arg.to_yaml)
-    expected = {rubycom_non_opt_arg: test_arg}
-    assert_equal(expected, result)
-  end
-
-  def test_parse_arg_code
-    test_arg = 'def self.test_code_method; raise "Fail - test_parse_arg_code";end'
-    result = Rubycom::Arguments.parse_arg(test_arg.to_s)
-    expected = {rubycom_non_opt_arg: 'def self.test_code_method; raise "Fail - test_parse_arg_code";end'}
-    assert_equal(expected, result)
-  end
-
-  def test_parse_opt_string_eq
-    test_arg = "-test_arg=\"test\""
-    result = Rubycom::Arguments.parse_arg(test_arg)
-    expected = {test_arg: "test"}
-    assert_equal(expected, result)
-  end
-
-  def test_parse_opt_string_sp
-    test_arg = "-test_arg \"test\""
-    result = Rubycom::Arguments.parse_arg(test_arg)
-    expected = {test_arg: "test"}
-    assert_equal(expected, result)
-  end
-
-  def test_parse_opt_long_string_eq
-    test_arg = "--test_arg=\"test\""
-    result = Rubycom::Arguments.parse_arg(test_arg)
-    expected = {test_arg: "test"}
-    assert_equal(expected, result)
-  end
-
-  def test_parse_opt_long_string_sp
-    test_arg = "--test_arg \"test\""
-    result = Rubycom::Arguments.parse_arg(test_arg)
-    expected = {test_arg: "test"}
-    assert_equal(expected, result)
-  end
-
-  def test_get_param_definitions
-    test_method = UtilTestModule.public_method('test_command_with_args')
-    expected = {:test_arg => {:def => "test_arg", :type => :req, :default => :nil_rubycom_required_param}, :another_test_arg => {:def => "another_test_arg", :type => :req, :default => :nil_rubycom_required_param}}
-    result = Rubycom::Arguments.get_param_definitions(test_method)
-    assert_equal(expected, result)
-  end
-
-  def test_get_param_definitions_no_args
-    test_method = UtilTestModule.public_method('test_command')
-    expected = {}
-    result = Rubycom::Arguments.get_param_definitions(test_method)
-    assert_equal(expected, result)
-  end
-
-  def test_get_param_definitions_arr_param
-    test_method = UtilTestModule.public_method('test_command_options_arr')
-    expected = {:test_option => {:def => "test_option=\"test_option_default\"", :type => :opt, :default => "test_option_default"}, :test_options => {:def => "*test_options", :type => :rest, :default => :nil_rubycom_required_param}}
-    result = Rubycom::Arguments.get_param_definitions(test_method)
-    assert_equal(expected, result)
-  end
-
-  def test_get_param_definitions_all_options
-    test_method = UtilTestModule.public_method('test_command_all_options')
-    expected = {:test_arg => {:def => "test_arg='test_arg_default'", :type => :opt, :default => "test_arg_default"}, :test_option => {:def => "test_option='test_option_default'", :type => :opt, :default => "test_option_default"}}
-    result = Rubycom::Arguments.get_param_definitions(test_method)
-    assert_equal(expected, result)
-  end
-
-  def test_get_param_definitions_mixed
-    test_method = UtilTestModule.public_method('test_command_with_options')
-    expected = {:test_arg => {:def => "test_arg", :type => :req, :default => :nil_rubycom_required_param}, :test_option => {:def => "test_option='option_default'", :type => :opt, :default => "option_default"}}
-    result = Rubycom::Arguments.get_param_definitions(test_method)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_no_params
-    test_method = UtilTestModule.public_method(:test_command)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = []
-    expected = nil
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_one_param
-    test_method = UtilTestModule.public_method(:test_command_with_arg)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = ["abc"]
-    expected = {:test_arg=>"abc"}
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_one_param_array
-    test_method = UtilTestModule.public_method(:test_command_with_arg)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = ["[a,b,c,1,2,3]"]
-    expected = {:test_arg=>['a','b','c',1,2,3]}
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_one_param_hash
-    test_method = UtilTestModule.public_method(:test_command_with_arg)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = ["{abc: 123}"]
-    expected = {:test_arg=>{"abc"=>123}}
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_too_many_args
-    test_method = UtilTestModule.public_method(:test_command)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = ["123"]
-    expected = nil
-    result = nil
-    assert_raise Rubycom::CLIError do
-      result = Rubycom::Arguments.resolve(params, arguments)
-    end
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_too_few_args
-    test_method = UtilTestModule.public_method(:test_command_with_arg)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = []
-    expected = nil
-    result = nil
-    assert_raise Rubycom::CLIError do
-      result = Rubycom::Arguments.resolve(params, arguments)
-    end
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_with_options
-    test_method = UtilTestModule.public_method(:test_command_with_options)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = [";asd"]
-    expected = {:test_arg=>";asd", :test_option=>"option_default"}
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_with_options_filled
-    test_method = UtilTestModule.public_method(:test_command_with_options)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = ["[1,2,3]","--test_option=abc"]
-    expected = {:test_arg=>[1, 2, 3], :test_option=>"abc"}
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_all_options
-    test_method = UtilTestModule.public_method(:test_command_all_options)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = []
-    expected = {:test_arg=>"test_arg_default", :test_option=>"test_option_default"}
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_all_opts_args_entered
-    test_method = UtilTestModule.public_method(:test_command_all_options)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = ["[1,2,3]","abc"]
-    expected = {:test_arg=>[1, 2, 3], :test_option=>"abc"}
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_all_opts_filled
-    test_method = UtilTestModule.public_method(:test_command_all_options)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = ["-test_arg='123asd'","--test_option=[b,c,d]"]
-    expected = {:test_arg=>"123asd", :test_option=>["b","c","d"]}
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_arr_option
-    test_method = UtilTestModule.public_method(:test_command_arg_arr)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = ["--test_arr=['123','abc']"]
-    expected = {:test_arr=>["123","abc"]}
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_options_arr
-    test_method = UtilTestModule.public_method(:test_command_options_arr)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = [",a2","1","2","3","a","b","c"]
-    expected = {:test_option=>",a2", :test_options=>[1, 2, 3, "a", "b", "c"]}
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_options_arr_with_arr
-    test_method = UtilTestModule.public_method(:test_command_options_arr)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = [",a2","[1,2,3,a,b,c]"]
-    expected = {:test_option=>",a2", :test_options=>[[1, 2, 3, "a", "b", "c"]]}
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-  def test_parse_args_hash
-    test_method = UtilTestModule.public_method(:test_command_arg_hash)
-    params = Rubycom::Arguments.get_param_definitions(test_method)
-    arguments = ["{testing: 'arg1', 123: 'abc', abc: 123}"]
-    expected = {:test_hash=>{"testing"=>"arg1", 123=>"abc", "abc"=>123}}
-    result = Rubycom::Arguments.resolve(params, arguments)
-    assert_equal(expected, result)
-  end
-
-end