cp 0.0.1.pre1 → 0.0.1

data/lib/cp/version.rb

@@ -1,3 +1,3 @@
 module CP
-  VERSION = "0.0.1.pre1"
+  VERSION = "0.0.1"
 end

data/spec/app_spec.rb

@@ -8,43 +8,56 @@ describe CP::App do
   it_should_behave_like "it accepts commands"
   it_should_behave_like "it accepts options"
 
-  describe "#instance" do
-    it "should always return the same object" do
-      @target.should == CP::App.instance
+  describe "#error" do
+    it "should take one argument" do
+      CP::App.instance.method( :error ).arity.should === 1
+    end
+
+    it "should print the message" do
+      errors, output = trap_output do
+        CP::App.instance.error( "test error" )
+      end
+
+      errors.should match( /test error/ )
     end
   end
 
-  describe "#parser" do
-    it "should default to CmdParser" do
-      @target.parser.should == CP::Parsers::CmdParse
+  describe "#instance" do
+    it "should always return the same object" do
+      @target.should == CP::App.instance
     end
   end
 
   describe "#run" do
     it "should exist" do
-      @target.methods.include?( :run ).should be_true
+      CP::App.methods.include?( :run ).should be_true
     end
 
-    it "should not take any parameters" do
-      @target.method( :run ).arity.should === 0
+    it "should take an number of arguments" do
+      CP::App.method( :run ).arity.should === -1
     end
   end
 
   describe "properties" do
-    [:name, :version].each do |prop_name|
-      it "should accept a #{prop_name} property" do
-        prop_val = "0.1.1"
-
+    [:name, :version].each do |prop|
+      it "should accept a #{prop} property" do
+        value = "0.1.1"
         lambda {
-          @target.app prop_name, prop_val
-        }.should change( @target, prop_name ).from( nil ).to( prop_val )
+          @target.app prop, value
+        }.should change( @target, prop ).from( @target.send( prop ) ).to( value )
       end
     end
 
     it "should raise a ArgumentError when setting other properties" do
       lambda {
-        test_app.app :foo, "bar"
+        @target.app :foo, "bar"
       }.should raise_error( ArgumentError, /no such property/ )
     end
+
+    describe "#name" do
+      it "should default to the name of the script" do
+        @target.name.should === File.basename( $0 )
+      end
+    end
   end
 end

data/spec/command_spec.rb

@@ -2,7 +2,7 @@ require File.join( File.dirname( __FILE__ ), "support", "spec_helper" )
 
 describe CP::Command do
   before( :each ) do
-    @target = test_command
+    @target = CP::Command.new( :test )
   end
 
   it_should_behave_like "it accepts commands"
@@ -12,7 +12,6 @@ describe CP::Command do
     [
       [:description, "description"],
       [:summary,     "summary"],
-      [:execute,     lambda {}],
     ].each { |(attr, val)|
       it "defines a ##{attr} accessor" do
         lambda {
@@ -23,8 +22,8 @@ describe CP::Command do
   end
 
   describe "#new" do
-    it "takes one parameter" do
-      CP::Command.instance_method( :initialize ).arity.should === 1
+    it "takes 1 or 2 parameters" do
+      @target.method( :initialize ).arity.should === -2
     end
 
     it "takes a symbol" do
@@ -37,6 +36,13 @@ describe CP::Command do
       CP::Command.new( :test ).name.should === :test
     end
 
+    it "saves the block as #block" do
+      block_ran = false
+      @target.execute { block_ran = true }
+      @target.block.call( nil )
+      block_ran.should be_true
+    end
+
     it "yields itself" do
       yielded = nil
       c = CP::Command.new( :test ) do |cmd|

data/spec/cp_spec.rb

@@ -4,7 +4,7 @@ describe CP do
   describe "methods" do
     def assert_method_added( method )
       Object.new.methods.include?( method ).should be_false
-      App.new.methods.include?( method ).should be_true
+      TestApp.new.methods.include?( method ).should be_true
     end
 
     it "should define a app method" do

data/spec/has/commands_spec.rb

@@ -0,0 +1,10 @@
+require File.join( File.dirname( __FILE__ ), "..", "support", "spec_helper" )
+
+describe CP::Has::Commands do
+  before( :each ) do
+    class Target; include CP::Has::Commands; end
+    @target = Target.new
+  end
+
+  it_should_behave_like "it accepts commands"
+end

data/spec/has/options_spec.rb

@@ -0,0 +1,10 @@
+require File.join( File.dirname( __FILE__ ), "..", "support", "spec_helper" )
+
+describe CP::Has::Options do
+  before( :each ) do
+    class Target; include CP::Has::Options; end
+    @target = Target.new
+  end
+
+  it_should_behave_like "it accepts options"
+end

data/spec/option_spec.rb

@@ -9,10 +9,8 @@ describe CP::Option do
   describe "attributes" do
     [
       [:allowed,     ["foo", "bar"]],
-      [:block,       lambda{}],
       [:description, "description"],
       [:long,        "--short"],
-      [:required,    true],
       [:short,       "-s"],
       [:type,        String]
     ].each { |(attr, val)|
@@ -39,6 +37,29 @@ describe CP::Option do
     end
   end
 
+  describe "#block" do
+    it "should save the value" do
+      block = lambda {}
+      @target.block.call( "foo" )
+      @target.value.should === "foo"
+    end
+
+    it "should call the use's block" do
+      called = false
+      @target.block = lambda { |val| called = true }
+      @target.block.call( "value" )
+      called.should be_true
+    end
+  end
+
+  describe "#default" do
+    it "should be returned as the value when no value is set" do
+      @target.short = "-s VAL"
+      @target.default = "foo"
+      @target.value.should === "foo"
+    end
+  end
+
   describe "#name" do
     it "returns a symbol" do
       @target.name.is_a?( Symbol )
@@ -107,7 +128,7 @@ describe CP::Option do
     end
     it "sets the block from arguments" do
       ran = false
-      CP::Option.new( "-s", lambda{ ran = true } ).block.call
+      CP::Option.new( "-s", lambda{ ran = true } ).block.call( nil )
       ran.should be_true
     end
 
@@ -136,23 +157,30 @@ describe CP::Option do
     end
   end
 
-  describe "#long=" do
+  describe "#long" do
     it "parses the option, separating the option argument" do
-      o = CP::Option.new do |opt|
-        opt.long = "--switch VALUE"
-      end
-      o.arg.should == " VALUE"
-      o.long.should == "--switch"
+      @target.long = "--switch VALUE"
+      @target.arg.should == " VALUE"
+      @target.long.should == "--switch"
     end
   end
 
-  describe "#short=" do
+  describe "#required" do
+    it "defaults to false" do
+      @target.required?.should be_false
+    end
+
+    it "is converted to a boolean" do
+      @target.required = "not a boolean"
+      @target.required?.should be_true
+    end
+  end
+
+  describe "#short" do
     it "parses the option, separating the option argument" do
-      o = CP::Option.new do |opt|
-        opt.short = "-s VALUE"
-      end
-      o.arg.should == " VALUE"
-      o.short.should == "-s"
+      @target.short = "-s VALUE"
+      @target.arg.should == " VALUE"
+      @target.short.should == "-s"
     end
   end
 

data/spec/options_struct_spec.rb

@@ -0,0 +1,7 @@
+require File.join( File.dirname( __FILE__ ), "support", "spec_helper" )
+
+describe CP::OptionsStruct do
+  it "is a proper Struct" do
+    CP::OptionsStruct.new( :test ).should be_a( Struct )
+  end
+end

data/spec/runners/cmd_parse_spec.rb

@@ -1,47 +1,15 @@
-require File.join( File.dirname( __FILE__ ), "support", "spec_helper" )
+require File.join( File.dirname( __FILE__ ), "..", "support", "spec_helper" )
 
 describe CP::Runners::CmdParse do
   before( :each ) do
-    @target = test_app.parser
+    @target = CP::Runners::CmdParse.new( create_test_app )
   end
 
-  describe "#instance" do
-    it "should always return the same object" do
-      @target.should == CP::App.instance
-    end
-  end
-
-  describe "#parser" do
-    it "should default to CmdParser" do
-      @target.parser.should == CP::Parsers::CmdParse
-    end
-  end
-
-  describe "#run" do
-    it "should exist" do
-      @target.methods.include?( :run ).should be_true
-    end
-
-    it "should not take any parameters" do
-      @target.method( :run ).arity.should === 0
-    end
-  end
-
-  describe "properties" do
-    [:name, :version].each do |prop_name|
-      it "should accept a #{prop_name} property" do
-        prop_val = "0.1.1"
-
-        lambda {
-          @target.app prop_name, prop_val
-        }.should change( @target, prop_name ).from( nil ).to( prop_val )
-      end
-    end
+  it_should_behave_like "it is a runner"
 
-    it "should raise a ArgumentError when setting other properties" do
-      lambda {
-        test_app.app :foo, "bar"
-      }.should raise_error( ArgumentError, /no such property/ )
+  describe "#runner" do
+    it "return a CmdParse::CommandParser" do
+      @target.runner.should be_a( CmdParse::CommandParser )
     end
   end
 end

data/spec/support/lib/test_app_runner.rb

@@ -0,0 +1,16 @@
+class TestAppRunner
+  attr_reader :errors, :exit_status, :output
+
+  def run( *args )
+    @errors, @output = trap_output do
+      app = create_test_app
+      yield app if block_given?
+
+      begin
+        app.run *args
+      rescue SystemExit => e
+        @exit_status = e.status
+      end
+    end
+  end
+end

data/spec/support/shared_examples/commands_examples.rb

@@ -0,0 +1,52 @@
+shared_examples_for "it accepts commands" do
+  describe "#command" do
+    it "should return a Command" do
+      @target.command( :test ).should be_an_instance_of( CP::Command )
+    end
+
+    it "should return the existing Command" do
+      @target.command( :test ).should === @target.command( :test )
+    end
+
+    describe "automatic subcommand creation" do
+      it "should define the parent command" do
+        @target.command( "test foo" )
+        @target.command( :test ).commands.size.should === 1
+      end
+
+      it "should define subcommands when the name includes spaces" do
+        @target.command( :test )
+        lambda {
+          @target.command( "test foo" )
+        }.should_not change(){ @target.commands.size }.by( 1 )
+      end
+
+      it "should return the subcommand" do
+        @target.command( "test foo" ).name.should === :foo
+      end
+    end
+  end
+
+  describe "#commands" do
+    it "should return an array" do
+      @target.commands.should be_an_instance_of( Array )
+    end
+
+    it "should increase with each defined command" do
+      lambda {
+        @target.command( :test )
+      }.should change(){ @target.commands.size }.by( 1 )
+    end
+
+    it "should include each defined command" do
+      @target.commands.include?( @target.command( :test ) ).should be_true
+    end
+
+    it "should only allow one default command" do
+      lambda {
+        @target.command( :test ) { |c| c.default = true }
+        @target.command( :test2 ) { |c| c.default = true }
+      }.should raise_error( CP::CommandError, /only one/ )
+    end
+  end
+end

data/spec/support/shared_examples/options_examples.rb

@@ -0,0 +1,23 @@
+shared_examples_for "it accepts options" do
+  describe "#option" do
+    it "should return an Option" do
+      @target.option( "-s" ).should be_an_instance_of( CP::Option )
+    end
+  end
+
+  describe "#options" do
+    it "should return an array" do
+      @target.options.should be_an_instance_of( Array )
+    end
+
+    it "should increase with each defined option" do
+      lambda {
+        @target.option( "-s" )
+      }.should change(){ @target.options.length}.by( 1 )
+    end
+
+    it "should include each defined option" do
+      @target.options.include?( @target.option( "-s" ) ).should be_true
+    end
+  end
+end

data/spec/support/shared_examples/runner_examples.rb

@@ -0,0 +1,173 @@
+shared_examples_for "it is a runner" do
+  describe "#new" do
+    it "should take one parameter" do
+      @target.method( :initialize ).arity.should === 1
+    end
+  end
+
+  describe "arguments" do
+    it "should be passed to the command block" do
+      passed_args = nil
+
+      run( "test", "foo", "bar" ) do |app|
+        app.command( :test ) { |c|
+          c.execute { |args, opts| passed_args = args }
+        }
+      end
+
+      passed_args.should == ["foo", "bar"]
+    end
+  end
+
+  describe "commands" do
+    describe "invalid commands" do
+      it "should explain that it's not valid" do
+        run( "invalid" ).errors.should match( /'invalid' is not a (\w+ )+command/i )
+      end
+
+      it "should exit with a nonzero status" do
+        run( "invalid" ).exit_status.should_not === 0
+      end
+    end
+
+    describe "the help command" do
+      it "should exist" do
+        run( "help" ).exit_status.should === 0
+      end
+
+      it "should not overwrite a custom help command" do
+        custom_help_ran = false
+
+        run( "help" ) do |app|
+          app.command( :help ) do |c|
+            c.execute { custom_help_ran  = true }
+          end
+        end
+
+        custom_help_ran .should be_true
+      end
+    end
+  end
+
+  describe "options" do
+    describe "boolean options" do
+      describe "defaults" do
+        it "should allow a `true` default" do
+          passed_value = nil
+
+          run( "test" ) do |app|
+            app.command( :test ) { |c|
+              c.option( "--[no-]option" ) { |o| o.default = true }
+              c.execute { |args, opts| passed_value = opts.option }
+            }
+          end
+
+          passed_value.should be_true
+        end
+
+        it "should allow overriding of the `true` default" do
+          passed_value = nil
+
+          run( "test", "--no-option" ) do |app|
+            app.command( :test ) { |c|
+              c.option( "--[no-]option" ) { |o| o.default = true }
+              c.execute { |args, opts| passed_value = opts.option }
+            }
+          end
+
+          passed_value.should be_false
+        end
+      end
+    end
+
+    describe "default values" do
+      it "should pass them to the command block" do
+        passed_value = nil
+
+        run( "test" ) do |app|
+          app.command( :test ) { |c|
+            c.option( "--option VAL" ) { |o| o.default = "foo" }
+            c.execute { |args, opts| passed_value = opts.option }
+          }
+        end
+
+        passed_value.should === "foo"
+      end
+    end
+
+    describe "invalid options" do
+      it "should explain that it's not valid" do
+        run( "--invalid" ).errors.should match( /'--invalid' is not a valid option/i )
+      end
+
+      it "should exit with a nonzero status" do
+        run( "--invalid" ).exit_status.should_not === 0
+      end
+    end
+
+    describe "required options" do
+      describe "missing" do
+        before( :each ) do
+          @result = run( "test" ) do |app|
+            app.command( :test ) { |c|
+              c.option( "--option" ) { |o| o.required = true }
+              c.execute { |args, opts| }
+            }
+          end
+        end
+
+        it "should explain that the option is required" do
+          @result.errors.should match( /'--option' is required/i )
+        end
+
+        it "should exit with a nonzero status" do
+          @result.exit_status.should_not === 0
+        end
+      end
+    end
+
+    describe "the options struct" do
+      it "should be passed to the command block" do
+        opts_struct = nil
+
+        run( "test", "foo", "bar" ) do |app|
+          app.command( :test ) { |c|
+            c.execute { |args, opts| opts_struct = opts }
+          }
+        end
+
+        opts_struct.should be_a( Struct::Options )
+      end
+
+      it "should provide access to passed option values" do
+        passed_value = nil
+
+        run( "test", "--option", "foo" ) do |app|
+          app.command( :test ) { |c|
+            c.option( "--option FOO" )
+            c.execute { |args, opts| passed_value = opts.option }
+          }
+        end
+
+        passed_value.should === "foo"
+      end
+
+      it "should include parent options" do
+        passed_value = nil
+
+        run( "cmd", "sub1", "--option", "foo", "sub2" ) do |app|
+          app.command( :cmd ) { |cmd|
+            cmd.command( :sub1 ) { |sub1|
+              sub1.option( "--option FOO" )
+              sub1.command( :sub2 ) { |sub2|
+                sub2.execute { |args, opts| passed_value = opts.option }
+              }
+            }
+          }
+        end
+
+        passed_value.should === "foo"
+      end
+    end
+  end
+end