ame 0.1.0

data/test/unit/ame/arguments.rb

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Enumerable do Ame::Arguments.new end
+
+  expect 0 do
+    Ame::Arguments.new.arity
+  end
+  expect 1 do
+    Ame::Arguments.new.argument(:a, 'd').arity
+  end
+  expect(-1) do
+    Ame::Arguments.new.argument(:a, 'd', :optional => true).arity
+  end
+  expect 2 do
+    Ame::Arguments.new.argument(:a, 'd').argument(:b, 'd').arity
+  end
+  expect(-2) do
+    Ame::Arguments.new.argument(:a, 'd').
+                       argument(:b, 'd', :optional => true).arity
+  end
+  expect(-3) do
+    Ame::Arguments.new.argument(:a, 'd').
+                       argument(:b, 'd').
+                       argument(:c, 'd', :optional => true).arity
+  end
+  expect(-4) do
+    Ame::Arguments.new.argument(:a, 'd').
+                       argument(:b, 'd').
+                       splat(:c, 'd').arity
+  end
+  expect(-3) do
+    Ame::Arguments.new.argument(:a, 'd').
+                       argument(:b, 'd').
+                       splat(:c, 'd', :optional => true).arity
+  end
+  expect(-3) do
+    Ame::Arguments.new.argument(:a, 'd').
+                       argument(:b, 'd').
+                       argument(:c, 'd', :optional => true).
+                       argument(:d, 'd', :optional => true).arity
+  end
+  expect(-3) do
+    Ame::Arguments.new.argument(:a, 'd').splat(:b, 'd').arity
+  end
+
+  expect ArgumentError.new('argument b must come before splat argument a') do
+    Ame::Arguments.new.splat(:a, 'd').argument(:b, 'd')
+  end
+
+  expect ArgumentError.new('optional argument a may not precede required argument b') do
+    Ame::Arguments.new.argument(:a, 'd', :optional => true).argument(:b, 'd')
+  end
+
+  expect ArgumentError.new('splat argument a already defined: b') do
+    Ame::Arguments.new.splat(:a, 'd').splat(:b, 'd')
+  end
+
+  expect ArgumentError.new('optional argument a may not precede required splat argument b') do
+    Ame::Arguments.new.argument(:a, 'd', :optional => true).splat(:b, 'd')
+  end
+
+  expect Ame::MissingArgument do
+    Ame::Arguments.new.argument(:a, 'd').process({}, [])
+  end
+
+  expect [] do
+    Ame::Arguments.new.process({}, [])
+  end
+
+  expect [1] do
+    Ame::Arguments.new.argument(:a, 'd', :type => Integer).process({}, %w[1])
+  end
+
+  expect [1, TrueClass] do
+    Ame::Arguments.new.argument(:a, 'd', :type => Integer).
+                       argument(:b, 'd', :type => FalseClass).
+                       process({}, %w[1 true])
+  end
+
+  expect Ame::MissingArgument do
+    Ame::Arguments.new.argument(:a, 'd', :type => Integer).
+                       splat(:b, 'd').
+                       process({}, %w[1])
+  end
+
+  expect [1, []] do
+    Ame::Arguments.new.argument(:a, 'd', :type => Integer).
+                       splat(:b, 'd', :optional => true).
+                       process({}, %w[1])
+  end
+
+  expect [1, [2, 3]] do
+    Ame::Arguments.new.argument(:a, 'd', :type => Integer).
+                       splat(:b, 'd', :type => Integer).
+                       process({}, %w[1 2 3])
+  end
+
+  expect Ame::Splat do
+    Ame::Arguments.new.splat(:a, 'd').splat
+  end
+
+  expect Ame::SuperfluousArgument do
+    Ame::Arguments.new.process({}, %w[1])
+  end
+end

data/test/unit/ame/help/console.rb

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect output(%{Usage: help-console-test-1 [OPTIONS]... ARG1 ARG2 ARGN...
+  Method description
+
+Arguments:
+  ARG1     Argument 1
+  ARG2     Argument 2
+  ARGN...  Argument N
+
+Options:
+  -a, --abc=ABC  Abc description
+      --help     Display help for this method
+  -v             V description
+      --version  Display version information
+  -x=LEVEL       X description
+}) do |io|
+    Class.new(Ame::Root) {
+      help Ame::Help::Console.new(io, false)
+
+      description 'Method description'
+      option :abc, 'Abc description', :aliases => :a, :type => String
+      option :v, 'V description'
+      option :x, 'X description', :type => String, :argument => 'level'
+      argument :arg1, 'Argument 1'
+      argument :arg2, 'Argument 2'
+      splat :argN, 'Argument N'
+      def help_console_test_1() end
+    }.process('help-console-test-1', %w[--help])
+  end
+
+  expect output(%{Usage: dispatch [OPTIONS]... METHOD [ARGUMENTS]...
+  Dispatch description
+
+Arguments:
+  METHOD          Method to run
+  [ARGUMENTS]...  Arguments to pass to METHOD
+
+Options:
+      --help     Display help for this method
+      --version  Display version information
+
+Methods:
+  method-1  Method 1 does a
+  method-2  Method 2 does b
+}) do |io|
+    Class.new(Ame::Root) {
+      help Ame::Help::Console.new(io, false)
+
+      dispatch Class.new(Ame::Class) {
+        basename 'dispatch'
+
+        description 'Dispatch description'
+        def initialize() end
+
+        description 'Method 1 does a'
+        def method_1() end
+
+        description 'Method 2 does b'
+        def method_2() end
+      }
+    }.process('dispatch', %w[--help])
+  end
+
+  expect output(%{Usage: dispatch-1 dispatch-2 [OPTIONS]... METHOD [ARGUMENTS]...
+  Dispatch 2 description
+
+Arguments:
+  METHOD          Method to run
+  [ARGUMENTS]...  Arguments to pass to METHOD
+
+Options:
+      --help  Display help for this method
+
+Methods:
+  method-1  Method 1 does a
+  method-2  Method 2 does b
+}) do |io|
+    Class.new(Ame::Root) {
+      help Ame::Help::Console.new(io, false)
+
+      dispatch Class.new(Ame::Class) {
+        basename 'dispatch-1'
+
+        description 'Dispatch 1 description'
+        def initialize() end
+
+        dispatch Class.new(Ame::Class) {
+          basename 'dispatch-2'
+
+          description 'Dispatch 2 description'
+          def initialize() end
+
+          description 'Method 1 does a'
+          def method_1() end
+
+          description 'Method 2 does b'
+          def method_2() end
+        }
+      }
+    }.process('dispatch-1', %w[dispatch-2 --help])
+  end
+
+  expect output(%{Usage: dispatch [OPTIONS]... [METHOD] [ARGUMENTS]...
+  Dispatch description
+
+Arguments:
+  [METHOD=method-1]  Method to run
+  [ARGUMENTS]...     Arguments to pass to METHOD
+
+Options:
+      --help     Display help for this method
+      --version  Display version information
+
+Methods:
+  method-1  Method 1 does a
+  method-2  Method 2 does b
+}) do |io|
+    Class.new(Ame::Root) {
+      help Ame::Help::Console.new(io, false)
+
+      dispatch Class.new(Ame::Class) {
+        basename 'dispatch'
+
+        description 'Dispatch description'
+        def initialize() end
+
+        description 'Method 1 does a'
+        def method_1() end
+
+        description 'Method 2 does b'
+        def method_2() end
+      }, :default => 'method-1'
+    }.process('dispatch', %w[--help])
+  end
+
+  expect output(%{method 0.1.0\n}) do |io|
+    Class.new(Ame::Root) {
+      Version = '0.1.0'
+
+      help Ame::Help::Console.new(io)
+
+      description 'd'
+      def method() end
+    }.process 'method', %w[--version]
+  end
+
+  expect output("method: error message\n") do |io|
+    begin
+      Class.new(Ame::Root) {
+        help Ame::Help::Console.new(io, false)
+
+        description 'd'
+        def method()
+          raise 'error message'
+        end
+      }.process 'method', []
+    rescue RuntimeError => e
+      raise unless e.message == 'error message'
+    end
+  end
+end

data/test/unit/ame/method.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect 'd' do Ame::Method.new(nil).description('d').description end
+
+  expect Ame::Method.new(nil).not.to.be.valid?
+
+  expect Ame::Method.new(nil).description('d').to.be.valid?
+
+  expect :name do Ame::Method.new(nil).description('d').define(:name).name end
+
+  expect mock.to.receive.method('b', 1, true, ['d', 'e', 'f'], {:a => true}).once do |o|
+    Ame::Method.new(o).
+      option(:a, 'd').
+      argument(:a, 'd').
+      argument(:b, 'd', :type => Integer).
+      argument(:c, 'd', :type => FalseClass).
+      splat(:d, 'd').
+      description('d').
+      define(:method).
+      process o, %w[b -a 1 on d e f]
+  end
+
+  expect mock.to.receive.method(1, false, [], {:a => 5}).once do |o|
+    Ame::Method.new(o).
+      option(:a, 'd', :default => 5).
+      argument(:b, 'd', :optional => true, :default => 1).
+      argument(:c, 'd', :optional => true, :default => false).
+      splat(:d, 'd', :optional => true).
+      description('d').
+      define(:method).
+      call o
+  end
+
+  expect Ame::Class.to.receive.help_for_method(Ame::Method) do |o|
+    catch Ame::AbortAllProcessing do
+      Ame::Method.new(o).description('d').define(:method).process o, %w[--help]
+    end
+  end
+end

data/test/unit/ame/methods.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Enumerable do Ame::Methods.new end
+
+  expect Ame::Methods.new do |o| o << Ame::Method.new(nil) end
+
+  expect Ame::Method.new(nil) do |o| (Ame::Methods.new << o.define(:name))[:name] end
+  expect Ame::Method.new(nil) do |o| (Ame::Methods.new << o.define(:name))['name'] end
+end

data/test/unit/ame/option.rb

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Ame::Argument do
+    Ame::Option.new(:a, 'd')
+  end
+
+  expect ArgumentError do
+    Ame::Option.new(:a, 'd', :type => String, :optional => true)
+  end
+
+  expect Ame::Option.new(:a, 'd').to.be.optional?
+
+  expect Ame::Option.new(:a, 'd', :type => String).not.to.be.optional?
+
+  expect FalseClass do
+    Ame::Option.new(:a, 'd').default
+  end
+
+  expect TrueClass do
+    Ame::Option.new(:a, 'd').process({}, [], 'true')
+  end
+
+  expect FalseClass do
+    Ame::Option.new(:a, 'd').process({}, [], 'off')
+  end
+
+  expect 'string' do
+    Ame::Option.new(:a, 'd', :type => String).process({}, [], 'string')
+  end
+
+  expect 'a' do
+    Ame::Option.new(:a, 'd', :type => String).argument_name
+  end
+
+  expect 'b' do
+    Ame::Option.new(:a, 'd', :argument => 'b', :type => String).argument_name
+  end
+
+  expect ArgumentError do
+    Ame::Option.new(:a, 'd', :argument => 'a').argument_name
+  end
+
+  expect [:b] do
+    Ame::Option.new(:a, 'd', :aliases => :b).aliases
+  end
+
+  expect [:b, :c, :d] do
+    Ame::Option.new(:a, 'd', :aliases => [:b, :c, :d]).aliases
+  end
+
+  expect [:b, :c, :d] do
+    Ame::Option.new(:a, 'd', :alias => :b, :aliases => [:c, :d]).aliases
+  end
+
+  expect '-a' do
+    Ame::Option.new(:a, 'd').to_s
+  end
+
+  expect '--abc' do
+    Ame::Option.new(:abc, 'd').to_s
+  end
+
+  expect :a do
+    Ame::Option.new(:abc, 'd', :aliases => [:a, :b]).short
+  end
+
+  expect :abc do
+    Ame::Option.new(:a, 'd', :aliases => [:abc, :b]).long
+  end
+
+  expect Ame::Option.new(:a, 'd').not.to.be.ignored?
+
+  expect Ame::Option.new(:a, 'd', :ignore => true).to.be.ignored?
+end

data/test/unit/ame/options.rb

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+
+Expectations do
+  expect Enumerable do
+    Ame::Options.new
+  end
+
+  expect [:a, :b] do
+    Ame::Options.new.option('a', 'd').option('b', 'd').map{ |o| o.name }
+  end
+
+  expect [:a, :b] do
+    Ame::Options.new.option(:a, 'd').option(:b, 'd').map{ |o| o.name }
+  end
+
+  expect ArgumentError do
+    Ame::Options.new.option(:a, 'd').option(:a, 'd')
+  end
+
+  expect Ame::Options.new.option(:a, 'd').to.include?('a')
+  expect Ame::Options.new.option(:a, 'd').to.include?(:a)
+
+  expect [{:a => 1, :b => 2}, []] do
+    Ame::Options.new.
+      option(:a, 'd', :default => 1).
+      option(:b, 'd', :default => 2).process([])
+  end
+
+  expect [{:a => 3, :b => 4}, []] do
+    Ame::Options.new.
+      option(:a, 'd', :default => 1).
+      option(:b, 'd', :default => 2).process(['-a=3', '-b=4'])
+  end
+
+  expect [{:a => 3, :b => 4}, []] do
+    Ame::Options.new.
+      option(:a, 'd', :default => 1).
+      option(:b, 'd', :default => 2).process(['-a', '3', '-b', '4'])
+  end
+
+  expect Ame::MalformedArgument do
+    Ame::Options.new.option(:a, 'd', :default => 1).process(['-a='])
+  end
+
+  expect Ame::MissingArgument do
+    Ame::Options.new.option(:a, 'd', :default => 1).process(['-a'])
+  end
+
+  expect Ame::UnrecognizedOption do
+    Ame::Options.new.option(:a, 'd', :default => 1).process(['-b'])
+  end
+
+  expect Ame::MalformedArgument do
+    Ame::Options.new.
+      option(:a, 'd', :default => 1).
+      option(:b, 'd').process(['-ab'])
+  end
+
+  expect Ame::MissingArgument do
+    Ame::Options.new.
+      option(:a, 'd').
+      option(:b, 'd', :default => 1).process(['-ab'])
+  end
+
+  expect [{:a => true, :b => 2}, []] do
+    Ame::Options.new.
+      option(:a, 'd').
+      option(:b, 'd', :default => 1).process(['-ab2'])
+  end
+
+  expect [{:a => true, :b => 2}, []] do
+    Ame::Options.new.
+      option(:a, 'd').
+      option(:b, 'd', :default => 1).process(['-ab', '2'])
+  end
+
+  expect [{:a => true, :b => true}, []] do
+    Ame::Options.new.
+      option(:a, 'd').
+      option(:b, 'd').process(['-ab'])
+  end
+
+  expect [{:a => true, :b => true}, []] do
+    Ame::Options.new.
+      option(:a, 'd').
+      option(:b, 'd').process(['-a', '-b'])
+  end
+
+  expect [{:a => true, :b => false}, ['-b']] do
+    Ame::Options.new.
+      option(:a, 'd').
+      option(:b, 'd').process(['-a', '--', '-b'])
+  end
+
+  expect [{:a => true, :b => true}, ['arg']] do
+    stub(ENV).include?{ false }
+    Ame::Options.new.
+      option(:a, 'd').
+      option(:b, 'd').process(['arg', '-a', '-b'])
+  end
+
+  expect [{:a => false, :b => false}, ['arg', '-a', '-b']] do
+    Ame::Options.new.
+      options_must_precede_arguments.
+      option(:a, 'd').
+      option(:b, 'd').process(['arg', '-a', '-b'])
+  end
+
+  expect [{:a => true}, []] do
+    Ame::Options.new.option(:a, 'd', :aliases => [:b]).process(['-b'])
+  end
+
+  expect [{:a => false}, []] do
+    Ame::Options.new.option(:a, 'd', :default => true).process(['-a'])
+  end
+
+  expect [{:abc => true}, []] do
+    Ame::Options.new.option(:abc, 'd').process(['--abc'])
+  end
+
+  expect [{:abc => 1}, []] do
+    Ame::Options.new.option(:abc, 'd', :type => Integer).process(['--abc=1'])
+  end
+
+  expect [{:abc => 1}, []] do
+    Ame::Options.new.option(:abc, 'd', :type => Integer).process(['--abc', '1'])
+  end
+
+  expect [{}, []] do
+    Ame::Options.new.option(:abc, 'd', :ignore => true).process(['--abc'])
+  end
+
+  expect [{:a => [1, 2, 3]}, []] do
+    Ame::Options.new.option(:a, 'd', :type => Ame::Types::Array[Integer]).process(%w[-a 1 -a 2 -a 3])
+  end
+end