devinator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 046f88a18615ff14000b6152870bc84c8e8f7eedfd827a9c8a24d1c001f5fb9a
+  data.tar.gz: d22ff6f57a13d3c6166cc61665f26bd40f3da09c4af11e1aa8bb37ce043c262b
+SHA512:
+  metadata.gz: 8df565e8abfe627a0092227af9d393242c5e906bc85279ea5ff09147e5a64a3e98c81d5d7b7b17776058df9b486fbdd8a08bf9e7e7ea6d19f6696fc98538e55d
+  data.tar.gz: 14f6a8f20a1109135bf49acea9f5139a51524efc3828e9124445af3067bc78fbdeb216a94cc93a25ef9d71cd09af3ee70c6b80a3ee639275f686079489746a2f

data/.git-hooks/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bin/test

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--format documentation

data/Gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org" do
+  gem "tty-command"
+
+  group :development do
+    gem "standardrb"
+  end
+
+  group :test do
+    gem "rspec"
+  end
+end

data/Gemfile.lock

@@ -0,0 +1,85 @@
+GEM
+  specs:
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.3)
+    diff-lcs (1.6.2)
+    json (2.15.1)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    parallel (1.27.0)
+    parser (3.3.9.0)
+      ast (~> 2.4.1)
+      racc
+    pastel (0.8.0)
+      tty-color (~> 0.5)
+    prism (1.6.0)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    regexp_parser (2.11.3)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.6)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.6)
+    rubocop (1.80.2)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.46.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.47.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.4)
+    rubocop-performance (1.25.0)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.75.0, < 2.0)
+      rubocop-ast (>= 1.38.0, < 2.0)
+    ruby-progressbar (1.13.0)
+    standard (1.51.1)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.80.2)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.8)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.8.0)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.25.0)
+    standardrb (1.0.1)
+      standard
+    tty-color (0.6.0)
+    tty-command (0.10.1)
+      pastel (~> 0.8)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.1.0)
+
+PLATFORMS
+  ruby
+  x86_64-linux
+
+DEPENDENCIES
+  rspec!
+  standardrb!
+  tty-command!
+
+BUNDLED WITH
+   2.7.2

data/Makefile

@@ -0,0 +1,9 @@
+.PHONY: setup_hooks pretty build
+build:
+	gem build
+
+setup_hooks:
+	git config core.hooksPath ./.git-hooks
+
+pretty:
+	bin/formatting-fix

data/README.md

@@ -0,0 +1,16 @@
+# Devinator
+
+A simple tool to help start your development environment. It's fairly
+opinionated but can be twisted to your will.
+
+## How it works
+
+Simply `cd` to your project and run `devinator`. It will do several things for
+you in this order:
+
+1. `dx/build`
+2. `dx/start`
+3. `bin/setup` or `bin/setup`
+4. start your multiplexer
+5. launch your editor
+6. run the commands in `Procfile.dev` or `bin/dev`

data/bin/devinator

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.expand_path("./lib")
+
+require "devinator"
+
+Devinator.run

data/bin/pretty

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "=== Bundle ==="
+bundle check || bundle install
+
+echo "=== StandardRB ==="
+bundle exec standardrb --fix-unsafely

data/bin/test

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "=== Bundle ==="
+bundle check || bundle install
+
+echo "=== StandardRB ==="
+bundle exec standardrb
+
+echo "=== RSpec ==="
+bundle exec rspec

data/devinator.gemspec

@@ -0,0 +1,21 @@
+require_relative "lib/devinator/version"
+
+Gem::Specification.new do |gem|
+  gem.name = "devinator"
+  gem.version = Devinator::VERSION
+  gem.summary = "Start your development environment with one command!"
+  gem.description = <<-DESC
+    A little tool to help you get your development
+    environment up and running with a single command.
+  DESC
+  gem.authors = ["Sean Earle"]
+  gem.email = ["sean.r.earle@gmail.com"]
+  gem.homepage = "https://github.com/HellRok/devinator"
+  gem.license = "MIT"
+  gem.required_ruby_version = ">= 2.6.0"
+
+  gem.files = `git ls-files`.split($\)
+  gem.executables = [
+    "devinator"
+  ]
+end

data/lib/devinator/backends/tmux.rb

@@ -0,0 +1,64 @@
+class Devinator
+  module Backends
+    class Tmux
+      BINARY = "tmux"
+
+      def initialize(name:, commands:, executer:)
+        @name = name
+        @commands = commands
+        @executer = executer
+      end
+
+      def launch
+        if session?
+          reconnect
+        else
+          run_commands
+          connect
+        end
+      end
+
+      def session?
+        @executer.run!(BINARY, "has-session", "-t", @name).success?
+      end
+
+      def reconnect
+        Process.exec(BINARY, "attach-session", "-t", @name)
+      end
+
+      def connect
+        @executer.run(
+          BINARY, "select-window", "-t", "#{@name}:0",
+          only_output_on_error: true
+        )
+        Process.exec(BINARY, "attach-session", "-t", @name)
+      end
+
+      def run_commands
+        @executer.run(
+          BINARY, "new-session", "-d", "-s", @name,
+          only_output_on_error: true
+        )
+
+        @commands.each_with_index do |command, index|
+          if index.zero?
+            @executer.run(
+              BINARY, "rename-window", "-t", @name, command[:title],
+              only_output_on_error: true
+            )
+          else
+            @executer.run(
+              BINARY, "new-window", "-t", @name, "-n", command[:title],
+              only_output_on_error: true
+            )
+          end
+
+          @executer.run(
+            BINARY, "send-keys", "-t", @name, command[:command], "C-m",
+            only_output_on_error: true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/devinator/config.rb

@@ -0,0 +1,68 @@
+require "devinator/editor_configuration"
+require "devinator/user_configuration"
+
+class Devinator
+  class Config
+    @setup_commands = []
+    @commands = []
+
+    def self.user_configuration
+      @user_configuration ||= Devinator::UserConfiguration.new
+    end
+
+    def self.configure
+      yield user_configuration
+    end
+
+    def self.setup_commands
+      @setup_commands = []
+
+      @setup_commands += user_configuration.setup_commands
+
+      @setup_commands << "dx/build" if File.exist? "dx/build"
+      @setup_commands << "dx/start" if File.exist? "dx/start"
+
+      @setup_commands << dx_exec("bin/setup") if File.exist? "bin/setup"
+
+      @setup_commands << user_configuration.editor.command if user_configuration.editor.timing == :end_of_setup
+
+      @setup_commands
+    end
+
+    def self.run_commands
+      @commands = []
+
+      if user_configuration.editor.timing == :first_command
+        @commands << {
+          title: user_configuration.editor.title,
+          command: user_configuration.editor.command
+        }
+      end
+
+      if File.exist? "Procfile.dev"
+        File.read("Procfile.dev").lines.each { |line|
+          name, command = line.split(":", 2)
+          @commands << {title: name, command: dx_exec(command.strip)}
+        }
+
+      elsif File.exist? "bin/dev"
+        @commands << {title: "dev", command: dx_exec("bin/dev")}
+      end
+
+      if user_configuration.editor.timing == :last_command
+        @commands << {
+          title: user_configuration.editor.title,
+          command: user_configuration.editor.command
+        }
+      end
+
+      @commands
+    end
+
+    private_class_method def self.dx_exec(command)
+      result = ""
+      result << "dx/exec " if File.exist? "dx/exec"
+      result << command
+    end
+  end
+end

data/lib/devinator/editor_configuration.rb

@@ -0,0 +1,18 @@
+class Devinator
+  class EditorConfiguration
+    VALID_TIMINGS = [:end_of_setup, :first_command, :last_command]
+    attr_accessor :command, :title
+    attr_reader :timing
+
+    def timing=(val)
+      unless VALID_TIMINGS.include? val
+        raise(
+          ArgumentError,
+          "must be one of #{VALID_TIMINGS.inspect}"
+        )
+      end
+
+      @timing = val
+    end
+  end
+end

data/lib/devinator/user_configuration.rb

@@ -0,0 +1,21 @@
+class Devinator
+  class UserConfiguration
+    attr_writer :setup_commands
+
+    def initialize
+      @setup_commands = []
+    end
+
+    def editor
+      @editor_configuration ||= Devinator::EditorConfiguration.new
+    end
+
+    def setup_commands
+      if @setup_commands.is_a?(Enumerable)
+        @setup_commands
+      else
+        [@setup_commands].compact
+      end
+    end
+  end
+end

data/lib/devinator/version.rb

@@ -0,0 +1,3 @@
+class Devinator
+  VERSION = "0.0.1"
+end

data/lib/devinator.rb

@@ -0,0 +1,23 @@
+require "tty-command"
+
+require "devinator/config"
+require "devinator/backends/tmux"
+
+class Devinator
+  def self.run
+    tty = TTY::Command.new(uuid: false)
+
+    user_config_path = File.expand_path("~/.config/devinator.rb")
+    Kernel.require(user_config_path) if File.exist?(user_config_path)
+
+    Devinator::Config.setup_commands.each { tty.run it, only_output_on_error: true }
+
+    tmux = Devinator::Backends::Tmux.new(
+      name: File.basename(Dir.pwd),
+      commands: Devinator::Config.run_commands,
+      executer: tty
+    )
+
+    tmux.launch
+  end
+end

data/spec/backends/tmux_spec.rb

@@ -0,0 +1,185 @@
+describe Devinator::Backends::Tmux do
+  before do
+    @tmux = Devinator::Backends::Tmux
+  end
+
+  describe "#session?" do
+    before do
+      @tty = double(:tty)
+    end
+
+    it "returns true if there is a session" do
+      expect(@tty).to receive(:run!).with(
+        "tmux", "has-session", "-t", "the-session"
+      ).and_return(double(:result, success?: true))
+
+      expect(
+        @tmux.new(
+          name: "the-session",
+          commands: [],
+          executer: @tty
+        ).session?
+      ).to be(true)
+    end
+
+    it "returns false if there is no session" do
+      expect(@tty).to receive(:run!).with(
+        "tmux", "has-session", "-t", "the-session"
+      ).and_return(double(:result, success?: false))
+
+      expect(
+        @tmux.new(
+          name: "the-session",
+          commands: [],
+          executer: @tty
+        ).session?
+      ).to be(false)
+    end
+
+    describe "#reconnect" do
+      it "reconnects to the session" do
+        expect(Process).to receive(:exec).with(
+          "tmux", "attach-session", "-t", "the-session"
+        )
+
+        @tmux.new(
+          name: "the-session",
+          commands: [],
+          executer: @tty
+        ).reconnect
+      end
+    end
+
+    describe "#run_commands" do
+      it "launches a session and on the first command renames the window then a new window for each following command" do
+        expect(@tty).to receive(:run).with(
+          "tmux", "new-session", "-d", "-s", "the-session",
+          only_output_on_error: true
+        )
+
+        expect(@tty).to receive(:run).with(
+          "tmux", "rename-window", "-t", "the-session", "cmd1",
+          only_output_on_error: true
+        )
+
+        expect(@tty).to receive(:run).with(
+          "tmux", "send-keys", "-t", "the-session", "command 1", "C-m",
+          only_output_on_error: true
+        )
+
+        expect(@tty).to receive(:run).with(
+          "tmux", "new-window", "-t", "the-session", "-n", "cmd2",
+          only_output_on_error: true
+        )
+
+        expect(@tty).to receive(:run).with(
+          "tmux", "send-keys", "-t", "the-session", "command 2", "C-m",
+          only_output_on_error: true
+        )
+
+        expect(@tty).to receive(:run).with(
+          "tmux", "new-window", "-t", "the-session", "-n", "cmd3",
+          only_output_on_error: true
+        )
+
+        expect(@tty).to receive(:run).with(
+          "tmux", "send-keys", "-t", "the-session", "command 3", "C-m",
+          only_output_on_error: true
+        )
+
+        @tmux.new(
+          name: "the-session",
+          commands: [
+            {title: "cmd1", command: "command 1"},
+            {title: "cmd2", command: "command 2"},
+            {title: "cmd3", command: "command 3"}
+          ],
+          executer: @tty
+        ).run_commands
+      end
+    end
+
+    describe "#connect" do
+      it "connects to the tmux session" do
+        expect(@tty).to receive(:run).with(
+          "tmux", "select-window", "-t", "the-session:0",
+          only_output_on_error: true
+        )
+
+        expect(Process).to receive(:exec).with(
+          "tmux", "attach-session", "-t", "the-session"
+        )
+
+        @tmux.new(
+          name: "the-session",
+          commands: [],
+          executer: @tty
+        ).connect
+      end
+    end
+
+    describe "#launch" do
+      context "with a session available" do
+        before do
+          @tty = double(:tty)
+        end
+
+        it "reconnects to that session" do
+          expect(@tty).to receive(:run!).with(
+            "tmux", "has-session", "-t", "the-session"
+          ).and_return(double(:result, success?: true))
+
+          expect(Process).to receive(:exec).with(
+            "tmux", "attach-session", "-t", "the-session"
+          )
+
+          @tmux.new(
+            name: "the-session",
+            commands: [],
+            executer: @tty
+          ).launch
+        end
+      end
+
+      context "without a session" do
+        it "creates a new session" do
+          expect(@tty).to receive(:run!).with(
+            "tmux", "has-session", "-t", "the-session"
+          ).and_return(double(:result, success?: false))
+
+          expect(@tty).to receive(:run).with(
+            "tmux", "new-session", "-d", "-s", "the-session",
+            only_output_on_error: true
+          )
+
+          expect(@tty).to receive(:run).with(
+            "tmux", "rename-window", "-t", "the-session", "cmd1",
+            only_output_on_error: true
+          )
+
+          expect(@tty).to receive(:run).with(
+            "tmux", "send-keys", "-t", "the-session", "command 1", "C-m",
+            only_output_on_error: true
+          )
+
+          expect(@tty).to receive(:run).with(
+            "tmux", "select-window", "-t", "the-session:0",
+            only_output_on_error: true
+          )
+
+          expect(Process).to receive(:exec).with(
+            "tmux", "attach-session", "-t", "the-session"
+          )
+
+          @tmux.new(
+            name: "the-session",
+            commands: [
+              {title: "cmd1", command: "command 1"}
+            ],
+            executer: @tty
+          ).launch
+        end
+      end
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,207 @@
+describe Devinator::Config do
+  describe ".configure" do
+    it "does nothing with an empty block" do
+      Devinator::Config.configure {}
+
+      expect(Devinator::Config.setup_commands).to eq([])
+      expect(Devinator::Config.run_commands).to eq([])
+    end
+
+    it "loads the setup commands" do
+      Devinator::Config.configure do |config|
+        config.setup_commands = [
+          "update_secrets",
+          "load_secrets sean"
+        ]
+      end
+
+      expect(Devinator::Config.setup_commands).to eq(
+        [
+          "update_secrets",
+          "load_secrets sean"
+        ]
+      )
+      expect(Devinator::Config.run_commands).to eq([])
+    end
+  end
+
+  describe ".setup_commands" do
+    it "returns nothing when no files" do
+      expect(Devinator::Config.setup_commands).to eq([])
+    end
+
+    it "returns bin/setup when available" do
+      File.write "bin/setup", ""
+
+      expect(Devinator::Config.setup_commands).to eq(["bin/setup"])
+    end
+
+    it "returns dx/exec bin/setup when both are available" do
+      File.write "dx/exec", ""
+      File.write "bin/setup", ""
+
+      expect(Devinator::Config.setup_commands).to eq(["dx/exec bin/setup"])
+    end
+
+    it "returns dx/start when available" do
+      File.write "dx/start", ""
+
+      expect(Devinator::Config.setup_commands).to eq(["dx/start"])
+    end
+
+    it "returns dx/build when available" do
+      File.write "dx/build", ""
+
+      expect(Devinator::Config.setup_commands).to eq(["dx/build"])
+    end
+
+    it "returns all files when available" do
+      File.write "bin/setup", ""
+      File.write "dx/start", ""
+      File.write "dx/build", ""
+
+      Devinator::Config.configure do |config|
+        config.setup_commands = [
+          "update_secrets",
+          "load_secrets sean",
+          "git pull"
+        ]
+      end
+
+      expect(Devinator::Config.setup_commands).to eq(
+        [
+          "update_secrets",
+          "load_secrets sean",
+          "git pull",
+          "dx/build",
+          "dx/start",
+          "bin/setup"
+        ]
+      )
+    end
+
+    context "with an editor command setup" do
+      describe "when the timing is :end_of_setup" do
+        it "returns before the other commands" do
+          Devinator::Config.configure do |config|
+            config.editor.command = "nvim"
+            config.editor.timing = :end_of_setup
+          end
+
+          File.write "bin/setup", ""
+
+          expect(Devinator::Config.setup_commands).to eq([
+            "bin/setup", "nvim"
+          ])
+        end
+      end
+    end
+  end
+
+  describe ".run_commands" do
+    context "with a bin/dev" do
+      it "returns nothing when no files" do
+        expect(Devinator::Config.run_commands).to eq([])
+      end
+
+      it "returns bin/dev when available" do
+        File.write "bin/dev", ""
+
+        expect(Devinator::Config.run_commands).to eq([
+          {title: "dev", command: "bin/dev"}
+        ])
+      end
+
+      it "returns dx/exec bin/dev when both available" do
+        File.write "dx/exec", ""
+        File.write "bin/dev", ""
+
+        expect(Devinator::Config.run_commands).to eq([
+          {title: "dev", command: "dx/exec bin/dev"}
+        ])
+      end
+    end
+
+    context "with a Procfile.dev" do
+      it "returns nothing when no files" do
+        expect(Devinator::Config.run_commands).to eq([])
+      end
+
+      it "uses Procfile.dev commands" do
+        File.write "Procfile.dev", <<~PROCFILE
+          web: bin/web
+          assets: bin/assets
+        PROCFILE
+
+        expect(Devinator::Config.run_commands).to eq([
+          {title: "web", command: "bin/web"},
+          {title: "assets", command: "bin/assets"}
+        ])
+      end
+
+      it "returns dx/exec for the commands when present" do
+        File.write "dx/exec", ""
+        File.write "Procfile.dev", <<~PROCFILE
+          web: bin/web
+          assets: bin/assets
+        PROCFILE
+
+        expect(Devinator::Config.run_commands).to eq([
+          {title: "web", command: "dx/exec bin/web"},
+          {title: "assets", command: "dx/exec bin/assets"}
+        ])
+      end
+
+      context "when bin/dev is also present" do
+        it "uses Procfile.dev commands and ignores bin/dev" do
+          File.write "bin/dev", ""
+          File.write "Procfile.dev", <<~PROCFILE
+            web: bin/web
+            tests: bin/tests
+          PROCFILE
+
+          expect(Devinator::Config.run_commands).to eq([
+            {title: "web", command: "bin/web"},
+            {title: "tests", command: "bin/tests"}
+          ])
+        end
+      end
+    end
+
+    context "with an editor command setup" do
+      describe "when the timing is :first_command" do
+        it "returns before the other commands" do
+          Devinator::Config.configure do |config|
+            config.editor.title = "editor"
+            config.editor.command = "nvim"
+            config.editor.timing = :first_command
+          end
+
+          File.write "bin/dev", ""
+
+          expect(Devinator::Config.run_commands).to eq([
+            {title: "editor", command: "nvim"},
+            {title: "dev", command: "bin/dev"}
+          ])
+        end
+      end
+
+      describe "when the timing is :last_command" do
+        it "returns before the other commands" do
+          Devinator::Config.configure do |config|
+            config.editor.title = "editor"
+            config.editor.command = "nvim"
+            config.editor.timing = :last_command
+          end
+
+          File.write "bin/dev", ""
+
+          expect(Devinator::Config.run_commands).to eq([
+            {title: "dev", command: "bin/dev"},
+            {title: "editor", command: "nvim"}
+          ])
+        end
+      end
+    end
+  end
+end

data/spec/devinator_spec.rb

@@ -0,0 +1,54 @@
+describe Devinator do
+  describe ".run" do
+    before do
+      @tty = double(:tty)
+      allow(TTY::Command).to receive(:new).and_return(@tty)
+
+      allow(Dir).to receive(:pwd).and_return("/path/to/project")
+      allow(Devinator::Config).to receive(:setup_commands).and_return([])
+      allow(Devinator::Config).to receive(:run_commands).and_return([])
+
+      @tmux = double(:tmux)
+      allow(Devinator::Backends::Tmux).to receive(:new).and_return(@tmux)
+      allow(@tmux).to receive(:launch)
+    end
+
+    it "runs the setup commands before run commands" do
+      expect(File).to receive(:expand_path).with("~/.config/devinator.rb").and_return("user config")
+      expect(File).to receive(:exist?).with("user config").and_return(false)
+      expect(TTY::Command).to receive(:new).with(uuid: false)
+
+      expect(Dir).to receive(:pwd).and_return("/path/to/project")
+      expect(Devinator::Config).to receive(:setup_commands).and_return(["bin/setup"])
+
+      expect(@tty).to receive(:run).with(
+        "bin/setup",
+        only_output_on_error: true
+      )
+
+      allow(Devinator::Config).to receive(:run_commands).and_return(
+        [{title: "dev", command: "bin/dev"}]
+      )
+      expect(Devinator::Backends::Tmux).to receive(:new).with(
+        name: "project",
+        commands: [
+          title: "dev", command: "bin/dev"
+        ],
+        executer: @tty
+      ).and_return(@tmux).ordered
+
+      expect(@tmux).to receive(:launch)
+
+      Devinator.run
+    end
+
+    it "loads the user config" do
+      expect(File).to receive(:expand_path).with("~/.config/devinator.rb").and_return("user config")
+      expect(File).to receive(:exist?).with("user config").and_return(true)
+
+      expect(Kernel).to receive(:require).with("user config")
+
+      Devinator.run
+    end
+  end
+end

data/spec/editor_configuration_spec.rb

@@ -0,0 +1,24 @@
+describe Devinator::UserConfiguration do
+  describe "#timing=" do
+    it "lets you set :end_of_setup, :first_command, and :last_command" do
+      config = Devinator::EditorConfiguration.new
+
+      expect do
+        config.timing = :end_of_setup
+        config.timing = :first_command
+        config.timing = :last_command
+      end.not_to raise_error
+    end
+
+    it "raises an error if passed a different value" do
+      config = Devinator::EditorConfiguration.new
+
+      expect do
+        config.timing = :nope
+      end.to raise_error(
+        ArgumentError,
+        "must be one of [:end_of_setup, :first_command, :last_command]"
+      )
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,113 @@
+require "tmpdir"
+
+require "devinator"
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See https://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+  #   # This allows you to limit a spec run to individual examples or groups
+  #   # you care about by tagging them with `:focus` metadata. When nothing
+  #   # is tagged with `:focus`, all examples get run. RSpec also provides
+  #   # aliases for `it`, `describe`, and `context` that include `:focus`
+  #   # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  #   config.filter_run_when_matching :focus
+  #
+  #   # Allows RSpec to persist some state between runs in order to support
+  #   # the `--only-failures` and `--next-failure` CLI options. We recommend
+  #   # you configure your source control system to ignore this file.
+  #   config.example_status_persistence_file_path = "spec/examples.txt"
+  #
+  #   # Limits the available syntax to the non-monkey patched syntax that is
+  #   # recommended. For more details, see:
+  #   # https://rspec.info/features/3-12/rspec-core/configuration/zero-monkey-patching-mode/
+  #   config.disable_monkey_patching!
+  #
+  #   # This setting enables warnings. It's recommended, but in some cases may
+  #   # be too noisy due to issues in dependencies.
+  #   config.warnings = true
+  #
+  #   # Many RSpec users commonly either run the entire suite or an individual
+  #   # file, and it's useful to allow more verbose output when running an
+  #   # individual spec file.
+  #   if config.files_to_run.one?
+  #     # Use the documentation formatter for detailed output,
+  #     # unless a formatter has already been configured
+  #     # (e.g. via a command-line flag).
+  #     config.default_formatter = "doc"
+  #   end
+  #
+  #   # Print the 10 slowest examples and example groups at the
+  #   # end of the spec run, to help surface which specs are running
+  #   # particularly slow.
+  #   config.profile_examples = 10
+  #
+  #   # Run specs in random order to surface order dependencies. If you find an
+  #   # order dependency and want to debug it, you can fix the order by providing
+  #   # the seed, which is printed after each run.
+  #   #     --seed 1234
+  #   config.order = :random
+  #
+  #   # Seed global randomization in this process using the `--seed` CLI option.
+  #   # Setting this allows you to use `--seed` to deterministically reproduce
+  #   # test failures related to randomization by passing the same `--seed` value
+  #   # as the one that triggered the failure.
+  #   Kernel.srand config.seed
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.around do |spec|
+    original_dir = Dir.pwd
+    Dir.chdir Dir.mktmpdir "devinator-specs-"
+    Dir.mkdir "bin"
+    Dir.mkdir "dx"
+    spec.run
+  ensure
+    Dir.chdir original_dir
+    Devinator::Config.instance_variable_set(:@user_configuration, nil)
+  end
+end

data/spec/user_configuration_spec.rb

@@ -0,0 +1,31 @@
+describe Devinator::UserConfiguration do
+  describe "#setup_commands" do
+    it "returns an empty array if not specifically set" do
+      expect(Devinator::UserConfiguration.new.setup_commands).to eq([])
+    end
+
+    it "returns an array if set to a single value" do
+      config = Devinator::UserConfiguration.new
+
+      config.setup_commands = "load_secrets"
+
+      expect(config.setup_commands).to eq(["load_secrets"])
+    end
+
+    it "returns normally if already an array" do
+      config = Devinator::UserConfiguration.new
+
+      config.setup_commands = ["update_secrets", "load_secrets", "git pull"]
+
+      expect(config.setup_commands).to eq(["update_secrets", "load_secrets", "git pull"])
+    end
+  end
+
+  describe "#editor" do
+    it "is a EditorConfiguration class" do
+      config = Devinator::UserConfiguration.new
+
+      expect(config.editor).to be_a(Devinator::EditorConfiguration)
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: devinator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sean Earle
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |2
+      A little tool to help you get your development
+      environment up and running with a single command.
+email:
+- sean.r.earle@gmail.com
+executables:
+- devinator
+extensions: []
+extra_rdoc_files: []
+files:
+- ".git-hooks/pre-commit"
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- Makefile
+- README.md
+- bin/devinator
+- bin/pretty
+- bin/test
+- devinator.gemspec
+- lib/devinator.rb
+- lib/devinator/backends/tmux.rb
+- lib/devinator/config.rb
+- lib/devinator/editor_configuration.rb
+- lib/devinator/user_configuration.rb
+- lib/devinator/version.rb
+- spec/backends/tmux_spec.rb
+- spec/config_spec.rb
+- spec/devinator_spec.rb
+- spec/editor_configuration_spec.rb
+- spec/spec_helper.rb
+- spec/user_configuration_spec.rb
+homepage: https://github.com/HellRok/devinator
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Start your development environment with one command!
+test_files: []