cldwalker-lightning 0.1.1

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2008 Gabriel Horner
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,127 @@
+Description
+===========
+
+Autocomplete a group of files and directories simply by listing their globbable paths
+in a config file. Generate completions from your config, source them into your shell
+and you're ready to rock.
+
+So instead of carpal-typing
+
+    bash> vim /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/irb.rb
+
+you type or complete
+
+    bash> rvim irb.rb
+
+Uneasy about what lightning will execute? Test it out with a -test flag
+
+    bash> rvim -test irb.rb
+    rvim '/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/irb.rb'
+
+As you can see, you only need to autocomplete the basenames of paths and lightning will resolve their
+full paths.  rvim is a lightning command configured to autocomplete a certain group of paths for vim.
+In this case, rvim is configured to complete my ruby core and standard library files.
+
+
+Install
+=======
+
+To make your own commands, you'll need to:
+
+1. Create ~/.lightning.yml or a lightning.yml in the current directory.
+   Use the Configuration section below and the provided lightning.yml.example as guides.
+
+2. Execute `lightning-install` to generate ~/.lightning\_completions from your config.
+   There is a config option for changing the location of the generated file. See Configuration
+   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`.
+
+
+Globbable paths
+===============
+
+Since the globbable paths are interpreted by ruby's Dir.glob(), you can:
+
+1. Autocomplete files and directories that don't start with specific letters.
+
+   Dir.glob("[^ls]*") -> Matches anything not starting with l or s
+
+2. Autocomplete files ending with specific file extensions for a given directory.
+
+   Dir.glob("/painfully/long/path/*.{rb,erb}") -> Matches files ending with .rb or .erb
+
+3. Autocomplete all directories however many levels deep under the current directory.
+
+   Dir.glob("**/")
+
+`ri Dir.glob` for more examples.
+
+Configuration
+=====================
+
+It helps to look at lightning.yml.example while reading this.
+
+Configuration options are:
+
+* generated\_file: Location of shell script file generated from config. Defaults to
+  ~/.lightning\_completions.
+* ignore\_paths: List of paths to globally ignore when listing completions.
+* shell: Specifies shell script generator used for generating completions. Defaults to bash.
+* commands: A list of lightning commands. A lightning command is just a shell function
+  which executes a specified shell function with a defined set of paths to autocomplete on.
+  A command consists of the following options/keys:
+  
+  * name (required): Name of the lightning command you'll be typing.
+  * map\_to (required): Shell command which the lightning command passes arguments to.
+  * description: Description which is placed as a comment in the generated shell script.
+  * paths (required): A list of globbable paths, whose basenames are autocompleted. You can also
+    pass this a path name that has been defined in the paths option. 
+
+* paths: This takes a hash (pairs) of path names and globbable paths. This should be used when
+  you have a group of paths that are used in multiple commands. When doing that, you would specify
+  the path name defined here in the command's paths key.
+  Note: path names should only be alphanumeric
+
+* post\_path: Text to add immediately after a resolved path. lightning.yml.example contains
+  an example used for opening gem documentation in your browser.
+
+Duplicate Basenames
+===================
+
+So what happens when their are multiple matches for the same basename?
+Lightning appends a '/' + the full directory to each of the basenames.
+
+For example, if I autocomplete button.rb for my ruby standard libraries I get:
+
+      bash> rvim button.rb
+      button.rb//System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/tk
+      button.rb//System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/tkextlib/bwidget
+      button.rb//System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/tkextlib/blt/tile
+
+This isn't the prettiest completion but it resolves duplicates, displays the path differences
+between each and easily autocompletes. I'm open to suggestions on this syntax.
+
+Limitations
+===========
+
+* The generated shell scripts default to bash but could easily be extended for other shell languages. Patches welcome.
+* All arguments passed to a lightning command are considered part of the basename to resolve. So
+  it's not yet possible to resolve some arguments and not others.
+
+Motivation
+==========
+
+I've seen dotfiles on github and on blogs which accomplish this kind of autocompletion for gem
+documentation. There's even a gem just for gem editing: http://gemedit.rubyforge.org/.
+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
+====
+
+* Clean up code to better test.
+* Aliases for common autocompletions.
+* Allow lightning commands to only path-resolve one of multiple arguments given.

data/bin/lightning-complete

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(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

data/bin/lightning-full_path

@@ -0,0 +1,15 @@
+#!/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.
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/lightning")
+
+key = ARGV.shift or raise "No key given"
+if ARGV.empty?
+  puts "No arguments given" 
+  exit 1
+end
+puts Lightning.full_path_for_completion(ARGV, key) || ''
+exit 0

data/bin/lightning-install

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/lightning")
+
+Lightning::Generator.generate_completions

data/lib/lightning/completion.rb

@@ -0,0 +1,30 @@
+# derived from http://github.com/ryanb/dotfiles/tree/master/bash/completion_scripts/project_completion
+#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
+    end
+      
+    def initialize(text_typed, path_key)
+      @text_typed = text_typed
+      @path_key = path_key
+    end
+  
+    def matches
+      possible_completions.select do |e|
+        e[0, typed.length] == typed
+      end
+    end
+  
+    def typed
+      # @text_typed[/\s(.+?)$/, 1] || ''
+      text = @text_typed[/^(\S+)\s+(#{Lightning::TEST_FLAG})?\s*(.+?)$/, 3] || ''
+      text.strip
+    end
+  
+    def possible_completions
+      Lightning.path_map.completions(@path_key)
+    end    
+  end
+end

data/lib/lightning/config.rb

@@ -0,0 +1,60 @@
+module Lightning::Config
+  def config
+    unless @config
+      @config = read_config
+      add_command_paths(@config)
+    end
+    @config
+  end
+  
+  def read_config(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)
+    "#{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|
+      #mapping a referenced path
+      if e['paths'].is_a?(String)
+        e['path_key'] = e['paths'].dup
+        e['paths'] = config[:paths][e['paths'].strip] || []
+      end
+      #create a path entry + key if none exists
+      if e['path_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']
+      end
+    end
+  end
+  
+  def ignore_paths
+    unless @ignore_paths
+      @ignore_paths = []
+      @ignore_paths += config[:ignore_paths] if config[:ignore_paths] && !config[:ignore_paths].empty?
+    end
+    @ignore_paths
+  end
+end

data/lib/lightning/core_extensions.rb

@@ -0,0 +1,9 @@
+class Hash
+  #from Rails' ActiveSupport
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+end

data/lib/lightning/generator.rb

@@ -0,0 +1,47 @@
+#This class generates shell scripts from a configuration.
+class Lightning
+  class Generator
+    class<<self
+    def generate_completions
+      output = generate(Lightning.config[:shell], Lightning.config[:commands])
+      File.open(Lightning.config[:generated_file], 'w'){|f| f.write(output) }
+      output
+    end
+          
+    def generate(*args)
+      shell = args.shift
+      send("#{shell}_generator", *args)
+    end
+    
+    def bash_generator(commands)
+      body = <<-INIT
+      #### This file was generated by Lightning. ####
+      #LBIN_PATH="$PWD/bin/" #only use for development
+      LBIN_PATH="" 
+      
+      INIT
+      commands.each do |e|
+        body += <<-EOS
+          
+          #{'#' + e['description'] if e['description']}
+          #{e['name']} () {
+            if [ -z "$1" ]; then
+              echo "No arguments given"
+              return
+            fi
+            FULL_PATH="`${LBIN_PATH}lightning-full_path #{e['path_key']} $@`#{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
+            else
+              #{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']}
+        EOS
+      end
+      body.gsub(/^\s{6,10}/, '')
+    end
+    end
+  end
+end

data/lib/lightning/path_map.rb

@@ -0,0 +1,57 @@
+#This class maps completions to their full paths for a given path key.
+class Lightning
+  class PathMap
+    def initialize
+      @maps = {}
+    end
+  
+    def [](key)
+      @maps[key] ||= create_map(key)
+    end
+    
+    def completions(key)
+      self[key].keys
+    end
+    
+    def create_map(key)
+      create_map_for_globs(Lightning.globbable_paths_by_key(key))
+    end
+    
+    #should return hash
+    def create_map_for_globs(globs)
+      path_hash = {}
+      ignore_paths = ['.', '..'] + Lightning.ignore_paths
+      globs.each do |d|
+        Dir.glob(d, File::FNM_DOTMATCH).each do |e|
+          basename = File.basename(e)
+          unless ignore_paths.include?(basename)
+            #save paths of duplicate basenames to process later
+            if path_hash.has_key?(basename)
+              if path_hash[basename].is_a?(Array)
+                path_hash[basename] << e
+              else
+                path_hash[basename] = [path_hash[basename], e]
+              end
+            else
+              path_hash[basename] = e
+            end
+          end
+        end
+      end
+      map_duplicate_basenames(path_hash)
+      path_hash
+    end
+    
+    #map saved duplicates
+    def map_duplicate_basenames(path_hash)
+      path_hash.select {|k,v| v.is_a?(Array)}.each do |key,paths|
+        paths.each do |e|
+          new_key = "#{key}/#{File.dirname(e)}"
+          path_hash[new_key] = e
+        end
+        path_hash.delete(key)
+      end
+    end
+    
+  end
+end

data/lib/lightning.rb

@@ -0,0 +1,26 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__))
+require 'yaml'
+require 'lightning/completion'
+require 'lightning/config'
+require 'lightning/path_map'
+require 'lightning/core_extensions'
+require 'lightning/generator'
+
+class Lightning
+  TEST_FLAG = '-test'
+  extend Config
+  class<<self    
+    def path_map
+      @path_map ||= PathMap.new
+    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}/]
+      end
+      path_map[path_key][basename]
+    end
+  end
+end

data/lightning.yml.example

@@ -0,0 +1,85 @@
+---
+generated_file: lightning_completions
+
+ignore_paths:
+    - .DS_Store
+    - .git
+
+# You'll notice that most commands have the format of "#{original_command_alias}-#{path_alias}"
+# I recommend this for most of these commands as you can then easily autocomplete them for recall.
+commands:
+    - name : c
+      map_to : cd
+      description : my code directories
+      paths: 
+        - /Users/bozo/code/gems/*
+        - /Users/bozo/code/repo/*
+        - /Users/bozo/code/tds/gems/*
+        
+    - name : cd-g
+      map_to : cd
+      paths: gem
+      
+    - name : m-g
+      map_to : mate
+      paths: gem
+      
+    - name : o-g
+      map_to : open
+      description : open gem's doc in browser
+      post_path : /rdoc/index.html
+      paths: gem_rdoc
+    
+    - name : v-r
+      map_to : vim
+      description : ruby core files
+      paths: 
+      #picked from $LOAD_PATH
+        - /Library/Ruby/Site/1.8/**/*.rb
+        - /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/**/*.rb
+
+    - name : cd-r
+      map_to : cd
+      description : ruby core directories
+      paths:
+         - /Library/Ruby/Site/1.8/**/
+         - /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/**/
+    
+    - name : oa
+      map_to : open -a
+      description : open mac applications
+      paths:
+        - /Applications/*.app
+        - /Applications/Utilities/*.app
+        
+    - name : v-g
+      map_to : vim
+      description : open files when in the base directory of a ruby gem project
+      paths:
+        - lib/**/*.rb
+        - test/**/*.rb
+        - spec/**/*.rb
+        - bin/**
+    
+    - name : v-rr
+      map_to : vim
+      description: open files when in the base directory of a rails project
+      paths:
+        - config/**/*.rb
+        - app/**/*.{rb,erb,rhtml}
+        - lib/**/*.rb
+        - test/**/*.rb
+        - spec/**/*.rb
+      
+paths: 
+    # to obtain your own paths to your ruby gems:
+    # `gem environment path`.split(":").map {|e| e +"/gems/*" }
+    gem:
+      - /Users/bozo/.gem/ruby/1.8/gems/*
+      - /Library/Ruby/Gems/1.8/gems/*
+      - /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8/gems/*
+
+    gem_rdoc:
+      - /Users/bozo/.gem/ruby/1.8/doc/*
+      - /Library/Ruby/Gems/1.8/doc/*
+      - /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8/doc/*

data/lightning_completions.example

@@ -0,0 +1,147 @@
+#### This file was generated by Lightning. ####
+#LBIN_PATH="$PWD/bin/" #only use for development
+LBIN_PATH="" 
+       
+#my code directories
+c () {
+  if [ -z "$1" ]; then
+    echo "No arguments given"
+    return
+  fi
+  FULL_PATH="`${LBIN_PATH}lightning-full_path cd-c $@`"
+  if [ $1 == '-test' ]; then
+    CMD="cd '$FULL_PATH'"
+    echo $CMD
+  else
+    cd "$FULL_PATH"
+  fi
+}
+complete -o default -C "${LBIN_PATH}lightning-complete cd-c" c
+
+
+cd-g () {
+  if [ -z "$1" ]; then
+    echo "No arguments given"
+    return
+  fi
+  FULL_PATH="`${LBIN_PATH}lightning-full_path gem $@`"
+  if [ $1 == '-test' ]; then
+    CMD="cd '$FULL_PATH'"
+    echo $CMD
+  else
+    cd "$FULL_PATH"
+  fi
+}
+complete -o default -C "${LBIN_PATH}lightning-complete gem" cd-g
+
+
+m-g () {
+  if [ -z "$1" ]; then
+    echo "No arguments given"
+    return
+  fi
+  FULL_PATH="`${LBIN_PATH}lightning-full_path gem $@`"
+  if [ $1 == '-test' ]; then
+    CMD="mate '$FULL_PATH'"
+    echo $CMD
+  else
+    mate "$FULL_PATH"
+  fi
+}
+complete -o default -C "${LBIN_PATH}lightning-complete gem" m-g
+
+#open gem's doc in browser
+o-g () {
+  if [ -z "$1" ]; then
+    echo "No arguments given"
+    return
+  fi
+  FULL_PATH="`${LBIN_PATH}lightning-full_path gem_rdoc $@`/rdoc/index.html"
+  if [ $1 == '-test' ]; then
+    CMD="open '$FULL_PATH'"
+    echo $CMD
+  else
+    open "$FULL_PATH"
+  fi
+}
+complete -o default -C "${LBIN_PATH}lightning-complete gem_rdoc" o-g
+
+#ruby core files
+v-r () {
+  if [ -z "$1" ]; then
+    echo "No arguments given"
+    return
+  fi
+  FULL_PATH="`${LBIN_PATH}lightning-full_path vim-v-r $@`"
+  if [ $1 == '-test' ]; then
+    CMD="vim '$FULL_PATH'"
+    echo $CMD
+  else
+    vim "$FULL_PATH"
+  fi
+}
+complete -o default -C "${LBIN_PATH}lightning-complete vim-v-r" v-r
+
+#ruby core directories
+cd-r () {
+  if [ -z "$1" ]; then
+    echo "No arguments given"
+    return
+  fi
+  FULL_PATH="`${LBIN_PATH}lightning-full_path cd-cd-r $@`"
+  if [ $1 == '-test' ]; then
+    CMD="cd '$FULL_PATH'"
+    echo $CMD
+  else
+    cd "$FULL_PATH"
+  fi
+}
+complete -o default -C "${LBIN_PATH}lightning-complete cd-cd-r" cd-r
+
+#open mac applications
+oa () {
+  if [ -z "$1" ]; then
+    echo "No arguments given"
+    return
+  fi
+  FULL_PATH="`${LBIN_PATH}lightning-full_path open-oa $@`"
+  if [ $1 == '-test' ]; then
+    CMD="open -a '$FULL_PATH'"
+    echo $CMD
+  else
+    open -a "$FULL_PATH"
+  fi
+}
+complete -o default -C "${LBIN_PATH}lightning-complete open-oa" oa
+
+#open files when in the base directory of a ruby gem project
+v-g () {
+  if [ -z "$1" ]; then
+    echo "No arguments given"
+    return
+  fi
+  FULL_PATH="`${LBIN_PATH}lightning-full_path vim-v-g $@`"
+  if [ $1 == '-test' ]; then
+    CMD="vim '$FULL_PATH'"
+    echo $CMD
+  else
+    vim "$FULL_PATH"
+  fi
+}
+complete -o default -C "${LBIN_PATH}lightning-complete vim-v-g" v-g
+
+#open files when in the base directory of a rails project
+v-rr () {
+  if [ -z "$1" ]; then
+    echo "No arguments given"
+    return
+  fi
+  FULL_PATH="`${LBIN_PATH}lightning-full_path vim-v-rr $@`"
+  if [ $1 == '-test' ]; then
+    CMD="vim '$FULL_PATH'"
+    echo $CMD
+  else
+    vim "$FULL_PATH"
+  fi
+}
+complete -o default -C "${LBIN_PATH}lightning-complete vim-v-rr" v-rr

data/test/lightning.yml

@@ -0,0 +1,39 @@
+---
+generated_file: lightning_completions
+
+ignore_paths:
+    - .DS_Store
+    - .git
+
+#only oa command is currently used
+commands:
+    - name : oa
+      map_to : open -a
+      description : open mac applications
+      paths:
+        - /Applications/*.app
+        - /Applications/Utilities/*.app
+      
+    - name : gcd
+      map_to : cd
+      paths: gem
+      
+    - name : rcd
+      map_to : cd
+      description : ruby core directories
+      paths:
+         - /Library/Ruby/Site/1.8/**/
+         - /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/**/
+    
+paths: 
+    # to obtain your own paths to your ruby gems:
+    # `gem environment path`.split(":").map {|e| e +"/gems/*" }
+    gem:
+      - /Users/bozo/.gem/ruby/1.8/gems/*
+      - /Library/Ruby/Gems/1.8/gems/*
+      - /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8/gems/*
+
+    gem_rdoc:
+      - /Users/bozo/.gem/ruby/1.8/doc/*
+      - /Library/Ruby/Gems/1.8/doc/*
+      - /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8/doc/*

data/test/lightning_completion_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class LightningCompletionTest < Test::Unit::TestCase
+  context "Completion" do
+    
+    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}
+    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')
+      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')
+      assert_arrays_equal @completion.matches, %w{at ap}
+    end
+  end
+end

data/test/lightning_config_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class LightningConfigTest < Test::Unit::TestCase
+  context "A config" do
+    config = Lightning.read_config(File.dirname(__FILE__) + '/lightning.yml')
+    
+    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]
+      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    
+  end
+end

data/test/lightning_path_map_test.rb

@@ -0,0 +1,44 @@
+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)
+      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
+    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'])
+    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'])
+    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
+  end
+end

data/test/lightning_test.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class LightningTest < Test::Unit::TestCase
+  context "Generator" do
+    before(:all) do
+      @config_file =  File.dirname(__FILE__) + '/lightning_completions'
+      Lightning.config[:generated_file] = @config_file
+      Lightning::Generator.generate_completions
+    end
+    after(:all) {  FileUtils.rm_f(Lightning.config[:generated_file]) }
+    
+    test "generates file in expected location" do
+      assert File.exists?(@config_file)
+    end
+
+    #this depends on oa 
+    test "generates expected output for a command" do
+      generated_command = <<-EOS.gsub(/^\s{6}/,'')
+      #open mac applications
+      oa () {
+        FULL_PATH="`${LBIN_PATH}lightning-full_path open-oa $@`"
+        if [ $1 == '-test' ]; then
+          CMD="open -a '$FULL_PATH'"
+          echo $CMD
+        else
+          open -a "$FULL_PATH"
+        fi
+      }
+      complete -o default -C "${LBIN_PATH}lightning-complete open-oa" oa
+      EOS
+      output = File.read(@config_file)
+      assert output.include?(generated_command)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'test/unit'
+require 'context' #gem
+require 'stump' #gem
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+require 'lightning'
+
+class Test::Unit::TestCase
+  def assert_arrays_equal(a1, a2)
+    assert_equal a1.map {|e| e.to_s}.sort, a2.map{|e| e.to_s}.sort
+  end
+  
+end
+
+#from ActiveSupport
+class Hash
+  def slice(*keys)
+    reject { |key,| !keys.include?(key) }
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: cldwalker-lightning
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Gabriel Horner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-15 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Path completions for your shell that will let you navigate like lightning.
+email: gabriel.horner@gmail.com
+executables: 
+- lightning-complete
+- lightning-full_path
+- lightning-install
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+- LICENSE.txt
+files: 
+- lightning_completions.example
+- lightning.yml.example
+- README.markdown
+- LICENSE.txt
+- bin/lightning-complete
+- bin/lightning-full_path
+- bin/lightning-install
+- lib/lightning
+- lib/lightning/completion.rb
+- lib/lightning/config.rb
+- lib/lightning/core_extensions.rb
+- lib/lightning/generator.rb
+- lib/lightning/path_map.rb
+- lib/lightning.rb
+- test/lightning.yml
+- test/lightning_completion_test.rb
+- test/lightning_config_test.rb
+- test/lightning_path_map_test.rb
+- test/lightning_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/cldwalker/lightning
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Path completions for your shell that will let you navigate like lightning.
+test_files: []
+