lightning 0.2.1 → 0.3.0

data/test/commands_test.rb

@@ -0,0 +1,98 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+context "Commands:" do
+  # this test seems to run much longer than expected i.e. 0.02
+  # rr and raising?
+  test "run_command handles unexpected error" do
+    mock($stderr).puts(/^Error: Unexpected/)
+    mock(Commands).complete(anything) { raise "Unexpected" }
+    run_command :complete
+  end
+
+  test "complete defaults to ARGV if no ENV['COMP_LINE']" do
+    mock(Completion).complete('o-a Col', anything)
+    capture_stdout { run_command(:complete, ['o-a', 'Col']) }
+  end
+
+  test "complete prints usage for no arguments" do
+    capture_stdout { run_command(:complete, []) }.should =~ /^Usage/
+  end
+
+  test "complete prints error for invalid command" do
+    capture_stdout { run_command(:complete, ['invalid','invalid']) }.should =~ /^#Error.*Please/m
+  end
+
+  test "translate prints usage for no arguments" do
+    capture_stdout { run_command(:translate, []) }.should =~ /^Usage/
+  end
+
+  test "translate prints error for invalid command" do
+    capture_stdout { run_command(:translate, %w{invalid blah}) }.should =~ /#Error/
+  end
+
+  test "command prints usage with -h" do
+    capture_stdout { run_command :install, ['-h'] }.should =~ /^Usage/
+  end
+
+  context "first install" do
+    before_all {
+      @old_config = Lightning.config
+      Lightning.config = Lightning::Config.new({})
+      @old_functions = Lightning.functions
+      Lightning.functions = nil
+
+      mock(Lightning.config).save.times(2)
+      mock(Commands).first_install? { true }.times(2)
+      stub.instance_of(Generator).call_generator { [] }
+      mock(File).open(anything, 'w')
+      @stdout = capture_stdout { run_command :install }
+    }
+
+    assert "generates default bolts" do
+      Generator::DEFAULT_GENERATORS.all? {|e| Lightning.config[:bolts].key?(e) }
+    end
+
+    assert "default bolts are global" do
+      Generator::DEFAULT_GENERATORS.all? {|e| Lightning.config[:bolts][e]['global'] }
+    end
+
+    test "builds 8 default functions" do
+      expected = %w{cd-gem cd-local_ruby cd-ruby cd-wild echo-gem echo-local_ruby echo-ruby echo-wild}
+      Lightning.functions.keys.sort.should == expected
+    end
+
+    test "prints correct install message" do
+      @stdout.should =~ /^Created.*lightningrc\nCreated.*functions\.sh for bash/m
+    end
+
+    after_all { Lightning.config = @old_config; Lightning.functions = @old_functions }
+  end
+
+  context "run" do
+    test "with no command prints usage" do
+      mock(Commands).print_help
+      Commands.run []
+    end
+
+    test "with aliased command executes correct command" do
+      mock(Commands).run_command('bolt', [])
+      Commands.run ['b']
+    end
+
+    test "with -h prints usage" do
+      mock(Commands).print_help
+      Commands.run ['-h']
+    end
+
+    test "with invalid command prints messaged and usage" do
+      mock(Commands).print_help
+      capture_stdout { Commands.run ['blah'] }.should =~ /Command 'blah'/
+    end
+
+    test "passes -h as command argument" do
+      mock(Commands).print_command_help.never
+      mock(Commands).complete(['blah', '-h'])
+      Commands.run(['complete', 'blah', '-h'])
+    end
+  end
+end

data/test/completion_map_test.rb

@@ -1,58 +1,35 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Lightning::CompletionMapTest < Test::Unit::TestCase
+context "CompletionMap" do
+  def create_map(path_hash, new_options={})
+    stub(Dir).glob('blah/*', File::FNM_DOTMATCH) { path_hash.values }
+    @completion_map = CompletionMap.new('blah/*', new_options)
+  end
+
+  test "creates basic map" do
+    expected_map = {"path1"=>"/dir1/path1", "path2"=>"/dir1/path2"}
+    create_map(expected_map)
+    @completion_map.map.should == expected_map
+  end
+
+  test "ignores paths from Lightning.ignore_paths" do
+    CompletionMap.ignore_paths = ['path1', 'dir2', '\.\.?$']
+    expected_map = {"path1"=>"/dir1/path1", "path2"=>"/dir1/path2", 'path3'=>'/dir2/path3', '.'=>'/dir1/path4/.'}
+    create_map(expected_map)
+    @completion_map.map.should == slice_hash(expected_map, 'path2')
+    CompletionMap.ignore_paths = nil
+  end
+
+  test "creates map with duplicates" do
+    expected_map = {"path1///dir3"=>"/dir3/path1", "path2"=>"/dir1/path2", "path1///dir1"=>"/dir1/path1", "path1///dir2"=>"/dir2/path1"}
+    create_map(expected_map)
+    @completion_map.map.should == expected_map
+  end
 
-  context "CompletionMap" do    
-    def create_map(path_hash, new_options={})
-      Dir.stub!(:glob) { path_hash.values }
-      @completion_map = Lightning::CompletionMap.new('blah', new_options)
-    end
-    
-    test "creates basic map" do
-      expected_map = {"path1"=>"/dir1/path1", "path2"=>"/dir1/path2"}
-      create_map(expected_map)
-      assert_equal expected_map, @completion_map.map
-    end
-    
-    test "ignores paths from Lightning.ignore_paths" do
-      Lightning.stub!(:ignore_paths, :return=>['path1'])
-      expected_map = {"path1"=>"/dir1/path1", "path2"=>"/dir1/path2"}
-      create_map(expected_map)
-      assert_equal expected_map.slice('path2'), @completion_map.map
-    end
-    
-    test "creates map with duplicates" do
-      expected_map = {"path1//dir3"=>"/dir3/path1", "path2"=>"/dir1/path2", "path1//dir1"=>"/dir1/path1", "path1//dir2"=>"/dir2/path1"}
-      create_map(expected_map)
-      assert_equal expected_map, @completion_map.map
-    end
-    
-    test "fetches correct path completion" do
-      map = {"path1"=>"/dir1/path1", "path2"=>"/dir1/path2"}
-      create_map(map)
-      assert_equal '/dir1/path1', @completion_map['path1']
-    end
-    
-    test "creates alias map" do
-      create_map({}, :aliases=>{'path3'=>'/dir1/path3'}, :global_aliases=>{'path2'=>'/dir1/path2'})
-      assert_equal({"path2"=>"/dir1/path2", "path3"=>"/dir1/path3"}, @completion_map.alias_map)
-    end
-    
-    test "fetches correct alias completion" do
-      create_map({}, :aliases=>{'path3'=>'/dir1/path3'})
-      assert_equal '/dir1/path3', @completion_map['path3']
-    end
-    
-    test "fetches correct global alias completion" do
-      map = {"path1"=>"/dir1/path1", "path2"=>"/dir1/path2"}
-      create_map(map, :global_aliases=>{'path3'=>'/dir1/path3'})
-      assert_equal '/dir1/path3', @completion_map['path3']
-    end
-    
-    test "keys include aliases" do
-      map = {"path2"=>"/dir1/path2"}
-      create_map(map, :global_aliases=>{'path3'=>'/dir1/path3'})
-      assert_arrays_equal ['path2','path3'], @completion_map.keys
-    end
+  test "ignores duplicate paths created by overlapping globs" do
+    mock(Dir).glob('/usr/**', File::FNM_DOTMATCH) { ['/usr/lib/path1', '/usr/lib/path2'] }
+    mock(Dir).glob('/usr/lib/*', File::FNM_DOTMATCH) { ['/usr/lib/path1'] }
+    @completion_map = CompletionMap.new('/usr/**', '/usr/lib/*')
+    @completion_map.map.should == {'path1'=>'/usr/lib/path1', 'path2'=>'/usr/lib/path2'}
   end
-end
+end

data/test/completion_test.rb

@@ -1,49 +1,119 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Lightning::CompletionTest < Test::Unit::TestCase
-  context "Completion" do
-    before(:each) {
-      @key = 'blah'; 
-      Lightning.bolts[@key].stub!(:completions, :return=>%w{at ap blah})
-      Lightning.config[:complete_regex] = true
-    }
-    test "from script matches" do
-      Lightning.config[:complete_regex] = false
-      assert_arrays_equal %w{at ap}, Lightning::Completion.complete('cd-test a', @key)
+context "Completion" do
+  before {
+    @command = 'blah';
+    cmd = Function.new 'name'=>@command, 'bolt'=>Bolt.new('blah')
+    stub(cmd).completions { ['at', 'ap', 'blah.rb', 'has space'] }
+    Lightning.functions[@command] = cmd
+  }
+
+  def tab(input, expected, complete_regex=false)
+    Lightning.config[:complete_regex] = complete_regex
+    mock(Commands).puts(expected)
+    run_command :complete, [@command, 'cd-test '+ input]
+  end
+
+  test "from script matches" do
+    tab 'a', %w{at ap}
+  end
+
+  test "ending with space matches everything" do
+    tab 'a ', ["at", "ap", "blah.rb", "has\\ space"]
+  end
+
+  test "has no matches" do
+    tab 'zaza', []
+  end
+
+  test "has no matches for a local directory" do
+    tab 'bling/ok', []
+  end
+
+  test "with multiple words matches last word" do
+    tab '-r b', ['blah.rb']
+  end
+
+  test "with multiple words matches quoted last word" do
+    tab '-r "b"', ['blah.rb']
+  end
+
+  test "with multiple words matches shell escaped last word" do
+    tab 'lib has\\ ', ['has\\ space']
+  end
+
+  test "in nonexistent subdirectory errors properly" do
+    tab 'at/', Completion.error_array("Nonexistent directory.")
+  end
+
+  test "in bolt subdirectory matches" do
+    mock(Dir).entries('at') { ['..', '.', 'f1']}
+    tab 'at/', ['at/f1']
+  end
+
+  test "in nested bolt subdirectory matches" do
+    mock(Dir).entries('at/the') { ['f1']}
+    tab 'at/the/', ['at/the/f1']
+  end
+
+  test "for directory in bolt subdirectory matches and appends / " do
+    stub(File).directory? { true }
+    mock(Dir).entries('at/the') { %w{ab lib}}
+    tab 'at/the/l', ['at/the/lib/']
+  end
+
+  test "for file in bolt subdirectory matches" do
+    mock(Dir).entries('at/the') { %w{ab ge fe fi fo}}
+    tab 'at/the/f', ['at/the/fe', 'at/the/fi', 'at/the/fo']
+  end
+
+  test "in bolt file's superdirectory matches" do
+    mock(File).expand_path('blah.rb/..') { '/dir' }
+    mock(Dir).entries('/dir') { ['f1', 'f2'] }
+    tab 'blah.rb/../', ['blah.rb/../f1', 'blah.rb/../f2']
+  end
+
+  test "in bolt file's superdirectory's subdirectory matches" do
+    mock(File).expand_path('blah.rb/../sub') { '/dir/sub' }
+    mock(Dir).entries('/dir/sub') { ['f1', 'f2'] }
+    tab 'blah.rb/../sub/', ['blah.rb/../sub/f1', 'blah.rb/../sub/f2']
+  end
+
+  context "with a regex" do
+    test "matches starting letters" do
+      tab 'a', %w{at ap}, true
     end
-    
-    test "for basic case matches" do
-      Lightning.config[:complete_regex] = false
-      @completion = Lightning::Completion.new('cd-test a', @key)
-      assert_arrays_equal %w{at ap}, @completion.matches
+
+    test "and asterisk matches" do
+      tab '[ab]*', %w{at ap blah.rb}, true
     end
-    
-    test "with test flag matches" do
-      Lightning.config[:complete_regex] = false
-      @completion = Lightning::Completion.new('cd-test -test a', @key)
-      assert_arrays_equal %w{at ap}, @completion.matches
+
+    test "with space matches" do
+      tab 'has', ['has\\ space']
     end
-    
-    test "with complete_regex on matches" do
-      Lightning.config[:complete_regex] = true
-      @completion = Lightning::Completion.new('cd-test *', @key)
-      assert_arrays_equal %w{at ap blah}, @completion.matches
+
+    test "with typed space matches" do
+      tab 'has\\ ', ['has\\ space']
     end
-    
-    test "with invalid regex is rescued" do
-      Lightning.config[:complete_regex] = true
-      @completion = Lightning::Completion.new('cd-test []', @key)
-      assert !@completion.matches.grep(/Error/).empty?
+
+    test "which is invalid errors gracefully" do
+      tab '[]', Completion.error_array('Invalid regular expression.'), true
     end
   end
-  
+end
+
+context "Completion misc" do
   test "blob_to_regex converts * to .*" do
-    @lc = Lightning::Completion.new('blah', @key)
-    assert_equal '.*a.*blah', @lc.blob_to_regex('*a*blah')
+    @lc = Completion.new('blah', nil)
+    @lc.blob_to_regex('*a*blah').should == '.*a.*blah'
   end
-  
+
   test "blob_to_regex doesn't modify .*" do
-    @lc = Lightning::Completion.new('blah', @key)
-    assert_equal '.*blah.*', @lc.blob_to_regex('.*blah.*')
+    @lc = Completion.new('blah', nil)
+    @lc.blob_to_regex('.*blah.*').should == '.*blah.*'
+  end
+
+  test "Completion error array must be more than one element to display and not complete error" do
+    Completion.error_array("testing").size.should > 1
   end
 end

data/test/config_test.rb

@@ -1,62 +1,28 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Lightning::ConfigTest < Test::Unit::TestCase
-  context "A config" do
-    before(:all) {
-      @config = Lightning::Config.create
-    }
-    
-    should "be a hash" do
-      assert @config.is_a?(Hash)
-    end
-    
-    should "have keys that are symbols" do
-      assert @config.keys.all? {|e| e.is_a?(Symbol)}
-    end
-    
-    should "have read supported keys" do
-      supported_keys = [:generated_file, :commands, :ignore_paths, :paths, :shell, :complete_regex]
-      assert_arrays_equal supported_keys, @config.keys 
-    end
-    
-    should "have a generated_file key which is a string" do
-      assert @config[:generated_file].is_a?(String)
-    end
-    
-    should "have a commands key which is an array" do
-      assert @config[:commands].is_a?(Array)
-    end
-    
-    should "have a command with valid keys" do
-      assert @config[:commands][0].slice('name', 'map_to', 'description').values.all? {|e| e.is_a?(String)}
-      assert @config[:commands][0]['paths'].is_a?(Array)
-    end
-    
-    should "have a paths key which is a hash" do
-      assert @config[:paths].is_a?(Hash)
-    end
-    
-    should "have an ignore_paths key which is an array" do
-      assert @config[:ignore_paths].is_a?(Array)
-    end
+context "A config" do
+  before_all {
+    @config = Lightning::Config.new
+  }
+
+  assert "has keys that are symbols" do
+    @config.keys.all? {|e| e.is_a?(Symbol)}
+  end
+  
+  assert "has read supported keys" do
+    supported_keys = [:source_file, :ignore_paths, :bolts, :complete_regex]
+    supported_keys.all? {|e| @config.key?(e) }
+  end
+  
+  assert "has a source_file key which is a string" do
+    @config[:source_file].is_a?(String)
+  end
+  
+  assert "has a bolts key which is a hash" do
+    @config[:bolts].is_a?(Hash)
   end
   
-  context ":configure_commands_and_paths" do
-    test "generates bolt key if none exists" do
-      config = {:commands=>[{'name'=>'c1', 'map_to'=>'s1'}]}
-      assert ! Lightning::Config.configure_commands_and_paths(config)[:commands][0]['bolt_key'].nil?
-    end
-    
-    test "adds generated bolt key to config.paths if it didn't exist" do
-      config = {:commands=>[{'name'=>'c1', 'map_to'=>'s1', 'paths'=>['*']}]}
-      new_config = Lightning::Config.configure_commands_and_paths(config)
-      bolt_key = new_config[:commands][0]['bolt_key']
-      assert new_config[:paths].has_key?(bolt_key)
-    end
-    
-    test "adds reference to bolt key if command.paths is a string" do
-      config = {:commands=>[{'name'=>'c1', 'map_to'=>'s1', 'paths'=>'blah'}]}
-      assert_equal 'blah', Lightning::Config.configure_commands_and_paths(config)[:commands][0]['bolt_key']
-    end
+  assert "has an ignore_paths key which is an array" do
+    @config[:ignore_paths].is_a?(Array)
   end
 end

data/test/function_test.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+context "Function" do
+  def create_function(attributes={})
+    # bolt, path and aliases depend on test/lightning.yml
+    @fn = Function.new({'name'=>'blah', 'bolt'=>Bolt.new('app'), 'desc'=>'blah'}.merge(attributes))
+    @fn.completion_map.map = {'path1'=>'/dir/path1','path2'=>'/dir/path2',
+      'path3'=>'/dir/path3', 'file 1'=>'/dir/file 1'}
+  end
+
+  def translate(input, *expected)
+    Lightning.functions['blah'] = @fn
+    mock(Commands).puts(expected.join("\n"))
+    run_command :translate, ['blah'] + input.split(' ')
+  end
+
+  before_all do
+    create_function
+    @map = @fn.completion_map
+  end
+
+  test "has correct completions" do
+    assert_arrays_equal %w{a1 a2}+['file 1']+%w{path1 path2 path3}, @fn.completions
+  end
+
+  test "has bolt's globs" do
+    @fn.globs.should.not.be.empty?
+    @fn.globs.should == @fn.bolt.globs
+  end
+
+  test "has bolt's aliases" do
+    @fn.aliases.should.not.be.empty?
+    @fn.aliases.should == @fn.bolt.aliases
+  end
+
+  test "can have a desc" do
+    @fn.desc.should.not.be.empty?
+  end
+
+  test "translates a completion" do
+    translate 'path1', @map['path1']
+  end
+
+  test "translates multiple completions separately" do
+    translate 'path1 path2', @map['path1'], @map['path2']
+  end
+
+  test "translates instant multiple completions (..)" do
+    translate 'path.. blah a1', @map['path1'], @map['path2'], @map['path3'], 'blah', @map['a1']
+  end
+
+  test "translates instant multiple completions containing spaces" do
+    translate 'file..', @map['file 1']
+  end
+
+  test "translates non-completion to same string" do
+    translate 'blah', 'blah'
+  end
+
+  test "translates completion anywhere amongst non-completions" do
+    translate '-r path1', "-r", "#{@map['path1']}"
+    translate '-r path1 doc/', "-r", "#{@map['path1']}", "doc/"
+  end
+
+  test "translates completion embedded in subdirectory completion" do
+    translate '-r path1/sub/dir', "-r", "#{@map['path1']}/sub/dir"
+  end
+
+  test "translates completion with a superdirectory" do
+    mock(File).expand_path("#{@map['path1']}/../file1") { '/dir/file1' }
+    translate 'path1/../file1', '/dir/file1'
+  end
+
+  test "translates completion over alias" do
+    translate 'path3', '/dir/path3'
+  end
+
+  test "translates alias" do
+    translate 'a1', @map['a1']
+  end
+
+  after_all { Lightning.config[:aliases] = {}}
+
+  context "function attributes:" do
+    test "post_path added after each translation" do
+      create_function 'post_path'=>'/rdoc/index.html'
+      translate '-r path1 path2', "-r", "/dir/path1/rdoc/index.html", "/dir/path2/rdoc/index.html"
+    end
+  end
+end