tmuxinator 0.9.0 → 0.10.0

data/lib/tmuxinator/window.rb

@@ -2,39 +2,53 @@ module Tmuxinator
   class Window
     include Tmuxinator::Util
 
-    attr_reader :name, :root, :panes, :layout, :commands, :index, :project, :synchronize
+    attr_reader :commands, :index, :name, :project
 
     def initialize(window_yaml, index, project)
-      @name = if !window_yaml.keys.first.nil?
-                window_yaml.keys.first.to_s.shellescape
-              end
-      @root = nil
-      @panes = []
-      @synchronize = false
-      @layout = nil
-      @pre = nil
+      first_key = window_yaml.keys.first
+
+      @name = first_key.to_s.shellescape unless first_key.nil?
+      @yaml = window_yaml.values.first
       @project = project
       @index = index
+      @commands = build_commands(tmux_window_command_prefix, @yaml)
+    end
+
+    def panes
+      build_panes(yaml["panes"]) || []
+    end
 
-      value = window_yaml.values.first
+    def _hashed?
+      @yaml.is_a?(Hash)
+    end
 
-      if value.is_a?(Hash)
-        @synchronize = value["synchronize"] || false
-        @layout = value["layout"] ? value["layout"].shellescape : nil
-        @pre = value["pre"] if value["pre"]
-        @root = if value["root"]
-                  File.expand_path(value["root"]).shellescape
-                elsif project.root?
-                  project.root
-                end
+    def yaml
+      _hashed? ? @yaml : {}
+    end
 
-        @panes = build_panes(value["panes"])
-      end
+    def layout
+      yaml["layout"] ? yaml["layout"].shellescape : nil
+    end
 
-      @commands = build_commands(tmux_window_command_prefix, value)
+    def synchronize
+      yaml["synchronize"] || false
+    end
+
+    def root
+      _yaml_root || _project_root
+    end
+
+    def _yaml_root
+      File.expand_path(yaml["root"]).shellescape if yaml["root"]
+    end
+
+    def _project_root
+      project.root if project.root?
     end
 
     def build_panes(panes_yml)
+      return if panes_yml.nil?
+
       Array(panes_yml).map.with_index do |pane_yml, index|
         commands =  case pane_yml
                     when Hash
@@ -62,10 +76,12 @@ module Tmuxinator
     end
 
     def pre
-      if @pre.is_a?(Array)
-        @pre.join(" && ")
-      elsif @pre.is_a?(String)
-        @pre
+      _pre = yaml["pre"]
+
+      if _pre.is_a?(Array)
+        _pre.join(" && ")
+      elsif _pre.is_a?(String)
+        _pre
       end
     end
 

data/spec/fixtures/sample.yml

@@ -4,7 +4,6 @@
 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: -f ~/.tmux.mac.conf # Pass arguments to tmux
 tmux_detached: false

data/spec/lib/tmuxinator/cli_spec.rb

@@ -1,4 +1,5 @@
 require "spec_helper"
+
 describe Tmuxinator::Cli do
   let(:cli) { Tmuxinator::Cli }
 
@@ -73,7 +74,7 @@ describe Tmuxinator::Cli do
       end
 
       it "accepts a flag for alternate name" do
-        ARGV.replace(["start", "foo" "--name=bar"])
+        ARGV.replace(["start", "foo", "--name=bar"])
 
         expect(Kernel).to receive(:exec)
         capture_io { cli.start }
@@ -231,16 +232,16 @@ describe Tmuxinator::Cli do
         end
       end
 
-      context "files exists" do
-        let(:root_path) { "#{ENV['HOME']}\/\.tmuxinator\/#{name}\.yml" }
+      context "file exists" do
+        let(:project_path) { Tmuxinator::Config.project(name).to_s }
 
         before do
           allow(File).to receive(:exist?).with(anything).and_return(false)
-          expect(File).to receive(:exist?).with(root_path).and_return(true)
+          expect(File).to receive(:exist?).with(project_path).and_return(true)
         end
 
         it "just opens the file" do
-          expect(Kernel).to receive(:system).with(%r{#{root_path}})
+          expect(Kernel).to receive(:system).with(%r{#{project_path}})
           capture_io { cli.start }
         end
       end
@@ -264,7 +265,7 @@ describe Tmuxinator::Cli do
         end
       end
 
-      context "files exists" do
+      context "file exists" do
         let(:path) { Tmuxinator::Config::LOCAL_DEFAULT }
         before do
           expect(File).to receive(:exist?).with(path) { true }
@@ -276,6 +277,62 @@ describe Tmuxinator::Cli do
         end
       end
     end
+
+    # this command variant only works for tmux version 1.6 and up.
+    context "from a session" do
+      context "with tmux >= 1.6", if: Tmuxinator::Config.version >= 1.6 do
+        before do
+          # Necessary to make `Doctor.installed?` work in specs
+          allow(Tmuxinator::Doctor).to receive(:installed?).and_return(true)
+        end
+
+        context "session exists" do
+          before(:all) do
+            # Can't add variables through `let` in `before :all`.
+            @session = "for-testing-tmuxinator"
+            # Pass the -d option, so that the session is not attached.
+            Kernel.system "tmux new-session -d -s #{@session}"
+          end
+
+          before do
+            ARGV.replace ["new", name, @session]
+          end
+
+          after(:all) do
+            puts @session
+            Kernel.system "tmux kill-session -t #{@session}"
+          end
+
+          it "creates a project file" do
+            capture_io { cli.start }
+            expect(file.string).to_not be_empty
+            # make sure the output is valid YAML
+            expect { YAML.parse file.string }.to_not raise_error
+          end
+        end
+
+        context "session doesn't exist" do
+          before do
+            ARGV.replace ["new", name, "sessiondoesnotexist"]
+          end
+
+          it "fails" do
+            expect { cli.start }.to raise_error RuntimeError
+          end
+        end
+      end
+
+      context "with tmux < 1.6" do
+        before do
+          ARGV.replace ["new", name, "sessionname"]
+          allow(Tmuxinator::Config).to receive(:version).and_return(1.5)
+        end
+
+        it "is unsupported" do
+          expect { cli.start }.to raise_error RuntimeError
+        end
+      end
+    end
   end
 
   describe "#copy" do
@@ -295,7 +352,7 @@ describe Tmuxinator::Cli do
       end
     end
 
-    context "existing project doens't exist" do
+    context "existing project doesn't exist" do
       before do
         allow(Tmuxinator::Config).to receive(:exists?) { false }
       end
@@ -444,10 +501,27 @@ describe Tmuxinator::Cli do
       capture_io { cli.start }
     end
 
-    it "deletes all projects" do
-      expect(FileUtils).to receive(:remove_dir)
+    it "deletes the configuration directory(s)" do
+      allow(Tmuxinator::Config).to receive(:directories) \
+        { [Tmuxinator::Config.xdg, Tmuxinator::Config.home] }
+      expect(FileUtils).to receive(:remove_dir).once.
+        with(Tmuxinator::Config.xdg)
+      expect(FileUtils).to receive(:remove_dir).once.
+        with(Tmuxinator::Config.home)
+      expect(FileUtils).to receive(:remove_dir).never
       capture_io { cli.start }
     end
+
+    context "$TMUXINATOR_CONFIG specified" do
+      it "only deletes projects in that directory" do
+        allow(ENV).to receive(:[]).and_call_original
+        allow(ENV).to receive(:[]).with("TMUXINATOR_CONFIG").and_return "dir"
+        allow(File).to receive(:directory?).with("dir").and_return true
+        expect(FileUtils).to receive(:remove_dir).once.with("dir")
+        expect(FileUtils).to receive(:remove_dir).never
+        capture_io { cli.start }
+      end
+    end
   end
 
   describe "#list" do
@@ -478,9 +552,9 @@ describe Tmuxinator::Cli do
     end
 
     it "checks requirements" do
-      expect(Tmuxinator::Config).to receive(:installed?)
-      expect(Tmuxinator::Config).to receive(:editor?)
-      expect(Tmuxinator::Config).to receive(:shell?)
+      expect(Tmuxinator::Doctor).to receive(:installed?)
+      expect(Tmuxinator::Doctor).to receive(:editor?)
+      expect(Tmuxinator::Doctor).to receive(:shell?)
       capture_io { cli.start }
     end
   end
@@ -571,7 +645,7 @@ describe Tmuxinator::Cli do
       subject { described_class.new.create_project(params) }
 
       before do
-        allow(Tmuxinator::Config).to receive_messages(root: path)
+        allow(Tmuxinator::Config).to receive_messages(directory: path)
       end
 
       it_should_behave_like :a_proper_project

data/spec/lib/tmuxinator/config_spec.rb

@@ -1,9 +1,133 @@
 require "spec_helper"
 
 describe Tmuxinator::Config do
-  describe "#root" do
-    it "is ~/.tmuxintaor" do
-      expect(Tmuxinator::Config.root).to eq "#{ENV['HOME']}/.tmuxinator"
+  let(:fixtures_dir) { File.expand_path("../../../fixtures/", __FILE__) }
+  let(:xdg_config_dir) { "#{fixtures_dir}/xdg-tmuxinator" }
+  let(:home_config_dir) { "#{fixtures_dir}/dot-tmuxinator" }
+
+  describe "#directory" do
+    context "environment variable $TMUXINATOR_CONFIG non-blank" do
+      it "is $TMUXINATOR_CONFIG" do
+        allow(ENV).to receive(:[]).with("TMUXINATOR_CONFIG").
+          and_return "expected"
+        allow(File).to receive(:directory?).and_return true
+        expect(Tmuxinator::Config.directory).to eq "expected"
+      end
+    end
+
+    context "only ~/.tmuxinator exists" do
+      it "is ~/.tmuxinator" do
+        allow(File).to receive(:directory?).
+          with(Tmuxinator::Config.environment).and_return false
+        allow(File).to receive(:directory?).
+          with(Tmuxinator::Config.xdg).and_return false
+        allow(File).to receive(:directory?).
+          with(Tmuxinator::Config.home).and_return true
+        expect(Tmuxinator::Config.directory).to eq Tmuxinator::Config.home
+      end
+    end
+
+    context "only $XDG_CONFIG_HOME/tmuxinator exists" do
+      it "is #xdg" do
+        allow(File).to receive(:directory?).
+          with(Tmuxinator::Config.environment).and_return false
+        allow(File).to receive(:directory?).
+          with(Tmuxinator::Config.xdg).and_return true
+        allow(File).to receive(:directory?).
+          with(Tmuxinator::Config.home).and_return false
+        expect(Tmuxinator::Config.directory).to eq Tmuxinator::Config.xdg
+      end
+    end
+
+    context "both $XDG_CONFIG_HOME/tmuxinator and ~/.tmuxinator exist" do
+      it "is #xdg" do
+        allow(File).to receive(:directory?).
+          with(Tmuxinator::Config.environment).and_return false
+        allow(File).to receive(:directory?).
+          with(Tmuxinator::Config.xdg).and_return true
+        allow(File).to receive(:directory?).
+          with(Tmuxinator::Config.home).and_return true
+        expect(Tmuxinator::Config.directory).to eq Tmuxinator::Config.xdg
+      end
+    end
+
+    context "parent directory(s) do not exist" do
+      it "creates parent directories if required" do
+        allow(File).to receive(:directory?).and_call_original
+        allow(File).to receive(:directory?).with(Tmuxinator::Config.home).
+          and_return false
+        Dir.mktmpdir do |dir|
+          config_parent = "#{dir}/non_existant_parent/s"
+          allow(XDG).to receive(:[]).with("CONFIG").and_return config_parent
+          expect(Tmuxinator::Config.directory).
+            to eq "#{config_parent}/tmuxinator"
+          expect(File.directory?("#{config_parent}/tmuxinator")).to be true
+        end
+      end
+    end
+  end
+
+  describe "#enviroment" do
+    context "environment variable $TMUXINATOR_CONFIG is not empty" do
+      it "is $TMUXINATOR_CONFIG" do
+        allow(ENV).to receive(:[]).with("TMUXINATOR_CONFIG").
+          and_return "expected"
+        # allow(XDG).to receive(:[]).with("CONFIG").and_return "expected"
+        allow(File).to receive(:directory?).and_return true
+        expect(Tmuxinator::Config.environment).to eq "expected"
+      end
+    end
+
+    context "environment variable $TMUXINATOR_CONFIG is nil" do
+      it "is an empty string" do
+        allow(ENV).to receive(:[]).with("TMUXINATOR_CONFIG").
+          and_return nil
+        # allow(XDG).to receive(:[]).with("CONFIG").and_return nil
+        allow(File).to receive(:directory?).and_return true
+        expect(Tmuxinator::Config.environment).to eq ""
+      end
+    end
+
+    context "environment variable $TMUXINATOR_CONFIG is set and empty" do
+      it "is an empty string" do
+        allow(XDG).to receive(:[]).with("CONFIG").and_return ""
+        expect(Tmuxinator::Config.environment).to eq ""
+      end
+    end
+  end
+
+  describe "#directories" do
+    it "is empty if no configuration directories exist" do
+      allow(File).to receive(:directory?).and_return false
+      expect(Tmuxinator::Config.directories).to eq []
+    end
+
+    it "is only [$TMUXINATOR_CONFIG] if set" do
+      allow(ENV).to receive(:[]).with("TMUXINATOR_CONFIG").
+        and_return "expected"
+      allow(File).to receive(:directory?).and_return true
+      expect(Tmuxinator::Config.directories).to eq ["expected"]
+    end
+
+    it "contains #xdg before #home" do
+      allow(File).to receive(:directory?).with(Tmuxinator::Config.xdg).
+        and_return true
+      allow(File).to receive(:directory?).with(Tmuxinator::Config.home).
+        and_return true
+      expect(Tmuxinator::Config.directories).to eq \
+        [Tmuxinator::Config.xdg, Tmuxinator::Config.home]
+    end
+  end
+
+  describe "#home" do
+    it "is ~/.tmuxinator" do
+      expect(Tmuxinator::Config.home).to eq "#{ENV['HOME']}/.tmuxinator"
+    end
+  end
+
+  describe "#xdg" do
+    it "is $XDG_CONFIG_HOME/tmuxinator" do
+      expect(Tmuxinator::Config.xdg).to eq "#{XDG['CONFIG_HOME']}/tmuxinator"
     end
   end
 
@@ -42,7 +166,7 @@ describe Tmuxinator::Config do
   end
 
   describe "#default?" do
-    let(:root) { Tmuxinator::Config.root }
+    let(:directory) { Tmuxinator::Config.directory }
     let(:local_default) { Tmuxinator::Config::LOCAL_DEFAULT }
     let(:proj_default) { Tmuxinator::Config.default }
 
@@ -71,77 +195,19 @@ describe Tmuxinator::Config do
 
   describe "#configs" do
     before do
-      allow(Dir).to receive_messages(:[] => ["test.yml"])
-    end
-
-    it "gets a list of all projects" do
-      expect(Tmuxinator::Config.configs).to include("test")
-    end
-  end
-
-  describe "#installed?" do
-    context "tmux is installed" do
-      before do
-        allow(Kernel).to receive(:system) { true }
-      end
-
-      it "returns true" do
-        expect(Tmuxinator::Config.installed?).to be_truthy
-      end
-    end
-
-    context "tmux is not installed" do
-      before do
-        allow(Kernel).to receive(:system) { false }
-      end
-
-      it "returns true" do
-        expect(Tmuxinator::Config.installed?).to be_falsey
-      end
-    end
-  end
-
-  describe "#editor?" do
-    context "$EDITOR is set" do
-      before do
-        allow(ENV).to receive(:[]).with("EDITOR") { "vim" }
-      end
-
-      it "returns true" do
-        expect(Tmuxinator::Config.editor?).to be_truthy
-      end
-    end
-
-    context "$EDITOR is not set" do
-      before do
-        allow(ENV).to receive(:[]).with("EDITOR") { nil }
-      end
-
-      it "returns false" do
-        expect(Tmuxinator::Config.editor?).to be_falsey
-      end
+      allow(Tmuxinator::Config).to receive_messages(xdg: xdg_config_dir)
+      allow(Tmuxinator::Config).to receive_messages(home: home_config_dir)
     end
-  end
-
-  describe "#shell?" do
-    context "$SHELL is set" do
-      before do
-        allow(ENV).to receive(:[]).with("SHELL") { "vim" }
-      end
 
-      it "returns true" do
-        expect(Tmuxinator::Config.shell?).to be_truthy
-      end
+    it "gets a sorted list of all projects" do
+      expect(Tmuxinator::Config.configs).
+        to eq ["both", "both", "dup/local-dup", "home", "local-dup", "xdg"]
     end
 
-    context "$SHELL is not set" do
-      before do
-        allow(ENV).to receive(:[]).with("SHELL") { nil }
-      end
-
-      it "returns false" do
-        expect(Tmuxinator::Config.shell?).to be_falsey
-      end
+    it "lists only projects in $TMUXINATOR_CONFIG when set" do
+      allow(ENV).to receive(:[]).with("TMUXINATOR_CONFIG").
+        and_return "#{fixtures_dir}/TMUXINATOR_CONFIG"
+      expect(Tmuxinator::Config.configs).to eq ["TMUXINATOR_CONFIG"]
     end
   end
 
@@ -156,24 +222,31 @@ describe Tmuxinator::Config do
     end
   end
 
-  describe "#project_in_root" do
-    let(:root) { Tmuxinator::Config.root }
-    let(:base) { "#{root}/sample.yml" }
+  describe "#global_project" do
+    let(:directory) { Tmuxinator::Config.directory }
+    let(:base) { "#{directory}/sample.yml" }
+    let(:first_dup) { "#{home_config_dir}/dup/local-dup.yml" }
 
     before do
-      path = File.expand_path("../../../fixtures/", __FILE__)
-      allow(Tmuxinator::Config).to receive_messages(root: path)
+      allow(Tmuxinator::Config).to receive_messages(xdg: fixtures_dir)
+      allow(Tmuxinator::Config).to receive_messages(home: fixtures_dir)
     end
 
     context "with project yml" do
       it "gets the project as path to the yml file" do
-        expect(Tmuxinator::Config.project_in_root("sample")).to eq base
+        expect(Tmuxinator::Config.global_project("sample")).to eq base
       end
     end
 
     context "without project yml" do
       it "gets the project as path to the yml file" do
-        expect(Tmuxinator::Config.project_in_root("new-project")).to be_nil
+        expect(Tmuxinator::Config.global_project("new-project")).to be_nil
+      end
+    end
+
+    context "with duplicate project files" do
+      it "is the first .yml file found" do
+        expect(Tmuxinator::Config.global_project("local-dup")).to eq first_dup
       end
     end
   end
@@ -186,39 +259,39 @@ describe Tmuxinator::Config do
     end
   end
 
-  describe "#project_in_local" do
+  describe "#local_project" do
     let(:default) { Tmuxinator::Config::LOCAL_DEFAULT }
 
     context "with a project yml" do
       it "gets the project as path to the yml file" do
         expect(File).to receive(:exist?).with(default) { true }
-        expect(Tmuxinator::Config.project_in_local).to eq default
+        expect(Tmuxinator::Config.local_project).to eq default
       end
     end
 
     context "without project yml" do
       it "gets the project as path to the yml file" do
-        expect(Tmuxinator::Config.project_in_local).to be_nil
+        expect(Tmuxinator::Config.local_project).to be_nil
       end
     end
   end
 
   describe "#project" do
-    let(:root) { Tmuxinator::Config.root }
-    let(:path) { File.expand_path("../../../fixtures/", __FILE__) }
+    let(:directory) { Tmuxinator::Config.directory }
     let(:default) { Tmuxinator::Config::LOCAL_DEFAULT }
 
-    context "with project yml in the root directory" do
+    context "with an non-local project yml" do
       before do
-        allow(Tmuxinator::Config).to receive_messages(root: path)
+        allow(Tmuxinator::Config).to receive_messages(directory: fixtures_dir)
       end
 
       it "gets the project as path to the yml file" do
-        expect(Tmuxinator::Config.project("sample")).to eq "#{root}/sample.yml"
+        expect(Tmuxinator::Config.project("sample")).
+          to eq "#{directory}/sample.yml"
       end
     end
 
-    context "with a local project, but no project in root" do
+    context "with a local project, but no global project" do
       it "gets the project as path to the yml file" do
         expect(File).to receive(:exist?).with(default) { true }
         expect(Tmuxinator::Config.project("sample")).to eq "./.tmuxinator.yml"
@@ -226,7 +299,7 @@ describe Tmuxinator::Config do
     end
 
     context "without project yml" do
-      let(:expected) { "#{root}/new-project.yml" }
+      let(:expected) { "#{directory}/new-project.yml" }
       it "gets the project as path to the yml file" do
         expect(Tmuxinator::Config.project("new-project")).to eq expected
       end
@@ -234,7 +307,6 @@ describe Tmuxinator::Config do
   end
 
   describe "#validate" do
-    let(:path) { File.expand_path("../../../fixtures", __FILE__) }
     let(:default) { Tmuxinator::Config::LOCAL_DEFAULT }
 
     context "when a project name is provided" do
@@ -245,7 +317,7 @@ describe Tmuxinator::Config do
       end
 
       it "should load and validate the project" do
-        expect(Tmuxinator::Config).to receive_messages(root: path)
+        expect(Tmuxinator::Config).to receive_messages(directory: fixtures_dir)
         expect(Tmuxinator::Config.validate(name: "sample")).to \
           be_a Tmuxinator::Project
       end
@@ -260,7 +332,7 @@ describe Tmuxinator::Config do
       end
 
       it "should load and validate the project" do
-        content = File.read(File.join(path, "sample.yml"))
+        content = File.read(File.join(fixtures_dir, "sample.yml"))
 
         expect(File).to receive(:exist?).with(default).at_least(:once) { true }
         expect(File).to receive(:read).with(default).and_return(content)