exogenesis 0.0.1 → 0.2.0

data/lib/exogenesis/passengers/homebrew_cask.rb

@@ -0,0 +1,70 @@
+require 'exogenesis/support/passenger'
+
+class HomebrewCask < Passenger
+  CASKROOM = 'caskroom/cask'
+
+  register_as :homebrew_cask
+  needs :casks
+  with_emoji :beer
+
+  def up
+    tap_cask
+    install_missing_casks
+  end
+
+  def clean
+    execute 'Clean Up', 'brew cask cleanup'
+  end
+
+  def down
+    uninstall_installed_casks
+    untap_cask
+  end
+
+  private
+
+  def install_missing_casks
+    (casks || []).each do |cask|
+      next if installed_casks.include?(cask)
+      install_package cask
+    end
+  end
+
+  def uninstall_installed_casks
+    installed_casks.each do |cask|
+      uninstall_package cask
+    end
+  end
+
+  def install_package(name)
+    execute "Installing #{name}", "brew cask install #{name}"
+  end
+
+  def uninstall_package(name)
+    execute "Uninstalling #{name}", "brew cask uninstall #{name}"
+  end
+
+  def tap_cask
+    if cask_tapped?
+      skip_task 'Tap Cask'
+    else
+      execute_interactive 'Tap Cask', "brew tap #{CASKROOM}"
+    end
+  end
+
+  def untap_cask
+    execute 'Untap Cask', "brew untap #{CASKROOM}"
+  end
+
+  def cask_tapped?
+    installed_taps.include?(CASKROOM)
+  end
+
+  def installed_casks
+    @installed_casks ||= silent_execute('brew cask list').split(/\s/)
+  end
+
+  def installed_taps
+    @installed_taps ||= silent_execute('brew tap').split(/\n/)
+  end
+end

data/lib/exogenesis/passengers/npm.rb

@@ -0,0 +1,43 @@
+require 'exogenesis/support/passenger'
+
+# Install NPM and NPM packages
+# REQUIRES: Homebrew (so put it after your homebrew task)
+class Npm < Passenger
+  register_as :npm
+  needs :npms
+  with_emoji :cyclone
+
+  def up
+    install_node
+
+    npms.each do |package|
+      if installed.include? package
+        update_package(package)
+      else
+        install_package(package)
+      end
+    end
+  end
+
+  private
+
+  def install_node
+    if command_exists? 'npm'
+      skip_task 'Install Node'
+    else
+      execute 'Install Node', 'brew install node'
+    end
+  end
+
+  def installed
+    @installed ||= silent_execute('npm ls -g --depth=0').scan(/(\S+)@[\d.]+/).flatten
+  end
+
+  def update_package(package)
+    execute "Update #{package}", "npm update -g #{package}"
+  end
+
+  def install_package(package)
+    execute "Install #{package}", "npm install -g #{package}"
+  end
+end

data/lib/exogenesis/passengers/python.rb

@@ -0,0 +1,37 @@
+require 'exogenesis/support/passenger'
+
+# Install Python and pip packages
+# REQUIRES: Homebrew (so put it after your homebrew task)
+class Python < Passenger
+  register_as :python
+  needs :pips
+  with_emoji :snake
+
+  def up
+    if command_exists? 'pip'
+      skip_task 'Install Python'
+    else
+      execute 'Install Python', 'brew install python'
+    end
+
+    execute 'Link Python', 'brew link --overwrite python' do |output|
+      raise TaskSkipped, 'Already linked' if output.include? 'Already linked'
+    end
+
+    (['pip'] + pips).each do |package|
+      if installed_pips.include? package
+        execute "Upgrade #{package}", "pip install --user --upgrade #{package}" do |output|
+          raise TaskSkipped, 'Already up to date' if output.include? 'already up-to-date'
+        end
+      else
+        execute "Install #{package}", "pip install --user #{package}"
+      end
+    end
+  end
+
+  private
+
+  def installed_pips
+    @installed_pips ||= silent_execute('pip list').scan(/(\S+) \([\d.]+\)/).flatten
+  end
+end

data/lib/exogenesis/passengers/rbenv.rb

@@ -0,0 +1,51 @@
+require 'exogenesis/support/passenger'
+
+# Manages the Ruby Version Manager Rbenv and the ruby installer ruby-build
+class Rbenv < Passenger
+  register_as :rbenv
+  needs :rubies
+  with_emoji :cyclone
+
+  def up
+    if command_exists? 'rbenv'
+      update_rbenv
+    else
+      install_rbenv
+    end
+    rubies.each { |ruby| install_ruby ruby }
+    execute 'Rehash', 'rbenv rehash'
+  end
+
+  def down
+    execute_interactive 'Teardown', 'rm -r ~/.rbenv'
+  end
+
+  private
+
+  def install_rbenv
+    execute 'Install rbenv', 'git clone https://github.com/sstephenson/rbenv.git ~/.rbenv'
+    execute 'Install ruby-build plugin', 'git clone https://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build'
+  end
+
+  def update_rbenv
+    execute 'Update rbenv', 'cd ~/.rbenv && git pull'
+    execute 'Update ruby-build', 'cd ~/.rbenv/plugins/ruby-build && git pull'
+  end
+
+  def install_ruby(ruby)
+    return if installed_versions.include? ruby
+    execute "Installing #{ruby}", "rbenv install #{ruby}"
+  end
+
+  def installed_versions
+    return @installed_versions if @installed_versions
+
+    @installed_versions = []
+    execute 'Getting Installed Versions', 'rbenv versions' do |output|
+      output.scan(/^[\*]?\s*([\S]*).*$/).each do |ruby|
+        @installed_versions << ruby[0]
+      end
+    end
+    @installed_versions
+  end
+end

data/lib/exogenesis/passengers/rvm.rb

@@ -0,0 +1,55 @@
+require 'exogenesis/support/passenger'
+
+# Manages the Ruby Version Manager RVM
+class Rvm < Passenger
+  register_as :rvm
+  needs :rubies
+  with_emoji :cyclone
+
+  def up
+    if command_exists? 'rvm'
+      skip_task 'Setup'
+    else
+      execute_interactive 'Setup', '\\curl -L https://get.rvm.io | bash -s'
+    end
+    execute 'Update', 'rvm get head'
+    rubies.each { |ruby| install_or_update_ruby ruby }
+    execute 'Reload', 'rvm reload'
+  end
+
+  def down
+    execute_interactive 'Teardown', 'rvm implode'
+  end
+
+  private
+
+  def install_or_update_ruby(ruby)
+    if installed_versions[ruby].nil?
+      install_ruby ruby
+    else
+      update_ruby installed_versions[ruby], ruby
+    end
+  end
+
+  def install_ruby(ruby)
+    execute "Installing #{ruby}", "rvm install #{ruby} --with-gcc=gcc-4.2"
+  end
+
+  def update_ruby(old_ruby, new_ruby)
+    execute "Upgrading #{new_ruby}", "rvm upgrade #{old_ruby} #{new_ruby} --force --with-gcc=gcc-4.2" do |_output, error_output|
+      raise TaskSkipped, 'Already Up to Date' if error_output.include? 'are the same'
+    end
+  end
+
+  def installed_versions
+    return @installed_versions if @installed_versions
+
+    @installed_versions = {}
+    execute 'Getting Installed Versions', 'rvm list' do |output|
+      output.scan(/((\w+-[\w\.]+)(-(p\d+))?)/).each do |ruby|
+        @installed_versions[ruby[1]] = ruby[0]
+      end
+    end
+    @installed_versions
+  end
+end

data/lib/exogenesis/passengers/vundle.rb

@@ -0,0 +1,37 @@
+require 'exogenesis/support/passenger'
+
+# Manages the Vim Package Manager Vundle
+class Vundle < Passenger
+  VUNDLE_REPO = 'git://github.com/gmarik/vundle.git'
+
+  register_as :vundle
+  with_emoji :gift
+
+  def up
+    if vundle_folder.exist?
+      skip_task 'Cloning Vundle'
+    else
+      mkpath(vundle_folder)
+      execute 'Cloning Vundle', "git clone #{VUNDLE_REPO} #{vundle_folder}"
+    end
+    execute_interactive 'Installing and Updating Vim Bundles', 'vim +BundleInstall\! +qall'
+  end
+
+  def down
+    rm_rf vim_folder
+  end
+
+  def clean
+    execute_interactive 'Cleaning', 'vim +BundleClean\! +qall'
+  end
+
+  private
+
+  def vim_folder
+    @vim_folder ||= get_path_in_home '.vim'
+  end
+
+  def vundle_folder
+    @vundle_folder ||= get_path_in_home '.vim', 'bundle', 'vundle'
+  end
+end

data/lib/exogenesis/support/executor.rb

@@ -0,0 +1,195 @@
+require 'fileutils'
+require 'singleton'
+require 'open3'
+require 'bundler'
+require 'exogenesis/support/output'
+require 'exogenesis/support/task_skipped'
+
+# Executor is a Singleton. Get the instance
+# via `Executor.instance`
+# If you add a public method here, please also
+# add it to the `executor_double`. Same goes for
+# removing public methods ;)
+class Executor
+  include Singleton
+
+  def initialize
+    @output = Output.instance
+  end
+
+  # Start a new output section with a given
+  # text
+  def start_section(text, emoji_name)
+    @output.decorated_header(text, emoji_name)
+  end
+
+  # Notify the user that you started with a
+  # task like 'Configure Homebrew'
+  def start_task(text)
+    @output.left(text)
+  end
+
+  # Notify the user that the started task
+  # was successful.
+  def task_succeeded(further_information = '')
+    @output.success(further_information)
+  end
+
+  # Notify the user that the started task
+  # failed.
+  def task_failed(further_information, exit_status = 1)
+    @output.failure(further_information)
+    exit(exit_status)
+  end
+
+  # Notify the user that you have skipped a task
+  def skip_task(description, further_information = '')
+    @output.left(description)
+    @output.skipped(further_information)
+  end
+
+  # Notify the user about something
+  # TODO: It has to be possible to give an info for a started task
+  def info(description, information)
+    @output.left(description)
+    @output.info(information)
+  end
+
+  # Create a path
+  # Expects a PathName
+  def mkpath(path)
+    FileUtils.mkpath(path)
+  end
+
+  # Get a path starting from the home dir
+  def get_path_in_home(*path)
+    Pathname.new(File.join(Dir.home, *path))
+  end
+
+  # Get a path starting from the current working directory
+  def get_path_in_working_directory(*path)
+    Pathname.pwd.join(*path)
+  end
+
+  # Get an expanded PathName for a String
+  def get_path_for(path_as_string)
+    Pathname.new(File.expand_path(path_as_string))
+  end
+
+  # Execute a shell script. The description will
+  # be printed before the execution. This method
+  # will handle failures of the executed script.
+  # If you provide a block, execute will pass the output
+  # of the execution to it. If you raise a TaskSkipped
+  # Exception, it will skip the task instead of marking
+  # it as done (and give the text you provided to the
+  # exception as additional information if verbose is
+  # active)
+  def execute(description, script)
+    start_task description
+
+    output, error_output, exit_status = nil
+    Bundler.with_clean_env do
+      Open3.popen3(script) do |_stdin, stdout, stderr, process|
+        output = stdout.read
+        error_output = stderr.read
+        exit_status = process.value.exitstatus
+      end
+    end
+
+    yield(output, error_output) if block_given?
+
+    if exit_status > 0
+      task_failed("An Error occured while executing `#{script}`: \n#{output} #{error_output}", exit_status)
+    else
+      task_succeeded(output)
+    end
+  rescue TaskSkipped => e
+    @output.skipped(e)
+  end
+
+  # Executes the script via system, so the user
+  # can interact with the output. Instead of
+  # the usual output of the other commands, it
+  # will draw a border around the interactive section
+  def execute_interactive(description, script)
+    @output.start_border description
+    system script
+    @output.end_border
+  end
+
+  # Execute without printing anything, return the result
+  # (Use instead of `command` to mock it)
+  def silent_execute(command)
+    Bundler.with_clean_env do
+      `#{command}`
+    end
+  end
+
+  # Wrapper around FileUtils' `rm_rf`
+  # First check if the path exists, info if it doesn't exist
+  # If it exists, ask if the user really wants to delete it
+  # path: Needs to be a PathName
+  def rm_rf(path)
+    if path.exist?
+      FileUtils.rm_rf(path) if ask?("Do you really want to `rm -rf #{path}?`")
+    else
+      info("Delete `#{path}`", 'Already deleted')
+    end
+  end
+
+  # Wrapper around FileUtils' `ln_s`
+  def ln_s(src, dest)
+    if dest.symlink? && dest.readlink == src
+      skip_task "Linking #{src}", 'Already linked'
+    else
+      start_task "Linking #{src}"
+      if dest.exist? || dest.symlink?
+        task_failed 'Target already exists'
+      else
+        FileUtils.ln_s(src, dest)
+        task_succeeded
+      end
+    end
+  end
+
+  # Ask the user a yes/no question
+  def ask?(question)
+    start_task("#{question} (y for yes, everything else aborts)")
+    STDIN.gets == "y\n"
+  end
+
+  # Clone a git repository
+  # TODO: Currently only supports Github Repos, but should work in hub-style in the future
+  # git_repo: A Github repo name
+  # target: A path object where you want to clone to
+  def clone_repo(git_repo, target)
+    execute "Cloning #{git_repo}", "git clone git@github.com:#{git_repo}.git #{target}"
+  end
+
+  # Pull a git repository
+  # git_repo: Is just used for the description
+  # git_repo: A Github repo name (only used for task description)
+  # target: A path object where you want to pull
+  def pull_repo(git_repo, target)
+    check_if_git_repo! target
+    execute "Pulling #{git_repo}", "cd #{target} && git pull"
+  end
+
+  # Check if a command exists
+  def command_exists?(command)
+    system("which #{command} &>/dev/null;")
+  end
+
+  private
+
+  # Path: A pathname object where you want to pull
+  def check_if_git_repo!(path)
+    start_task "Checking #{path.basename}"
+    if path.children.one? { |child| child.basename.to_s == '.git' }
+      task_succeeded
+    else
+      task_failed 'Not a git repository'
+    end
+  end
+end