lightning 0.2.1 → 0.3.0

data/lib/lightning/builder.rb

@@ -0,0 +1,87 @@
+module Lightning
+  # Builds shell file ~/.lightning/functions.sh from the config file. This file
+  # is built and sourced into a user's shell using `lightning-reload`.
+  # Currently supports bash and zsh shells. Defaults to building for bash.
+  module Builder
+    extend self
+
+    # @private
+    HEADER = <<-INIT.gsub(/^\s{4}/,'')
+    #### This file was built by lightning. ####
+    #LBIN_PATH="$PWD/bin/" #only use for development
+    LBIN_PATH=""
+    
+    lightning-reload() {
+      lightning install $@
+      source_file=$(lightning source_file)
+      source $source_file
+      echo Loaded $source_file
+    }
+    INIT
+
+    # @return [Boolean] Determines if Builder can build a file for its current shell
+    def can_build?
+      respond_to? "#{shell}_builder"
+    end
+
+    # @return [String] Current shell, defaults to 'bash'
+    def shell
+      Lightning.config[:shell] || 'bash'
+    end
+
+    # @return [String] Builds shell file
+    def run
+      return puts("No builder exists for #{Builder.shell} shell") unless Builder.can_build?
+      functions = Lightning.functions.values
+      check_for_existing_commands(functions)
+      output = build(functions)
+      File.open(Lightning.config.source_file, 'w') {|f| f.write(output) }
+      output
+    end
+
+    # @param [Array] Function objects
+    # @return [String] Shell file string to be saved and sourced
+    def build(args)
+      HEADER + "\n\n" + send("#{shell}_builder", *[args])
+    end
+
+    protected
+    def bash_builder(functions)
+      functions.map do |e|
+        <<-EOS.gsub(/^\s{10}/,'')
+          #{e.name} () {
+            local IFS=$'\\n'
+            local arr=( $(${LBIN_PATH}lightning-translate #{e.name} $@) )
+            #{e.shell_command} "${arr[@]}"
+          }
+          complete -o default -C "${LBIN_PATH}lightning-complete #{e.name}" #{e.name}
+        EOS
+      end.join("\n")
+    end
+
+    def zsh_builder(functions)
+      functions.map do |e|
+        <<-EOS.gsub(/^\s{10}/,'')
+          #{e.name} () {
+            local IFS=$'\\n'
+            local arr
+            arr=( $(${LBIN_PATH}lightning-translate #{e.name} $@) )
+            #{e.shell_command} "${arr[@]}"
+          }
+          _#{e.name} () {
+            local IFS=$'\\n'
+            reply=( $(${LBIN_PATH}lightning-complete #{e.name} "${@}") )
+          }
+          compctl -QK _#{e.name} #{e.name}
+        EOS
+      end.join("\n")
+    end
+
+    def check_for_existing_commands(functions)
+      if !(existing_commands = functions.select {|e| Util.shell_command_exists?(e.name) }).empty?
+        puts "The following commands already exist in $PATH and are being generated: "+
+          "#{existing_commands.map {|e| e.name}.join(', ')}"
+      end
+    end
+  end
+end

data/lib/lightning/commands.rb

@@ -1,92 +1,115 @@
-class Lightning
-  # TODO: Provide commands for the lightning binary.
+module Lightning
+  # Runs lightning commands which are methods in this namespace.
+  #
+  # == Command Basics
+  # To get a list of commands and their description: +lightning -h+. To get usage and description on
+  # a command +lightning COMMAND -h+ i.e +lightning bolt -h+. Any command and subcommand can be abbreviated.
+  # For example, +lightning b c gem path1+ is short for +lightning bolt create gem path1+.
+  #
+  # == Command Plugins
+  # Command plugins are a way for users to define their own lightning commands.
+  # A command plugin is a .rb file in ~/.lightning/commands/. Each plugin can have multiple
+  # commands since a command is just a method in Lightning::Commands.
+  #
+  # A sample command plugin looks like this:
+  #   module Lightning::Commands
+  #     desc 'COMMAND', 'Prints hello'
+  #     def hello(argv)
+  #       puts "Hello with #{argv.size} arguments"
+  #     end
+  #   end
+  #
+  # To register a command, {Commands#desc desc} must be placed before a method, describing the command's
+  # usage and description. Note that a command receives commandline arguments as an array. See
+  # {CommandsUtil} for helper methods to be used inside a command.
+  #
+  # For command plugin examples
+  # {read the source}[http://github.com/cldwalker/lightning/tree/master/lib/lightning/commands/].
   module Commands
-    # @options :search=>:string, :command=>:string
-    def lightning_command(*args)
-      puts "Lightning Commands"
-      if options[:command]
-        lightning_commands = Lightning.config[:commands].select {|e| e['map_to'] == options['command']}
+    @desc = {}
+    extend self
+    extend CommandsUtil
+
+    # Called by `lightning` to call proper lightning command, print help or print version
+    def run(argv=ARGV)
+      if (command = argv.shift) && (actual_command = unalias_command(command))
+        run_command(actual_command, argv)
+      elsif command && respond_to?(command)
+        run_command(command, argv)
+      elsif %w{-v --version}.include?(command)
+        puts "lightning #{VERSION}"
       else
-        lightning_commands = Lightning.config[:commands]
+        load_user_commands
+        puts "Command '#{command}' not found.","\n" if command && !%w{-h --help}.include?(command)
+        print_help
       end
-      puts lightning_commands.map {|e| e['name'] }.join("\n")
     end
 
-    #@options :add=>:boolean, :delete=>:boolean
-    def path(*args)
-      command_name = args.shift
-      if options['delete']
-        return puts("Path needed") if args[0].nil?
-        delete_path(command_name, args[0])
-      elsif options['add']
-        return puts("Path needed") if args[0].nil?
-        add_path(command_name, args[0])
-      else
-        puts "Paths for command '#{command_name}'"
-        puts config_command_paths(command_name).join("\n")
-      end
+    # @return [Array] Available lightning commands
+    def commands
+      @desc.keys
     end
 
-    #@options :delete=>:boolean, :add=>:boolean, :global=>:boolean
-    def alias(*args)
-      if options['delete']
-        delete_command_alias(*args.slice(0,2))
-      elsif options['add']
-        add_command_alias(*args.slice(0,3))
+    # Calls proper lightning command with remaining commandline arguments
+    def run_command(command, args)
+      @command = command.to_s
+      if %w{-h --help}.include?(args[0])
+        print_command_help
       else
-        puts "Aliases"
-        (Lightning.config[:aliases] || []).each do |path_alias, path|
-          puts "#{path_alias} : #{path}"
-        end
+        send(command, args)
       end
+    rescue StandardError
+      $stderr.puts "Error: "+ $!.message
+    end
+
+    # @return [String] Command usage for current command
+    def command_usage
+      "Usage: lightning #{@command} #{desc_array[0]}"
+    end
+
+    # Place before a command method to set its usage and description
+    def desc(*args)
+      @next_desc = args
     end
 
     private
-    def config_command_paths(name)
-      if command = Lightning.config_command(name, true)
-        if command['paths'].is_a?(String)
-           Lightning.config[:paths][command['paths']]
-        else
-          command['paths']
-        end
-      else
-        []
-      end
+    def print_command_help
+      puts [command_usage, '', desc_array[1]]
     end
 
-    def add_command_alias(command_name, path_alias, path)
-      if (command = Lightning.config_command(command_name, true))
-        path = File.expand_path(path)
-        command['aliases'][path_alias] = path
-        Lightning.config.save
-        puts "Path alias '#{path_alias}' added"
-      end
+    def print_help
+      puts "lightning COMMAND [arguments]", ""
+      puts "Available commands:"
+      print_sorted_hash @desc.inject({}) {|a,(k,v)| a[k] = v[1]; a }, true
+      puts "", "For more information on a command use:"
+      puts "  lightning COMMAND -h", ""
+      puts "Options: "
+      puts "  -h, --help     Show this help and exit"
+      puts "  -v, --version  Print current version and exit"
+      puts "", "Commands and subcommands can be abbreviated."
+      puts "For example, 'lightning b c gem path1' is short for 'lightning bolt create gem path1'."
     end
 
-    def delete_command_alias(command_name, path_alias)
-      if (command = Lightning.config_command(command_name, true))
-        command['aliases'].delete(path_alias)
-        Lightning.config.save
-        puts "Path alias '#{path_alias}' deleted"
-      end
+    def desc_array
+      Array(@desc[@command])
     end
 
-    def add_path(command_name, path)
-      if (command = Lightning.config_command(command_name, true))
-        path = File.expand_path(path)
-        config_command_paths(command_name) << path
-        Lightning.config.save
-        puts "Path '#{path}' added"
-      end
+    def unalias_command(command)
+      actual_command = commands.sort.find {|e| e[/^#{command}/] }
+      # don't load plugin commands for faster completion/translation
+      load_user_commands unless %w{translate complete}.include?(actual_command)
+      actual_command || commands.sort.find {|e| e[/^#{command}/] }
     end
 
-    def delete_path(command_name, path)
-      if (command = Lightning.config_command(command_name, true))
-        path = File.expand_path(path)
-        config_command_paths(command_name).delete(path)
-        Lightning.config.save
-        puts "Path '#{path}' deleted"
-      end
+    def load_user_commands
+      @load_user_commands ||= Util.load_plugins(Lightning.dir, 'commands') || true
+    end
+
+    def method_added(meth)
+      @desc[meth.to_s] = @next_desc if @next_desc
+      @next_desc = nil
     end
   end
 end
+
+Lightning::Util.load_plugins File.dirname(__FILE__), 'commands'

data/lib/lightning/commands/bolt.rb

@@ -0,0 +1,63 @@
+module Lightning::Commands
+  protected
+  desc "(list [-a|--alias] | alias BOLT ALIAS | create BOLT GLOBS | delete BOLT |\n#{' '*22} "+
+    "generate BOLT [generator] [-t|--test] | global ON_OR_OFF BOLTS | show BOLT)",
+    "Commands for managing bolts. Defaults to listing them."
+  def bolt(argv)
+    subcommand = argv.shift || 'list'
+    subcommand = %w{alias create delete generate global list show}.find {|e| e[/^#{subcommand}/]} || subcommand
+    bolt_subcommand(subcommand, argv) if subcommand_has_required_args(subcommand, argv)
+  end
+
+  def bolt_subcommand(subcommand, argv)
+    case subcommand
+    when 'list'     then  list_subcommand(:bolts, argv)
+    when 'create'   then  create_bolt(argv.shift, argv)
+    when 'alias'    then  alias_bolt(argv[0], argv[1])
+    when 'delete'   then  delete_bolt(argv[0])
+    when 'show'     then  show_bolt(argv[0])
+    when 'global'   then  globalize_bolts(argv.shift, argv)
+    when 'generate' then  generate_bolt(argv)
+    else puts "Invalid subcommand '#{subcommand}'", command_usage
+    end
+  end
+
+  def generate_bolt(argv)
+    args, options = parse_args argv
+    Lightning::Generator.run(args[0], :once=>args[1], :test=>options[:test] || options[:t])
+  end
+
+  def create_bolt(bolt, globs)
+    config.bolts[bolt] = Lightning::Config.bolt(globs)
+    save_and_say "Created bolt '#{bolt}'"
+  end
+
+  def alias_bolt(bolt, bolt_alias)
+    if_bolt_found(bolt) do |bolt|
+      config.bolts[bolt]['alias'] = bolt_alias
+      save_and_say "Aliased bolt '#{bolt}' to '#{bolt_alias}'"
+    end
+  end
+
+  def delete_bolt(bolt)
+    if_bolt_found(bolt) do |bolt|
+      config.bolts.delete(bolt)
+      save_and_say "Deleted bolt '#{bolt}' and its functions"
+    end
+  end
+
+  def show_bolt(bolt)
+    if_bolt_found(bolt) {|b| puts config.bolts[b].to_yaml.sub("--- \n", '') }
+  end
+
+  def globalize_bolts(boolean, arr)
+    return puts("First argument must be 'on' or 'off'") unless %w{on off}.include?(boolean)
+    if boolean == 'on'
+      valid = arr.select {|b| if_bolt_found(b) {|bolt| config.bolts[bolt]['global'] = true } }
+      save_and_say "Global on for bolts #{valid.join(', ')}" unless valid.empty?
+    else
+      valid = arr.select {|b| if_bolt_found(b) {|bolt| config.bolts[bolt].delete('global') ; true } }
+      save_and_say "Global off for bolts #{valid.join(', ')}" unless valid.empty?
+    end
+  end
+end

data/lib/lightning/commands/core.rb

@@ -0,0 +1,57 @@
+module Lightning
+  module Commands
+    # Silent command used by `lightning-reload` which prints {Builder}'s shell file
+    def source_file(argv)
+      puts config.source_file
+    end
+
+    protected
+    desc "FUNCTION [arguments]", "Prints a function's completions based on the last argument."
+    def complete(argv)
+      return unless command_has_required_args(argv, 1)
+      # this arg is needed by zsh in Complete
+      function = argv[0]
+      # bash hack: read ENV here because passing $COMP_LINE from the shell
+      # is a different incorrect buffer
+      buffer = ENV["COMP_LINE"] || argv.join(' ')
+      # zsh hack: when tabbing on blank space $@ is empty
+      # this ensures all completions
+      buffer += " " if argv.size == 1
+
+      puts Completion.complete(buffer, Lightning.functions[function])
+    end
+
+    desc "FUNCTION ARGUMENTS", "Translates each argument and prints it on a separate line."
+    def translate(argv)
+      return unless command_has_required_args(argv, 2)
+      translations = (fn = Lightning.functions[argv.shift]) ?
+        fn.translate(argv).join("\n") : '#Error-no_function_found_to_translate'
+      puts translations
+    end
+
+    desc "[--file=FILE] [--shell=SHELL]",
+      "Builds shell functions and installs them into FILE to be sourced by shell."
+    def install(argv)
+      args, options = parse_args(argv)
+      config[:shell] = options[:shell] if options[:shell]
+      config.source_file = options[:file] if options[:file]
+
+      if first_install?
+        Generator.run
+        puts "Created ~/.lightningrc"
+        config.bolts.each {|k,v| v['global'] = true }
+        config.save
+      end
+
+      Builder.run
+      puts "Created #{config.source_file}"+ (first_install? ? " for #{Builder.shell}" : '')
+    end
+
+    def first_install?; !File.exists?(Config.config_file); end
+
+    desc '', 'Lists available generators.'
+    def generator(argv)
+      print_sorted_hash Generator.generators
+    end
+  end
+end

data/lib/lightning/commands/function.rb

@@ -0,0 +1,76 @@
+module Lightning::Commands
+  protected
+  desc '(list [--command=SHELL_COMMAND] [--bolt=BOLT] | create SHELL_COMMAND BOLT [function] | delete FUNCTION)',
+    'Commands for managing functions. Defaults to listing them.'
+  def function(argv)
+    subcommand = argv.shift || 'list'
+    subcommand = %w{create delete list}.find {|e| e[/^#{subcommand}/]} || subcommand
+    function_subcommand(subcommand, argv) if subcommand_has_required_args(subcommand, argv)
+  end
+
+  def function_subcommand(subcommand, argv)
+    case subcommand
+    when 'list'    then list_function(argv)
+    when 'create'  then create_function_and_bolt(argv)
+    when 'delete'  then delete_function argv.shift
+    else puts "Invalid subcommand '#{subcommand}'", command_usage
+    end
+  end
+
+  def list_function(argv)
+    args, options = parse_args argv
+    functions = if options[:bolt]
+      Lightning.functions.values.select {|e| e.bolt.name == options[:bolt] }.map {|e| e.name}
+    elsif options[:command]
+      Lightning.functions.values.select {|e| e.shell_command == options[:command] }.map {|e| e.name}
+    else
+      Lightning.functions.keys
+    end
+    puts functions.sort
+  end
+
+  def create_function_and_bolt(argv)
+    bolt = config.unalias_bolt(argv[1])
+    (config.bolts[bolt] || Lightning::Generator.run(bolt, :once=>bolt)) &&
+      create_function(argv[0], bolt, :name=>argv[2])
+  end
+
+  def create_function(scmd, bolt, options={})
+    options[:name] ||= Lightning.bolts[bolt].function_name(scmd) unless global_commands.include?(scmd)
+    function = options[:name] || Lightning.bolts[bolt].function_name(scmd)
+
+    if find_function(config.bolts[bolt]['functions'], 'shell_command', scmd)
+      puts("Function '#{function}' already exists")
+    else
+      if_bolt_found(bolt) do |bolt|
+        fn = options[:name] ? {'name'=>options[:name],'shell_command'=>scmd} : scmd
+        (config.bolts[bolt]['functions'] ||= []) << fn
+        save_and_say "Created function '#{function}'"
+      end
+    end
+  end
+
+  def find_function(functions, attribute, query)
+    Array(functions).find {|e|
+      attribute != 'shell_command' ? (e.is_a?(Hash) && e[attribute] == query) :
+        config.only_command(e.is_a?(Hash) ? e['shell_command'] : e) == query
+    }
+  end
+
+  def delete_function(fn)
+    if (function = Lightning.functions[fn])
+      cmd = config.unaliased_command(fn.split('-')[0])
+      if_bolt_found(function.bolt.name) {|bolt|
+        if (element = find_function(config.bolts[bolt]['functions'], 'name', fn) ||
+            find_function(config.bolts[bolt]['functions'], 'shell_command', cmd) )
+          config.bolts[bolt]['functions'].delete(element)
+          return save_and_say("Deleted function '#{fn}'")
+        elsif function.bolt.global && config.global_commands.include?(cmd)
+          return puts("Can't delete function '#{fn}' which is generated by a shell command '#{cmd}'.",
+          "Can only delete by deleting shell command: shell_command delete #{cmd}")
+        end
+      }
+    end
+    puts "Can't find function '#{fn}'"
+  end
+end