clive 0.8.1 → 1.0.0

data/spec/clive/arguments/parser_spec.rb

@@ -0,0 +1,35 @@
+$: << File.dirname(__FILE__) + '/../..'
+require 'helper'
+
+class Clive::Arguments::ParserSubject < Clive::Arguments::Parser
+  attr_reader :opts
+end
+
+describe Clive::Arguments::Parser do
+
+  subject { Clive::Arguments::ParserSubject }
+
+  describe '#initialize' do
+    it 'normalises key names' do
+      subject.new(:kind => String, :in => %w(a b c)).opts.keys.must_include :type, :within
+    end
+  end
+  
+  describe '#to_a' do
+    it 'returns an array of hashes' do
+      subject.new(:type => [Integer, Time]).to_a.must_equal [{:type => Integer, :name => 'arg'},
+                                                             {:type => Time, :name => 'arg'}]
+    end
+  end
+  
+  describe '#to_args' do
+    it 'returns an array of Argument instances' do
+      args = subject.new(:args => '<a> <b> [<c>]', :type => [Integer, Time]).to_args
+      args.size.must_equal 3
+      args[0].must_be_argument :name => :a, :type => Clive::Type::Integer
+      args[1].must_be_argument :name => :b, :type => Clive::Type::Time
+      args[2].must_be_argument :name => :c, :optional => true
+    end
+  end
+
+end

data/spec/clive/arguments_spec.rb

@@ -0,0 +1,191 @@
+$: << File.dirname(__FILE__) + '/..'
+require 'helper'
+
+describe Clive::Arguments do
+
+  subject {
+    Clive::Arguments.create :args => '[<a>] <b> <c> [<d>]', 
+                            :type => [Integer] * 4,
+                            :constraint => [:even?, :odd?] * 2
+  }
+  
+  describe '.create' do
+    it 'parses the options passed using Parser' do
+      parser, opts = mock, stub
+      parser.expects(:to_args).returns([])
+      Clive::Arguments::Parser.expects(:new).with(opts).returns(parser)
+      Clive::Arguments.create opts
+    end
+    it 'returns a list of Argument instances' do
+      a = Clive::Arguments.create :args => '[<a>] <b>', :as => [Integer, nil], :in => [1..5, nil]
+      a[0].must_be_argument :name => :a, :optional => true, :within => 1..5, 
+                            :type => Clive::Type::Integer
+      a[1].must_be_argument :name => :b, :optional => false
+    end
+  end
+
+  describe '#zip' do
+    it 'zips arguments properly' do
+      def subject.simple_zip(other); zip(other).map(&:last); end
+    
+      # These behaviours are definitely what should happen
+      subject.simple_zip(%w(1 4)).must_equal     [nil, '1', '4', nil]
+      subject.simple_zip(%w(1 4 3)).must_equal   [nil, '1', '4', '3']
+      subject.simple_zip(%w(2 1 4 3)).must_equal ['2', '1', '4', '3']
+      subject.simple_zip(%w(2 1 4)).must_equal   ['2', '1', '4', nil]
+      
+      # These behaviours may change
+      subject.simple_zip(%w(2)).must_equal   [nil, nil, '2', nil]
+      subject.simple_zip(%w(1)).must_equal   [nil, '1', nil, nil]
+      subject.simple_zip(%w(2 1)).must_equal [nil, nil, '2', nil]
+    end  
+  end
+  
+  describe '#to_s' do
+    subject {
+     Clive::Arguments.new( [
+       Clive::Argument.new(:a), 
+       Clive::Argument.new(:b, :optional => true),
+       Clive::Argument.new(:c, :optional => true),
+       Clive::Argument.new(:d)
+     ])
+    }
+  
+    it 'removes extra square brackets' do
+      subject.to_s.must_equal "<a> [<b> <c>] <d>"
+    end
+  end
+  
+  describe '#min' do
+    it 'returns the number of non-optional arguments' do
+      subject.min.must_equal 2
+    end
+  end
+  
+  describe '#max' do
+    it 'returns the total number of arguments' do
+      subject.max.must_equal 4
+    end
+  end
+  
+  describe '#possible?' do
+    it 'is true if each argument is possible and list is not too long' do
+      subject.must_be :possible?, [2]
+      subject.must_be :possible?, [2, 3]
+      subject.must_be :possible?, [2, 3, 4]
+      subject.must_be :possible?, [2, 3, 4, 5]
+    end
+    
+    it 'is false if the list is too long' do
+      subject.wont_be :possible?, [2, 3, 4, 5, 6]
+    end
+    
+    it 'is true even if an argument is not possible' do
+      subject.must_be :possible?, ['hello']
+    end
+    
+    it 'single' do
+      subject = Clive::Arguments.create :arg => '<name>'
+      subject.must_be :possible?, []
+      subject.must_be :possible?, %w(John)
+      subject.wont_be :possible?, %w(John Doe)
+    end
+    
+    it 'single optional' do
+      subject = Clive::Arguments.create :arg => '[<name>]'
+      subject.must_be :possible?, []
+      subject.must_be :possible?, %w(John)
+      subject.wont_be :possible?, %w(John Doe)
+    end
+    
+    it 'single with constraint' do
+      subject = Clive::Arguments.create :arg => '<name>', :constraint => proc {|i| i.size == 4 }
+      subject.must_be :possible?, []
+      subject.must_be :possible?, %w(John)
+      subject.wont_be :possible?, %w(James)
+      subject.wont_be :possible?, %w(John Doe)
+    end
+    
+    it 'single optional with constraint' do
+      subject = Clive::Arguments.create :arg => '[<name>]', :constraint => proc {|i| i.size == 4 }
+      subject.must_be :possible?, []
+      subject.must_be :possible?, %w(John)
+      subject.wont_be :possible?, %w(James)
+      subject.wont_be :possible?, %w(John Doe)
+    end
+  
+    it 'multiple surrounding' do
+      subject = Clive::Arguments.create :args => '<first> [<middle>] <last>'
+      subject.must_be :possible?, []
+      subject.must_be :possible?, %w(John)
+      subject.must_be :possible?, %w(John Doe)
+      subject.must_be :possible?, %w(John David Doe)
+      subject.wont_be :possible?, %w(John David James Doe)
+    end
+    
+    it 'multiple middle' do
+      subject = Clive::Arguments.create :args => '[<first>] <middle> [<last>]'
+      subject.must_be :possible?, []
+      subject.must_be :possible?, %w(John)
+      subject.must_be :possible?, %w(John Doe)
+      subject.must_be :possible?, %w(John David Doe)
+      subject.wont_be :possible?, %w(John David James Doe)
+    end
+    
+    it 'multiple surrounding with constraints' do
+      subject = Clive::Arguments.create :args => '<first> [<middle>] <last>',
+        :constraint => [proc {|i| i.size == 3 }, proc {|i| i.size == 4 }, proc {|i| i.size == 5 }]
+      subject.must_be :possible?, []
+      
+      subject.must_be :possible?, %w(Joe)   # [Joe, ..., ...]
+      subject.wont_be :possible?, %w(Gary)  # [!!!, Gary, ...]
+      subject.wont_be :possible?, %w(David) # [!!!, nil, David]
+      
+      subject.must_be :possible?, %w(Joe Gary)   # [Joe, Gary, ...]
+      subject.must_be :possible?, %w(Joe David)  # [Joe, ..., David]
+      subject.wont_be :possible?, %w(Gary David) # [!!!, Gary, David]
+      
+      subject.must_be :possible?, %w(Joe Gary David)     # [Joe, Gary, David]
+      subject.wont_be :possible?, %w(Joe Gary David Doe) # [Joe, Gary, David] Doe
+    end
+  end
+  
+  describe '#valid?' do
+    it 'is false if the list is not #possible' do
+      subject.stubs(:possible?).returns(false)
+      subject.wont_be :valid?, [1, 2]
+    end
+    
+    it 'is false if the list is too short' do
+      subject.stubs(:possible?).returns(true)
+      subject.wont_be :valid?, [1]
+    end
+    
+    it 'is true if the list is #possible? and not too short' do
+      subject.stubs(:possible?).returns(true)
+      subject.must_be :valid?, [1, 2]
+      subject.must_be :valid?, [1, 2, 3]
+      subject.must_be :valid?, [0, 1, 2, 3]
+    end
+  end
+  
+  describe '#create_valid' do
+    it 'returns the correct arguments' do
+      a = Clive::Arguments.create :args => '[<a>] <b> [<c>]'
+      a.create_valid(%w(a b c)).must_equal ['a', 'b', 'c']
+      a.create_valid(%w(a b)).must_equal ['a', 'b', nil]
+      a.create_valid(%w(a)).must_equal [nil, 'a', nil]
+    end
+    
+    it 'coerces the arguments' do
+      a = Clive::Arguments.create :args => '<a> <b>', :as => [Integer, Float]
+      a.create_valid(%w(50.55 50.55)).must_equal [50, 50.55]
+    end
+    
+    it 'uses defaults where needed' do
+      a = Clive::Arguments.create :args => '[<a>] <b> [<c>]', :defaults => ['y', nil, 'y']
+      a.create_valid(%w(n)).must_equal %w(y n y)
+    end
+  end
+
+end

data/spec/clive/command_spec.rb

@@ -1,240 +1,307 @@
-require 'spec_helper'
+$: << File.dirname(__FILE__) + '/..'
+require 'helper'
 
 describe Clive::Command do
 
-  context "when creating a base command" do
-    subject { Clive::Command.setup(Class.new) {} }
-  end
-  
-  subject { 
-    Clive::Command.new([:co, :comm], "A command", Class.new) do
-      bool(:boo) {}
-      switch(:swi) {}
-      flag(:fla) {}
-      command(:com) {}
-    end
-  }
-  
-  it_behaves_like "an option"
-  
-  describe "#initialize" do
-    subject { 
-      Clive::Command.new([:com], "A command", Class.new) do
-        flag(:test)
-      end
+  it 'can take arguments' do
+    command = Clive::Command.create([:test], '', :arg => '<dir>')
+
+    state = {:test => {}}
+    command.run(state, ['~/somewhere'])
+    state[:test][:args].must_equal '~/somewhere'
+  end
+
+  it 'can run a block with arguments' do
+    command = Clive::Command.create [], '', :arg => '<dir>' do
+      action { puts dir }
+    end
+
+    this { command.run({}, ['~/somewhere']) }.must_output "~/somewhere\n"
+  end
+
+  describe '#initialize' do
+    subject {
+      Clive::Command.new([:c,:b,:a],
+                         'A command',
+                         :head => true,
+                         :args => '<a> [<b>]',
+                         :as => [Integer, nil],
+                         :group => 'Cool commands',
+                         :help => true,
+                         :name => 'file.rb')
     }
-  
-    it "generates a help header" do
-      File.stub!(:basename).and_return("test")
-      subject.instance_variable_get("@header").should == "Usage: test com [options]"
-    end
-    
-    it "generates an option missing proc" do
-      proc = subject.instance_variable_get("@option_missing")
-      expect {
-        proc.call("hey")
-      }.should raise_error Clive::NoOptionError
-    end
-    
-    it "doesn't run the block given" do
-      subject.flags.size.should == 0
-    end
-    
-    it "generates a help switch" do
-      subject.switches.map {|i| i.names}.should include ["h", "help"]
-    end
-  end
-  
-  describe "#bools" do
-    it "returns an array of bools" do
-      subject.find
-      subject.bools.each do |i|
-        i.should be_kind_of Clive::Bool
-      end
+
+    it 'sets the names' do
+      subject.names.must_equal [:c,:b,:a]
+    end
+
+    it 'sets the description' do
+      subject.description.must_equal 'A command'
+    end
+
+    it 'sets the options' do
+      subject.config[:head].must_be_true
+      subject.config[:group].must_equal 'Cool commands'
+    end
+
+    it 'sets the arguments' do
+      subject.args.size.must_equal 2
+      subject.args.map(&:name).must_equal [:a, :b]
+    end
+
+    it 'sets a default header' do
+      subject.instance_variable_get(:@header).call.must_equal 'Usage: file.rb c,b,a [options]'
+    end
+
+    it 'sets a default footer' do
+      subject.instance_variable_get(:@footer).must_equal ''
+    end
+
+    it 'adds the help option' do
+      subject.must_be :has?, '--help'
+      subject.must_be :has?, '-h'
+    end
+
+    it 'resets the current description' do
+      subject.instance_variable_get(:@_last_desc).must_equal ''
     end
   end
-  
-  describe "#switches" do
-    it "returns an array of switches" do
-      subject.find
-      subject.switches.each do |i|
-        i.should be_kind_of Clive::Switch
-      end
+
+  describe '#name' do
+    it 'returns the first, in order when defined, name' do
+      command = Clive::Command.new [:efg, :abc, :zxy]
+      command.name.must_equal :efg
     end
   end
-  
-  describe "#flags" do
-    it "returns an array of flags" do
-      subject.find
-      subject.flags.each do |i|
-        i.should be_kind_of Clive::Flag
-      end
+
+  describe '#to_s' do
+    it 'returns the names joined' do
+      command = Clive::Command.new [:a, :b, :c]
+      command.to_s.must_equal 'a,b,c'
     end
   end
-  
-  describe "#find" do
-    it "runs the block for the command" do
-      subject.flags.size.should == 0
-      subject.find
-      subject.flags.size.should == 1
-    end
-    
-    it "sets the block to nil" do
-      subject.find
-      subject.block.should be_nil
-    end
-  end
-  
-  describe "#run" do
-    it "returns an array of unused arguments" do
-      subject.find
-      subject.run(%w(--swi what)).should == ['what']
-    end
-  end
-  
-  describe "#to_h" do
-    it "returns a hash of data for help formatting" do
-      hsh = {'names' => subject.names, 'desc' => subject.desc}
-      subject.to_h.should == hsh
-    end
-  end
-  
-  describe "#command" do
-    it "creates a new command" do
-      expect {
-        subject.command(:comm)
-      }.should change {subject.commands.size}.by(1)
-    end
-    
-    it "resets the current description" do
-      subject.desc 'A command'
-      subject.command(:comm)
-      subject.current_desc.should == ""
-    end
-  end
-  
-  describe "#switch" do
-    it "creates a new switch" do
-      expect {
-        subject.switch(:s, :switch)
-      }.should change {subject.switches.size}.by(1)
-    end
-    
-    it "resets the current description" do
-      subject.desc 'A switch'
-      subject.switch(:s, :switch)
-      subject.current_desc.should == ""
-    end
-  end
-  
-  describe "#flag" do
-    it "creates a new flag" do
-      expect {
-        subject.flag(:f, :flag)
-      }.should change {subject.flags.size}.by(1)
-    end
-    
-    it "resets the current description" do
-      subject.desc 'A flag'
-      subject.flag(:f, :flag)
-      subject.current_desc.should == ""
-    end
-  end
-  
-  describe "#bool" do
-    it "creates two bool switches" do
-      expect {
-        subject.bool(:b, :bool)
-      }.should change {subject.bools.size}.by(2)
-    end
-    
-    it "resets the current description" do
-      subject.desc 'A bool'
-      subject.bool(:b, :bool)
-      subject.current_desc.should == ""
-    end
-  end
-  
-  describe "#desc" do
-    context "when called with no arguments" do
-      it "returns the description for the command" do
-        subject.desc.should == "A command"
+
+  describe '#run_block' do
+    it 'runs the block passed to command' do
+      command = Clive::Command.new do
+        print 'Hey I was ran'
       end
+      this { command.run_block({}) }.must_output 'Hey I was ran'
     end
-    
-    context "when called with an argument" do
-      it "sets the current description" do
-        subject.desc "A new desc"
-        subject.instance_variable_get("@current_desc").should == "A new desc"
-      end
+
+    it 'returns a possibly modified state' do
+      state = {}
+      command = Clive::Command.new { set :a, true }
+      state.wont_have :key?, :a
+      command.run_block(state)
+      state.must_have :key?, :a
+    end
+  end
+
+  describe '#header' do
+    it 'sets the header' do
+      command = Clive::Command.new
+      command.header 'A header'
+      command.instance_variable_get(:@header).must_equal 'A header'
+    end
+  end
+
+  describe '#footer' do
+    it 'sets the footer' do
+      command = Clive::Command.new
+      command.footer 'A footer'
+      command.instance_variable_get(:@footer).must_equal 'A footer'
+    end
+  end
+
+  describe '#config' do
+    it 'sets options' do
+      command = Clive::Command.new
+      command.config :name => 'my cool app'
+      command.config[:name].must_equal 'my cool app'
+    end
+  end
+
+  describe '#set' do
+    it 'sets a value to the state hash' do
+      command = Clive::Command.new
+      command.instance_variable_set :@state, {}
+      command.set :a, true
+      command.instance_variable_get(:@state).must_equal :a => true
+    end
+  end
+
+  describe '#option' do
+    it 'creates an option' do
+      command = Clive::Command.new
+      command.option :O, :opt, 'An option', :tail => true
+
+      opt = command.find('-O')
+      opt.name.must_equal :opt
+      opt.description.must_equal 'An option'
+      opt.config.must_contain :tail => true
+    end
+  end
+
+  describe '#boolean' do
+    it 'creates a new boolean option' do
+      command = Clive::Command.new
+      command.boolean :auto, 'Auto build', :head => true
+
+      bool = command.find('--auto')
+      bool.name.must_equal :auto
+      bool.description.must_equal 'Auto build'
+      bool.config.must_contain :head => true
+      bool.config[:boolean].must_be_true
+    end
+  end
+
+  describe '#action' do
+    it 'stores a block' do
+      command = Clive::Command.new
+      block = proc {}
+      command.action &block
+      command.instance_variable_get(:@block).to_s.must_equal block.to_s
     end
   end
-  
-  describe "#option_missing" do
-    it "sets the option missing proc" do
-      proc = lambda {|n| puts "What? #{name} doesn't exist" }
-      subject.option_missing(&proc)
-      subject.instance_variable_get("@option_missing").should == proc
+
+  describe '#description' do
+    it 'sets the description' do
+      command = Clive::Command.new
+      command.description 'Some description'
+      command.instance_variable_get(:@_last_desc).must_equal 'Some description'
+    end
+
+    it 'gets the description' do
+      command = Clive::Command.new [], 'A command'
+      command.description.must_equal 'A command'
     end
   end
-  
-  describe "#header" do
-    it "sets the header" do
-      subject.header "A header"
-      subject.instance_variable_get("@header").should == "A header"
+
+  describe '#find' do
+    subject {
+      Clive::Command.create [:command] do
+        bool :F, :force
+        opt :auto_build
+      end
+    }
+
+    it 'finds boolean options' do
+      subject.find('--force').name.must_equal :force
+    end
+
+    it 'finds short options' do
+      subject.find('-F').name.must_equal :force
+    end
+
+    it 'does not find short negative boolean options' do
+      subject.find('--no-F').must_be_nil
+    end
+
+    it 'does not find negative boolean options' do
+      subject.find('--no-force').must_be_nil
+    end
+
+    it 'finds options with multiple words in name' do
+      subject.find('--auto_build').name.must_equal :auto_build
+    end
+
+    it 'finds options with dashes in name' do
+      subject.find('--auto-build').name.must_equal :auto_build
+    end
+
+    it 'does not find non existent options' do
+      subject.find('--no-auto-build').must_be_nil
+      subject.find('--unreal').must_be_nil
     end
   end
-  
-  describe "#footer" do
-    it "sets the footer" do
-      subject.footer "A footer"
-      subject.instance_variable_get("@footer").should == "A footer"
+
+  describe '#find_option' do
+    subject {
+      Clive::Command.create do
+        bool :F, :force
+        opt :auto_build
+      end
+    }
+
+    it 'finds boolean options' do
+      subject.find_option(:force).name.must_equal :force
+    end
+
+    it 'finds short options' do
+      subject.find_option(:F).name.must_equal :force
+    end
+
+    it 'does not find short negative boolean options' do
+      subject.find_option(:no_F).must_be_nil
+    end
+
+    it 'does not find negative boolean options' do
+      subject.find_option(:no_force).must_be_nil
+    end
+
+    it 'finds options with multiple words in name' do
+      subject.find_option(:auto_build).name.must_equal :auto_build
+    end
+
+    it 'does not find non existent options' do
+      subject.find_option(:no_auto_build).must_be_nil
+      subject.find_option(:unreal).must_be_nil
     end
   end
-  
-  describe "#build_help" do
-    it "adds a switch for help" do
-      subject.options = []
-      subject.options.should be_empty
-      subject.build_help
-      subject.options.map(&:names).should include ['h', 'help']
+
+  describe '#has?' do
+    it 'tries to find the option' do
+      command = Clive::Command.new
+      command.expects(:find).with('--option').returns(Clive::Option.new)
+      command.has?('--option').must_be_true
     end
   end
-  
-  describe "#help" do
-    it "returns a string of help" do
-      help = <<EOS
-Usage: rspec co, comm [options]
 
-  Options: 
-    -h, --help                \e[90mDisplay help\e[0m
-EOS
-    
-      subject.help.should == help
+  describe '#group' do
+    it 'sets the group for options created' do
+      command = Clive::Command.create do
+        group 'Testing'
+        opt :test
+        group 'Changed'
+        opt :change
+        opt :manual, :group => 'Set'
+      end
+
+      command.find_option(:test).config[:group].must_equal   'Testing'
+      command.find_option(:change).config[:group].must_equal 'Changed'
+      command.find_option(:manual).config[:group].must_equal 'Set'
     end
   end
-  
-  describe "#help_formatter" do
-    context "when called with a symbol" do
-      it "uses the named formatter" do
-        before = subject.instance_variable_get("@formatter")
-        subject.help_formatter(:white)
-        subject.instance_variable_get("@formatter").should_not == before
+
+  describe '#end_group' do
+    it 'calls #group with nil' do
+      command = Clive::Command.create do
+        group 'Testing'
+        option :test
+        end_group
+        option :none
       end
+
+      command.find_option(:none).config[:group].must_be_nil
     end
-    
-    context "when called with argumentss and a block" do
-      it "creates a new help formatter" do
-        subject.help_formatter :width => 40, :prepend => 5 do |h|
-          h.switch  "switch"
-          h.bool    "bool"
-          h.flag    "flag"
-          h.command "command"
-        end
-        formatter = subject.instance_variable_get("@formatter")
-        formatter.width.should == 40
+  end
+
+  describe '#help' do
+    it 'builds a help string using the defined formatter' do
+      f = mock
+      command = Clive::Command.create [], "", :formatter => f, :help => true do
+        header 'Top'
+        footer 'Bottom'
       end
+
+      f.expects(:header=).with('Top')
+      f.expects(:footer=).with('Bottom')
+      f.expects(:options=).with([command.find_option(:help)])
+      f.expects(:to_s).with()
+
+      command.help
     end
   end
 
-end
+end