amp-front 0.1.0

data/spec/amp-front_spec.rb

@@ -0,0 +1,25 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Amp do
+  it "has a version" do
+    Amp::VERSION.should_not be_nil
+  end
+  
+  it "has a version title" do
+    Amp::VERSION_TITLE.should_not be_nil
+  end
+end

data/spec/command_specs/base_spec.rb

@@ -0,0 +1,123 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'amp-front/dispatch/commands/base'
+
+describe Amp::Command::Base do
+  before do
+    @klass = Class.new(Amp::Command::Base)
+  end
+  
+  describe '#call' do
+    it "sets the instance's options before running on_call" do
+      input_opts = {:a => :b}
+      received_opts = nil
+      @klass.on_call { received_opts = options }
+      @klass.new.call(input_opts, nil)
+      received_opts.should == input_opts
+    end
+    
+    it "sets the instance's arguments before running on_call" do
+      input_args = [1, 2, 3]
+      received_args = nil
+      @klass.on_call { received_args = arguments }
+      @klass.new.call(nil, input_args)
+      received_args.should == input_args
+    end
+  end 
+  
+  describe '#on_call' do
+    it "sets the class's on_call handler when a block is given" do
+      flag = false
+      @klass.on_call { flag = true }
+      @klass.new.call(nil, nil)
+      flag.should be_true
+    end
+    
+    it 'returns the current handler if no block is given' do
+      @klass.on_call.should == nil
+      @klass.on_call { puts 'hello' }
+      @klass.on_call.should_not == nil
+      @klass.on_call.should respond_to(:call)
+    end
+  end
+  
+  describe '#opt' do
+    it 'adds an option to the command class' do
+      @klass.options.should == []
+      @klass.opt :verbose, 'Provide verbose output', :type => :boolean
+      @klass.options.should == [[:verbose, 'Provide verbose output',
+                                {:type => :boolean}]
+                               ]
+    end
+  end
+  
+  describe '#collect_options' do
+    context 'with no options specified' do
+      it 'returns a nearly empty hash' do
+        @klass.new.collect_options([]).first.should == {:help => false}
+      end
+    end
+    
+    context 'with --verbose specified' do
+      before do
+        @klass.opt :verbose, 'Text', :type => :boolean
+      end
+
+      context 'with --verbose not provided' do
+        it 'returns :verbose_given => false' do
+          opts,args = @klass.new.collect_options([])
+          opts[:verbose_given].should be_false
+        end
+      end
+      
+      context 'with --verbose provided' do
+        it 'returns :verbose_given => true, :verbose => true' do
+          opts,args = @klass.new.collect_options(['--verbose'])
+          opts[:verbose_given].should be_true
+          opts[:verbose].should be_true
+        end
+
+        it 'leaves ARGV alone' do
+          swizzling_argv(['--verbose']) do
+            @klass.new.collect_options([])
+            ARGV.should == ['--verbose']
+          end
+        end
+
+        it 'returns modified arguments' do
+          arguments = ['--verbose']
+          opts,args = @klass.new.collect_options(arguments)
+          arguments.should == ['--verbose']
+          args.should == []
+        end
+      end
+    end
+  end
+
+  it 'should have a name' do
+    @klass.name.should_not be_nil
+  end
+
+  describe '#all_commands' do
+    it 'should not include nil' do
+      @klass.all_commands.should_not include(nil)
+    end
+
+    it 'should have itself' do
+      @klass.all_commands.should include(@klass)
+    end
+  end
+end

data/spec/command_specs/command_spec.rb

@@ -0,0 +1,97 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'amp-front/dispatch/commands/base.rb'
+
+describe Amp::Command do
+  it 'should fail to look up a nonexistent command' do
+    Amp::Command.for_name('sillyzargbyl --verbose').should be_nil
+  end
+
+  context 'when created with a specific name' do
+    before do
+      @name = next_name
+      @command_name = @name.capitalize
+      @class = Amp::Command.create(@command_name) do |c|
+        c.desc 'Hello'
+        c.opt :verbose, "Verbose output", :type => :boolean
+      end
+    end
+    
+    it 'creates the named class as a submodule of Amp::Command' do
+      Amp::Command.const_get(@command_name).should == @class
+    end
+    
+    it 'uppercases the first letter of the name' do
+      klass = Amp::Command.create('search0') {|c| }
+      Amp::Command.const_get('Search0').should == klass
+    end
+    
+    it 'stores the new subclass in the all_commands list' do
+      Amp::Command::Base.all_commands.should include(@class)
+    end
+    
+    it 'can be looked up by for_name' do
+      Amp::Command.for_name(@command_name).should == @class
+    end
+    
+    it "doesn't crash if you have an odd argument" do
+      # The hyphen cause const_defined? to bail at one point since it's
+      # not allowed in module names
+      Amp::Command.for_name("#{@command_name} new-commands").should == @class
+    end
+    
+    it 'can be looked up by a set of command line arguments' do
+      Amp::Command.for_name("#{@command_name} show --verbose").should == @class
+    end
+    
+    it 'has a description' do
+      @class.desc.should == 'Hello'
+    end
+    
+    it 'has a name' do
+      @class.name.should == @command_name
+    end
+  end
+  
+  context 'when created within a namespace' do
+    before do
+      @name = next_name
+      Amp::Command.namespace 'TempNamespace' do
+        @class = Amp::Command.create(@name) do |c|
+          c.opt :verbose, "Verbose output", :type => :boolean
+        end
+      end
+    end
+    
+    it 'should create the requested namespace as a module' do
+      Amp::Command::Tempnamespace.should_not be_nil
+    end
+    
+    it "should create the command in the namespace's module" do
+      Amp::Command::Tempnamespace.const_get(@name.capitalize).should == @class
+    end
+    
+    it 'can be looked up by for_name with the nested command syntax' do
+      Amp::Command.for_name("tempnamespace #{@name.downcase}").should == @class
+    end
+  end 
+
+  context 'when no name given' do
+    it 'should return nil' do
+      Amp::Command.for_name('').should == nil
+    end
+  end
+end

data/spec/command_specs/help_spec.rb

@@ -0,0 +1,33 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Amp::Command::Help do
+  it 'creates the help command' do
+    Amp::Command::Help.should_not be_nil
+  end
+  
+  it 'stores the help command in the all_commands list' do
+    Amp::Command::Base.all_commands.should include(Amp::Command::Help)
+  end
+  
+  it 'can be looked up as base help' do
+    Amp::Command.for_name('help').should == Amp::Command::Help
+  end
+  
+  it 'prints the help text of all commands' do
+    run_command('help').should include('Thanks for using Amp!')
+  end
+end

data/spec/command_specs/spec_helper.rb

@@ -0,0 +1,37 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+def run_command(command, opts={}, args=[])
+  swizzling_stdout do
+    Amp::Command.for_name(command).new.call(opts, args)
+  end
+end
+
+
+def next_name
+  # Shared by all subclasses.
+  @@__next_name_counter ||= 0
+  @@__next_name_counter += 1
+  "TempClass#{@@__next_name_counter}"
+end
+
+def swizzling_argv(argv)
+  old_argv = ARGV.dup
+  ARGV.replace(argv)
+  yield
+ensure
+  ARGV.replace(old_argv)
+end

data/spec/command_specs/validations_spec.rb

@@ -0,0 +1,267 @@
+##################################################################
+#                  Licensing Information                         #
+#                                                                #
+#  The following code is licensed, as standalone code, under     #
+#  the Ruby License, unless otherwise directed within the code.  #
+#                                                                #
+#  For information on the license of this code when distributed  #
+#  with and used in conjunction with the other modules in the    #
+#  Amp project, please see the root-level LICENSE file.          #
+#                                                                #
+#  © Michael J. Edgar and Ari Brown, 2009-2010                   #
+#                                                                #
+##################################################################
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'amp-front/dispatch/commands/base'
+
+describe Amp::Command::Validations do
+  before do
+    @klass = Amp::Command.create(next_name) do |command|
+      command.before do |opts,args|
+        opts[:hello] && args.size >= 1
+      end
+      command.after do |opts,args|
+        !opts[:world]
+      end
+    end
+  end
+  
+  context '#valid?' do
+    it 'runs before blocks to check validity' do
+      instance = @klass.new
+      instance.should be_valid({:hello => true}, ['stuff'])
+      instance.should_not be_valid({:hello => false}, ['stuff'])
+      instance.should_not be_valid({:hello => true}, [])
+    end
+  end
+  
+  context '#run_after' do
+    it 'runs the after blocks' do
+      instance = @klass.new
+      instance.run_after({:world => false}, []).should be_true
+      instance.run_after({:world => true}, []).should be_false
+    end
+  end
+  
+  context '#validates_each' do
+    before do
+      @class = Amp::Command.create(next_name) do |c|
+        c.validates_each(:hello, :world) do |opts, key, value|
+          value > 0
+        end
+      end
+    end
+    
+    it 'runs the validation block on the named options' do
+      instance = @class.new
+      instance.should be_valid({:hello => 3, :world => 5},[])
+      instance.should_not be_valid({:hello => -3, :world => 5},[])
+      instance.should_not be_valid({:hello => 3, :world => -5},[])
+    end
+  end
+  
+  context '#validates_block' do
+    before do
+      @class = Amp::Command.create(next_name) do |c|
+        c.validates_block(:unless => :some_method) do |opts, args|
+          args.size == 0
+        end
+      end
+
+      @class.send(:define_method, :some_method) do |opts, args|
+        opts[:skip_validation]
+      end
+    end
+    
+    it 'only runs the validation when some_method returns true' do
+      instance = @class.new
+      instance.should be_valid({:skip_validation => false}, [])
+      instance.should be_valid({:skip_validation => true},  [])
+      instance.should be_invalid({:skip_validation => false}, [5])
+      instance.should be_valid({:skip_validation => true},  [5])
+    end
+  end
+  
+  context '#validates_presence_of' do
+    before do
+      @class = Amp::Command.create(next_name) do |c|
+        c.validates_presence_of :hello
+      end
+    end
+    
+    it 'runs the validation block on the named options' do
+      instance = @class.new
+      instance.should be_valid({:hello => 3, :hello_given => true},[])
+      instance.should be_invalid({:hello => 3, :hello_given => false},[])
+      instance.should be_valid({:hello => nil, :hello_given => true},[])
+      instance.should be_invalid({:hello => nil, :hello_given => false},[])
+    end
+  end
+  
+  context '#validates_inclusion_of' do
+    before do
+      @class = Amp::Command.create(next_name) do |c|
+        c.validates_inclusion_of(:hello, :in => 3..15)
+        c.validates_inclusion_of(:world, :in => %w[mike ari])
+      end
+    end
+    
+    it 'runs the validation block on the named options' do
+      instance = @class.new
+      instance.should be_valid({:hello => 3, :world => 'mike'},[])
+      instance.should be_invalid({:hello => -1, :world => 'ari'},[])
+      instance.should be_invalid({:hello => 5, :world => 'steve'},[])
+    end
+    
+    it 'fails when no options hash is provided' do
+      proc {
+        Amp::Command.create(next_name) do |c|
+          c.validates_inclusion_of(:temp)
+        end
+      }.should raise_error(ArgumentError)
+    end
+    
+    it 'handles being parameterized by :if' do
+      klass = Amp::Command.create(next_name) do |c|
+        c.validates_inclusion_of(:temp, :in => 3..15, :if => proc {|opts,args| args.size >= 1})
+      end
+      
+      instance = klass.new
+      instance.should be_valid({:temp => 5}, ['hello'])
+      instance.should be_valid({:temp => 1}, [])
+      instance.should be_invalid({:temp => 1}, ['hello'])
+    end
+  end
+  
+  context '#validates_length_of' do    
+    it 'runs the validation block handling :in and :within' do
+      klass = Amp::Command.create(next_name) do |c|
+        c.validates_length_of(:hello, :in => 3..15)
+        c.validates_length_of(:world, :within => 13..25)
+      end
+      instance = klass.new
+      instance.should be_valid({:hello => 'a' * 3, :world => 'a' * 24},[])
+      instance.should be_invalid({:hello => 'a' * 1, :world => 'a' * 19},[])
+      instance.should be_invalid({:hello => 'a' * 5, :world => 'a' * 3},[])
+    end
+    
+    it 'runs the validation block handling :maximum' do
+      klass = Amp::Command.create(next_name) do |c|
+        c.validates_length_of(:hello, :maximum => 10)
+      end
+      instance = klass.new
+      instance.should be_valid({:hello => 'a' * 8},[])
+      instance.should be_valid({:hello => 'a' * 10},[])
+      instance.should be_invalid({:hello => 'a' * 11},[])
+      instance.should be_valid({:hello => ''},[])
+    end
+    
+    it 'runs the validation block handling :minimum' do
+      klass = Amp::Command.create(next_name) do |c|
+        c.validates_length_of(:hello, :minimum => 10)
+      end
+      instance = klass.new
+      instance.should be_valid({:hello => 'a' * 12},[])
+      instance.should be_valid({:hello => 'a' * 10},[])
+      instance.should be_invalid({:hello => 'a' * 9},[])
+      instance.should be_invalid({:hello => ''},[])
+    end
+    
+    it 'runs the validation block handling :is' do
+      klass = Amp::Command.create(next_name) do |c|
+        c.validates_length_of(:hello, :is => 4)
+      end
+      instance = klass.new
+      instance.should be_valid({:hello => 'a' * 4},[])
+      instance.should be_invalid({:hello => 'a' * 5},[])
+      instance.should be_invalid({:hello => 'a' * 3},[])
+      instance.should be_invalid({:hello => ''},[])
+    end
+    
+    it 'fails when no length keys are provided' do
+      proc {
+        Amp::Command.create(next_name) do |c|
+          c.validates_length_of(:temp, {})
+        end
+      }.should raise_error(ArgumentError)
+    end
+    
+    it 'handles being parameterized by :if' do
+      klass = Amp::Command.create(next_name) do |c|
+        c.validates_length_of(:temp, :in => 3..15, :if => proc {|opts,args| args.size >= 1})
+      end
+      
+      instance = klass.new
+      instance.should be_valid({:temp => 'a' * 5}, ['hello'])
+      instance.should be_valid({:temp => 'a' * 1}, [])
+      instance.should be_invalid({:temp => 'a' * 1}, ['hello'])
+    end
+  end
+  
+  
+  context '#validates_argument_count' do    
+    it 'runs the validation block handling :in and :within' do
+      klass = Amp::Command.create(next_name) do |c|
+        c.validates_argument_count(:in => 1..2)
+      end
+      instance = klass.new
+      instance.should be_valid({}, [3] * 1)
+      instance.should be_invalid({}, [3] * 3)
+      instance.should be_invalid({}, [])
+    end
+    
+    it 'runs the validation block handling :maximum' do
+      klass = Amp::Command.create(next_name) do |c|
+        c.validates_argument_count(:maximum => 10)
+      end
+      instance = klass.new
+      instance.should be_valid({},[3] * 8)
+      instance.should be_valid({},[3] * 10)
+      instance.should be_invalid({},[3] * 11)
+      instance.should be_valid({},[])
+    end
+    
+    it 'runs the validation block handling :minimum' do
+      klass = Amp::Command.create(next_name) do |c|
+        c.validates_argument_count(:minimum => 10)
+      end
+      instance = klass.new
+      instance.should be_valid({},[3] * 12)
+      instance.should be_valid({},[3] * 10)
+      instance.should be_invalid({},[3] * 9)
+      instance.should be_invalid({},[])
+    end
+    
+    it 'runs the validation block handling :is' do
+      klass = Amp::Command.create(next_name) do |c|
+        c.validates_argument_count(:is => 4)
+      end
+      instance = klass.new
+      instance.should be_valid({},[3] * 4)
+      instance.should be_invalid({},[3] * 3)
+      instance.should be_invalid({},[3] * 5)
+      instance.should be_invalid({},[])
+    end
+    
+    it 'fails when no length keys are provided' do
+      proc {
+        Amp::Command.create(next_name) do |c|
+          c.validates_argument_count
+        end
+      }.should raise_error(ArgumentError)
+    end
+    
+    it 'handles being parameterized by :if' do
+      klass = Amp::Command.create(next_name) do |c|
+        c.validates_argument_count(:in => 2..3, :unless => proc {|opts,args| args[0] == 'off'})
+      end
+      
+      instance = klass.new
+      instance.should be_valid({}, ['hello', 'world'])
+      instance.should be_valid({}, ['off'])
+      instance.should be_invalid({}, ['hello'])
+    end
+  end
+end
+