clive 0.8.1 → 1.0.0

data/spec/clive/formatter/colour_spec.rb

@@ -0,0 +1,129 @@
+$: << File.dirname(__FILE__) + '/../..'
+require 'helper'
+
+describe Clive::Formatter::Colour do
+
+  let :clive do
+    Clive.new {
+
+      header 'Usage: clive_test.rb [command] [options]'
+      footer 'Further help is available online'
+
+      opt :version, :tail => true
+
+      opt :S, :super_size, :head => true
+      bool :a, :auto
+      opt :s, :size, 'Size of thing', :arg => '<size>'
+
+
+      desc 'A super long description for a super stupid option, this should test the _extreme_ wrapping abilities as it should all be aligned. Maybe I should go for another couple of lines just for good measure. That\'s all'
+      opt :complex, :arg => '[<one>] <two> [<three>]'
+
+      command :new, 'Creates new things', :arg => '<dir>' do
+        opt :type, :in => %w(post page blog), :default => :page
+        opt :force, 'Force overwrite'
+      end
+    }
+  end
+
+  subject { Clive::Formatter::Colour }
+
+  describe '#to_s' do
+
+    it 'builds the help string' do
+      this {
+        clive.run s('help'), :formatter => subject.new(:width => 80)
+      }.must_output <<EOS
+Usage: clive_test.rb [command] [options]
+
+  Commands:
+    new <dir>                             \e[90m# \e[0m\e[90mCreates new things\e[0m
+    help [<command>]                      \e[90m# \e[0m\e[90mDisplay help\e[0m
+
+  Options:
+    -S, --super-size
+    -a, --[no-]auto
+    --complex [<one>] <two> [<three>]     \e[90m# \e[0m\e[90mA super long description for a
+                                            super stupid option, this should
+                                            test the _extreme_ wrapping
+                                            abilities as it should all be
+                                            aligned. Maybe I should go for
+                                            another couple of lines just for
+                                            good measure. That's all\e[0m
+    -s, --size <size>                     \e[90m# \e[0m\e[90mSize of thing\e[0m
+    -h, --help                            \e[90m# \e[0m\e[90mDisplay this help message\e[0m
+    --version
+
+Further help is available online
+EOS
+    end
+
+    it 'obeys minimum ratio' do
+      this {
+        clive.run s('help'), :formatter => subject.new(:width => 80, :min_ratio => 0.7)
+      }.must_output r = <<EOS
+Usage: clive_test.rb [command] [options]
+
+  Commands:
+    new <dir>                                             \e[90m# \e[0m\e[90mCreates new things\e[0m
+    help [<command>]                                      \e[90m# \e[0m\e[90mDisplay help\e[0m
+
+  Options:
+    -S, --super-size
+    -a, --[no-]auto
+    --complex [<one>] <two> [<three>]                     \e[90m# \e[0m\e[90mA super long
+                                                            description for a
+                                                            super stupid option,
+                                                            this should test the
+                                                            _extreme_ wrapping
+                                                            abilities as it
+                                                            should all be
+                                                            aligned. Maybe I
+                                                            should go for
+                                                            another couple of
+                                                            lines just for good
+                                                            measure. That's all\e[0m
+    -s, --size <size>                                     \e[90m# \e[0m\e[90mSize of thing\e[0m
+    -h, --help                                            \e[90m# \e[0m\e[90mDisplay this help
+                                                            message\e[0m
+    --version
+
+Further help is available online
+EOS
+#------------------------------------------------------------------------------| 80
+#                                                       |======================| 24
+
+
+    end
+
+    it 'obeys the maximum ratio' do
+      this {
+        clive.run s('help'), :formatter => subject.new(:width => 80, :min_ratio => 0, :max_ratio => 0.3)
+      }.must_output <<EOS
+Usage: clive_test.rb [command] [options]
+
+  Commands:
+    new <dir>             \e[90m# \e[0m\e[90mCreates new things\e[0m
+    help [<command>]      \e[90m# \e[0m\e[90mDisplay help\e[0m
+
+  Options:
+    -S, --super-size
+    -a, --[no-]auto
+    --complex [<one>] <two> [<three>]
+                          \e[90m# \e[0m\e[90mA super long description for a super stupid option,
+                            this should test the _extreme_ wrapping abilities as
+                            it should all be aligned. Maybe I should go for
+                            another couple of lines just for good measure.
+                            That's all\e[0m
+    -s, --size <size>     \e[90m# \e[0m\e[90mSize of thing\e[0m
+    -h, --help            \e[90m# \e[0m\e[90mDisplay this help message\e[0m
+    --version
+
+Further help is available online
+EOS
+#======================|  #
+#------------------------------------------------------------------------------|
+    end
+
+  end
+end

data/spec/clive/formatter/plain_spec.rb

@@ -0,0 +1,129 @@
+$: << File.dirname(__FILE__) + '/../..'
+require 'helper'
+
+describe Clive::Formatter::Plain do
+
+  let :clive do
+    Clive.new {
+
+      header 'Usage: clive_test.rb [command] [options]'
+      footer 'Further help is available online'
+
+      opt :version, :tail => true
+
+      opt :S, :super_size, :head => true
+      bool :a, :auto
+      opt :s, :size, 'Size of thing', :arg => '<size>'
+
+
+      desc 'A super long description for a super stupid option, this should test the _extreme_ wrapping abilities as it should all be aligned. Maybe I should go for another couple of lines just for good measure. That\'s all'
+      opt :complex, :arg => '[<one>] <two> [<three>]'
+
+      command :new, 'Creates new things', :arg => '<dir>' do
+        opt :type, :in => %w(post page blog), :default => :page
+        opt :force, 'Force overwrite'
+      end
+    }
+  end
+
+  subject { Clive::Formatter::Plain }
+
+  describe '#to_s' do
+
+    it 'builds the help string' do
+      this {
+        clive.run s('help'), :formatter => subject.new(:width => 80)
+      }.must_output <<EOS
+Usage: clive_test.rb [command] [options]
+
+  Commands:
+    new <dir>                             # Creates new things
+    help [<command>]                      # Display help
+
+  Options:
+    -S, --super-size
+    -a, --[no-]auto
+    --complex [<one>] <two> [<three>]     # A super long description for a
+                                            super stupid option, this should
+                                            test the _extreme_ wrapping
+                                            abilities as it should all be
+                                            aligned. Maybe I should go for
+                                            another couple of lines just for
+                                            good measure. That's all
+    -s, --size <size>                     # Size of thing
+    -h, --help                            # Display this help message
+    --version
+
+Further help is available online
+EOS
+    end
+
+    it 'obeys minimum ratio' do
+      this {
+        clive.run s('help'), :formatter => subject.new(:width => 80, :min_ratio => 0.7)
+      }.must_output r = <<EOS
+Usage: clive_test.rb [command] [options]
+
+  Commands:
+    new <dir>                                             # Creates new things
+    help [<command>]                                      # Display help
+
+  Options:
+    -S, --super-size
+    -a, --[no-]auto
+    --complex [<one>] <two> [<three>]                     # A super long
+                                                            description for a
+                                                            super stupid option,
+                                                            this should test the
+                                                            _extreme_ wrapping
+                                                            abilities as it
+                                                            should all be
+                                                            aligned. Maybe I
+                                                            should go for
+                                                            another couple of
+                                                            lines just for good
+                                                            measure. That's all
+    -s, --size <size>                                     # Size of thing
+    -h, --help                                            # Display this help
+                                                            message
+    --version
+
+Further help is available online
+EOS
+#------------------------------------------------------------------------------| 80
+#                                                       |======================| 24
+
+
+    end
+
+    it 'obeys the maximum ratio' do
+      this {
+        clive.run s('help'), :formatter => subject.new(:width => 80, :min_ratio => 0, :max_ratio => 0.3)
+      }.must_output <<EOS
+Usage: clive_test.rb [command] [options]
+
+  Commands:
+    new <dir>             # Creates new things
+    help [<command>]      # Display help
+
+  Options:
+    -S, --super-size
+    -a, --[no-]auto
+    --complex [<one>] <two> [<three>]
+                          # A super long description for a super stupid option,
+                            this should test the _extreme_ wrapping abilities as
+                            it should all be aligned. Maybe I should go for
+                            another couple of lines just for good measure.
+                            That's all
+    -s, --size <size>     # Size of thing
+    -h, --help            # Display this help message
+    --version
+
+Further help is available online
+EOS
+#======================|  #
+#------------------------------------------------------------------------------|
+    end
+
+  end
+end

data/spec/clive/option/runner_spec.rb

@@ -0,0 +1,92 @@
+$: << File.dirname(__FILE__) + '/../..'
+require 'helper'
+
+describe Clive::Option::Runner do
+  subject { Clive::Option::Runner }
+
+  describe '#_run' do
+    it 'executes the function passed within it' do
+      this {
+        subject._run({}, {}, proc { puts self.name })
+      }.must_output "Clive::Option::Runner\n"
+    end
+  end
+
+  describe '#get' do
+    it 'gets a value from state' do
+      this {
+        subject._run({}, {:a => 1}, proc { puts get(:a) })
+      }.must_output "1\n"
+    end
+  end
+
+  describe '#set' do
+    it 'sets a value to state' do
+      state = {}
+      subject._run({}, state, proc { set(:a, 1) })
+      state[:a].must_equal 1
+    end
+  end
+
+  describe '#update' do
+    it 'updates a state value using a method' do
+      state = {:name => 'John Doe'}
+      subject._run({}, state, proc {
+        update :name, :upcase
+      })
+      state[:name].must_equal "JOHN DOE"
+    end
+
+    it 'updates a state value using a method with arguments' do
+      state = {:line => "A man a plan a canal"}
+      subject._run({}, state, proc {
+        update :line, :gsub, /[Aa]/, 'i'
+      })
+      state[:line].must_equal "i min i plin i cinil"
+    end
+
+    it 'updates a state value using a block' do
+      state = {:list => []}
+      subject._run({}, state, proc {
+        update(:list) {|l| l << 1 }
+      })
+      state[:list].must_equal [1]
+    end
+
+    it 'raises an exception if arguments are missing' do
+      this {
+        subject._run({}, {}, proc { update(:a) })
+      }.must_raise ArgumentError
+    end
+  end
+
+  describe '#has?' do
+    it 'is true if the state contains the key' do
+      this {
+        subject._run({}, {:key => nil}, proc { puts has?(:key) })
+      }.must_output "true\n"
+    end
+
+    it 'is false if the state does not have the key' do
+      this {
+        subject._run({}, {}, proc { puts has?(:key) })
+      }.must_output "false\n"
+    end
+
+  end
+
+  describe '#method_missing' do
+    it 'makes the arguments available by name' do
+      this {
+        subject._run({:a => 1}, {}, proc { puts a })
+      }.must_output "1\n"
+    end
+
+    it 'passes unknown calls to super' do
+      this {
+        subject.run({}, {}, proc { puts z })
+      }.must_raise NoMethodError
+    end
+  end
+
+end

data/spec/clive/option_spec.rb

@@ -1,34 +1,160 @@
-require 'spec_helper'
+$: << File.dirname(__FILE__) + '/..'
+require 'helper'
 
 describe Clive::Option do
-  subject { Clive::Option.new([:n, :names], "A test option") { $stdout.puts "hi" } }
+  subject { Clive::Option }
 
-  it_behaves_like "an option"
-  
-  describe "#run" do
-    it "calls the block" do
-      $stdout.should_receive(:puts).with("hi")
-      subject.run
+  def option_with(config, &block)
+    Clive::Option.new [:o, :opt], "", config, &block
+  end
+
+  describe '#initialize' do
+    it 'sorts names by size' do
+      subject.new([:zz, :a]).names.must_equal [:a, :zz]
+      subject.new([:aa, :z]).names.must_equal [:z, :aa]
+    end
+
+    let(:opt) { option_with :head => true, :args => '<a> <b>', :as => [String, Integer] }
+
+    it 'finds all options' do
+      opt.config.must_include :head
+      opt.config.wont_include :args
+    end
+
+    it 'uses default options when not set' do
+      opt.config.must_include :runner
+    end
+
+    describe 'setting :head' do
+      it 'is true if head is set to true' do
+        option_with(:head => true).config.must_contain :head => true
+      end
+
+      it 'is false otherwise' do
+        option_with({}).config.must_contain :head => false
+      end
+    end
+
+    describe 'setting :tail' do
+      it 'is true if tail is set to true' do
+        option_with(:tail => true).config.must_contain :tail => true
+      end
+
+      it 'is false otherwise' do
+        option_with({}).config.must_contain :tail => false
+      end
+    end
+
+    describe 'setting :boolean' do
+      it 'is true if boolean is set to true' do
+        option_with(:boolean => true).config.must_contain :boolean => true
+      end
+
+      it 'is false otherwise' do
+        option_with({}).config.must_contain :boolean => false
+      end
+    end
+
+    it 'creates the args list' do
+      opt.args.first.must_be_argument :name => :a, :type => Clive::Type::String
+      opt.args.last.must_be_argument :name => :b, :type => Clive::Type::Integer
     end
   end
-  
-  describe "#sort_name" do
-    it "returns the name to sort by" do
-      subject.sort_name.should == 'n'
+
+  describe '#name' do
+    it 'returns the long name' do
+      opt = subject.new [:opt, :o]
+      opt.name.must_equal :opt
+    end
+
+    it 'returns the short name if no long name exists' do
+      opt = subject.new [:o]
+      opt.name.must_equal :o
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns a string representation of the option' do
+      opt = subject.new [:o, :opt]
+      opt.to_s.must_equal "-o, --opt"
+    end
+
+    it 'adds a --[no-] prefix to boolean options' do
+      opt = subject.new [:o, :opt], "", :boolean => true
+      opt.to_s.must_equal "-o, --[no-]opt"
+    end
+
+    it 'uses dashes instead of underscores' do
+      opt = subject.new [:S, :super_long_option_name]
+      opt.to_s.must_equal "-S, --super-long-option-name"
     end
   end
-  
-  describe "#<=>" do
-    it "sorts by #sort_name" do
-      other = Clive::Option.new([:z, :apple], "Another") {}
-      (subject <=> other).should == -1
+
+  describe '#run' do
+    let(:block) { proc {} }
+
+    it 'calls Runner#_run with true if #boolean?' do
+      t = mock
+      t.expects(:_run).with([[:truth, true]], {}, block)
+      ot = option_with :boolean => true, :runner => t, &block
+      ot.run({}, [true])
+    end
+
+    it 'calls Runner#_run with false if #boolean?' do
+      f = mock
+      f.expects(:_run).with([[:truth, false]], {}, block)
+      of = option_with :boolean => true, :runner => f, &block
+      of.run({}, [false])
+    end
+
+    it 'calls Runner#_run with mapped args' do
+      r = mock
+      r.expects(:_run).with([[:a, 'a'], [:b, 'b']], {}, block)
+      o = option_with :args => '<a> <b>', :runner => r, &block
+      o.run({}, ['a', 'b'])
+    end
+
+    it 'sets state if no block exists' do
+      o = option_with :args => '<a> <b>'
+      state = Clive::StructHash.new
+      o.run state, ['a', 'b']
+      state[:opt].must_equal ['a', 'b']
     end
   end
-  
-  describe "#to_h" do
-    it "returns a hash for help" do
-      hsh = {"names" => subject.names_to_strings, "desc" => subject.desc}
-      subject.to_h.should == hsh
+
+  describe '#<=>' do
+    let(:heada) { subject.new [:a], "", :head => true }
+    let(:headz) { subject.new [:z], "", :head => true }
+    let(:taila) { subject.new [:a], "", :tail => true }
+    let(:tailz) { subject.new [:z], "", :tail => true }
+    let(:aaa)  { subject.new [:aaa] }
+    let(:zzz)  { subject.new [:zzz] }
+
+    it 'puts head?s first' do
+      heada.must_be :<, aaa
+      heada.must_be :<, zzz
+    end
+
+    it 'compares 2 head?s alphabetically' do
+      heada.must_be :<, headz
+    end
+
+    it 'puts tail?s last' do
+      taila.must_be :>, aaa
+      taila.must_be :>, zzz
+    end
+
+    it 'compares 2 tail?s alphabetically' do
+      taila.must_be :<, tailz
+    end
+
+    it 'compares options based on #name' do
+      aaa.must_be :<, zzz
+    end
+
+    it 'sorts options properly' do
+      [taila, headz, tailz, zzz, heada, aaa].sort.
+        must_equal [heada, headz, aaa, zzz, taila, tailz]
     end
   end
-end
+end