choosy 0.1.0

data/spec/choosy/parser_spec.rb

@@ -0,0 +1,275 @@
+require 'spec_helpers'
+require 'choosy/parser'
+require 'choosy/command'
+require 'choosy/dsl/command_builder'
+
+module Choosy
+  class ParserBuilder
+    def initialize
+      @terminals = nil
+      @lazy = false
+      @command = Choosy::Command.new(:parser)
+    end
+
+    def lazy!
+      @lazy = true
+      self
+    end
+
+    def parse!(*args)
+      parser = build
+      parser.parse!(args)
+    end
+
+    def terminals(*terms)
+      @terminals = terms
+      self
+    end
+
+    def boolean(sym, default=nil)
+      default ||= false
+      @command.alter do |c|
+        c.boolean(sym, sym.to_s, :default => default)
+      end
+      self
+    end
+
+    def single(sym)
+      @command.alter do |c|
+        c.single(sym, sym.to_s)
+      end
+      self
+    end
+
+    def multiple(sym, min=nil, max=nil)
+      min ||= 1
+      max ||= 1000
+      @command.alter do |c|
+        c.multiple(sym, sym.to_s) do |m|
+          m.count :at_least => min, :at_most => max
+        end
+      end
+      self
+    end
+
+    def build
+      Parser.new(@command, @lazy, @terminals)
+    end
+  end
+
+  describe Parser do
+    before :each do
+      @pb = ParserBuilder.new
+    end
+
+    describe "with no options" do
+      it "should handle everyting after the '--'" do
+        @pb.parse!('--', '-a', 'not an option').args.should have(2).items
+      end
+
+      it "should be able to parse a list of unremarvable objects" do
+        @pb.parse!('a', 'b', 'c').args.should have(3).items
+      end
+
+      it "should stop when it encounters a terminal" do
+        @pb.terminals('a', 'b')
+        res = @pb.parse!('c', 'n', 'b', 'q')
+        res.args.should eql(['c', 'n'])
+        res.unparsed.should eql(['b', 'q'])
+      end
+
+      it "should capture even if the first item is a terminal" do
+        res = @pb.terminals('a').parse!('a', 'b')
+        res.unparsed.should eql(['a', 'b'])
+      end
+    end
+
+    describe "when being built" do
+      it "should fail when duplicate short options are given" do
+        @pb.boolean :opt
+        @pb.boolean :opt2
+        attempting {
+          @pb.build
+        }.should raise_error(Choosy::ConfigurationError, /Duplicate option: '-o'/)
+      end
+
+      it "should fail when duplicate long options are given" do
+        @pb.boolean :opt
+        @pb.boolean :Opt
+        attempting {
+          @pb.build
+        }.should raise_error(Choosy::ConfigurationError, /Duplicate option: '--opt'/)
+      end
+    end
+
+    describe "while unsuccessfully parsing arguments" do
+      it "should fail with an unassociated '-'" do
+        attempting {
+          @pb.parse!('a', '-')
+        }.should raise_error(Choosy::ParseError, /'-'/)
+      end
+
+      it "should fail on unrecognized option" do
+        attempting {
+          @pb.parse!('a', '-l')
+        }.should raise_error(Choosy::ParseError, "Unrecognized option: '-l'")
+      end
+
+      it "should fail when a boolean argument attaches an argument" do
+        attempting {
+          @pb.boolean(:o).parse!('-o=blah')
+        }.should raise_error(Choosy::ParseError, "Argument given to boolean flag: '-o=blah'")
+      end
+
+      it "should fail when a required argument is missing" do
+        attempting {
+          @pb.single(:option).parse!('-o')
+        }.should raise_error(Choosy::ParseError, "Argument missing for option: '-o'")
+      end
+
+      describe "of multiple arity" do
+        it "should fail when not enough arguments are provided after the '='" do
+          attempting {
+            @pb.multiple(:option, 2).parse!('-o=Opt')
+          }.should raise_error(Choosy::ParseError, "The '-o' flag requires at least 2 arguments")
+        end
+
+        it "should fail when not enough arguments are provided" do
+          attempting {
+            puts @pb.multiple(:option, 3).parse!('-o', 'Opt', 'OO').options
+          }.should raise_error(Choosy::ParseError, "The '-o' flag requires at least 3 arguments")
+        end
+      end
+    end
+
+    describe "while successfully parsing options" do
+      it "should handle a single short boolean argument" do
+        res = @pb.boolean(:o).parse!('-o')
+        res.args.should be_empty
+        res.options.should eql({:o => true})
+      end
+
+      it "should handle a boolean flag whose default is true" do
+        res = @pb.boolean(:opt, true).parse!('-o')
+        res.options.should eql({:opt => false})
+      end
+
+      it "should handle a flag with an arity of 1" do
+        res = @pb.single(:option).parse!('-o', 'Opt')
+        res.args.should be_empty
+        res.options.should eql({:option => 'Opt'})
+      end
+
+      it "should handle a flag of arity 1 with an '=' sign" do
+        res = @pb.single(:option).parse!('-o=Opt')
+        res.args.should be_empty
+        res.options.should eql({:option => 'Opt'})
+      end
+
+      describe "of multiple arity" do
+        it "should parse a single argument" do
+          res = @pb.multiple(:option).parse!('-o', 'Opt')
+          res.args.should be_empty
+          res.options.should eql({:option => ['Opt']})
+        end
+
+        it "should leave args at the end if limited in size" do
+          res = @pb.multiple(:option, 1, 2).parse!('-o', '1', '2', '3')
+          res.args.should eql(['3'])
+          res.options.should eql({:option => ['1', '2']})
+        end
+
+        it "should handle the '-' part to end argument parsing to options" do
+          res = @pb.multiple(:option).parse!('-o', '1', '2', '-', '3')
+          res.args.should eql(['3'])
+          res.options.should eql({:option => ['1', '2']})
+        end
+      end
+
+      describe "in combination" do
+        it "should handle multiple boolean flags" do
+          @pb.boolean(:abs)
+          @pb.boolean(:not)
+          res = @pb.parse!('-a', '-n', 'q')
+          res.args.should eql(['q'])
+          res.options.should eql({:abs => true, :not => true})
+        end
+
+        it "should be able to hantld multi-arg options and booleans" do
+          @pb.boolean(:abs)
+          @pb.multiple(:mult)
+          res = @pb.parse!('a', '-m', 'b', 'c', '-a', 'c')
+          res.args.should eql(['a', 'c'])
+          res.options.should eql({:abs => true, :mult => ['b', 'c']})
+        end
+
+        it "should be able to handle multiple single arg options" do
+          @pb.single(:sub)
+          @pb.single(:add)
+          res = @pb.parse!('-s', '1', '3', '-a', '2', '4')
+          res.args.should eql(['3', '4'])
+          res.options.should eql({:sub => '1', :add => '2'})
+        end
+      end
+    end
+
+    describe "while being lazy" do
+      it "should keep extra arguments as unparsed" do
+        res = @pb.lazy!.parse!('a', 'b')
+        res.unparsed.should eql(['a', 'b'])
+      end
+
+      it "should simply retain the '-' character" do
+        res = @pb.lazy!.parse!('a', '-', 'b')
+        res.unparsed.should eql(['a', '-', 'b'])
+      end
+
+      it "should feed args after '--'" do
+        res = @pb.lazy!.parse!('a', '--', 'z')
+        res.unparsed.should eql(['a', '--', 'z'])
+      end
+
+      it "should skip options it doesn't capture" do
+        res = @pb.lazy!.parse!('-a', 'b')
+        res.unparsed.should eql(['-a', 'b'])
+        res.options.should eql({})
+      end
+
+      it "should skip irrelevant boolean args" do
+        res = @pb.lazy!.boolean(:opt).parse!('a', '-b', '--opt', 'c')
+        res.unparsed.should eql(['a', '-b', 'c'])
+      end
+
+      it "should capture relevant boolean args" do
+        res = @pb.lazy!.boolean(:opt).parse!('a', '-b', '--opt', 'c')
+        res.options.should eql({:opt => true})
+      end
+
+      it "should capture relevant 1 arity args" do
+        res = @pb.lazy!.single(:opt).parse!('-a', 'n', '-o', 'i', 'q')
+        res.options.should eql({:opt => 'i'})
+      end
+
+      it "should skip uncaptured 1 arity args" do
+        res = @pb.lazy!.single(:opt).parse!('-a', 'n', '-o', 'i', 'q')
+        res.unparsed.should eql(['-a', 'n', 'q'])
+      end
+
+      it "should capture multipe argument items" do
+        res = @pb.lazy!.multiple(:opt).parse!('-a', '-o', 'r', 's', 't', '-', 'q')
+        res.options.should eql({:opt => ['r', 's', 't']})
+      end
+
+      it "should skip anything stopped by the '-' in a multi-arg parse" do
+        res = @pb.lazy!.multiple(:opt).parse!('-a', '-o', 'r', 's', 't', '-', 'q')
+        res.unparsed.should eql(['-a', 'q'])
+      end
+
+      it "should include the terminals in the unparsed part" do
+        res = @pb.lazy!.boolean(:a).terminals('b', 'c').parse!('q', '-a', 'b', 'c')
+        res.unparsed.should eql(['q', 'b', 'c'])
+      end
+    end#lazy
+  end
+end
+

data/spec/choosy/printing/color_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helpers'
+require 'choosy/printing/color'
+
+module Choosy::Printing
+  describe Color do
+    before :each do
+      @c = Color.new
+    end
+
+    it "should be enabled when run from the command line" do
+      @c.disabled?.should be(false)
+    end
+
+    it "should not respond to random colors" do
+      attempting {
+        @c.non_color
+      }.should raise_error(NoMethodError)
+    end
+  
+    it "should respond to colors" do
+      Color::COLORS.each_key do |k|
+        @c.respond_to?(k).should be(true)
+      end
+    end
+
+    it "should respond to effects" do
+      Color::EFFECTS.each_key do |k|
+        @c.respond_to?(k).should be(true)
+      end
+    end
+    
+    it "should return the string itself if not enabled" do
+      @c.disable!
+      @c.red("this").should eql("this")
+    end
+
+    it "should return an empty string if not enabled" do
+      @c.disable!
+      @c.red.should eql("")
+    end
+
+    it "should fail on too many arguments" do
+      attempting {
+        @c.red("string", :foreground, "extra")
+      }.should raise_error(ArgumentError, /Color#red/)
+    end
+
+    it "should fail when setting a style not foreground or background" do
+      attempting {
+        @c.red("string", :no_method) 
+      }.should raise_error(ArgumentError, /:foreground or :background/)
+    end
+
+    it "should return a formatted string for just the color code when no args are given" do
+      @c.red.should eql("e31[m")
+    end
+
+    it "should return a formatted string with a reset if a full string is supplied" do
+      @c.red("this").should eql("e31[mthise0[m")
+    end
+
+    it "should recognize when the foreground is being set" do
+      @c.red("this", :foreground).should eql("e31[mthise0[m")
+    end
+
+    it "should recognize when the background is being set" do
+      @c.red("this", :background).should eql("e41[mthise0[m")
+    end
+
+    it "should also handle effects" do
+      @c.blink("this").should eql("e5[mthise0[m")
+    end
+  end
+end

data/spec/choosy/printing/help_printer_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helpers'
+require 'choosy/command'
+require 'choosy/printing/help_printer'
+
+module Choosy::Printing
+  describe HelpPrinter do
+    before :each do
+      @h = HelpPrinter.new
+      @c = Choosy::Command.new :foo do |foo|
+        foo.summary "This is a summary of a command."
+        foo.desc <<EOF
+This is a description of this command that should span
+
+multiple lines and carry itself beyond the average line length when actually called out from the unit tests itself so that we can correctly guage the line wrapping.
+EOF
+        foo.separator
+        foo.boolean :evaluate, "The evaluation"
+        foo.integer :count, "The count"
+        foo.separator
+
+        foo.separator 'Indifferent options:'
+        foo.boolean :debug, "Debug output"
+        foo.version "1.2"
+        foo.help
+      end
+    end
+
+    it "should know the width of the screen, if possible, or set a default [COULD BREAK ON YOUR MACHINE]" do
+      @h.columns.should satisfy {|c| c >= HelpPrinter::DEFAULT_COLUMN_COUNT }
+    end
+
+    it "should know the lenght the screen, if possible, or set a default [COULD BREAK ON YOUR MACHINE]" do
+      @h.lines.should satisfy {|l| l >= HelpPrinter::DEFAULT_LINE_COUNT }
+    end
+
+    it "should now how to format a usage string" do
+      o = capture :stdout do
+        @h.print_usage(@c)
+      end
+
+      o.should eql("USAGE: foo [OPTIONS]\n")
+    end
+
+    it "should show the usage string if it accepts extra arguments" do
+      @c.alter do |foo|
+        foo.arguments do |args|
+        end
+      end
+
+      o = capture :stdout do
+        @h.print_usage(@c)
+      end
+
+      o.should eql("USAGE: foo [OPTIONS] [ARGS]\n")
+    end
+
+    it "should print a newline on an empty separator" do
+      o = capture :stdout do
+        @h.print_separator("")
+      end
+
+      o.should eql("\n\n")
+    end
+
+    it "should print a line with separator text" do
+      o = capture :stdout do
+        @h.print_separator("this line")
+      end
+
+      o.should eql("\nthis line\n")
+    end
+
+    it "should print out a command" do
+      o = capture :stdout do
+        @h.print_command(@c)
+      end
+
+      o.should eql("  foo\tThis is a summary of a command.\n")
+    end
+
+    it "should print the summary, if present" do
+      o = capture :stdout do
+        @h.print_summary(@c.summary)
+      end
+
+      o.should eql("  This is a summary of a command.\n")
+    end
+
+    it "should print out an option on 2 lines." do
+      o = capture :stdout do
+        @h.print_option(@c.listing[2])
+      end
+
+      o.should eql("  -c, --count COUNT\n       The count\n")
+    end
+    
+    it "should print out any commands that are present"
+
+    it "should print out the description" do
+      @h.columns = 80
+      o = capture :stdout do
+        @h.print_description(@c.description)
+      end
+
+      o.should eql(<<EOF
+
+DESCRIPTION
+  This is a description of this command that should span
+
+  multiple lines and carry itself beyond the average line length when actually
+  called out from the unit tests itself so that we can correctly guage the line
+  wrapping.
+EOF
+                  )
+    end
+  end
+end

data/spec/choosy/super_command_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helpers'
+require 'choosy/super_command'
+
+module Choosy
+  describe SuperCommand do
+    before :each do 
+      @c = SuperCommand.new :superfoo
+    end
+
+    describe :parse! do
+      it "should be able to print out the version number" do
+        @c.alter do |c|
+          c.version "superblah"
+        end
+
+        o = capture :stdout do
+          @c.parse!(['--version'])
+        end
+
+        o.should eql("superblah\n")
+      end
+
+      it "should print out the supercommand help message" do
+        @c.alter do |c|
+          c.help
+        end
+
+        o = capture :stdout do
+          @c.parse!([])
+        end
+
+        o.should match(/USAGE:/)
+      end
+
+      it "should print out a subcommand help message" do
+        @c.alter do |c|
+          c.help
+          c.command :bar do |bar|
+            bar.boolean :count, "The count"
+          end
+        end
+
+        o = capture :stdout do
+          @c.parse!(['help', 'bar'])
+        end
+
+        o.should match(/--count/)
+      end
+    end#parse!
+
+    describe :execute! do
+      it "should fail when no executor is present" do
+        @c.alter do |c|
+          c.command :bar do |bar|
+            bar.boolean :count, "The count"
+          end
+        end
+
+        attempting {
+          @c.execute!(['bar', '--count'])
+        }.should raise_error(Choosy::ConfigurationError, /No executor/)
+      end
+
+      it "should call the executors" do
+        count = 0
+        @c.alter do |c|
+          c.command :bar do |bar|
+            bar.integer :count, "The count"
+            bar.executor do |opts, args|
+              count = opts[:count]
+            end
+          end
+        end
+
+        @c.execute!(['bar', '--count', '5'])
+        count.should eql(5)
+      end
+    end#execute!
+  end
+end

data/spec/choosy/super_parser_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helpers'
+require 'choosy/super_parser'
+require 'choosy/super_command'
+
+module Choosy
+  class SuperParserBuilder
+    attr_reader :super
+    
+    def initialize
+      @super = Choosy::SuperCommand.new :super
+      @parsimonious = false
+    end
+
+    def command(name)
+      @super.alter do |a|
+        a.command name do |c|
+          yield c if block_given?
+        end
+      end
+      self
+    end
+
+    def single(name)
+      @super.alter do |a|
+        a.single name, name.to_s
+      end
+      self
+    end
+
+    def parse!(*args)
+      parser = build
+      parser.parse!(args)
+    end
+
+    def parsimonious!
+      @parsimonious = true
+    end 
+
+    def build
+      SuperParser.new(@super, @parsimonious)
+    end
+  end
+
+  describe SuperParser do
+    before :each do
+      @p = SuperParserBuilder.new
+    end
+
+    describe "without any subcommands" do
+      it "should fail with a regular global options" do
+        attempting {
+          @p.single(:count).parse!('--count', '5')
+        }.should raise_error(Choosy::SuperParseError, /requires a command/)
+      end
+
+      it "should fail on unrecognized subcommands" do
+        attempting {
+          @p.single(:count).parse!('baz')
+        }.should raise_error(Choosy::SuperParseError, /unrecognized command: 'baz'/)
+      end
+
+      it "should fail on unrecognized options" do
+        attempting {
+          @p.parse!('--here')
+        }.should raise_error(Choosy::SuperParseError, /unrecognized option: '--here'/)
+      end
+
+      it "should raise a HelpCalled error when a help command is defined" do
+        @p.super.builder.help
+        attempting {
+          @p.parse!()
+        }.should raise_error(Choosy::HelpCalled, :super)
+      end
+    end
+
+    describe "with subcommands" do
+      describe "being liberal" do
+        it "should be able to parse a single subcommand" do
+          @p.command(:bar).parse!('bar').subresults.should have(1).item
+        end
+
+        it "should merge parent option with child commands" do
+          @p.single(:count).command(:bar).parse!('bar').subresults[0].options.should eql({:count => nil})
+        end
+
+        it "should merge parent option value with child" do
+          @p.single(:count).command(:bar).parse!('bar', '--count', '3').subresults[0].options.should eql({:count => '3'})
+        end
+          
+        it "should collect other names of commands as arguments" do
+          @p.command(:bar).command(:baz).parse!('bar', 'baz').subresults.should have(1).item
+        end
+      end
+
+      describe "being parsimonious" do
+        before :each do
+          @p.parsimonious!
+        end
+
+        it "should parse separate commands" do
+          @p.command(:bar).command(:baz).parse!('bar', 'baz').subresults.should have(2).items
+        end
+      end
+    end
+  end
+end