briefcase 0.4.0

data/lib/briefcase/commands/generate.rb

@@ -0,0 +1,65 @@
+module Briefcase
+  module Commands
+
+    # Generate looks through through the dotfiles directory for any redacted
+    # dotfiles. It attempts to generate a normal version of each file it finds,
+    # using the values stored in the .briefcase_secrets file.
+    class Generate < Base
+
+      def execute
+        intro "Generating redacted dotfiles in #{dotfiles_path}"
+
+        Dir.glob(File.join(dotfiles_path, "*.#{REDACTED_EXTENSION}")) do |path|
+          generate_file_for_path(path)
+        end
+
+        write_secrets
+      end
+
+      private
+
+      # Generates a standard dotfile from a redacted dotfile
+      #
+      # This method will attempt to find secret values in the secrets file. If
+      # any aren't found, it will print a message about the offending key and
+      # add that key to the secrets file without a value (to make it easier for
+      # users to fill in the missing value).
+      #
+      # path - the path to the redacted dotfile
+      def generate_file_for_path(path)
+        static_path = path.gsub(/.#{REDACTED_EXTENSION}$/, '')
+        basename = File.basename(static_path)
+        dotfile_path = generate_dotfile_path(basename)
+
+        if !File.exist?(dotfile_path) || overwrite_file?(dotfile_path)
+          info "Generating %s", dotfile_path
+          content = File.read(path)
+          edited_content = content.gsub(COMMENT_REPLACEMENT_REGEX) do |match|
+            key = $2
+            if (replacement = get_secret(static_path, key))
+              info "Restoring secret value for key: #{key}"
+              $1 + replacement
+            else
+              info "Secret missing for key: #{key}"
+              add_secret(static_path, key, '')
+              match
+            end
+          end
+          write_file(dotfile_path, edited_content)
+        else
+          info "Skipping %s as there is already a file at %s", path, dotfile_path
+        end
+      end
+
+      # TODO consolidate this method and Import#overwrite_file?
+      def overwrite_file?(path)
+        decision = choose("#{path} already exists as a dotfile. Do you want to replace it?", 'replace', 'skip') do |menu|
+          menu.index = :letter
+          menu.layout = :one_line
+        end
+        decision == 'replace'
+      end
+
+    end
+  end
+end

data/lib/briefcase/commands/git.rb

@@ -0,0 +1,37 @@
+module Briefcase
+  module Commands
+
+    # Run git commands in the dotfiles directory.
+    #
+    # This command simply passes everything passed to it on to the git
+    # executable on the user's PATH.
+    #
+    # A basic equivalent of this command:
+    #
+    #     briefcase git status
+    #
+    # Would be:
+    #
+    #     cd ~/.dotfiles && git status
+    class Git < Base
+
+      # Execute a git command in the dotfiles directory. Will prompt the user
+      # to create a dotfiles directory if it does not exist, which will also
+      # create an empty git repository.
+      def execute
+        verify_dotfiles_directory_exists
+        command = @args.join(' ')
+        intro("Running git %s in %s", command, dotfiles_path)
+        run_git_command(command)
+      end
+
+      private
+
+      def run_git_command(command)
+        puts `cd #{dotfiles_path} && git #{command}`
+      end
+
+    end
+  end
+end
+

data/lib/briefcase/commands/import.rb

@@ -0,0 +1,81 @@
+require 'tempfile'
+
+module Briefcase
+  module Commands
+
+    # Import copies a dotfile into the dotfiles directory and created a
+    # symlink in the file's previous location, pointing to its new location.
+    #
+    # The file's name in the repository will be the dotfile's name with the
+    # leading period removed. So, importing '~/.bashrc' will move that file to
+    # ~/.dotfiles/bashrc and then create a symlink at ~/.bashrc pointing to
+    # ~/.dotfiles/bashrc.
+    #
+    # If there was already a file located at ~/.dotfiles/bashrc, the user will
+    # be asked if it is OK to mvoe the existing file aside. If the user accepts
+    # the move, the existing file is renamed to bashrc.old.1 before the new
+    # file is imported, and a message would be shown indicating this has
+    # occurred.
+    class Import < Base
+
+      # Execute verifies that the dotfiles directory exists before attempting
+      # the import.
+      #
+      # Raises an error if the specified path does not exist.
+      def execute
+        verify_dotfiles_directory_exists
+
+        @path = File.expand_path(@args.first)
+        raise UnrecoverableError.new("#{@path} does not exist") unless File.exist?(@path)
+
+        intro("Importing %s into %s", @path, dotfiles_path)
+        import_file
+      end
+
+      private
+
+      # Import a file. Creates the dotfiles directory if it doesn't exist
+      # before attempting the import. Prompts the user when there is a naming
+      # collision between an existing dotfile and the file to be imported.
+      #
+      # Raises CommandAborted if there is a colision and the user declines to
+      # move the existing file.
+      def import_file
+        collision = dotfile_exists?(@path)
+        if !collision || overwrite_file?
+
+          mkdir_p(dotfiles_path)
+          destination = generate_dotfile_path(@path)
+
+          if collision
+            existing = Dir.glob("#{destination}.old.*").size
+            sideline = "#{destination}.old.#{existing+1}"
+            info "Moving %s to %s", destination, sideline
+            mv(destination, sideline)
+          end
+
+          move(@path, destination)
+          symlink(destination, @path)
+        else
+          raise CommandAborted.new('Cancelled.')
+        end
+      end
+
+      # Ask the user if it is OK to move an existing file so a new file can be
+      # imported.
+      #
+      # Returns whether the user accepts the move or not as a Boolean.
+      #
+      # TODO: Rename this method as it doesn't overwrite anything.
+      def overwrite_file?
+        decision = choose("#{@path} already exists as a dotfile. Do you want to replace it? Your original file will be renamed.", 'replace', 'abort') do |menu|
+          menu.index = :letter
+          menu.layout = :one_line
+        end
+
+        decision == 'replace'
+      end
+
+    end
+  end
+end

data/lib/briefcase/commands/redact.rb

@@ -0,0 +1,76 @@
+module Briefcase
+  module Commands
+
+    # Redact is similar to Import, but it will also prompt the user to replace
+    # any secure information in the file with a special replacement syntax. Any
+    # values replaces in this way will be stored in the secrets file, and the
+    # dotfile will be imported sans secrets.
+    class Redact < Import
+
+      EDITING_HELP_TEXT = <<-TEXT
+# Edit the file below, replacing and sensitive information to turn this:
+#
+#   password: superSecretPassword
+#
+# Into:
+#
+#   password: # briefcase(password)
+#
+########################################################################
+TEXT
+
+      private
+
+      def import_file
+        super
+        create_redacted_version
+      end
+
+      # Copy the file to be imported into the dotfiles directory and append the
+      # redacted extension to its name. This file is then opened in an
+      # editor, where the user has a chance to replace sensitive information.
+      # After saving and closing the file, the differences are examined and the
+      # replaces values are detected. These values and their replacement keys
+      # are stored in the secrets file.
+      def create_redacted_version
+        destination = generate_dotfile_path(@path)
+        redacted_path = destination + ".#{REDACTED_EXTENSION}"
+        info "Creating redacted version at #{redacted_path}"
+
+        content_to_edit = original_content = File.read(destination)
+
+        unless Briefcase.testing?
+          content_to_edit = EDITING_HELP_TEXT + content_to_edit
+        end
+
+        write_file(redacted_path, content_to_edit)
+        edited_content = edit_file_with_editor(redacted_path).gsub!(EDITING_HELP_TEXT, '')
+        write_file(redacted_path, edited_content)
+
+        edited_content.lines.each_with_index do |line, line_index|
+          if line =~ COMMENT_REPLACEMENT_REGEX
+            key = $2
+            mask = %r{^#{$1}(.*)$}
+            value = original_content.lines.to_a[line_index].match(mask)[1]
+            info "Storing secret value for key: #{key}"
+            add_secret(destination, key, value)
+          end
+        end
+
+        write_secrets
+        add_to_git_ignore(visible_name(destination))
+      end
+
+      # Open a file with an editor. The editor can be specified using the
+      # EDITOR environment variable, with vim being the current default.
+      #
+      # Returns the content of the file after the editor is closed.
+      def edit_file_with_editor(path)
+        editor_command = ENV['BRIEFCASE_EDITOR'] || 'vim'
+        system(editor_command, path)
+        File.read(path)
+      end
+
+    end
+  end
+end

data/lib/briefcase/commands/sync.rb

@@ -0,0 +1,66 @@
+module Briefcase
+  module Commands
+
+    # Sync scans the dotfiles directory for dotfiles, and creates any missing
+    # symlinks in the user's home directory.
+    #
+    # A message is printed out for each file, indicating if a matching symlink
+    # was found in the home directory or if one was created.
+    #
+    # If there is a symlink in the user's home directory with a dotfile's name
+    # but it is pointing to the wrong location, it is removed and a new symlink
+    # is created in its place.
+    class Sync < Base
+
+      # Scan the dotfiles directory for files, and process each one. Files
+      # with names containing '.old' are ignored and a warning is show to alert
+      # the user of their presence.
+      def execute
+        intro "Synchronizing dotfiles between #{dotfiles_path} and #{home_path}"
+
+        Dir.glob(File.join(dotfiles_path, '*')) do |path|
+          basename = File.basename(path)
+          next if %w{. ..}.include?(basename)
+          next if basename =~ /.#{REDACTED_EXTENSION}$/
+
+          if basename.include?('.old')
+            warn "Skipping %s, you may want to remove it.", path
+          else
+            create_or_verify_symlink(basename)
+          end
+        end
+      end
+
+      private
+
+      # Verifies if a symlink following briefcase's conventions exists for the
+      # supplied filename. Creates a symlink if it doesn't exist, or if there
+      # is a corectly named symlink with the wrong target.
+      #
+      # basename - The String filename to use when building paths
+      def create_or_verify_symlink(basename)
+        dotfile_name = ".#{basename}"
+        symlink_path = File.join(home_path, dotfile_name)
+        dotfile_path = generate_dotfile_path(basename)
+
+        if File.exist?(symlink_path)
+          if File.symlink?(symlink_path)
+            if File.readlink(symlink_path) == dotfile_path
+              info "Symlink verified: %s -> %s", symlink_path, dotfile_path
+              return
+            else
+              info "Removing outdated symlink %s", symlink_path
+              rm(symlink_path)
+            end
+          else
+            info "Found normal file at %s, skipping...", symlink_path
+            return
+          end
+        end
+
+        symlink(dotfile_path, symlink_path)
+      end
+
+    end
+  end
+end

data/lib/briefcase/main.rb

@@ -0,0 +1,44 @@
+require 'commander/import'
+require File.expand_path('../briefcase', File.dirname(__FILE__))
+
+program :name, 'Briefcase'
+program :version, Briefcase::VERSION
+program :description, 'Makes it easier to keep dotfiles in git'
+
+command :import do |c|
+  c.syntax = 'briefcase import PATH'
+  c.description = 'Move PATH to the version controlled directory and symlink its previous location to its new one.'
+  c.when_called Briefcase::Commands::Import
+end
+
+command :redact do |c|
+  c.syntax = 'briefcase redact PATH'
+  c.description = 'Edit PATH to remove sensitive information, save the edited version to the version controlled directory, and symlink its previous location to its new one, and add to .gitignore.'
+  c.when_called Briefcase::Commands::Redact
+end
+
+command :sync do |c|
+  c.syntax = 'briefcase sync'
+  c.description = 'Updates all symlinks for files included in ~/.dotfiles'
+  c.when_called Briefcase::Commands::Sync
+end
+
+command :generate do |c|
+  c.syntax = 'briefcase generate'
+  c.description = 'Generates static versions of all redacted dotfiles in ~/.dotfiles'
+  c.when_called Briefcase::Commands::Generate
+end
+
+command :git do |c|
+  c.syntax = 'briefcase git [options]'
+  c.description = 'Run a git command in the dotfiles directory'
+  c.when_called Briefcase::Commands::Git
+end
+
+default_command :help
+
+# command :suggest do |c|
+#   c.syntax = 'briefcase suggest'
+#   c.description 'List dotfiles that are in your home directory and not in ~/.dotfiles'
+#   c.when_called Briefcase::Commands::Suggest
+# end

data/lib/briefcase/version.rb

@@ -0,0 +1,3 @@
+module Briefcase
+  VERSION = '0.4.0'
+end

data/spec/bin/editor

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+responses_path = File.expand_path('/tmp/briefcase_spec_work/briefcase_editor_responses', File.dirname(__FILE__))
+response_file = ARGV[0].gsub(/\//, '_')
+File.open(ARGV[0], 'w') do |file|
+  file.write(File.read(File.join(responses_path, response_file)))
+end

data/spec/generate_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Briefcase::Commands::Generate do
+
+  describe "with an existing dotfiles directory" do
+
+    before do
+      create_dotfiles_directory
+      create_home_directory
+    end
+
+    after do
+      cleanup_dotfiles_directory
+      cleanup_home_directory
+    end
+
+    it "generates a static version of a redacted dotfile" do
+      static_path = File.join(dotfiles_path, 'test')
+      redacted_path = File.join(dotfiles_path, 'test.redacted')
+
+      create_secrets('test' => {'email' => 'google@internet.com'})
+      create_file redacted_path, <<-TEXT
+username: # briefcase(email)
+favorite_color: blue
+TEXT
+
+      run_command("generate")
+
+      output_must_contain(/Generating/, /Loading existing secrets/, /Restoring secret value/)
+
+      file_must_contain static_path, <<-TEXT
+username: google@internet.com
+favorite_color: blue
+TEXT
+    end
+
+    it "create a secrets file and adds discovered secrets to it" do
+      static_path = File.join(dotfiles_path, 'test')
+      redacted_path = File.join(dotfiles_path, 'test.redacted')
+
+      create_file redacted_path, <<-TEXT
+username: # briefcase(email)
+TEXT
+
+      run_command("generate")
+
+      output_must_contain(/Generating/, /Secret missing for key: email/)
+
+      file_must_contain static_path, <<-TEXT
+username: # briefcase(email)
+TEXT
+
+      secret_must_be_stored('test', 'email', '')
+    end
+
+    it "adds discovered secrets to the secrets file without values" do
+      static_path = File.join(dotfiles_path, 'test')
+      redacted_path = File.join(dotfiles_path, 'test.redacted')
+
+      create_file redacted_path, <<-TEXT
+username: # briefcase(email)
+TEXT
+      create_secrets
+
+      run_command("generate")
+
+      output_must_contain(/Generating/, /Secret missing for key: email/)
+
+      file_must_contain static_path, <<-TEXT
+username: # briefcase(email)
+TEXT
+
+      secret_must_be_stored('test', 'email', '')
+    end
+
+  end
+
+end