tmuxinator 0.5.0 → 0.6.0

data/bin/mux

@@ -1,6 +1,11 @@
 #!/usr/bin/env ruby
-$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
+$: << File.expand_path("../../lib/", __FILE__)
 
-require 'tmuxinator'
+require "thor"
+require "tmuxinator"
 
-Tmuxinator::Cli.run(*ARGV)
+if ARGV.length == 1 && (ARGV & Tmuxinator::Cli.new.command_list).empty?
+  Tmuxinator::Cli.new.start(ARGV[0])
+else
+  Tmuxinator::Cli.start
+end

data/bin/tmuxinator

@@ -1,6 +1,11 @@
 #!/usr/bin/env ruby
-$:.unshift(File.dirname(__FILE__) + '/../lib') unless $:.include?(File.dirname(__FILE__) + '/../lib')
+$: << File.expand_path("../../lib/", __FILE__)
 
-require 'tmuxinator'
+require "thor"
+require "tmuxinator"
 
-Tmuxinator::Cli.run(*ARGV)
+if ARGV.length == 1 && (ARGV & Tmuxinator::Cli.new.command_list).empty?
+  Tmuxinator::Cli.new.start(ARGV[0])
+else
+  Tmuxinator::Cli.start
+end

data/completion/tmuxinator.bash

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+_tmuxinator() {
+    COMPREPLY=()
+    local word="${COMP_WORDS[COMP_CWORD]}"
+
+    if [ "$COMP_CWORD" -eq 1 ]; then
+        COMPREPLY=( $(compgen -W "$(tmuxinator commands)" -- "$word") )
+    else
+        local words=("${COMP_WORDS[@]}")
+        unset words[0]
+        unset words[$COMP_CWORD]
+        local completions=$(tmuxinator completions "${words[@]}")
+        COMPREPLY=( $(compgen -W "$completions" -- "$word") )
+    fi
+}
+
+complete -F _tmuxinator -o tmuxinator mux

data/completion/tmuxinator.zsh

@@ -0,0 +1,20 @@
+#!/usr/bin/env zsh
+
+if [[ ! -o interactive ]]; then
+    return
+fi
+
+compctl -K _tmuxinator tmuxinator mux
+
+_tmuxinator() {
+  local words completions
+  read -cA words
+
+  if [ "${#words}" -eq 2 ]; then
+    completions="$(tmuxinator commands)"
+  else
+    completions="$(tmuxinator completions ${words[2,-2]})"
+  fi
+
+  reply=("${(ps:\n:)completions}")
+}

data/lib/tmuxinator.rb

@@ -1,11 +1,17 @@
-require 'yaml'
-require 'ostruct'
-require 'erb'
-require 'tmuxinator/helper'
-require 'tmuxinator/cli'
-require 'tmuxinator/config_writer'
+require "yaml"
+require "erubis"
+require "shellwords"
+require "thor"
+require "active_support/all"
 
-TMUX_TEMPLATE  = "#{File.dirname(__FILE__)}/tmuxinator/assets/tmux_config.tmux"
+require "tmuxinator/util"
+require "tmuxinator/deprecations"
+require "tmuxinator/cli"
+require "tmuxinator/config"
+require "tmuxinator/pane"
+require "tmuxinator/project"
+require "tmuxinator/window"
+require "tmuxinator/version"
 
 module Tmuxinator
 end

data/lib/tmuxinator/assets/sample.yml

@@ -1,22 +1,35 @@
 # ~/.tmuxinator/<%= @name %>.yml
 # you can make as many tabs as you wish...
 
-project_name: Tmuxinator
-project_root: ~/code/rails_project
-socket_name: foo # Not needed.  Remove to use default socket
-rvm: 1.9.2@rails_project
-pre: sudo /etc/rc.d/mysqld start
-tabs:
+name: sample
+root: ~/test
+socket_name: foo # Remove to use default socket
+pre: sudo /etc/rc.d/mysqld start # Runs before everything
+pre_window: rbenv shell 2.0.0-p247 # Runs in each tab and pane
+tmux_options: -v -2 # Pass arguments to tmux
+windows:
   - editor:
+      pre:
+        - echo "I get run in each pane, before each pane command!"
+        -
       layout: main-vertical
       panes:
         - vim
         - #empty, will just run plain bash
         - top
   - shell: git pull
-  - database: rails db
-  - server: rails s
-  - logs: tail -f logs/development.log
-  - console: rails c
+  - guard:
+      layout: tiled
+      pre:
+        - echo "I get run in each pane."
+        - echo "Before each pane command!"
+      panes:
+        -
+        - #empty, will just run plain bash
+        -
+  - database: bundle exec rails db
+  - server: bundle exec rails s
+  - logs: tail -f log/development.log
+  - console: bundle exec rails c
   - capistrano:
-  - server: ssh me@myhost
+  - server: ssh user@example.com

data/lib/tmuxinator/assets/template.erb

@@ -0,0 +1,47 @@
+#!<%= ENV["SHELL"] || "/bin/bash" %>
+<%= tmux %> start-server\; has-session -t <%= name %> 2>/dev/null
+
+if [ "$?" -eq 1 ]; then
+  cd <%= root || "." %>
+
+  # Run pre command.
+  <%= pre %>
+
+  # Create the session and the first window.
+  <%= tmux %> new-session -d -s <%= name %> -n <%= windows.first.name %>
+
+  # Set the default path.
+  <%= tmux %> set-option -t <%= name %> default-path <%= root -%> 1>/dev/null
+
+  # Create other windows.
+  <%- windows.drop(1).each do |window| -%>
+  <%= window.tmux_new_window_command %>
+  <%- end -%>
+
+  <%- windows.each do |window| -%>
+
+  # Window "<%= window.name %>"
+    <%- unless window.panes? -%>
+  <%= window.tmux_pre_window_command %>
+  <%= window.tmux_main_command %>
+    <%- else -%>
+      <%- window.panes.each do |pane| -%>
+  <%= pane.tmux_pre_window_command %>
+  <%= pane.tmux_pre_command %>
+  <%= pane.tmux_main_command %>
+
+      <%- unless pane.last? -%>
+  <%= pane.tmux_split_command %>
+      <%- end -%>
+    <%- end -%>
+
+
+  <%= window.tmux_layout_command %>
+  <%= window.tmux_select_first_pane %>
+    <%- end -%>
+  <%- end -%>
+
+  <%= tmux %> select-window -t <%= base_index %>
+fi
+
+<%= tmux %> -u attach-session -t <%= name %>

data/lib/tmuxinator/cli.rb

@@ -1,175 +1,151 @@
-require 'fileutils'
-
 module Tmuxinator
-  class Cli
+  class Cli < Thor
+    include Tmuxinator::Util
 
-    class << self
-      include Tmuxinator::Helper
+    attr_reader :command_list
 
-      def run *args
-        if args.empty?
-          self.usage
-        else
-          self.send(args.shift, *args)
-        end
-      end
+    def initialize(*args)
+      super
+      @command_list = %w(commands copy debug delete doctor help implode list start version)
+    end
+
+    package_name "tmuxinator"
+
+    desc "commands", "Lists commands available in tmuxinator"
 
-      # print the usage string, this is a fall through method.
-      def usage
-        puts %{
-  Usage: tmuxinator ACTION [Arg] 
-  or 
-  tmuxinator [project_name]
-
-  ACTIONS:
-  start [project_name]
-      start a tmux session using project's tmuxinator config
-  open [project_name]
-      create a new project file and open it in your editor
-  copy [source_project] [new_project]
-      copy source_project project file to a new project called new_project
-  delete [project_name]
-      deletes the project called project_name
-  implode
-      deletes all existing projects!
-  list [-v]
-      list all existing projects
-  doctor
-    look for problems in your configuration
-  help
-      shows this help document
-  version
-      shows tmuxinator version number
-}
+    def commands
+      puts command_list.join("\n")
+    end
+
+    desc "completions [arg1 arg2]", "Used for shell completion"
+
+    def completions(arg)
+      if %w(start open copy delete).include?(arg)
+        configs = Tmuxinator::Config.configs
+        puts configs
       end
-      alias :help :usage
-      alias :h :usage
-
-      # Open a config file, it's created if it doesn't exist already.
-      def open *args
-        exit!("You must specify a name for the new project") unless args.size > 0
-        puts "warning: passing multiple arguments to open will be ignored" if args.size > 1
-        @name = args.shift
-        config_path = "#{root_dir}#{@name}.yml"
-        unless File.exists?(config_path)
-          template = File.exists?(user_config) ? user_config : sample_config
-          erb      = ERB.new(File.read(template)).result(binding)
-          tmp      = File.open(config_path, 'w') {|f| f.write(erb) }
-        end
-        system("$EDITOR #{config_path}")
+    end
+
+    desc "new [PROJECT]", "Create a new project file and open it in your editor"
+    map "open" => :new
+    map "o" => :new
+    map "n" => :new
+
+    def new(name)
+      config = Tmuxinator::Config.project(name)
+
+      unless Tmuxinator::Config.exists?(name)
+        template = Tmuxinator::Config.default? ? Tmuxinator::Config.default : Tmuxinator::Config.sample
+        erb  = ERB.new(File.read(template)).result(binding)
+        File.open(config, "w") { |f| f.write(erb) }
       end
-      alias :o :open
-      alias :new :open
-      alias :n :open
 
-      def copy *args
-        @copy = args.shift
-        @name = args.shift
-        @config_to_copy = "#{root_dir}#{@copy}.yml"
+      Kernel.system("$EDITOR #{config}")
+    end
 
-        exit!("Project #{@copy} doesn't exist!")             unless File.exists?(@config_to_copy)
-        exit!("You must specify a name for the new project") unless @name
+    desc "start [PROJECT]", "Start a tmux session using a project's tmuxinator config"
+    map "s" => :start
 
-        file_path = "#{root_dir}#{@name}.yml"
+    def start(name)
+      project = Tmuxinator::Config.validate(name)
 
-        if File.exists?(file_path)
-          confirm!("#{@name} already exists, would you like to overwrite it? (type yes or no):") do
-            FileUtils.rm(file_path)
-            puts "Overwriting #{@name}"
-          end
-        end
-        open @name
-      end
-      alias :c :copy
-
-      def delete *args
-        puts "warning: passing multiple arguments to delete will be ignored" if args.size > 1
-        filename  = args.shift
-        file_path = "#{root_dir}#{filename}.yml"
-
-        if File.exists?(file_path)
-          confirm!("Are you sure you want to delete #{filename}? (type yes or no):") do
-            FileUtils.rm(file_path)
-            puts "Deleted #{filename}"
-          end
-        else
-          exit! "That file doesn't exist."
-        end
+      if project.deprecations.any?
+        project.deprecations.each { |deprecation| say deprecation, :red }
+        puts
+        print "Press any key to continue."
+        STDIN.getc
       end
-      alias :d :delete
 
-      def implode *args
-        exit!("delete_all doesn't accapt any arguments!") unless args.empty?
-        confirm!("Are you sure you want to delete all tmuxinator configs? (type yes or no):") do
-          FileUtils.remove_dir(root_dir)
-          puts "Deleted #{root_dir}"
+      Kernel.exec(project.render)
+    end
+
+    desc "debug [PROJECT]", "Output the shell commands that are generated by tmuxinator"
+
+    def debug(name)
+      project = Tmuxinator::Config.validate(name)
+      puts project.render
+    end
+
+    desc "copy [EXISTING] [NEW]", "Copy an existing project to a new project and open it in your editor"
+    map "c" => :copy
+    map "cp" => :copy
+
+    def copy(existing, new)
+      existing_config_path = Tmuxinator::Config.project(existing)
+      new_config_path = Tmuxinator::Config.project(new)
+
+      exit!("Project #{existing} doesn't exist!") unless Tmuxinator::Config.exists?(existing)
+
+      if Tmuxinator::Config.exists?(new)
+        if yes?("#{new} already exists, would you like to overwrite it?", :red)
+          FileUtils.rm(new_config_path)
+          say "Overwriting #{new}"
         end
       end
-      alias :i :implode
-
-      def list *args
-        verbose = args.include?("-v")
-        puts "tmuxinator configs:"
-        Dir["#{root_dir}**"].each do |path|
-          next unless verbose || File.extname(path) == ".yml"
-          path = path.gsub(root_dir, '').gsub('.yml','') unless verbose
-          puts "    #{path}"
+
+      FileUtils.copy_file(existing_config_path, new_config_path)
+      Kernel.system("$EDITOR #{new_config_path}")
+    end
+
+    desc "delete [PROJECT]", "Deletes given project"
+    map "d" => :delete
+    map "rm" => :delete
+
+    def delete(project)
+      config =  "#{Tmuxinator::Config.root}#{project}.yml"
+
+      if Tmuxinator::Config.exists?(config)
+        if yes?("Are you sure you want to delete #{project}?", :red)
+          FileUtils.rm(config)
+          say "Deleted #{project}"
         end
+      else
+        exit! "That file doesn't exist."
       end
-      alias :l :list
-      alias :ls :list
+    end
 
-      def version
-        system("cat #{File.dirname(__FILE__) + '/../../VERSION'}")
-        puts
-      end
-      alias :v :version
-
-      def doctor
-        print "  checking if tmux is installed ==> "
-        puts system("which tmux > /dev/null") ?  "Yes" : "No"
-        print "  checking if $EDITOR is set ==> "
-        puts ENV['EDITOR'] ? "Yes" : "No"
-        print "  checking if $SHELL is set ==> "
-        puts ENV['SHELL'] ? "Yes" : "No"
-      end
+    desc "implode", "Delets all tmuxinator projects"
+    map "i" => :implode
 
-      # build script and run it
-      def start *args
-        exit!("You must specify a name for the new project") unless args.size > 0
-        puts "warning: passing multiple arguments to open will be ignored" if args.size > 1
-        project_name = args.shift
-        config_path = "#{root_dir}#{project_name}.yml"
-        config = Tmuxinator::ConfigWriter.new(config_path).render
-        # replace current proccess by running compiled tmux config
-        exec(config)
+    def implode
+      if yes?("Are you sure you want to delete all tmuxinator configs?", :red)
+        FileUtils.remove_dir(Tmuxinator::Config.root)
+        say "Deleted all tmuxinator projects."
       end
-      alias :s :start
+    end
 
-      def method_missing method, *args, &block
-        start method if File.exists?("#{root_dir}#{method}.yml")
-        puts "There's no command or project '#{method}' in tmuxinator"
-        usage
-      end
+    desc "list", "Lists all tmuxinator projects"
+    map "l" => :list
+    map "ls" => :list
 
-      private #==============================
+    def list
+      say "tmuxinator projects:"
 
-      def root_dir
-        # create ~/.tmuxinator directory if it doesn't exist
-        Dir.mkdir("#{ENV["HOME"]}/.tmuxinator/") unless File.directory?(File.expand_path("~/.tmuxinator"))
-        "#{ENV["HOME"]}/.tmuxinator/"
+      configs = Dir["#{Tmuxinator::Config.root}/*.yml"].sort.map do |path|
+        path.gsub("#{Tmuxinator::Config.root}/", "").gsub(".yml", "")
       end
 
-      def sample_config
-        "#{File.dirname(__FILE__)}/assets/sample.yml"
-      end
+      print_in_columns configs
+    end
 
-      def user_config
-        @config_to_copy || "#{ENV["HOME"]}/.tmuxinator/default.yml"
-      end
+    desc "version", "Display installed tmuxinator version"
+    map "-v" => :version
 
+    def version
+      say "tmuxinator #{Tmuxinator::VERSION}"
     end
 
+    desc "doctor", "Look for problems in your configuration"
+
+    def doctor
+      say "Checking if tmux is installed ==> "
+      yes_no Tmuxinator::Config.installed?
+
+      say "Checking if $EDITOR is set ==> "
+      yes_no Tmuxinator::Config.editor?
+
+      say "Checking if $SHELL is set ==> "
+      yes_no  Tmuxinator::Config.shell?
+    end
   end
 end
-