tabtab 0.9.0

data/features/steps/completions.rb

@@ -0,0 +1,15 @@
+Given /^env variable \$PATH includes fixture executables folder$/ do
+  ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + "/../../spec/fixtures/bin")}:#{ENV['PATH']}"
+end
+
+Then /^I should see a full list of options for 'test_app'$/ do
+  actual_output = File.read(File.join(@tmp_root, "executable.out"))
+  expected_output = %w[--extra --help -h -x].join("\n")
+  expected_output.should == actual_output.strip
+end
+
+Then /^I should not see any short form flags$/ do
+  actual_output = File.read(File.join(@tmp_root, "executable.out"))
+  expected_output = %w[--extra --help].join("\n")
+  expected_output.should == actual_output.strip
+end

data/features/steps/configuration.rb

@@ -0,0 +1,20 @@
+Given /^disable short flags$/ do
+  in_home_folder do
+    config = YAML.load(File.read('.tabtab.yml'))
+    config['shortflags'] = 'disable'
+    File.open('.tabtab.yml', 'w') do |f|
+      f << config.to_yaml
+    end
+  end
+end
+
+Given /^alias '(.*)' to existing '(.*)'$/ do |alias_name, app_name|
+  in_home_folder do
+    config = YAML.load(File.read('.tabtab.yml'))
+    config['aliases'] ||= {}
+    config['aliases'][alias_name] = app_name
+    File.open('.tabtab.yml', 'w') do |f|
+      f << config.to_yaml
+    end
+  end
+end

data/features/steps/env.rb

@@ -0,0 +1,17 @@
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'
+gem 'mocha'
+require 'mocha'
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end
+
+require 'yaml'
+
+require File.dirname(__FILE__) + "/../../lib/tabtab"
+require File.dirname(__FILE__) + "/../../lib/install_tabtab/cli"
+
+

data/features/steps/gems.rb

@@ -0,0 +1,18 @@
+Given %r{^a user's RubyGems gem cache} do
+  Given "a safe folder"
+  Given "env variable $GEM_HOME set to '#{gem_install_dir}'"
+end
+
+def gem_install_dir
+  install_dir = File.expand_path(File.join(@home_path), ".gem/ruby/1.8")
+end
+
+Given /^a RubyGem '(.*)' with autocompletions$/ do |gem_name|
+  @stdout = File.expand_path(File.join(@tmp_root, "geminstall.txt"))
+  @stderr = File.expand_path(File.join(@tmp_root, "geminstall.err"))
+  FileUtils.chdir(File.join(File.dirname(__FILE__) + "/../../spec/fixtures/gems/#{gem_name}")) do
+    system "rake gemspec > #{@stdout} 2> #{@stderr}"
+    system "gem build #{gem_name}.gemspec > #{@stdout} 2> #{@stderr}"
+    system "gem install --install-dir #{gem_install_dir} #{gem_name}*.gem > #{@stdout} 2> #{@stderr}"
+  end
+end

data/features/steps/shells.rb

@@ -0,0 +1,3 @@
+Given /^a bash shell$/ do
+  Given "env variable $SHELL set to '/bin/bash'"
+end

data/lib/dev_definitions/gem.rb

@@ -0,0 +1,54 @@
+TabTab::Definition.register('gem') do |c|
+  c.flags :version, :v
+  c.flags :h
+  
+  c.command :build do
+    Dir['**/*.gemspec']
+  end
+  c.command :check do |check|
+    check.flags :a, :alien
+    check.flags :t, :test
+  end
+  c.command :contents do
+    `gem list --local --no-versions --no-details`.split(/\n/)[3..-1]
+  end
+  c.command :dependency do
+    `gem list --local --no-versions --no-details`.split(/\n/)[3..-1]
+  end
+  c.command :install do |install|
+    # TODO this is very slow and may require caching somehow?!
+    install.default do
+      `gem list --remote --no-versions --no-details`.split(/\n/)[3..-1]
+    end
+  end
+  c.command :outdated do |outdated|
+    outdated.flags :local, :l
+    outdated.flags :remote, :r
+    outdated.flags :source
+    outdated.flags :platform do
+      Gem.platforms.map { |platform| platform.to_s }
+    end
+  end
+  c.command :specification do |spec|
+    spec.default do
+      `gem list --local --no-versions --no-details`.split(/\n/)[3..-1]
+    end
+    spec.flags :local, :l
+    spec.flags :remote, :r
+    spec.flags :source
+    spec.flags :platform do
+      Gem.platforms.map { |platform| platform.to_s }
+    end
+  end
+  c.command :uninstall do |uninstall|
+    uninstall.default do
+      `gem list --local --no-versions --no-details`.split(/\n/)[3..-1]
+    end
+  end
+  c.command :help do
+    ['commands'] + TabTab::Definition['gem'].contents.select do |definition|
+      definition.definition_type == :command
+    end.map { |definition| definition.name }
+  end
+end
+

data/lib/dev_definitions/rake.rb

@@ -0,0 +1,23 @@
+TabTab::Definition.register('rake', :import => true) do |c|
+  def rake_silent_tasks
+    if File.exists?(dotcache = File.join(File.expand_path('~'), ".raketabs-#{Dir.pwd.hash}"))
+      File.read(dotcache)
+    else
+      tasks = `rake --silent --tasks`
+      File.open(dotcache, 'w') { |f| f.puts tasks }
+      tasks
+    end
+  end
+  
+  c.default do |current|
+    tasks = (rake_silent_tasks.split("\n")[1..-1] || []).map { |line| line.split[1] }
+    if current =~ /^([-\w:]+:)/
+      upto_last_colon = $1
+      p upto_last_colon
+      tasks = tasks.map { |t| (t =~ /^#{Regexp.escape upto_last_colon}([-\w:]+)$/) ? "#{$1}" : t }
+    end
+    tasks
+  end
+  c.flags :silence, :s
+  c.flags :trace, :t
+end

data/lib/dev_definitions/script-generate.rb

@@ -0,0 +1,8 @@
+TabTab::Definition.register('script/generate', :import => true) do |c|
+  c.default do
+    generator_help = `script/generate`
+    generator_help.scan(/^\ +\w+:\s(.*)$/).map do |list|
+      list.first.strip.split(/,[\s\n]*/)
+    end.flatten
+  end
+end

data/lib/dev_definitions/script-server.rb

@@ -0,0 +1,14 @@
+TabTab::Definition.register('script/server', :import => true) do |c|
+  c.flag :environment, :e do
+    Dir['config/environments/*.rb'].map { |env| env.gsub(/^.*environments\//,'').gsub(/.rb$/,'') }
+  end
+  # script/server -p TABTAB -> generated first available port 3000, 3001, 3002
+  c.flag :port, :p do
+    port = 3000
+    until `netstat -an | grep "^tcp" | grep #{port}`.strip.empty? || port > 3010
+      port += 1
+    end
+    port > 3010 ? [] : [port.to_s]
+  end
+end
+

data/lib/install_tabtab/cli.rb

@@ -0,0 +1,139 @@
+require 'optparse'
+require 'yaml'
+require 'rubygems'
+
+# TODO extract into BashCompletion.install ...
+# TODO support non-Bash shells
+module InstallTabTab
+  class CLI
+    include TabTab::LocalConfig
+    
+    attr_reader :options
+    attr_reader :development_cli
+    
+    def self.execute(stdout, arguments=[])
+      self.new.execute(stdout, arguments)
+    end
+    
+    def execute(stdout, arguments=[])
+      $stdout = stdout
+      parse_options(arguments)
+      @to_file = []
+      install_externals
+      install_for_files
+      install_from_gems
+      @file = File.open(File.join(home, ".tabtab.bash"), "w")
+      @to_file.each { |line| @file << "#{line}\n" }
+      @file.close
+    end
+   
+    def parse_options(arguments)
+      @options = {}
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{$0} [options]"
+    
+        opts.on("-d", "--development", "Generate .tabtab.bash to use local bin/tabtab instead of RubyGems tabtab") do |v|
+          options[:development_cli] = v
+        end
+      end.parse!(arguments)
+    end
+   
+    def install_externals
+      return unless externals = config['external'] || config['externals']
+      for app_name_or_hash in externals
+        if app_name_or_hash.is_a?(String) || app_name_or_hash.is_a?(Symbol)
+          install_cmd_and_aliases(app_name_or_hash.to_s, "--external")
+        elsif app_name_or_hash.is_a?(Hash)
+          app_name_or_hash.each do |flag, app_list|
+            app_list.each do |app_name|
+              install_cmd_and_aliases(app_name, "--external")
+            end
+          end
+        end
+      end
+    end
+    
+    def install_for_files
+      return unless files_and_names = config['file'] || config['files']
+      for file in files_and_names.keys
+        case app_names = files_and_names[file]
+        when String
+          install_file file, app_names
+        when Array
+          app_names.each { |app_name| install_file(file, app_name) }
+        end
+      end
+    end
+    
+    def install_file(file, app_name)
+      install_cmd_and_aliases(app_name, "--file #{File.expand_path(file)}")
+    end
+    
+    def install_from_gems
+      find_gems_with_definition_files.each do |gem|
+        gem[:app_names].each do |app_name|
+          $stdout.puts "RubyGem #{gem[:gem_name]} contains TabTab definition for #{app_name}"
+          install_cmd_and_aliases(app_name, "--gem #{gem[:gem_name]}")
+        end
+      end
+    end
+    
+    def find_gems_with_definition_files
+      Gem.all_load_paths.inject([]) do |mem, path|
+        root = path.gsub(/(lib|bin)$/,'')
+        mem << root unless mem.include?(root)
+        mem
+      end.inject([]) do |mem, path|
+        common_file = Dir[File.join(path, "**", "tabtab_definitions.rb")].reject { |tabtab_path| tabtab_path =~ /(spec|test)/ }.first
+        gem_name = nil
+        unless common_file.nil? || common_file.empty?
+          gem_name = common_file.match(/\/([^\/]*)-\d+.\d+.\d+\/lib\//)[1]
+          TabTab::Definition.clear
+          load common_file
+          mem << { :gem_name => gem_name, :app_names => TabTab::Definition.app_names }
+        end
+        files = Dir[File.join(path, "**", "tabtab_definitions", "**", "*.rb")].reject { |tabtab_path| tabtab_path =~ /(spec|test)/ }
+        if files && files.size > 0
+          gem_path, gem_name = files.first.match(/^(.*\/([^\/]*)-\d+.\d+.\d+)/)[1..2]
+          files.each do |file|
+            TabTab::Definition.clear
+            load file
+            tabtab_path = file.gsub(gem_path, "")
+            mem << { :gem_name => "#{gem_name}#{tabtab_path}", :app_names => TabTab::Definition.app_names }
+          end
+        end
+        mem
+      end
+    end
+
+    def install_cmd_and_aliases(app_name, arg_str)
+      tabtab = tabtab_cmd(arg_str)
+      @to_file << "complete -o default -C '#{tabtab}' #{app_name}"
+      aliases.each do |alias_cmd, cmd|
+        if cmd == app_name
+          tabtab = tabtab_cmd(arg_str, cmd)
+          @to_file << "complete -o default -C '#{tabtab}' #{alias_cmd}"
+        end
+      end if aliases
+    end
+    
+    def usage
+      puts <<-EOS.gsub(/^      /, '')
+      USAGE: create a file ~/.tabtab.yml
+      EOS
+      exit 1
+    end
+   
+    def tabtab_cmd(flags, aliased_to=nil)
+      tabtab = options[:development_cli] ? File.expand_path(File.dirname(__FILE__) + "/../../bin/tabtab") : "tabtab"
+      aliased_to ? 
+      "#{tabtab} #{flags} --alias #{aliased_to}" :
+      "#{tabtab} #{flags}"
+    end
+    
+    def aliases
+      config["alias"] || config["aliases"]
+    end
+    
+  end
+end

data/lib/tabtab.rb

@@ -0,0 +1,10 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module TabTab
+  VERSION = '0.9.0'
+end
+
+require 'tabtab/local_config'
+require 'tabtab/completions'
+require 'tabtab/definitions'

data/lib/tabtab/cli.rb

@@ -0,0 +1,116 @@
+require 'optparse'
+
+module TabTab
+  class CLI
+    include TabTab::LocalConfig
+
+    attr_reader :stdout
+    attr_reader :full_line
+    attr_reader :options, :global_config
+    attr_reader :current_token, :previous_token
+    
+
+    def self.execute(stdout, arguments=[])
+      self.new.execute(stdout, arguments)
+    end
+    
+    def execute(stdout, arguments=[])
+      @stdout = stdout
+      # require "shellwords"
+      # @full_line = ENV['COMP_LINE']
+      # @full_line_argv = Shellwords.shellwords(@full_line)
+      @app_name, @current_token, @previous_token = arguments[-3..-1]
+      parse_options(arguments[0..-4])
+      load_global_config
+      if options[:external]
+        process_external
+      elsif options[:gem]
+        process_gem
+      elsif options[:file]
+        process_file
+      else
+        usage
+      end
+    end
+    
+    def parse_options(arguments)
+      @options = {}
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{$0} [options] app_name current_token previous_token"
+    
+        opts.on("--alias ALIAS", "Map an alias to an actual command with its own tabtab definition") do |v|
+          options[:alias] = v
+        end
+        opts.on("--external", "Automatically import flags from application's -h flags") do |v|
+          options[:external] = v
+        end
+        opts.on("--gem GEM_NAME", "Load the tabtab definition from within target RubyGem") do |v|
+          options[:gem] = v
+        end
+        opts.on("--file FILE_NAME", "Load the tabtab definition from a specific file") do |v|
+          options[:file] = v
+        end
+      end.parse!(arguments)
+    end
+    
+    def app_name
+      options[:alias] || @app_name
+    end
+    
+    #
+    # Support for external apps (optionally configured in ~/.tabtab.yml)
+    # Generates a completion list from the -h help output of the target application
+    #   --external
+    #
+    def process_external
+      usage unless config
+      # 'externals' => ['app1', 'app2', { '-?' => ['app3'] }]
+      # Only look for the internal hashes, and return -? if app_name == 'app3', else nil
+      options_flag = externals.inject(nil) do |o_flag, app_or_hash|
+        next if app_or_hash.is_a?(String) || app_or_hash.is_a?(Symbol)
+        app_or_hash.inject(nil) do |flag, flag_app_list|
+          flag, app_list = flag_app_list
+          flag if app_list.include?(app_name)
+        end
+      end
+      options_flag = options_flag.nil? ? '-h' : options_flag
+      stdout.puts TabTab::Completions::External.new(app_name, options_flag, global_config).starts_with(current_token)
+    end
+    
+    def externals
+      config["external"] || config["externals"]
+    end
+    
+    #
+    # Support for RubyGem-based completion definitions (found in any gem path)
+    #   --gem gem_name
+    #
+    def process_gem
+      stdout.puts TabTab::Completions::Gem.new(options[:gem], app_name, current_token, previous_token, global_config).extract.join("\n")
+    end
+    
+    #
+    # Support for file-based completion definitions (found in target file)
+    #   --file /path/to/definition.rb
+    #
+    def process_file
+      stdout.puts TabTab::Completions::File.new(options[:file], app_name, current_token, previous_token, global_config).extract.join("\n")
+    end
+    
+    def load_global_config
+      @global_config ||= {}
+      @global_config[:shortflags] = config["shortflags"] || "enable"
+    end
+    
+    def usage
+      stdout.puts <<-EOS.gsub(/^      /, '')
+      Invalid #{@app_type} flag provided to #{$0}. 
+      USAGE: 
+        #{$0} --external
+        #{$0} --gem GEM_NAME
+        #{$0} --file FILE_PATH
+      EOS
+      exit
+    end
+  end
+end