lightning 0.2.1 → 0.3.0

data/lib/lightning/function.rb

@@ -0,0 +1,70 @@
+module Lightning
+  # A Function object represents a shell function which wraps around a shell command and a {Bolt}.
+  # This shell function autocompletes bolt paths by their basenames and translates arguments that
+  # are these basenames to their full paths.
+  #
+  # == Argument Translation
+  # Before executing its shell command, a function checks each argument to see if it can translate it.
+  # Translation is done if the argument matches the basename of one its bolt's paths.
+  #   $ echo-ruby irb.rb
+  #   /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/irb.rb.
+  #
+  # For translation to occur, the full basename must match. The only exception to this is when using
+  # lightning's own filename expansion syntax: a '..' at the end of an argument expands the argument
+  # with all completions that matched up to '..'. For example:
+  #   $ echo-ruby ad[TAB]
+  #     address.rb  addressbook.rb
+  #   $ echo-ruby ad..
+  #   /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/osx/addressbook.rb
+  #   /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/wsdl/soap/address.rb
+  #
+  # This expansion of any bolt paths combined with regex completion makes for a powerfully quick
+  # way of typing paths.
+  class Function
+    ATTRIBUTES = :name, :post_path, :shell_command, :bolt, :desc
+    attr_accessor *ATTRIBUTES
+    def initialize(hash)
+      raise ArgumentError, "Function must have a name and bolt" unless hash['name'] && hash['bolt']
+      hash.each do |k,v|
+        instance_variable_set("@#{k}", v)
+      end
+    end
+
+    # @return [Array] All possible completions
+    def completions
+      completion_map.keys
+    end
+
+    # @return [Array] Globs used to create {Function#completion_map completion_map}
+    def globs
+      @globs ||= @bolt.globs
+    end
+
+    # User-defined aliases for any path. Defaults to its bolt's aliases.
+    # @return [Hash] Maps aliases to full paths
+    def aliases
+      @aliases ||= @bolt.aliases
+    end
+
+    # @return [CompletionMap] Map of basenames to full paths used in completion
+    def completion_map
+      @completion_map ||= CompletionMap.new(globs, :aliases=>aliases)
+    end
+
+    # @return [Array] Translates function's arguments
+    def translate(args)
+      translated = Array(args).map {|arg|
+        !completion_map[arg] && (new_arg = arg[/^(.*)\.\.$/,1]) ?
+          Completion.complete(new_arg, self, false) : arg
+      }.flatten.map {|arg|
+        new_arg = completion_map[arg] || arg.dup
+        new_arg << @post_path if @post_path && new_arg != arg
+        if new_arg == arg && (dir = new_arg[/^([^\/]+)\//,1]) && (full_dir = completion_map[dir])
+          new_arg.sub!(dir, full_dir)
+          new_arg = File.expand_path(new_arg)
+        end
+        new_arg
+      }
+    end
+  end
+end

data/lib/lightning/generator.rb

@@ -1,48 +1,82 @@
-#This class generates shell scripts from a configuration.
-class Lightning
+module Lightning
+  # Generates globs for bolts using methods defined in {Generators}.
+  # Generated bolts are inserted under Lightning.config[:bolts].
+  # Users can define their own generators with {Generators generator plugins}.
   class Generator
-    class<<self
-    def generate_completions(generated_file=nil)
-      generated_file ||= Lightning.config[:generated_file]
-      output = generate(Lightning.config[:shell], Lightning.config[:commands])
-      File.open(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['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
-            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['name']}" #{e['name']}
-        EOS
+    DEFAULT_GENERATORS = %w{gem ruby local_ruby wild}
+
+    # @return [Hash] Maps generators to their descriptions
+    def self.generators
+      load_plugins
+      Generators.generators
+    end
+
+    # Runs generators
+    # @param [Array<String>] Generators instance methods
+    # @param [Hash] options
+    # @option options [String] :once Generator to run once
+    # @option options [Boolean] :test Runs generators in test mode which only displays
+    #   generated globs and doesn't save them
+    def self.run(gens=[], options={})
+      load_plugins
+      new.run(gens, options)
+    rescue
+      $stderr.puts "Error: #{$!.message}"
+    end
+
+    # Loads default and user generator plugins
+    def self.load_plugins
+      @loaded ||= begin
+        Util.load_plugins File.dirname(__FILE__), 'generators'
+        Util.load_plugins Lightning.dir, 'generators'
+        true
+      end
+    end
+
+    # Object used to call generator(s)
+    attr_reader :underling
+    def initialize
+      @underling = Object.new.extend(Generators)
+    end
+
+    # @return [nil, true] Main method which runs generators
+    def run(gens, options)
+      if options.key?(:once)
+        run_once(gens, options)
+      else
+        gens = DEFAULT_GENERATORS if Array(gens).empty?
+        gens = Hash[*gens.zip(gens).flatten] if gens.is_a?(Array)
+        generate_bolts gens
+      end
+    end
+
+    protected
+    def run_once(bolt, options)
+      generator = options[:once] || bolt
+      if options[:test]
+        puts Config.bolt(Array(call_generator(generator)))['globs']
+      else
+        if generate_bolts(bolt=>generator)
+          puts "Generated following globs for bolt '#{bolt}':"
+          puts Lightning.config.bolts[bolt]['globs'].map {|e| "  "+e }
+          true
+        end
       end
-      body.gsub(/^\s{6,10}/, '')
     end
+
+    def generate_bolts(bolts)
+      results = bolts.map {|bolt, gen|
+        (globs = call_generator(gen)) && Lightning.config.bolts[bolt.to_s] = Config.bolt(globs)
+      }
+      Lightning.config.save if results.any?
+      results.all?
+    end
+
+    def call_generator(gen)
+      raise "Generator method doesn't exist." unless @underling.respond_to?(gen)
+      Array(@underling.send(gen)).map {|e| e.to_s }
+    rescue
+      $stdout.puts "Generator '#{gen}' failed with: #{$!.message}"
     end
   end
-end
+end

data/lib/lightning/generators.rb

@@ -0,0 +1,53 @@
+module Lightning
+  # This module contains methods which are used to generate bolts with 'lightning bolt generate'.
+  # Each method should return an array of bolt globs. The name of the method is the name given to the bolt.
+  #
+  # == Generator Plugins
+  # Generator plugins are a way for users to define and share generators.
+  # A generator plugin is a .rb file in ~/.lightning/generators/. Each plugin can have multiple
+  # generators since a generator is just a method in Lightning::Generators.
+  #
+  # A sample generator plugin looks like this:
+  #   module Lightning::Generators
+  #     desc "Files in $PATH"
+  #     def bin
+  #       ENV['PATH'].split(":").uniq.map {|e| "#{e}/*" }
+  #     end
+  #   end
+  #
+  # To register a generator, {Generators.desc desc} must be placed before a method and given a generator
+  # description. A generator should produce an array of globs. If a generator is to be shared with others
+  # it should dynamically generate filesystem-specific globs based on environment variables and commands.
+  # Generated globs don't have to expand '~' as lightning expands that automatically to the user's home.
+  #
+  # For generator plugin examples
+  # {read the source}[http://github.com/cldwalker/lightning/tree/master/lib/lightning/generators/].
+  module Generators
+    # @return [Hash] Maps generators to their descriptions
+    def self.generators
+      @desc ||= {}
+    end
+
+    # Used before a generator method to give it a description
+    def self.desc(arg)
+      @next_desc = arg
+    end
+
+    # Overridden for generators to error elegantly when a generator calls a shell command that
+    # doesn't exist
+    def `(*args)
+      cmd = args[0].split(/\s+/)[0] || ''
+      if Util.shell_command_exists?(cmd)
+        Kernel.`(*args)
+      else
+        raise "Command '#{cmd}' doesn't exist."
+      end
+    end
+
+    private
+    def self.method_added(meth)
+      generators[meth.to_s] = @next_desc if @next_desc
+      @next_desc = nil
+    end
+  end
+end

data/lib/lightning/generators/misc.rb

@@ -0,0 +1,12 @@
+module Lightning::Generators
+  protected
+  desc "*ALL* files and directories under the current directory. Careful where you do this."
+  def wild
+    ["**/*"]
+  end
+
+  desc "Files in $PATH"
+  def bin
+    ENV['PATH'].split(":").uniq.map {|e| "#{e}/*" }
+  end
+end

data/lib/lightning/generators/ruby.rb

@@ -0,0 +1,32 @@
+module Lightning::Generators
+  protected
+  desc "Directories of gems"
+  def gem
+    `gem environment path`.chomp.split(":").map {|e| e +"/gems/*" }
+  end
+
+  desc "System ruby files"
+  def ruby
+    system_ruby.map {|e| e +"/**/*.{rb,bundle,so,c}"}
+  end
+
+  desc "Files in a rails project"
+  def rails
+    ["{app,config,lib}/**/*", "{db}/**/*.rb"]
+  end
+
+  desc "*ALL* local ruby files. Careful where you do this."
+  def local_ruby
+    ["**/*.rb", "bin/*"]
+  end
+
+  desc "Test or spec files in a ruby project"
+  def test_ruby
+    ['{spec,test}/**/*_{test,spec}.rb', '{spec,test}/**/{test,spec}_*.rb', 'spec/**/*.spec']
+  end
+
+  def system_ruby
+    require 'rbconfig'
+    [RbConfig::CONFIG['rubylibdir'], RbConfig::CONFIG['sitelibdir']].compact.uniq
+  end
+end

data/lib/lightning/util.rb

@@ -0,0 +1,70 @@
+module Lightning
+  module Util
+    extend self
+
+    if RUBY_VERSION < '1.9.1'
+
+      # From Ruby 1.9's Shellwords#shellescape
+      def shellescape(str)
+        # An empty argument will be skipped, so return empty quotes.
+        return "''" if str.empty?
+
+        str = str.dup
+
+        # Process as a single byte sequence because not all shell
+        # implementations are multibyte aware.
+        str.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/n, "\\\\\\1")
+
+        # A LF cannot be escaped with a backslash because a backslash + LF
+        # combo is regarded as line continuation and simply ignored.
+        str.gsub!(/\n/, "'\n'")
+
+        return str
+      end
+    else
+
+      require 'shellwords'
+      def shellescape(str)
+        Shellwords.shellescape(str)
+      end
+    end
+
+    # @return [String] Cross-platform way to determine a user's home. From Rubygems.
+    def find_home
+      ['HOME', 'USERPROFILE'].each {|e| return ENV[e] if ENV[e] }
+      return "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}" if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
+      File.expand_path("~")
+    rescue
+      File::ALT_SEPARATOR ? "C:/" : "/"
+    end
+
+    # @return [Boolean] Determines if a shell command exists by searching for it in ENV['PATH'].
+    def shell_command_exists?(command)
+      (@path ||= ENV['PATH'].split(File::PATH_SEPARATOR)).
+        any? {|d| File.exists? File.join(d, command) }
+    end
+
+    # @return [Hash] Symbolizes keys of given hash
+    def symbolize_keys(hash)
+      hash.inject({}) do |h, (key, value)|
+        h[key.to_sym] = value; h
+      end
+    end
+
+    # Loads *.rb plugins in given directory and sub directory under it
+    def load_plugins(base_dir, sub_dir)
+      if File.exists?(dir = File.join(base_dir, sub_dir))
+        plugin_type = sub_dir.sub(/s$/, '')
+        Dir[dir + '/*.rb'].each {|file| load_plugin(file, plugin_type) }
+      end
+    end
+
+    protected
+    def load_plugin(file, plugin_type)
+      require file
+    rescue Exception => e
+      puts "Error: #{plugin_type.capitalize} plugin '#{File.basename(file)}'"+
+        " failed to load:", e.message
+    end
+  end
+end

data/lib/lightning/version.rb

@@ -0,0 +1,3 @@
+module Lightning
+  VERSION = '0.3.0'
+end

data/test/bolt_test.rb

@@ -1,36 +1,24 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Lightning::BoltTest < Test::Unit::TestCase
-  context "Bolt" do
-    before(:each) do
-      @completion_map = {'path1'=>'/dir/path1','path2'=>'/dir/path2'}
-      @bolt = Lightning::Bolt.new('blah')
-      @bolt.completion_map.map = @completion_map
-    end
-    
-    test "fetches correct completions" do
-      assert_equal @bolt.completions, @completion_map.keys
-    end
+# depends on test/lightning.yml
+context "Bolt generates correct command from" do
+  assert "shell command" do
+    Lightning.functions['less-app'].is_a?(Function)
+  end
 
-    test "resolves completion" do
-      assert_equal @completion_map['path1'], @bolt.resolve_completion('path1')
-    end
+  assert "command hash" do
+    Lightning.functions['oa'].is_a?(Function)
+  end
 
-    test "resolves completion with test flag" do
-      assert_equal @completion_map['path1'], @bolt.resolve_completion('-test path1')
-    end
+  assert "global shell command" do
+    Lightning.functions['grep-app'].is_a?(Function)
+  end
 
-    test "creates completion_map only once" do
-      assert_equal @bolt.completion_map.object_id, @bolt.completion_map.object_id
-    end
+  assert "aliased global shell command in config" do
+    Lightning.functions['v-app'].is_a?(Function)
   end
-  
-  test "Bolt's completion_map sets up alias map with options" do
-    old_config = Lightning.config
-    Lightning.stub!(:current_command, :return=>'blah')
-    Lightning.config = {:aliases=>{'path1'=>'/dir1/path1'}, :commands=>[{'name'=>'blah'}], :paths=>{}}
-    @bolt = Lightning::Bolt.new('blah')
-    assert_equal({'path1'=>'/dir1/path1'}, @bolt.completion_map.alias_map)
-    Lightning.config = old_config
+
+  assert "global shell command which has a local config" do
+    Lightning.functions['c'].is_a?(Function)
   end
 end

data/test/builder_test.rb

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+context "Builder" do
+  def build
+    Lightning.config.source_file = source_file
+    Builder.run
+  end
+
+  def source_file
+    @source_file ||= File.dirname(__FILE__) + '/lightning_completions'
+  end
+
+  test "prints error when unable to build" do
+    Lightning.config[:shell] = 'blah'
+    capture_stdout { build }.should =~ /No.*exists.*blah shell/
+    Lightning.config[:shell] = nil
+  end
+
+  test "with non-default shell builds" do
+    Lightning.config[:shell] = 'zsh'
+    mock(Builder).zsh_builder(anything) { '' }
+    build
+    Lightning.config[:shell] = nil
+  end
+
+  test "warns about existing commands being overridden" do
+    mock(Util).shell_command_exists?('bling') { true }
+    stub(Util).shell_command_exists?(anything) { false }
+    capture_stdout { build }.should =~ /following.*exist.*: bling$/
+  end
+
+  context "with default shell" do
+    before_all { build }
+
+    test "builds file in expected location" do
+      File.exists?(source_file).should == true
+    end
+
+    # depends on test/lightning.yml
+    test "builds expected output for a command" do
+      expected = <<-EOS.gsub(/^\s{6}/,'')
+      oa () {
+        local IFS=$'\\n'
+        local arr=( $(${LBIN_PATH}lightning-translate oa $@) )
+        open -a "${arr[@]}"
+      }
+      complete -o default -C "${LBIN_PATH}lightning-complete oa" oa
+      EOS
+      File.read(source_file).include?(expected).should == true
+    end
+  end
+
+  after_all {  FileUtils.rm_f(source_file) }
+end