cldwalker-lightning 0.1.1 → 0.1.2

data/README.markdown

@@ -26,6 +26,8 @@ In this case, rvim is configured to complete my ruby core and standard library f
 Install
 =======
 
+For newcomers to github, install this gem with: `gem install cldwalker-lightning -s http://gems.github.com`
+
 To make your own commands, you'll need to:
 
 1. Create ~/.lightning.yml or a lightning.yml in the current directory.
@@ -36,7 +38,7 @@ To make your own commands, you'll need to:
    below. See lightning\_completions.example for what would be generated for the enclosed example
    config.
 
-3. Source the generated file in your bashrc ie `source ~/.lightning\_completions`.
+3. Source the generated file in your bashrc ie `source ~/.lightning_completions`.
 
 
 Globbable paths
@@ -119,9 +121,9 @@ But once I saw how easy it was to manipulate completion through ruby,
 http://github.com/ryanb/dotfiles/blob/master/bash/completion\_scripts/project\_completion,
 I had to do something.
 
-Todo
-====
+Todo/Ideas
+==========
 
-* Clean up code to better test.
 * Aliases for common autocompletions.
 * Allow lightning commands to only path-resolve one of multiple arguments given.
+* Command interface to easily add/remove current directory or globs from a command

data/bin/lightning-complete

@@ -1,7 +1,13 @@
 #!/usr/bin/env ruby
 
-require File.expand_path(File.dirname(__FILE__) + "/../lib/lightning")
+#  == Description
+#  Used to complete a lightning command
+require File.expand_path(File.join(File.dirname(__FILE__), "..","lib","lightning"))
 
-key = ARGV.shift or raise "Path key needs to be specified"
-puts Lightning::Completion.complete(ENV["COMP_LINE"], key)
-exit 0
+if (command = ARGV.shift)
+  puts Lightning.complete(command, ENV["COMP_LINE"])
+  exit 0
+else
+  puts "No command given"
+  exit 1
+end

data/bin/lightning-full_path

@@ -1,15 +1,18 @@
 #!/usr/bin/env ruby
 
 # == Description
-# Used by path completion functions to return first possible full path which matches the given basename for the given key.
-# Warning: Basenames that occur in multiple directories will return the first directory found.
+# Used by path completion functions to return first possible full path which matches the given basename for the given command.
 
-require File.expand_path(File.dirname(__FILE__) + "/../lib/lightning")
+require File.expand_path(File.join(File.dirname(__FILE__), "..","lib","lightning"))
 
-key = ARGV.shift or raise "No key given"
+command = ARGV.shift 
+if command.nil?
+  puts "No command given"
+  exit 1
+end
 if ARGV.empty?
   puts "No arguments given" 
   exit 1
 end
-puts Lightning.full_path_for_completion(ARGV, key) || ''
+puts Lightning.translate(command, ARGV)
 exit 0

data/bin/lightning-install

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
-require File.expand_path(File.dirname(__FILE__) + "/../lib/lightning")
+# == Description
+# Used to generate shell file from configuration
 
-Lightning::Generator.generate_completions
+require File.expand_path(File.join(File.dirname(__FILE__), "..","lib","lightning"))
+Lightning::Generator.generate_completions ARGV.shift

data/lib/lightning/bolt.rb

@@ -0,0 +1,31 @@
+# A bolt, referenced by a key, is the basic unit needed to access a lightning command's functionality.
+class Lightning
+  class Bolt
+    attr_reader :key
+    def initialize(bolt_key)
+      @key = bolt_key
+    end
+    
+    def completions
+      path_map.keys
+    end
+    
+    def path_map
+      @path_map ||= Lightning::PathMap.new(self.paths)
+    end
+    
+    def resolve_completion(basename)
+      basename = basename.join(" ") if basename.is_a?(Array)
+      basename.gsub!(/\s*#{TEST_FLAG}\s*/,'')
+      #TODO
+      # if (regex = Lightning.config_command(Lightning.current_command)['completion_regex'])
+      #   basename = basename[/#{regex}/]
+      # end
+      path_map[basename] || ''
+    end
+    
+    def paths
+      @paths ||= Lightning.config[:paths][key] || []
+    end
+  end
+end

data/lib/lightning/bolts.rb

@@ -0,0 +1,12 @@
+# Hash of bolts accessed by their keys
+class Lightning
+  class Bolts
+    def initialize
+      @hash = {}
+    end
+  
+    def [](key)
+      @hash[key] ||= Lightning::Bolt.new(key)
+    end    
+  end
+end

data/lib/lightning/completion.rb

@@ -2,13 +2,13 @@
 #This class handles completions given a path key and the text already typed.
 class Lightning
   class Completion
-    def self.complete(text_to_complete, path_key)
-      new(text_to_complete, path_key).matches
+    def self.complete(text_to_complete, bolt_key)
+      new(text_to_complete, bolt_key).matches
     end
       
-    def initialize(text_typed, path_key)
+    def initialize(text_typed, bolt_key)
       @text_typed = text_typed
-      @path_key = path_key
+      @bolt_key = bolt_key
     end
   
     def matches
@@ -24,7 +24,7 @@ class Lightning
     end
   
     def possible_completions
-      Lightning.path_map.completions(@path_key)
+      Lightning.bolts[@bolt_key].completions
     end    
   end
-end
+end

data/lib/lightning/config.rb

@@ -1,53 +1,50 @@
 module Lightning::Config
+  def load_config
+    @config = setup_config
+  end
+  
   def config
-    unless @config
-      @config = read_config
-      add_command_paths(@config)
-    end
-    @config
+    @config ||= setup_config
+  end
+  
+  def setup_config
+    hash = read_config_file
+    configure_commands_and_paths(hash)
+    hash
   end
   
-  def read_config(config_file=nil)
+  def read_config_file(config_file=nil)
     default_config = {:shell=>'bash', :generated_file=>File.expand_path(File.join('~', '.lightning_completions'))}
     config_file ||= File.exists?('lightning.yml') ? 'lightning.yml' : File.expand_path(File.join("~",".lightning.yml"))
     hash = YAML::load(File.new(config_file))
     default_config.merge(hash.symbolize_keys)
   end
   
-  #should return array of globbable paths
-  def globbable_paths_by_key(key)
-    config[:paths][key] || []
-  end
-  
   def config_command(name)
     config[:commands].find {|e| e['name'] == name} || {}
   end
   
-  def command_to_path_key(map_to_command, new_command)
+  def commands_to_bolt_key(map_to_command, new_command)
     "#{map_to_command}-#{new_command}"
   end
   
-  def path_key_to_command(path_key)
-    path_key.split("-")[1]
-  end
-  
-  def add_command_paths(config)
-    config[:paths] ||= {}
-    config[:commands].each do |e|
+  def configure_commands_and_paths(hash)
+    hash[:paths] ||= {}
+    hash[:commands].each do |e|
       #mapping a referenced path
       if e['paths'].is_a?(String)
-        e['path_key'] = e['paths'].dup
-        e['paths'] = config[:paths][e['paths'].strip] || []
+        e['bolt_key'] = e['paths'].dup
       end
       #create a path entry + key if none exists
-      if e['path_key'].nil?
+      if e['bolt_key'].nil?
         #extract command in case it has options after it
         e['map_to'] =~ /\s*(\w+)/
-        path_key = command_to_path_key($1, e['name'])
-        e['path_key'] = path_key
-        config[:paths][path_key] = e['paths']
+        bolt_key = commands_to_bolt_key($1, e['name'])
+        e['bolt_key'] = bolt_key
+        hash[:paths][bolt_key] = e['paths'] || []
       end
     end
+    hash
   end
   
   def ignore_paths
@@ -57,4 +54,4 @@ module Lightning::Config
     end
     @ignore_paths
   end
-end
+end

data/lib/lightning/generator.rb

@@ -2,9 +2,10 @@
 class Lightning
   class Generator
     class<<self
-    def generate_completions
+    def generate_completions(generated_file=nil)
+      generated_file ||= Lightning.config[:generated_file]
       output = generate(Lightning.config[:shell], Lightning.config[:commands])
-      File.open(Lightning.config[:generated_file], 'w'){|f| f.write(output) }
+      File.open(generated_file, 'w'){|f| f.write(output) }
       output
     end
           
@@ -29,7 +30,7 @@ class Lightning
               echo "No arguments given"
               return
             fi
-            FULL_PATH="`${LBIN_PATH}lightning-full_path #{e['path_key']} $@`#{e['post_path'] if e['post_path']}"
+            FULL_PATH="`${LBIN_PATH}lightning-full_path #{e['name']} $@`#{e['post_path'] if e['post_path']}"
             if [ $1 == '#{Lightning::TEST_FLAG}' ]; then
               CMD="#{e['map_to']} '$FULL_PATH'#{' '+ e['add_to_command'] if e['add_to_command']}"
               echo $CMD
@@ -37,7 +38,7 @@ class Lightning
               #{e['map_to']} "$FULL_PATH"#{' '+ e['add_to_command'] if e['add_to_command']}
             fi
           }
-          complete -o default -C "${LBIN_PATH}lightning-complete #{e['path_key']}" #{e['name']}
+          complete -o default -C "${LBIN_PATH}lightning-complete #{e['name']}" #{e['name']}
         EOS
       end
       body.gsub(/^\s{6,10}/, '')

data/lib/lightning/path_map.rb

@@ -1,21 +1,21 @@
-#This class maps completions to their full paths for a given path key.
+#This class maps completions to their full paths for the given blobs
 class Lightning
   class PathMap
-    def initialize
-      @maps = {}
-    end
-  
-    def [](key)
-      @maps[key] ||= create_map(key)
-    end
+    attr_accessor :map
     
-    def completions(key)
-      self[key].keys
+    def initialize(*globs)
+      #globs need to be an array
+      globs.flatten!
+      @map = create_map_for_globs(globs)
     end
     
-    def create_map(key)
-      create_map_for_globs(Lightning.globbable_paths_by_key(key))
-    end
+     def [](completion)
+       @map[completion]
+     end
+     
+     def keys
+       @map.keys
+     end
     
     #should return hash
     def create_map_for_globs(globs)

data/lib/lightning.rb

@@ -1,5 +1,7 @@
 $:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__))
 require 'yaml'
+require 'lightning/bolt'
+require 'lightning/bolts'
 require 'lightning/completion'
 require 'lightning/config'
 require 'lightning/path_map'
@@ -9,18 +11,30 @@ require 'lightning/generator'
 class Lightning
   TEST_FLAG = '-test'
   extend Config
-  class<<self    
-    def path_map
-      @path_map ||= PathMap.new
+  class<<self
+    attr_accessor :current_command
+    def complete(command, text_to_complete)
+      load_config
+      @current_command = command
+      if bolt_key = config_command(command)['bolt_key']
+        Completion.complete(text_to_complete, bolt_key)
+      else
+        ["Error: No paths found for this command.", "If this is a bug contact me."]
+      end
     end
     
-    def full_path_for_completion(basename, path_key)
-      basename = basename.join(" ") if basename.is_a?(Array)
-      basename.gsub!(/\s*#{TEST_FLAG}\s*/,'')
-      if (regex = config_command(path_key_to_command(path_key))['completion_regex'])
-        basename = basename[/#{regex}/]
+    def translate(command, argv)
+      load_config
+      @current_command = command
+      if bolt_key = config_command(command)['bolt_key']
+        bolts[bolt_key].resolve_completion(argv)
+      else
+        'Error-no_paths_found_for_this_command'
       end
-      path_map[path_key][basename]
+    end
+    
+    def bolts
+      @bolts ||= Bolts.new
     end
   end
 end

data/test/lightning_bolt_test.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class LightningBoltTest < Test::Unit::TestCase
+  context "Bolt" do
+    before(:each) do
+      @path_map = {'path1'=>'/dir/path1','path2'=>'/dir/path2'}
+      @bolt = Lightning::Bolt.new('blah')
+      @bolt.path_map.map = @path_map
+    end
+    
+    test "fetches correct completions" do
+      assert_equal @bolt.completions, @path_map.keys
+    end
+
+    test "resolves completion" do
+      assert_equal @path_map['path1'], @bolt.resolve_completion('path1')
+    end
+
+    test "resolves completion with test flag" do
+      assert_equal @path_map['path1'], @bolt.resolve_completion('-test path1')
+    end
+
+    test "creates path_map only once" do
+      assert_equal @bolt.path_map.object_id, @bolt.path_map.object_id
+    end
+  end
+end

data/test/lightning_completion_test.rb

@@ -2,21 +2,21 @@ require File.dirname(__FILE__) + '/test_helper'
 
 class LightningCompletionTest < Test::Unit::TestCase
   context "Completion" do
-    
+    before(:each) {
+      @key = 'blah'; 
+      Lightning.bolts[@key].stub!(:completions, :return=>%w{at ap blah})
+    }
     test "from script matches correctly" do
-      Lightning.path_map.stub!(:completions, :return=>%w{at ap blah})
-      assert_arrays_equal Lightning::Completion.complete('cd-test a', 'blah'), %w{at ap}
+      assert_arrays_equal Lightning::Completion.complete('cd-test a', @key), %w{at ap}
     end
     
     test "for basic case matches correctly" do
-      Lightning.path_map.stub!(:completions, :return=>%w{at ap blah})
-      @completion = Lightning::Completion.new('cd-test a', 'blah')
+      @completion = Lightning::Completion.new('cd-test a', @key)
       assert_arrays_equal @completion.matches, %w{at ap}
     end
     
     test "with test flag matches correctly" do
-      Lightning.path_map.stub!(:completions, :return=>%w{at ap blah})
-      @completion = Lightning::Completion.new('cd-test -test a', 'blah')
+      @completion = Lightning::Completion.new('cd-test -test a', @key)
       assert_arrays_equal @completion.matches, %w{at ap}
     end
   end

data/test/lightning_config_test.rb

@@ -2,40 +2,61 @@ require File.dirname(__FILE__) + '/test_helper'
 
 class LightningConfigTest < Test::Unit::TestCase
   context "A config" do
-    config = Lightning.read_config(File.dirname(__FILE__) + '/lightning.yml')
+    before(:all) {
+      @config = Lightning.read_config_file(File.dirname(__FILE__) + '/lightning.yml')
+    }
     
     should "be a hash" do
-      assert config.is_a?(Hash)
+      assert @config.is_a?(Hash)
     end
     
     should "have keys that are symbols" do
-      assert config.keys.all? {|e| e.is_a?(Symbol)}
+      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]
-      assert_arrays_equal supported_keys, config.keys 
+      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)
+      assert @config[:generated_file].is_a?(String)
     end
     
     should "have a commands key which is an array" do
-      assert config[:commands].is_a?(Array)
+      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)
+      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)
+      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    
+      assert @config[:ignore_paths].is_a?(Array)
+    end
+  end
+  
+  context ":configure_commands_and_paths" do
+    test "generates bolt key if none exists" do
+      config = {:commands=>[{'name'=>'c1', 'map_to'=>'s1'}]}
+      assert ! Lightning.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.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.configure_commands_and_paths(config)[:commands][0]['bolt_key']
+    end
   end
-end
+end

data/test/lightning_path_map_test.rb

@@ -2,43 +2,29 @@ require File.dirname(__FILE__) + '/test_helper'
 
 class LightningPathMapTest < Test::Unit::TestCase
 
-  context "PathMap" do
-    before(:each) { @map = Lightning::PathMap.new }
-    
-    def stub_dir_glob(path_hash)
+  context "PathMap" do    
+    def create_map(path_hash)
       Dir.stub!(:glob) { path_hash.values }
-    end
-    
-    test "creates map only once when accessing same key multiple times" do
-      # @map.expects(:create_map).once.returns({})
-      called = 0
-      @map.stub!(:create_map) {|e| called += 1; {}}
-      @map['blah']
-      @map['blah']
-      assert called == 1
+      @path_map = Lightning::PathMap.new('blah') 
     end
     
     test "creates basic map" do
       expected_map = {"path1"=>"/dir1/path1", "path2"=>"/dir1/path2"}
-      stub_dir_glob(expected_map)
-      assert_equal expected_map, @map.create_map_for_globs(['blah'])
+      create_map(expected_map)
+      assert_equal expected_map, @path_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"}
-      stub_dir_glob(expected_map)
-      assert_equal expected_map.slice('path2'), @map.create_map_for_globs(['blah'])
+      create_map(expected_map)
+      assert_equal expected_map.slice('path2'), @path_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"}
-      stub_dir_glob(expected_map)
-      assert_equal expected_map, @map.create_map_for_globs(['blah'])
-    end
-    
-    test "creates hash even for invalid key" do
-      @map.create_map('blah').is_a?(Hash)
-    end
+      create_map(expected_map)
+      assert_equal expected_map, @path_map.map
+    end    
   end
 end

data/test/lightning_test.rb

@@ -18,7 +18,11 @@ class LightningTest < Test::Unit::TestCase
       generated_command = <<-EOS.gsub(/^\s{6}/,'')
       #open mac applications
       oa () {
-        FULL_PATH="`${LBIN_PATH}lightning-full_path open-oa $@`"
+        if [ -z "$1" ]; then
+          echo "No arguments given"
+          return
+        fi
+        FULL_PATH="`${LBIN_PATH}lightning-full_path oa $@`"
         if [ $1 == '-test' ]; then
           CMD="open -a '$FULL_PATH'"
           echo $CMD
@@ -26,10 +30,29 @@ class LightningTest < Test::Unit::TestCase
           open -a "$FULL_PATH"
         fi
       }
-      complete -o default -C "${LBIN_PATH}lightning-complete open-oa" oa
+      complete -o default -C "${LBIN_PATH}lightning-complete oa" oa
       EOS
       output = File.read(@config_file)
       assert output.include?(generated_command)
     end
   end
+  
+  context "Lightning" do
+    test "complete() returns correctly for valid command" do
+      Lightning::Completion.stub!(:complete, :return=>'blah')
+      assert_equal 'blah', Lightning.complete('oa', 'blah')
+    end
+  
+    test "complete() reports error for invalid command" do
+      assert ! Lightning.complete('invalid','invalid').grep(/Error/).empty?
+    end
+  
+    test "translate() returns errorless for valid command" do
+      assert Lightning.translate('oa', 'blah').grep(/Error/).empty?
+    end
+    
+    test "translate() reports error for invalid command" do
+      assert ! Lightning.translate('invalid', 'blah').grep(/Error/).empty?
+    end
+  end
 end

data/test/test_helper.rb

@@ -1,7 +1,8 @@
 require 'rubygems'
 require 'test/unit'
-require 'context' #gem
-require 'stump' #gem
+require 'context' #gem install jeremymcanally-context -s http://gems.github.com
+require 'stump' #gem install jeremymcanally-stump -s http://gems.github.com
+require 'pending' #gem install jeremymcanally-pending -s http://gems.github.com
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
 require 'lightning'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cldwalker-lightning
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Gabriel Horner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-15 00:00:00 -08:00
+date: 2009-01-16 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -33,6 +33,8 @@ files:
 - bin/lightning-full_path
 - bin/lightning-install
 - lib/lightning
+- lib/lightning/bolt.rb
+- lib/lightning/bolts.rb
 - lib/lightning/completion.rb
 - lib/lightning/config.rb
 - lib/lightning/core_extensions.rb
@@ -40,6 +42,7 @@ files:
 - lib/lightning/path_map.rb
 - lib/lightning.rb
 - test/lightning.yml
+- test/lightning_bolt_test.rb
 - test/lightning_completion_test.rb
 - test/lightning_config_test.rb
 - test/lightning_path_map_test.rb