choosy 0.1.0 → 0.2.0

data/spec/choosy/dsl/super_command_builder_spec.rb

@@ -11,16 +11,16 @@ module Choosy::DSL
 
     describe :command do
       it "should add the command to the listing" do
-        @builder.command :foo do |foo|
-          foo.boolean :count, "The count"
+        @builder.command :foo do
+          boolean :count, "The count"
         end
 
         @command.listing.should have(1).item
       end
 
       it "should add the command builder to the command_builders" do
-        o = @builder.command :foo do |foo|
-          foo.integer :size, "The size"
+        o = @builder.command :foo do
+          integer :size, "The size"
         end
 
         @command.command_builders[:foo].should be(o.builder)
@@ -32,13 +32,31 @@ module Choosy::DSL
       end
 
       it "should be able to accept a new command as an argument" do
-        cmd = Choosy::Command.new :cmd do |c|
-          c.float :float, "Float"
+        cmd = Choosy::Command.new :cmd do
+          float :float, "Float"
         end
         @builder.command cmd
         @command.listing[0].should be(cmd)
       end
     end
+    
+    describe :parsimonious do
+      it "should not be parsimonous by default" do
+        @command.parsimonious?.should be_false
+      end
+
+      it "should set parsimonious" do
+        @builder.parsimonious
+        @command.parsimonious?.should be_true
+      end
+    end
+
+    describe :metaname do
+      it "should set the super command's metaname for the subcommands" do
+        @builder.metaname 'META'
+        @command.metaname.should eql('META')
+      end
+    end
 
     describe "standard options" do
       it "should also be able to set flags" do
@@ -47,6 +65,13 @@ module Choosy::DSL
       end
     end
 
+    describe :finalize! do
+      it "should set the metaname if not already set" do
+        @builder.finalize!
+        @command.metaname.should eql('COMMAND')
+      end
+    end
+
     describe :help do
       it "should create a help command when asked" do
         h = @builder.help
@@ -67,14 +92,14 @@ module Choosy::DSL
         it "should return the super command name when called without arguments" do
           h = @builder.help
           attempting {
-            h.argument_validation.call([])
-          }.should raise_error(Choosy::HelpCalled, :superfoo)
+            h.arguments.validation_step.call([])
+          }.should raise_error(Choosy::HelpCalled, nil)
         end
 
         it "should return the name of the first argument when called, as a symbol" do
           h = @builder.help
           attempting {
-            h.argument_validation.call(['foo'])
+            h.arguments.validation_step.call(['foo'])
           }.should raise_error(Choosy::HelpCalled, :foo)
         end
       end

data/spec/choosy/parser_spec.rb

@@ -5,6 +5,8 @@ require 'choosy/dsl/command_builder'
 
 module Choosy
   class ParserBuilder
+    attr_reader :command, :lazy
+
     def initialize
       @terminals = nil
       @lazy = false
@@ -26,17 +28,22 @@ module Choosy
       self
     end
 
-    def boolean(sym, default=nil)
+    def boolean(sym, default=nil, negated=nil)
       default ||= false
-      @command.alter do |c|
-        c.boolean(sym, sym.to_s, :default => default)
+      negated ||= false
+      @command.alter do
+        boolean(sym, sym.to_s, :default => default) do
+          if negated
+            negate
+          end
+        end
       end
       self
     end
 
     def single(sym)
-      @command.alter do |c|
-        c.single(sym, sym.to_s)
+      @command.alter do
+        single(sym, sym.to_s)
       end
       self
     end
@@ -44,9 +51,9 @@ module Choosy
     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
+      @command.alter do
+        multiple(sym, sym.to_s) do
+          count :at_least => min, :at_most => max
         end
       end
       self
@@ -149,6 +156,21 @@ module Choosy
         res.options.should eql({:o => true})
       end
 
+      it "should handle negated boolean arguments" do
+        @pb.boolean(:o, false, true)
+        @pb.build.flags['--no-o'].should_not be_nil
+      end
+
+      it "should handle a negated boolean argument" do
+        res = @pb.boolean(:o, false, true).parse!('--no-o')
+        res.options.should eql({:o => false})
+      end
+
+      it "should handle a negated boolean argument whose default is true" do
+        res = @pb.boolean(:o, true, true).parse!('--no-o')
+        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})

data/spec/choosy/printing/color_spec.rb

@@ -52,23 +52,37 @@ module Choosy::Printing
     end
 
     it "should return a formatted string for just the color code when no args are given" do
-      @c.red.should eql("e31[m")
+      @c.red.should eql("\e[31m")
     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")
+      @c.red("this").should eql("\e[31mthis\e[0m")
     end
 
     it "should recognize when the foreground is being set" do
-      @c.red("this", :foreground).should eql("e31[mthise0[m")
+      @c.red("this", :foreground).should eql("\e[31mthis\e[0m")
     end
 
     it "should recognize when the background is being set" do
-      @c.red("this", :background).should eql("e41[mthise0[m")
+      @c.red("this", :background).should eql("\e[41mthis\e[0m")
     end
 
     it "should also handle effects" do
-      @c.blink("this").should eql("e5[mthise0[m")
+      @c.blink("this").should eql("\e[5mthis\e[0m")
+    end
+    
+    it "should fail when effects are handed too many parameters" do
+      attempting {
+        @c.blink("this", :noarg)
+      }.should raise_error(ArgumentError, /max 1/)
+    end
+
+    it "should not add an extra reset to the end if decorated more than once" do
+      @c.red(@c.blink("this")).should eql("\e[31m\e[5mthis\e[0m")
+    end
+
+    it "should be able to format multiple items" do
+      @c.multiple("this", [:red, :blink]).should eql("\e[5m\e[31mthis\e[0m")
     end
   end
 end

data/spec/choosy/printing/help_printer_spec.rb

@@ -1,117 +1,196 @@
 require 'spec_helpers'
 require 'choosy/command'
+require 'choosy/super_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
+      @c = Choosy::Command.new :foo do
+        summary "This is a fairly long summary that should wrap around the whole screen at least once, so that I can test whether it's properly formatted"
+
+        header 'DESCRIPTION'
+        para 'This is a description of this command that should span'
+        para '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.'
+
+        header 'OPTIONS'
+        boolean :evaluate, "The evaluation of some boolean something or other that really should span at least 3 lines of continuous text for testing the output of the option command."
+        integer :count, "The count of something that should also really span multiple lines, if possible."
+        boolean_ :debug, "Debug output"
+        version "1.2"
+        help
+
+        arguments do
+          metaname 'FOOS'
+          count 0..3
+        end
       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
+      @b = @c.builder
 
-    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
+      @s = Choosy::SuperCommand.new :super do
+        printer :standard, :color => true, :header_styles => [:bold, :blue]
+        command @c
+        metaname 'CMDS'
 
-    it "should now how to format a usage string" do
-      o = capture :stdout do
-        @h.print_usage(@c)
+        boolean :bold, "Bold"
       end
 
-      o.should eql("USAGE: foo [OPTIONS]\n")
+      @h = @s.printer
     end
 
-    it "should show the usage string if it accepts extra arguments" do
-      @c.alter do |foo|
-        foo.arguments do |args|
-        end
+    describe :print_usage do
+      it "should know how to format a regular command" do
+        @h.color.disable!
+        @h.columns = 60
+        @h.print_usage(@c)
+
+        @h.buffer.should eql("Usage: foo [-e|--evaluate] [-c|--count=COUNT] [--debug]
+           [--version] [-h|--help] FOOS\n")
       end
 
-      o = capture :stdout do
-        @h.print_usage(@c)
+      it "should know how to format a super command" do
+        @h.color.disable!
+        @h.columns = 60
+        @h.print_usage(@s)
+
+        @h.buffer.should eql("Usage: super [-b|--bold] CMDS\n")
       end
+    end
 
-      o.should eql("USAGE: foo [OPTIONS] [ARGS]\n")
+    it "should write a header, properly colored" do
+      @h.print_header("option")
+      @h.buffer.should eql("\e[34m\e[1moption\e[0m")
     end
 
-    it "should print a newline on an empty separator" do
-      o = capture :stdout do
-        @h.print_separator("")
-      end
+    it "should print out a formatted header" do
+      @h.print_element(@c.listing[0])
+      @h.buffer.should eql("\n\e[34m\e[1mDESCRIPTION\e[0m\n")
+    end
 
-      o.should eql("\n\n")
+    it "should print out a formatting element correctly" do
+      @h.print_element(@c.listing[1])
+      @h.buffer.should eql("\n  This is a description of this command that should span\n")
     end
 
-    it "should print a line with separator text" do
-      o = capture :stdout do
-        @h.print_separator("this line")
-      end
+    it "should wrap lines in a paragraph correctly" do
+      @h.columns = 70
+      @h.print_element(@c.listing[2])
+      @h.buffer.should eql("\n  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.\n")
+    end
+
+    it "should print out an option on multiple lines" do
+      @h.columns = 70
+      @h.print_option(@c.listing[4], '-e, --evaluate', ' ' * 20)
+      @h.buffer.should eql('  -e, --evaluate    The evaluation of some boolean something or other
+                    that really should span at least 3 lines of
+                    continuous text for testing the output of the
+                    option command.
+')
+    end
 
-      o.should eql("\nthis line\n")
+    it "should print out any commands that are present" do
+      @h.columns = 70
+      @h.print_command(@c, 'foo', '         ')
+      @h.buffer.should eql("  foo    This is a fairly long summary that should wrap around the
+         whole screen at least once, so that I can test whether it's
+         properly formatted\n")
     end
 
-    it "should print out a command" do
-      o = capture :stdout do
-        @h.print_command(@c)
+    describe "for the usage line" do
+      it "should format a full boolean option" do
+        o = @b.boolean :bold, "bold"
+        @h.usage_option(o).should eql("[-b|--bold]")
       end
 
-      o.should eql("  foo\tThis is a summary of a command.\n")
-    end
+      it "should format a partial boolean option" do
+        o = @b.boolean_ :bold, "bold"
+        @h.usage_option(o).should eql('[--bold]')
+      end
 
-    it "should print the summary, if present" do
-      o = capture :stdout do
-        @h.print_summary(@c.summary)
+      it "should format a short boolean option" do
+        o = @b.option :bold do
+          short '-b'
+        end
+        @h.usage_option(o).should eql('[-b]')
       end
 
-      o.should eql("  This is a summary of a command.\n")
-    end
+      it "should format a negation of a boolean option" do
+        o = @b.boolean :bold, "Bold!!" do
+          negate 'un'
+        end
+        @h.usage_option(o).should eql('[-b|--bold|--un-bold]')
+      end
+
+      it "should format a full single option" do
+        o = @b.single :color, "color"
+        @h.usage_option(o).should eql('[-c|--color=COLOR]')
+      end
 
-    it "should print out an option on 2 lines." do
-      o = capture :stdout do
-        @h.print_option(@c.listing[2])
+      it "should format a parial boolean option" do
+        o = @b.single_ :color, "color"
+        @h.usage_option(o).should eql('[--color=COLOR]')
+      end
+      
+      it "shoudl format a full multiple option" do 
+        o = @b.multiple :colors, "c"
+        @h.usage_option(o).should eql('[-c|--colors COLORS+]')
       end
 
-      o.should eql("  -c, --count COUNT\n       The count\n")
+      it "should format a partial multiple option" do
+        o = @b.multiple_ :colors, "c"
+        @h.usage_option(o).should eql('[--colors COLORS+]')
+      end
     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)
+    describe "for the option line" do
+      it "should format a full boolean option" do
+        o = @b.boolean :bold, "b"
+        @h.regular_option(o).should eql('-b, --bold')
       end
 
-      o.should eql(<<EOF
+      it "should format a partial boolean option" do
+        o = @b.boolean_ :bold, "b"
+        @h.regular_option(o).should eql('    --bold')
+      end
 
-DESCRIPTION
-  This is a description of this command that should span
+      it "should format a short boolean option" do
+        o = @b.option :bold do |b|
+          b.short '-b'
+        end
 
-  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
-                  )
+        @h.regular_option(o).should eql('-b')
+      end
+
+      it "should format a negation of an option" do
+        o = @b.boolean :bold, "Bold" do
+          negate 'un'
+        end
+
+        @h.regular_option(o).should eql('-b, --[un-]bold')
+      end
+
+      it "should format a full single option" do
+        o = @b.single :color, "color"
+        @h.regular_option(o).should eql('-c, --color COLOR')
+      end
+
+      it "should format a partial single option" do
+        o = @b.single_ :color, "color"
+        @h.regular_option(o).should eql('    --color COLOR')
+      end
+
+      it "should format a full multiple option" do
+        o = @b.multiple :colors, "colors"
+        @h.regular_option(o).should eql('-c, --colors COLORS+')
+      end
+
+      it "should format a partial multiple option" do
+        o = @b.multiple_ :colors, "colors"
+        @h.regular_option(o).should eql('    --colors COLORS+')
+      end
     end
   end
 end