briefcase 0.4.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Jim Benton
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,104 @@
+= briefcase
+
+briefcase is a tool to facilitate keeping dotfiles in git, including those with private information (such as .gitconfig).
+
+
+=== This is alpha software! I haven't published a gem yet for a good reason. Use at your own risk.
+
+
+== Getting started
+
+  gem install briefcase
+  briefcase import ~/.bashrc
+
+At this point, a git repository will have been created at ~/.dotfiles. At some point more of the git workflow will be automated (such as creating a repository at Github), but for now most git tasks are manual:
+
+  cd ~/.dotfiles
+  git commit -m "Added bashrc"
+
+== Filesystem layout
+
+With briefcase, dotfiles are stored in a centralized location (by default ~/.dotfiles), and symlinks are created for these files in the user's home directory. Here is a basic setup for a .gitconfig file:
+
+    +-~/                      Home Directory
+    | +-.briefcase_secrets         Secrets file
+    | +-.gitconfig            Symlink to ~/.dotfiles/gitconfig
+    | +-.dotfiles/            Dotfiles directory
+    | | +-gitconfig           Standard Dotfile
+    | | +-gitconfig.dynamic   Redacted dotfile
+
+=== Home directory (~)
+
+Where the action happens. Dotfiles that normally exist here are replaced by symlinks to files in the dotfiles directory
+
+=== Dotfiles directory (~/)
+
+Where dotfiles are stored. There are two types of dotfiles.
+
+==== Standard dotfiles
+
+A basic config file that would normally live in a user's home directory.
+
+==== Redacted dotfiles
+A config file that contains some secret information. The file is stored, sans secret info, with a '.redacted' extension in the repo. The dotfile that is symlinked to the user's home directory is then generated from this file.
+
+=== Secrets file
+
+This file, be default located at ~/.briefcase_secrets, contains the information removed from dotfiles imported using the redact command.
+
+== Commands
+
+=== import PATH_TO_FILE
+
+Imports a dotfile into thedotfiles directory, moving it to the dotfiles directory and replacing it with a symlink to its new location.
+
+
+=== redact PATH_TO_FILE
+
+Imports a dotfile that contains sensitive information. The user is presented with an editor, where the sensitive information can be removed by replacing secret information with a commented out call to a briefcase function
+
+  # before
+  password: superSecretPassword
+
+  # after
+  password: # briefcase(password)
+
+This file is then saved with a '.redacted' extension, and the original file is added to ~/.dotfiles/.gitignore so it will not be added to the repository.
+
+'superSecretPassword' will be stored using the key "password" in the secrets file.
+
+
+=== sync
+Creates a symlink in the user's home directory for each dotfile in the dotfiles directory.
+
+
+=== generate
+Creates local version of a redacted dotfile, using information found in the secrets file to fill in any that was removed.
+
+
+== Configuration
+
+The following environment variables can by used to customized the paths used by briefcase:
+
+  SHHH_DOTFILES_PATH: dotfiles path, defaults to SHHH_HOME_PATH/.dotfiles
+  SHHH_HOME_PATH: home path, defaults to ~
+  SHHH_SECRETS_PATH: secrets path, defaults to SHHH_HOME_PATH/.briefcase_secrets
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix on a topic branch.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request.
+
+== Changelog
+* 0.3.0 Added code documentation, internal renaming, general cleanup. First public release.
+* 0.2.0 Added redact command, use .redacted for dynamic dotfiles
+* 0.1.3 The sync command no longer creates symlinks for dynamic files
+* 0.1.2 Added dynamic file generation
+
+== Copyright
+
+Copyright (c) 2010 Jim Benton. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new('spec') do |t|
+  t.libs << 'spec'
+  t.pattern = "spec/*_spec.rb"
+end
+
+task :default => :spec

data/bin/briefcase

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'briefcase/main'

data/briefcase.gemspec

@@ -0,0 +1,33 @@
+require File.expand_path('lib/briefcase/version', File.dirname(__FILE__))
+
+Gem::Specification.new do |s|
+  s.name = %q{briefcase}
+  s.version = Briefcase::VERSION
+  s.summary = %q{Briefcase manages dotfiles and handles keeping their secrets safe}
+  s.description = %q{Command line program to migrate dotfiles to a git repo at ~/.dotfiles and generate static dotfiles with secret values.}
+  s.authors = ["Jim Benton"]
+  s.date = %q{2011-12-22}
+  s.default_executable = %q{briefcase}
+  s.email = %q{jim@autonomousmachine.com}
+  s.executables = ["briefcase"]
+  s.extra_rdoc_files = %w{README.rdoc LICENSE}
+  s.files = Dir['lib/**/*.rb'] +                                # library
+            Dir['bin/*'] +                                      # executable
+            Dir['spec/**/*.rb'] +                               # spec files
+            Dir['spec/bin/editor'] +                            # spec editor
+            %w{README.rdoc LICENSE briefcase.gemspec Rakefile}  # misc
+
+  s.homepage = %q{http://github.com/jim/briefcase}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.test_files = Dir['spec/*.rb']
+
+  s.add_runtime_dependency('commander')
+  s.add_runtime_dependency('activesupport')
+  s.add_development_dependency('minitest')
+  s.add_development_dependency('open4')
+  s.add_development_dependency('rake', '0.9.2.2')
+  s.add_development_dependency('turn')
+end
+

data/lib/briefcase.rb

@@ -0,0 +1,42 @@
+require 'yaml'
+
+require 'active_support/core_ext/hash/deep_merge'
+
+require File.expand_path('briefcase/commands', File.dirname(__FILE__))
+require File.expand_path('briefcase/version', File.dirname(__FILE__))
+
+module Briefcase
+
+  # The user's home path
+  DEFAULT_HOME_PATH = '~'
+
+  # The default path wher dotfiles are stored
+  DEFAULT_DOTFILES_PATH = File.join(DEFAULT_HOME_PATH, '.dotfiles')
+
+  # The default path to where secret information is stored
+  DEFAULT_SECRETS_PATH = File.join(DEFAULT_HOME_PATH, '.briefcase_secrets')
+
+  class << self
+    attr_accessor :dotfiles_path, :home_path, :secrets_path, :testing
+
+    def dotfiles_path
+      @dotfiles_path ||= File.expand_path(ENV['BRIEFCASE_DOTFILES_PATH'] || DEFAULT_DOTFILES_PATH)
+    end
+
+    def home_path
+      @home_path ||= File.expand_path(ENV['BRIEFCASE_HOME_PATH'] || DEFAULT_HOME_PATH)
+    end
+
+    def secrets_path
+      @secrets_path ||= File.expand_path(ENV['BRIEFCASE_SECRETS_PATH'] || DEFAULT_SECRETS_PATH)
+    end
+
+    def testing?
+      @testing ||= ENV['BRIEFCASE_TESTING'] == 'true'
+    end
+  end
+
+  class UnrecoverableError < StandardError; end
+  class CommandAborted < StandardError; end
+
+end

data/lib/briefcase/commands.rb

@@ -0,0 +1,6 @@
+require File.expand_path('commands/base', File.dirname(__FILE__))
+require File.expand_path('commands/import', File.dirname(__FILE__))
+require File.expand_path('commands/redact', File.dirname(__FILE__))
+require File.expand_path('commands/sync', File.dirname(__FILE__))
+require File.expand_path('commands/generate', File.dirname(__FILE__))
+require File.expand_path('commands/git', File.dirname(__FILE__))

data/lib/briefcase/commands/base.rb

@@ -0,0 +1,94 @@
+require 'fileutils'
+require File.expand_path('core/secrets', File.dirname(__FILE__))
+require File.expand_path('core/files', File.dirname(__FILE__))
+require File.expand_path('core/output', File.dirname(__FILE__))
+
+module Briefcase
+  module Commands
+
+    # Briefcase::Commands::Base is the base class for all commands in the system.
+    #
+    # Most behavior is actually defined by Core modules.
+    #
+    # Actual commands, which are created by creating a subclass of Base, must
+    # implement an instance method `execute`.
+    #
+    # Running a Commands::Base subclass is done by instantiating it with
+    # arguments and options.
+    class Base
+
+      # The extension to append to files when redacting information
+      REDACTED_EXTENSION = 'redacted'
+
+      include FileUtils
+      include Core::Files
+      include Core::Secrets
+      include Core::Output
+
+      def initialize(args, options)
+        @args = args
+        @options = options
+        run
+      end
+
+      # Begin execution of this command. Subclasses should not override this
+      # method, instead, they should define an `execute` method that performs
+      # their actual work.
+      def run
+        begin
+          execute
+          say('')
+          success "Done."
+        rescue CommandAborted, UnrecoverableError => e
+          error(e.message)
+          exit(255)
+        end
+      end
+
+      # Perform this command's work.
+      #
+      # This method should be overridden in subclasses.
+      def execute
+        raise "Not Implemented"
+      end
+
+      # Add a file to the .gitignore file inside the dotfiles_path
+      #
+      # filename - The String filename to be appended to the list of ignored paths
+      #
+      # Returns the Integer number of bytes written.
+      def add_to_git_ignore(filename)
+        File.open(File.join(dotfiles_path, '.gitignore'), "a+") do |file|
+          contents = file.read
+          unless contents =~ %r{^#{filename}$}
+            info("Adding #{filename} to #{File.join(dotfiles_path, '.gitignore')}")
+            file.write(filename + "\n")
+          end
+        end
+      end
+
+      # Check to see if the dotfiles directory exists. If it doesn't, present
+      # the user with the option to create it. If the user accepts, the
+      # directory is created.
+      #
+      # If the user declines creating the directory, a CommandAborted exception
+      # is raised.
+      def verify_dotfiles_directory_exists
+        if !File.directory?(dotfiles_path)
+          choice = choose("You don't appear to have a git repository at #{dotfiles_path}. Do you want to create one now?", 'create', 'abort') do |menu|
+            menu.index = :letter
+            menu.layout = :one_line
+          end
+          if choice == 'create'
+            info "Creating a directory at #{dotfiles_path}"
+            mkdir_p(dotfiles_path)
+            info `git init #{dotfiles_path}`
+          else
+            raise CommandAborted.new('Can not continue without a dotfiles repository!')
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/briefcase/commands/core/files.rb

@@ -0,0 +1,81 @@
+module Briefcase
+  module Commands
+    module Core
+      module Files
+
+        # Create a symlink at a path with a given target.
+        #
+        # target - the String target for the symlink
+        # destination - The String location for the symlink
+        def symlink(target, destination)
+          ln_s(target, destination)
+          info "Symlinking %s -> %s", destination, target
+        end
+
+        # Move a file from one location to another
+        #
+        # path - The String path to be moved
+        # destination - The String path to move the file to
+        def move(path, destination)
+          mv(path, destination)
+          info "Moving %s to %s", path, destination
+        end
+
+        # Write some content to a file path.
+        #
+        # path - The String path to the file that should be written to
+        # content - The String content to write to the file
+        # io_mode - The String IO mode to use when writing the file
+        def write_file(path, content, io_mode='w')
+          File.open(path, io_mode) do |file|
+            file.write(content)
+          end
+        end
+
+        # Returns the globally configured home path for the user.
+        def home_path
+          Briefcase.home_path
+        end
+
+        # Returns the globally configured dotfiles path.
+        def dotfiles_path
+          Briefcase.dotfiles_path
+        end
+
+        # Returns the globally configured secrets path.
+        def secrets_path
+          Briefcase.secrets_path
+        end
+
+        # Build a full dotfile path from a given file path, using the gobal
+        # dotfiles path setting.
+        #
+        # file_path - The String path to build a dotfile path from
+        def generate_dotfile_path(file_path)
+          File.join(dotfiles_path, visible_name(file_path))
+        end
+
+        # Check to see if there is a stored dotfile in the dotfiles directory
+        # that corresponds to the specified file.
+        #
+        # file_path - The String file name to check
+        #
+        # Returns whether the file exists or not as a Boolean
+        def dotfile_exists?(file_path)
+          File.exist?(generate_dotfile_path(file_path))
+        end
+
+        # Convert a file path into a file name and remove a leading period if
+        # it exists.
+        #
+        # file_path - The String file path to create a visible name for
+        #
+        # Returns the manipulated file name
+        def visible_name(file_path)
+          File.basename(file_path).gsub(/^\./, '')
+        end
+
+      end
+    end
+  end
+end

data/lib/briefcase/commands/core/output.rb

@@ -0,0 +1,24 @@
+module Briefcase
+  module Commands
+    module Core
+      module Output
+
+        # Print some bold green text to the console.
+        def success(*args); say $terminal.color(format(*args), :green, :bold); end
+
+        # Print some yellow text to the console.
+        def info(*args); say $terminal.color(format(*args), :yellow); end
+
+        # Print some red text to the console.
+        def error(*args); say $terminal.color(format(*args), :red); end
+
+        # Print some magenta text to the console.
+        def warn(*args); say $terminal.color(format(*args), :magenta); end
+
+        # Print some bold text to the console.
+        def intro(*args); say $terminal.color(format(*args), :bold); say(''); end
+
+      end
+    end
+  end
+end

data/lib/briefcase/commands/core/secrets.rb

@@ -0,0 +1,50 @@
+module Briefcase
+  module Commands
+    module Core
+      module Secrets
+
+        COMMENT_REPLACEMENT_REGEX = /^([^#]*)#\s*briefcase\(([a-zA-Z_]+)\)\s*$/
+
+        # Add a key and value to the secrets file for the given file.
+        #
+        # path - The String path to the file containing the secret.
+        # key - The String key to store the value as
+        # value - The String value to store
+        def add_secret(path, key, value)
+          path_key = File.basename(path)
+          secrets[path_key] ||= {}
+          secrets[path_key][key] = value
+        end
+
+        # Get a secret value for the given file and key.
+        #
+        # path - The String path to the file that contains the secret
+        # key - The String key to retrieve the value for
+        #
+        # Returns the string value from the secrets file for the given key.
+        def get_secret(path, key)
+          path_key = File.basename(path)
+          secrets[path_key][key] if secrets[path_key] && secrets[path_key][key]
+        end
+
+        # Write the internal secrets hash to the secrets file as YAML.
+        def write_secrets
+          write_file(secrets_path, secrets.to_yaml)
+        end
+
+        # The secrets hash.
+        #
+        # Returns the secrets hash if a a secrets file exists, or an empty hash
+        # if it does not.
+        def secrets
+          @secrets ||= if File.exist?(secrets_path)
+            info "Loading existing secrets from #{secrets_path}"
+            YAML.load_file(secrets_path)
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end