cmdopt 0.2.0

data/test/cmdopt_test.rb

@@ -0,0 +1,377 @@
+###
+### $Release: 0.2.0 $
+### $Copyright: copyright(c) 2011 kuwata-lab.com all rights reserved $
+### $License: MIT License $
+###
+
+require 'test/unit'
+require 'section9/unittest'
+
+require 'cmdopt'
+
+
+##
+## option definitions
+##
+$cmdopt_parser = Cmdopt::Parser.new()
+# short and long options
+$cmdopt_parser.option("-h, --help", "show help")
+# short option only, but specify attribute name
+$cmdopt_parser.option("-v #version", "print version")
+# validation example
+$cmdopt_parser.option("-m, --mode=MODE", "set mode ('verbose' or 'quiet')")\
+       .validation {|val| val !~ /^(verbose|quiet)$/ and "'verbose' or 'quiet' expected." }
+# action example
+$cmdopt_parser.option("    --quiet", "quiet mode")\
+       .action {|val, opts| opts.mode = "quiet" }
+# optional argument
+$cmdopt_parser.option("-i, --indent[=N]", "indent (default 2)")\
+       .validation {|val| !(val == true || val =~ /^\d+$/) and "integer expected." }
+# multiple option
+$cmdopt_parser.option("-I PATH  #paths", "include path (multiple OK)")\
+       .action {|val, opts| (opts.paths ||= []) << val }
+# private option (not displayed in help message)
+$cmdopt_parser.option("-D", nil)
+
+
+class Cmdopt_Schema_TC < TC
+
+  def schema_
+    @schema_ ||= Cmdopt::Schema.new
+  end
+
+  def item_
+    @item_ ||= schema_.add("-m, --mode=MODE", "set mode")
+  end
+
+  describe "#add()" do
+    it "returns item object." do
+      verify_(item_).is_a?(Cmdopt::SchemaItem)
+    end
+    it "parses command-option definition." do
+      item = item_
+      verify_(item.short)     == "m"
+      verify_(item.long)      == "mode"
+      verify_(item.arg)       == "MODE"
+      verify_(item.required)  == true
+      verify_(item.attr)      == "mode"
+      verify_(item.desc)      == "set mode"
+      verify_(item.validator) == nil
+    end
+    it "sets default handler function." do
+      verify_(item_.handler).is_a?(Proc)
+      opts = Cmdopt::Options.new(:mode=>nil)
+      item_.handler.call("verbose", opts)
+      verify_(opts.mode) == "verbose"
+    end
+    it "register item object." do
+      item_    # don't remove this!
+      verify_(schema_.get('-m')).same?(item_)
+      verify_(schema_.get('--mode')).same?(item_)
+    end
+    it "throws error when option definition is invalid." do
+      pr = proc { schema_.add("-m MODE, --mode", "set mode") }
+      verify_(pr).raise?(ArgumentError, "'-m MODE, --mode': invalid option definition.")
+    end
+    it "recognizes '#name' as attribute name." do
+      item = schema_.add('-q #quiet', nil)
+      verify_(item.attr)  == 'quiet'
+      verify_(item.short) == 'q'
+      verify_(item.long)  == nil
+      #
+      item = schema_.add('-q value #quiet', nil)
+      verify_(item.attr)  == 'quiet'
+      verify_(item.short) == 'q'
+      verify_(item.long)  == nil
+      #
+      item = schema_.add('--silent #quiet', nil)
+      verify_(item.attr)  == 'quiet'
+      verify_(item.short) == nil
+      verify_(item.long)  == 'silent'
+    end
+  end
+
+  def parser_
+    @parser_ ||= $cmdopt_parser
+  end
+
+  describe "#help()" do
+    it "returns help message of command-line options." do
+      expected = [
+        "  -h, --help          : show help\n",
+        "  -v                  : print version\n",
+        "  -m, --mode=MODE     : set mode ('verbose' or 'quiet')\n",
+        "      --quiet         : quiet mode\n",
+        "  -i, --indent[=N]    : indent (default 2)\n",
+        "  -I PATH             : include path (multiple OK)\n",
+        #"  -D                  : enable debug mode\n",
+      ].join
+      verify_(parser_.schema.help(20)) == expected
+      verify_(parser_       .help(20)) == expected
+    end
+    it "takes width and indent arguments." do
+      expected = [
+        "    -h, --help: show help\n",
+        "    -v        : print version\n",
+        "    -m, --mode=MODE: set mode ('verbose' or 'quiet')\n",
+        "        --quiet: quiet mode\n",
+        "    -i, --indent[=N]: indent (default 2)\n",
+        "    -I PATH   : include path (multiple OK)\n",
+        #"    -D        : enable debug mode\n",
+      ].join
+      verify_(parser_.schema.help(10, "    ")) == expected
+      verify_(parser_       .help(10, "    ")) == expected
+    end
+    it "calculates width when not specified." do
+      expected = [
+        "  -h, --help       : show help\n",
+        "  -v               : print version\n",
+        "  -m, --mode=MODE  : set mode ('verbose' or 'quiet')\n",
+        "      --quiet      : quiet mode\n",
+        "  -i, --indent[=N] : indent (default 2)\n",
+        "  -I PATH          : include path (multiple OK)\n",
+        #"  -D               : enable debug mode\n"
+      ].join
+      verify_(parser_.schema.help()) == expected
+      verify_(parser_       .help()) == expected
+    end
+  end
+
+end
+
+
+class Cmdopt_Builder_TC < TC
+
+  def item_
+    @item_ ||= Cmdopt::SchemaItem.new
+  end
+
+  def builder_
+    @builder_ ||= Cmdopt::Builder.new(item_)
+  end
+
+  describe "#get_item()" do
+    it "returns item object." do
+      verify_(builder_.get_item()).same?(item_)
+    end
+  end
+
+  describe "#validation()" do
+    it "sets validator function." do
+      builder_.validation {|va| "OK" }
+      verify_(builder_.get_item.validator.call(nil)) == "OK"
+    end
+    it "returns self." do
+      ret = builder_.validation {|val| "OK" }
+      verify_(ret).same?(builder_)
+    end
+  end
+
+  describe "#action()" do
+    it "sets handler function." do
+      builder_.action {|val, opts| "YES" }
+      verify_(builder_.get_item.handler.call(nil, {})) == "YES"
+    end
+    it "returns self." do
+      ret = builder_.action {|val, opts| "YES" }
+      verify_(ret).same?(builder_)
+    end
+  end
+
+end
+
+
+class Cmdopt_Parser_TC < TC
+
+  describe "#option()" do
+    it "registers option definition." do
+      parser = Cmdopt::Parser.new
+      parser.option("-h, --help", "show help")
+      item = parser.schema.get("-h")
+      verify_(item).is_a?(Cmdopt::SchemaItem)
+      verify_(item.short) == "h"
+      verify_(item.long)  == "help"
+      verify_(item.desc)  == "show help"
+    end
+    it "returns builder object." do
+      parser = Cmdopt::Parser.new
+      ret = parser.option("-h, --help", "show help")
+      verify_(ret).is_a?(Cmdopt::Builder)
+    end
+  end
+
+  describe "#help()" do
+    it "calls #schema.help()." do
+      parser = Cmdopt::Parser.new
+      rc = recorder()
+      rc.record_method(parser.schema, :help)
+      ret = parser.help(19, "   ")
+      verify_(rc[0].name) == :help
+      verify_(rc[0].args) == [19, "   "]
+    end
+  end
+
+  def parser_
+    @parser_ ||= $cmdopt_parser
+  end
+
+  describe "#parse()" do
+    it "parses args." do
+      args = ["-vmquiet", "--help", "foo", "bar"]
+      defaults = {:mode=>"verbose", :file=>"config.json"}
+      opts = parser_.parse(args, defaults)
+      verify_(opts).NOT.same?(defaults)
+      verify_(opts.help) == true
+      verify_(opts.version) == true
+      verify_(opts.mode) == "quiet"           # overrided
+      verify_(opts.file) == "config.json"     # not overrided
+      verify_(args) == ["foo", "bar"]
+    end
+    it "parses long options." do
+      # no argument
+      args = ["--quiet", "foo", "bar"]
+      opts = parser_.parse(args)
+      verify_(opts.mode) == "quiet"
+      verify_(args) == ["foo", "bar"]
+      # required argument
+      args = ["--mode=verbose", "foo", "bar"]
+      opts = parser_.parse(args)
+      verify_(opts.mode) == "verbose"
+      verify_(args) == ["foo", "bar"]
+    end
+    it "parses short options." do
+      args = ["-h", "-m", "quiet", "foo", "bar"]
+      opts = parser_.parse(args)
+      verify_(opts.help) == true      # no argument
+      verify_(opts.mode) == "quiet"   # required argument
+      verify_(args) == ["foo", "bar"];
+    end
+    it "short options can be conbined." do
+      args = ["-hmquiet", "foo", "bar"]
+      opts = parser_.parse(args)
+      verify_(opts.help) == true
+      verify_(opts.mode) == "quiet"
+      verify_(args) == ["foo", "bar"]
+    end
+    it "optional argument is available for short option." do
+      ## when optional argument is not passed
+      args = ["-i", "foo", "bar"]
+      opts = parser_.parse(args)
+      verify_(opts.indent) == true
+      verify_(args) == ["foo", "bar"]
+      ## when optional argument is passed
+      args = ["-i3", "foo", "bar"]
+      opts = parser_.parse(args)
+      verify_(opts.indent) == '3'
+      verify_(args) == ["foo", "bar"]
+    end
+    it "optional argument is available for long option." do
+      ## when optional argument is not passed
+      args = ["--indent", "foo", "bar"]
+      opts = parser_.parse(args)
+      verify_(opts.indent) == true
+      verify_(args) == ["foo", "bar"]
+      ## when optional argument is passed
+      args = ["--indent=3", "foo", "bar"]
+      opts = parser_.parse(args)
+      verify_(opts.indent) == '3'
+      verify_(args) == ["foo", "bar"]
+    end
+    it "throws error when unknown short option specified." do
+      args = ["-xD", "foo", "bar"]
+      pr = proc { parser_.parse(args, {}) }
+      verify_(pr).raise?(Cmdopt::ParseError, "-x: unknown option.")
+    end
+    it "throws error when unknown long option specified." do
+      ## when argument not passed
+      args = ["--SOS"]
+      pr = proc { parser_.parse(args) }
+      verify_(pr).raise?(Cmdopt::ParseError, "--SOS: unknown option.")
+      ## with argument passed
+      args = ["--sos=SOS"]
+      pr = proc { parser_.parse(args, {}) }
+      verify_(pr).raise?(Cmdopt::ParseError, "--sos=SOS: unknown option.")
+    end
+    it "calls handler function." do
+      args = ["--quiet", "foo", "bar"]
+      opts = parser_.parse(args)
+      verify_(opts.quiet) == nil
+      verify_(opts.mode) == "quiet"
+      ## multiple option
+      args = ["-Ipath1", "-Ipath2", "-Ipath3"]
+      opts = parser_.parse(args)
+      verify_(opts.paths) == ["path1", "path2", "path3"]
+    end
+    it "throws error when validator returns error message." do
+      ## when short option
+      args = ["-msilent", "foo", "bar"]
+      pr = proc { parser_.parse(args) }
+      verify_(pr).raise?(Cmdopt::ParseError, "-m silent: 'verbose' or 'quiet' expected.")
+      ## when short option (optional)
+      args = ["-i9.99", "foo", "bar"]
+      pr = proc { parser_.parse(args) }
+      verify_(pr).raise?(Cmdopt::ParseError, "-i9.99: integer expected.")
+      ## when long option
+      args = ["--indent=zero", "foo", "bar"]
+      pr = proc { parser_.parse(args) }
+      verify_(pr).raise?(Cmdopt::ParseError, "--indent=zero: integer expected.")
+    end
+    it "stop parsing when '--' found." do
+      args = ["-h", "--", "-m", "verbose"]
+      opts = parser_.parse(args)
+      verify_(args) == ["-m", "verbose"]
+      verify_(opts.help) == true
+      verify_(opts.mode) == nil
+    end
+    it "returns different object from defaults." do
+      args = ["-Dm", "verbose", "foo", "bar"]
+      defaults = {}
+      opts = parser_.parse(args, defaults)
+      verify_(opts).NOT.same? defaults
+      verify_(opts).NOT == defaults
+      verify_(defaults.empty?) == true
+    end
+  end
+
+end
+
+
+class Cmdopt_ParseError_TC < TC
+
+  def err_
+    @err ||= Cmdopt::ParseError.new("SOS")
+  end
+  it "subclass of Error" do
+    verify_(err_).is_a?(Exception)
+  end
+  it "#message is set." do
+    verify_(err_.message) == "SOS"
+  end
+
+end
+
+
+class Cmdopt_Options_TC < TC
+
+  def opts_
+    @opts_ ||= Cmdopt::Options.new(:indent=>2, :paths=>['path1'], :help=>true, :mode=>"verbose")
+  end
+
+  describe "#__init__()" do
+    it "takes keyword arguments." do
+      verify_(opts_.indent) == 2
+      verify_(opts_.paths)  == ['path1']
+      verify_(opts_.help)   == true
+      verify_(opts_.mode)   == "verbose"
+    end
+  end
+
+  describe "#__repr__()" do
+    it "prints key and values in order of key." do
+      expected = %Q`<Cmdopt::Options help=true, indent=2, mode="verbose", paths=["path1"]>`
+      verify_(opts_.inspect) == expected
+      #verify_("Haruhi\nMikuru\nYuki\n") == "Haruhi\nMichiru\nYuki\n"
+    end
+  end
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: cmdopt
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- makoto kuwata
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: section9-unittest
+  requirement: &2160150160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2160150160
+description: ! 'Cmdopt.rb is a command-line option parser.
+
+  It is easier to use than optparse.rb (which is a standard library of Ruby).
+
+'
+email: kwa(at)kuwata-lab.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.txt
+- MIT-LICENSE
+- setup.rb
+- cmdopt.gemspec
+- lib/cmdopt.rb
+- test/cmdopt_test.rb
+homepage: https://bitbucket.org/kwatch/cmdopt/wiki/Cmdopt.rb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: cmdopt
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: easy-to-use command option parser
+test_files:
+- test/cmdopt_test.rb