lolcommits 0.5.7 → 0.5.8

data/features/step_definitions/lolcommits_steps.rb

@@ -1,122 +1,142 @@
 # -*- encoding : utf-8 -*-
-include FileUtils
+require 'fileutils'
+require 'aruba/api'
 
-Given /^I am in a directory named "(.*?)"$/ do |dir_name|
-  steps %Q{
+def postcommit_hook
+  '.git/hooks/post-commit'
+end
+
+def default_repo
+  'mygit'
+end
+
+def default_loldir
+  absolute_path("~/.lolcommits/#{default_repo}")
+end
+
+Given(/^I am in a directory named "(.*?)"$/) do |dir_name|
+  steps %(
     Given a directory named "#{dir_name}"
     And I cd to "#{dir_name}"
-  }
+    )
 end
 
-Given /^a git repository named "(.*?)"$/ do |repo_name|
-  repo_dir = File.join current_dir, repo_name
-  mkdir_p repo_dir
-  Dir.chdir repo_dir do
-    system 'git init --quiet .'
-    system "git config user.name 'Testy McTesterson'"
-    system "git config user.email 'testy@tester.com'"
-  end
+Given(/^a git repo named "(.*?)"$/) do |repo_name|
+  steps %(
+   Given I successfully run `git init --quiet "#{repo_name}"`
+    )
 end
 
-Given /^the git repository named "(.*?)" has no "(.*?)" hook$/ do |repo_name, hook_name|
-  hook_file = File.join current_dir, repo_name, '.git', 'hooks', hook_name
-  delete(hook_file) if File.exists? hook_file
+Given(/^I am in a git repo named "(.*?)"$/) do |repo|
+  steps %(
+    Given a git repo named "#{repo}"
+    And I cd to "#{repo}"
+    )
 end
 
-Given /^the git repository named "(.*?)" has a "(.*?)" hook$/ do |repo_name, hook_name|
-  hook_file = File.join current_dir, repo_name, '.git', 'hooks', hook_name
-  touch(hook_file) if not File.exists? hook_file
+Given(/^I am in a git repo$/) do
+  steps %(
+    Given I am in a git repo named "#{default_repo}"
+    )
 end
 
-Given /^the "(.*?)" repository "(.*?)" hook has content "(.*?)"$/ do |repo_name, hook_name, hook_content|
-  step %{the git repository named "#{repo_name}" has a "#{hook_name}" hook}
-  hook_file = File.join current_dir, repo_name, '.git', 'hooks', hook_name
-  File.open(hook_file, 'w') { |f| f.write(hook_content) }
+Given(/^I am in a git repo named "(.*?)" with lolcommits enabled$/) do |repo|
+  steps %(
+    Given I am in a git repo named "#{repo}"
+    And I successfully run `lolcommits --enable`
+    )
 end
 
-Given /^a git repository named "(.*?)" with (a|no) "(.*?)" hook$/ do |repo_name, yesno_modifier, hook_name|
-  step %{a git repository named "#{repo_name}"}
-  step %{the git repository named "#{repo_name}" has #{yesno_modifier} "#{hook_name}" hook}
+Given(/^I am in a git repo with lolcommits enabled$/) do
+  steps %(
+    Given I am in a git repo named "#{default_repo}" with lolcommits enabled
+    )
 end
 
-Given /^I am in a git repository named "(.*?)"$/ do |repo_name|
-  steps %Q{
-    Given a git repository named "#{repo_name}"
-    And I cd to "#{repo_name}"
-  }
+Given(/^a post\-commit hook with "(.*?)"$/) do |file_content|
+  steps %(
+    Given a file named "#{postcommit_hook}" with:
+      """
+      #{file_content}
+      """
+    )
 end
 
-Given /^I am in a git repository named "(.*?)" with lolcommits enabled$/ do |repo_name|
-  steps %Q{
-    Given I am in a git repository named "#{repo_name}"
-    And I successfully run `lolcommits --enable`
-  }
+Then(/^the lolcommits post\-commit hook should be properly installed$/) do
+  steps %(
+    Then the post-commit hook should contain "lolcommits --capture"
+    )
+end
+
+Then(/^the post\-commit hook (should|should not) contain "(.*?)"$/) do |should, content|
+  steps %(
+    Then the file "#{postcommit_hook}" #{should} contain "#{content}"
+    )
 end
 
-Given /^I have environment variable (.*?) set to (.*?)$/ do |var, value|
+Given(/^I have environment variable (.*?) set to (.*?)$/) do |var, value|
   set_env var, value
 end
 
-When /^I run `(.*?)` and wait for output$/ do |command|
-  command = "cd #{current_dir} && #{command}"
-  @stdin, @stdout, @stderr = Open3.popen3(command)
-  @fields = Hash.new
+Given(/^its loldir has (\d+) lolimages$/) do |num_images|
+  steps %(
+    Given a loldir named "#{default_repo}" with #{num_images} lolimages
+    )
 end
 
-Given /^a loldir named "(.*?)" with (\d+) lolimages$/ do |repo_name, num_images|
-  loldir = "tmp/aruba/.lolcommits/#{repo_name}"
-  mkdir_p loldir
+Given(/^a loldir named "(.*?)" with (\d+) lolimages$/) do |repo, num_images|
+  loldir = absolute_path("~/.lolcommits/#{repo}")
+  FileUtils.mkdir_p loldir
   num_images.to_i.times do
-    random_hex = '%011x' % (rand * 0xfffffffffff)
-    cp 'test/images/test_image.jpg', File.join(loldir, "#{random_hex}.jpg")
+    hex = "#{format '%011x', (rand * 0xfffffffffff)}"
+    FileUtils.cp 'test/images/test_image.jpg', File.join(loldir, "#{hex}.jpg")
   end
 end
 
-Then /^I should be (prompted for|presented) "(.*?)"$/ do |_, prompt|
-  assert @stdout.read.to_s.include?(prompt)
-end
-
-When /^I enter "(.*?)" for "(.*?)"$/ do |input, field|
-  @fields[field] = input
-  @stdin.puts input
+Then(/^there should be exactly (.*?) (jpg|gif|pid)s? in its loldir$/) do |n, type|
+  steps %(
+    Then there should be exactly #{n} #{type} in "#{default_loldir}"
+    )
 end
 
-Then /^there should be (?:exactly|only) (.*?) (jpg|gif|pid)(?:s?) in "(.*?)"$/ do |n, type, folder|
-  assert_equal n.to_i, Dir["#{current_dir}/#{folder}/*.#{type}"].count
+Then(/^there should be exactly (.*?) (jpg|gif|pid)s? in "(.*?)"$/) do |n, type, folder|
+  expect(Dir[absolute_path(folder, "*.#{type}")].count).to eq(n.to_i)
 end
 
-Then /^the output should contain a list of plugins$/ do
-  step %{the output should contain "Available plugins: "}
+Then(/^the output should contain a list of plugins$/) do
+  step %(the output should contain "Available plugins: ")
 end
 
-When /^I do a git commit with commit message "(.*?)"$/ do |commit_msg|
+When(/^I do a git commit with commit message "(.*?)"$/) do |commit_msg|
   filename = Faker::Lorem.words(1).first
-  step %{a 98 byte file named "#{filename}"}
-  step %{I successfully run `git add #{filename}`}
-  step %{I successfully run `git commit -m "#{commit_msg}"`}
+  steps %(
+    Given a 98 byte file named "#{filename}"
+    And I successfully run `git add #{filename}`
+    And I successfully run `git commit -m "#{commit_msg}"`
+    )
 end
 
-When /^I do a git commit$/ do
-  commit_msg = Faker::Lorem.sentence
-  step %{I do a git commit with commit message "#{commit_msg}"}
+When(/^I do a git commit$/) do
+  step %(I do a git commit with commit message "#{Faker::Lorem.sentence}")
 end
 
-When /^I do (\d+) git commits$/ do |n|
+When(/^I do (\d+) git commits$/) do |n|
   n.to_i.times do
-    step %{I do a git commit}
+    step %(I do a git commit)
     sleep 0.1
   end
 end
 
-Then /^there should be (\d+) commit entries in the git log$/ do |n|
+Then(/^there should be (\d+) commit entries in the git log$/) do |n|
   sleep 1 # let the file writing catch up
-  assert_equal n.to_i, `git shortlog | grep -E '^[ ]+\w+' | wc -l`.chomp.to_i
+  expect(n.to_i).to eq `git shortlog | grep -E '^[ ]+\w+' | wc -l`.chomp.to_i
 end
 
-Given /^I am using a "(.*?)" platform$/ do |platform_name|
-  ENV['LOLCOMMITS_FAKEPLATFORM'] = platform_name
+Given(/^I am using a "(.*?)" platform$/) do |platform_name|
+  set_env 'LOLCOMMITS_FAKEPLATFORM', platform_name
 end
 
-When /^I wait for the child process to exit in "(.*?)"$/ do |repo_name|
-  sleep 0.1 while File.exist?("tmp/aruba/.lolcommits/#{repo_name}/lolcommits.pid")
+When(/^I wait for the child process to exit in "(.*?)"$/) do |repo_name|
+  pid_loc = absolute_path("~/.lolcommits/#{repo_name}/lolcommits.pid")
+  sleep 0.1 while File.exist?(pid_loc)
 end

data/features/support/env.rb

@@ -2,16 +2,12 @@
 require 'aruba/cucumber'
 require 'methadone/cucumber'
 require 'open3'
-require 'test/unit/assertions'
-include Test::Unit::Assertions
 require 'ffaker'
-require 'lolcommits/configuration'
+require 'fileutils'
+
 require File.join(File.expand_path(File.dirname(__FILE__)), 'path_helpers')
 include Lolcommits
 
-ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
-LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)), '..', '..', 'lib')
-
 World(PathHelpers)
 
 Before do
@@ -19,70 +15,44 @@ Before do
   @puts = true
   @aruba_timeout_seconds = 20
 
-  @original_rubylib = ENV['RUBYLIB']
-  ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
-
-  @original_fakecapture = ENV['LOLCOMMITS_FAKECAPTURE']
-  ENV['LOLCOMMITS_FAKECAPTURE'] = '1'
-
-  # @original_loldir = ENV['LOLCOMMITS_DIR']
-  # ENV['LOLCOMMITS_DIR'] = File.expand_path( File.join(current_dir, ".lolcommits") )
-
-  @original_home = ENV['HOME']
-  ENV['HOME'] = File.expand_path(current_dir)
-
-  ENV['LAUNCHY_DRY_RUN'] = 'true'
-end
-
-After do
-  ENV['RUBYLIB'] = @original_rubylib
-  ENV['LOLCOMMITS_FAKECAPTURE'] = @original_fakecapture
-  # ENV['LOLCOMMITS_DIR'] = @original_loldir
-  ENV['HOME'] = @original_home
-  ENV['LAUNCHY_DRY_RUN'] = nil
-  ENV['LOLCOMMITS_FAKEPLATFORM'] = nil
-end
-
-Before('@fake-interactive-rebase') do
-  # in order to fake an interactive rebase,
-  # we replace the editor with a script that simply squashes a few random commits
-  @original_git_editor = ENV['GIT_EDITOR']
-  # ENV['GIT_EDITOR'] = "sed -i -e 'n;s/pick/squash/g'" #every other commit
-  ENV['GIT_EDITOR'] = "sed -i -e '3,5 s/pick/squash/g'" # lines 3-5
-end
+  set_env 'LOLCOMMITS_FAKECAPTURE', '1'
+  set_env 'LAUNCHY_DRY_RUN', 'true'
 
-After('@fake-interactive-rebase') do
-  ENV['GIT_EDITOR'] = @original_git_editor
+  author_name  = 'Testy McTesterson'
+  author_email = 'testy@tester.com'
+  set_env 'GIT_AUTHOR_NAME',     author_name
+  set_env 'GIT_COMMITTER_NAME',  author_name
+  set_env 'GIT_AUTHOR_EMAIL',    author_email
+  set_env 'GIT_COMMITTER_EMAIL', author_email
 end
 
+# for tasks that may take an insanely long time (e.g. network related)
+# we should strive to not have any of these in our scenarios, naturally.
 Before('@slow_process') do
   @aruba_io_wait_seconds = 5
   @aruba_timeout_seconds = 60
 end
 
+# in order to fake an interactive rebase, we replace the editor with a script
+# to simply squash a few random commits. in this case, using lines 3-5.
+Before('@fake-interactive-rebase') do
+  set_env 'GIT_EDITOR', "sed -i -e '3,5 s/pick/squash/g'"
+end
+
 # adjust the path so tests dont see a global imagemagick install
 Before('@fake-no-imagemagick') do
   reject_paths_with_cmd('mogrify')
 end
 
-After('@fake-no-imagemagick') do
-  reset_path
-end
-
 # adjust the path so tests dont see a global ffmpeg install
 Before('@fake-no-ffmpeg') do
   reject_paths_with_cmd('ffmpeg')
 end
 
-After('@fake-no-ffmpeg') do
-  reset_path
-end
-
 # do test in temporary directory so our own git repo-ness doesn't affect it
 Before('@in-tempdir') do
   @dirs = [Dir.mktmpdir]
 end
-
 After('@in-tempdir') do
   FileUtils.rm_rf(@dirs.first)
 end

data/features/support/path_helpers.rb

@@ -1,12 +1,15 @@
 # -*- encoding : utf-8 -*-
+require 'fileutils'
+require 'aruba/api'
+require 'lolcommits/platform'
+
 module PathHelpers
   def reject_paths_with_cmd(cmd)
-    @original_path = ENV['PATH']
     # make a new subdir that still contains cmds
     tmpbindir = File.expand_path(File.join @dirs, 'bin')
     FileUtils.mkdir_p tmpbindir
 
-    preseve_cmds_in_path(['git', 'mplayer'], tmpbindir)
+    preseve_cmds_in_path(%w(git mplayer), tmpbindir)
 
     exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
     newpaths = ENV['PATH'].split(File::PATH_SEPARATOR).reject do |path|
@@ -20,19 +23,17 @@ module PathHelpers
 
     # add the temporary directory with git in it back into the path
     newpaths << tmpbindir
-    ENV['PATH'] = newpaths.join(File::PATH_SEPARATOR)
+
+    # use aruba/api set_env to set PATH, which will be automaticaly restored
+    set_env 'PATH', newpaths.join(File::PATH_SEPARATOR)
   end
 
   def preseve_cmds_in_path(cmds, tmpbindir)
     cmds.each do |cmd|
-      whichcmd = Lolcommits::Configuration.command_which(cmd)
+      whichcmd = Lolcommits::Platform.command_which(cmd)
       unless whichcmd.nil?
         FileUtils.ln_s whichcmd, File.join(tmpbindir, File.basename(whichcmd))
       end
     end
   end
-
-  def reset_path
-    ENV['PATH'] = @original_path
-  end
 end

data/lib/core_ext/mini_magick/utilities.rb

@@ -0,0 +1,15 @@
+# -*- encoding : utf-8 -*-
+# To maintain MiniMagick compatibility on Windows for v3.8.1 we need this patch
+# If/when we upgrade MiniMagick to 4.2+ this patch can be removed
+# We are locked at v3.8.1 since MiniMagick 4+ dropped support for Ruby 1.8.7
+module MiniMagick
+  module Utilities
+    class << self
+      # fixes issue introduced in this commit
+      # https://github.com/minimagick/minimagick/commit/65b6427395cbfe6
+      def windows_escape(cmdline)
+        '"' + cmdline.gsub(/\\(?=\\*\")/, '\\\\\\').gsub(/\"/, '\\"').gsub(/\\$/, '\\\\\\').gsub('%', '%%') + '"'
+      end
+    end
+  end
+end

data/lib/lolcommits/capturer/capture_linux.rb

@@ -12,7 +12,7 @@ module Lolcommits
       tmpdir = Dir.mktmpdir
 
       # Default delay is 1s
-      delay = if capture_delay != 0 then capture_delay else 1 end
+      delay = capture_delay != 0 ? capture_delay : 1
 
       # There's no way to give a capture delay in mplayer, but a number of frame
       # mplayer's "delay" is actually a number of frames at 25 fps

data/lib/lolcommits/capturer/capture_linux_animated.rb

@@ -8,21 +8,20 @@ module Lolcommits
 
       # capture the raw video with ffmpeg video4linux2
       system_call "ffmpeg -v quiet -y -f video4linux2 -video_size 320x240 -i #{capture_device_string} -t #{capture_duration} #{video_location} > /dev/null"
-      if File.exists?(video_location)
-        # convert raw video to png frames with ffmpeg
-        system_call "ffmpeg #{capture_delay_string} -v quiet -i #{video_location} -t #{animated_duration} #{frames_location}/%09d.png > /dev/null"
+      return unless File.exist?(video_location)
+      # convert raw video to png frames with ffmpeg
+      system_call "ffmpeg #{capture_delay_string} -v quiet -i #{video_location} -t #{animated_duration} #{frames_location}/%09d.png > /dev/null"
 
-        # use fps to set delay and number of frames to skip (for lower filesized gifs)
-        fps   = video_fps(video_location)
-        skip  = frame_skip(fps)
-        delay = frame_delay(fps, skip)
-        debug "Capturer: anaimated gif choosing every #{skip} frames with a frame delay of #{delay}"
+      # use fps to set delay and number of frames to skip (for lower filesized gifs)
+      fps   = video_fps(video_location)
+      skip  = frame_skip(fps)
+      delay = frame_delay(fps, skip)
+      debug "Capturer: anaimated gif choosing every #{skip} frames with a frame delay of #{delay}"
 
-        # create the looping animated gif from frames (picks nth frame with seq)
-        seq_command = "seq -f #{frames_location}/%09g.png 1 #{skip} #{Dir["#{frames_location}/*"].length}"
-        # convert to animated gif with delay and gif optimisation
-        system_call "convert -layers OptimizeTransparency -delay #{delay} -loop 0 `#{seq_command}` -coalesce #{snapshot_location} > /dev/null"
-      end
+      # create the looping animated gif from frames (picks nth frame with seq)
+      seq_command = "seq -f #{frames_location}/%09g.png 1 #{skip} #{Dir["#{frames_location}/*"].length}"
+      # convert to animated gif with delay and gif optimisation
+      system_call "convert -layers OptimizeTransparency -delay #{delay} -loop 0 `#{seq_command}` -coalesce #{snapshot_location} > /dev/null"
     end
 
     private

data/lib/lolcommits/capturer/capture_mac_animated.rb

@@ -8,21 +8,20 @@ module Lolcommits
 
       # capture the raw video with videosnap
       system_call "#{executable_path} -s 240 #{capture_device_string}#{capture_delay_string}-t #{animated_duration} --no-audio #{video_location} > /dev/null"
-      if File.exists?(video_location)
-        # convert raw video to png frames with ffmpeg
-        system_call "ffmpeg -v quiet -i #{video_location} -t #{animated_duration} #{frames_location}/%09d.png"
+      return unless File.exist?(video_location)
+      # convert raw video to png frames with ffmpeg
+      system_call "ffmpeg -v quiet -i #{video_location} -t #{animated_duration} #{frames_location}/%09d.png"
 
-        # use fps to set delay and number of frames to skip (for lower filesized gifs)
-        fps   = video_fps(video_location)
-        skip  = frame_skip(fps)
-        delay = frame_delay(fps, skip)
-        debug "Capturer: anaimated gif choosing every #{skip} frames with a frame delay of #{delay}"
+      # use fps to set delay and number of frames to skip (for lower filesized gifs)
+      fps   = video_fps(video_location)
+      skip  = frame_skip(fps)
+      delay = frame_delay(fps, skip)
+      debug "Capturer: anaimated gif choosing every #{skip} frames with a frame delay of #{delay}"
 
-        # create the looping animated gif from frames (picks nth frame with seq)
-        seq_command = "seq -f #{frames_location}/%09g.png 1 #{skip} #{Dir["#{frames_location}/*"].length}"
-        # convert to animated gif with delay and gif optimisation
-        system_call "convert -layers OptimizeTransparency -delay #{delay} -loop 0 `#{seq_command}` -coalesce #{snapshot_location}"
-      end
+      # create the looping animated gif from frames (picks nth frame with seq)
+      seq_command = "seq -f #{frames_location}/%09g.png 1 #{skip} #{Dir["#{frames_location}/*"].length}"
+      # convert to animated gif with delay and gif optimisation
+      system_call "convert -layers OptimizeTransparency -delay #{delay} -loop 0 `#{seq_command}` -coalesce #{snapshot_location}"
     end
 
     def executable_path

data/lib/lolcommits/capturer.rb

@@ -8,9 +8,17 @@ module Lolcommits
 
     def initialize(attributes = {})
       attributes.each do |attr, val|
-        self.send("#{attr}=", val)
+        send("#{attr}=", val)
       end
-      debug 'Capturer: initializing new instance ' + self.to_s
+      debug 'Capturer: initializing new instance ' + to_s
     end
   end
 end
+
+require 'lolcommits/capturer/capture_mac'
+require 'lolcommits/capturer/capture_mac_animated'
+require 'lolcommits/capturer/capture_linux'
+require 'lolcommits/capturer/capture_linux_animated'
+require 'lolcommits/capturer/capture_windows'
+require 'lolcommits/capturer/capture_cygwin'
+require 'lolcommits/capturer/capture_fake'

data/lib/lolcommits/cli/fatals.rb

@@ -0,0 +1,77 @@
+# -*- encoding: utf-8 -*-
+require 'lolcommits/platform'
+require 'methadone'
+
+module Lolcommits
+  module CLI
+    # Helper methods for failing on error conditions in the lolcommits CLI.
+    module Fatals
+      include Lolcommits
+      include Methadone::CLILogging
+
+      # Check for platform related conditions that could prevent lolcommits from
+      # working properly.
+      #
+      # Die with an informative error message if any occur.
+      def self.die_on_fatal_platform_conditions!
+        # make sure the capture binaries are in a good state
+        if Platform.platform_mac?
+          %w(imagesnap videosnap).each do |executable|
+            next if File.executable? File.join(Configuration::LOLCOMMITS_ROOT, 'vendor', 'ext', executable, executable)
+            fatal "Couldn't properly execute #{executable} for some reason, "\
+                  'please file a bug?!'
+            exit 1
+          end
+        elsif Platform.platform_linux?
+          unless Platform.command_which('mplayer')
+            fatal "Couldn't find mplayer in your PATH!"
+            exit 1
+          end
+        end
+
+        # make sure we can find the Impact truetype font
+        unless File.readable? File.join(Configuration::LOLCOMMITS_ROOT, 'vendor', 'fonts', 'Impact.ttf')
+          fatal "Couldn't properly read Impact font from gem package, "\
+                'please file a bug?!'
+          exit 1
+        end
+
+        # make sure imagemagick is around and good to go
+        unless Platform.valid_imagemagick_installed?
+          fatal 'FATAL: ImageMagick does not appear to be properly installed!'\
+                '(or version is too old)'
+          exit 1
+        end
+
+        # check for a error condition with git config affecting ruby-git
+        if Platform.git_config_color_always?
+          fatal 'Due to a bug in the ruby-git library, git config for color.ui'\
+                " cannot be set to 'always'."
+          fatal "Try setting it to 'auto' instead!"
+          exit 1
+        end
+      end
+
+      # Die with an informative error message if ffmpeg is not installed.
+      # This is only used for certain functions (such as animation), so only run
+      # this when you know the user wants to perform one of them.
+      def self.die_if_no_valid_ffmpeg_installed!
+        unless Platform.valid_ffmpeg_installed?
+          fatal 'FATAL: ffmpeg does not appear to be properly installed!'
+          exit 1
+        end
+      end
+
+      # If we are not in a git repo, we can't do git related things!
+      # Die with an informative error message in that case.
+      def self.die_if_not_git_repo!
+        debug 'Checking for valid git repo'
+        Git.open('.') # FIXME: should be extracted to GitInfo class
+        rescue ArgumentError
+          # ruby-git throws an argument error if path isnt for a valid git repo.
+          fatal "Erm? Can't do that since we're not in a valid git repository!"
+          exit 1
+      end
+    end
+  end
+end

data/lib/lolcommits/cli/launcher.rb

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+require 'launchy'
+
+module Lolcommits
+  module CLI
+    # Helper class for wrapping the opening of files on the desktop in a
+    # cross-platform way.
+    #
+    # Right now this is mostly just a wrapper for Launchy, in case we want
+    # to factor out it's dependency later or swap it out.
+    class Launcher
+      def self.open_image(path)
+        open_with_launchy(path)
+      end
+
+      def self.open_folder(path)
+        open_with_launchy(path)
+      end
+
+      # Opens with Launchy, which knows how to open pretty much anything
+      # local files, urls, etc.
+      #
+      # Private so we replace it later easier if we want.
+      def self.open_with_launchy(thing)
+        Launchy.open(thing)
+      end
+    end
+  end
+end

data/lib/lolcommits/cli/process_runner.rb

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+
+module Lolcommits
+  module CLI
+    # Helper class for forking lolcommits process to the background (or not).
+    class ProcessRunner
+      # Initializes a new process runner.
+      #
+      # @param config [Lolcommits::Configuration]
+      def initialize(config)
+        @configuration = config
+      end
+
+      # Forks the lolcommits process if requested.
+      #
+      # Writes the PID of the lolcommits process to the filesystem when
+      # backgrounded, for monitoring purposes.
+      #
+      # @param please [Boolean] whether or not to fork lolcommits process
+      # @yield the main event loop for lolcommits
+      def fork_me?(please, &block)
+        if please
+          $stdout.sync = true
+          write_pid fork {
+            yield block
+            delete_pid
+          }
+        else
+          yield block
+        end
+      end
+
+      private
+
+      def write_pid(pid)
+        File.open(pid_file, 'w') { |f| f.write(pid) }
+      end
+
+      def delete_pid
+        File.delete(pid_file) if File.exist?(pid_file)
+      end
+
+      def pid_file
+        File.join(@configuration.loldir, 'lolcommits.pid')
+      end
+    end
+  end
+end