dotify 0.0.3 → 0.1

data/.gitignore

@@ -8,6 +8,7 @@ InstalledFiles
 _yardoc
 coverage
 doc/
+test.sh
 lib/bundler/man
 pkg
 rdoc

data/.rspec

@@ -1,2 +1,4 @@
 --color
 --format progress
+--profile 
+--order rand

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
+script: bundle exec rspec spec
 rvm:
   - 1.8.7
   - 1.9.2

data/README.md

@@ -1,6 +1,8 @@
 # Dotify
 
-Dotify is a simple CLI tool to make managing dotfiles on your system easy and configurable.
+[![Build Status](https://secure.travis-ci.org/mattdbridges/dotify.png)](http://travis-ci.org/mattdbridges/dotify) [![Dependency Status](https://gemnasium.com/mattdbridges/dotify.png)](https://gemnasium.com/mattdbridges/dotify)
+
+Dotify is a simple CLI tool to make managing dotfiles on your system easy. When developing on a Linux/Unix basic system, keeping track of all of those dotfiles in the home directory can be pain. Some developers do not even bother managing them and many have come up with their own static or even dynamic way of managing them. This is a need in the community to make managing these crazy files a breeze.
 
 ## Installation
 
@@ -18,10 +20,28 @@ Or install it yourself as:
 
 ## Usage
 
-*Will come in the future*
+As dotify is a CLI tool, everything is done in the command line. Here are the current available methods for managing dotfiles.
+
+### `dotify setup`
+
+`dotify setup` will first create a `~/.dotify` directory in your home directory (yes, one more, but this is a good thing). It will then ask which files you want to copy from your home directory into your `.dotify` directory. 
+
+**Note:** This will *not* link up the dotfiles. This command simply copies the files over for you without having to go searching for them manually.
+
+### `dotify link`
+
+This is the heart of the Dotify tool. This command will link all of the files within the `.dotify` directory into your home directory.
+
+### `dotify unlink`
+
+Don't want and of the dotfiles anymore? Sure. You can wipe them out.
+
+Since this is a non-destructive task, you can simply run `dotify link` again if you want to restore your previous settings.
 
 ## Contributing
 
+This tool is developed with much influence from *37singals*' fantastic idea of **Do Less**. This is meant to be a *simple* tool. I am more than happy to add small features, but I do not want this turning into an RVM.
+
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Added some feature'`)

data/Rakefile

@@ -1,9 +1,2 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
-require "rspec/core/rake_task" 
-
-RSpec::Core::RakeTask.new(:rspec) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-end
-
-task :default => :rspec

data/dotify.gemspec

@@ -4,8 +4,8 @@ require File.expand_path('../lib/dotify/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Matt Bridges"]
   gem.email         = ["mbridges.91@gmail.com"]
-  gem.description   = %q{A CLI Tool for managing your dotfiles and profiles.}
-  gem.summary       = %q{A CLI Tool for managing your dotfiles and profiles.}
+  gem.description   = %q{A CLI Tool for managing your dotfiles}
+  gem.summary       = %q{A CLI Tool for managing your dotfiles}
   gem.homepage      = "https://github.com/mattdbridges/dotify"
 
   gem.files         = `git ls-files`.split($\)

data/lib/dotify.rb

@@ -1,6 +1,4 @@
 module Dotify
 end
-
-require "thor"
+require 'bundler/setup'
 require "fileutils"
-require "dotify/version"

data/lib/dotify/cli.rb

@@ -1,10 +1,11 @@
 require 'thor'
-require 'thor/util'
 require 'dotify'
-require 'dotify/version'
-require 'erb'
+require 'dotify/config'
+require 'dotify/files'
 require 'fileutils'
 
+Dotify::Config.load_config!
+
 module Dotify
   class CLI < Thor
     include Thor::Actions
@@ -15,121 +16,69 @@ module Dotify
     map "-b" => "backup"
     map "-r" => "restore"
 
-    DOTIFY_DIR_NAME = ENV['DOTIFY_DIR_NAME'] || '.dotify'
-    DOTIFY_PATH = ENV['DOTIFY_PATH'] || "#{Thor::Util.user_home}/#{DOTIFY_DIR_NAME}"
-    DOTIFY_BACKUP_PATH = ENV['DOTIFY_BACKUP_PATH'] || "#{DOTIFY_PATH}/.backup"
-
     def self.source_root
-      DOTIFY_PATH
+      Config.home
     end
 
-    desc :setup, "Get your system setup for dotfile management"
+    desc :setup, "Setup your system for Dotify to manage your dotfiles"
     def setup
-      ::FileUtils.mkdir_p DOTIFY_PATH
+      empty_directory(Config.path) unless File.directory?(Config.path)
+      Dir[File.join(Config.home, ".*")].each do |file|
+        filename = Files.file_name(file)
+        dotify_file = File.join(Config.path, filename)
+        unless ['.', '..', Config.dirname].include? filename
+          if yes?("Do you want to add #{filename} to Dotify? [Yn]", :yellow)
+            if File.directory?(Files.dotfile(file))
+              FileUtils.rm_rf dotify_file
+              FileUtils.cp_r Files.dotfile(file), dotify_file
+              say_status :create, dotify_file
+            else
+              copy_file Files.dotfile(file), dotify_file
+            end
+          end
+        end
+      end
+      say "Dotify has been successfully setup.", :blue
     end
 
-    desc :link, "Link up your dotfiles"
-    method_option :force, :default => false, :type => :boolean, :aliases => '-f', :desc => "Definitely link all dotfiles"
+    desc :link, "Link up all of your dotfiles"
+    method_option :all, :default => false, :type => :boolean, :aliases => '-a', :desc => "Link dotfiles without confirmation"
     def link
-      dotfile_list do |file|
-        if template? file
-          template file, dotfile_location(no_extension(filename(file)))
-        else
-          if options.force?
-            replace_link dotfile_location(file), file
+      count = 0
+      Files.dots do |file, dot|
+        if options[:all]
+          if File.exists? Files.dotfile(file)
+            replace_link Files.dotfile(file), file
           else
-            create_link dotfile_location(file), file
+            create_link Files.dotfile(file), file
+          end
+          count += 1
+        else
+          if yes?("Do you want to link ~/#{dot}? [Yn]", :green)
+            create_link Files.dotfile(file), file
+            count += 1
           end
         end
       end
+      say "No files were linked.", :yellow if count == 0
     end
 
-    desc :unlink, "Unlink individual dotfiles"
-    method_option :force, :default => false, :type => :boolean, :aliases => '-f', :desc => "Definitely remove all dotfiles"
+    desc :unlink, "Unlink all of your dotfiles"
+    method_option :all, :default => false, :type => :boolean, :aliases => '-a', :desc => 'Remove all installed dotfiles without confirmation'
     def unlink
-      dotfile_list do |file|
-        destination = filename(file)
-        if options.force? || yes?("Are you sure you want to remove ~/#{destination}? [Yn]", :blue)
-          remove_file dotfile_location(file), :verbose => true
-        end
-      end
-    end
-
-    desc :backup, "Backup your dotfiles for quick recovery if something goes wrong"
-    def backup
-      dotfile_list do |file|
-        file = filename(file)
-        backup = "#{DOTIFY_BACKUP_PATH}/#{file}"
-        if File.exists?(dotfile_location(file))
-          remove_file backup, :verbose => false if File.exists?(backup)
-          copy_file dotfile_location(file), backup, :verbose => false
-          say "Backing up ~/#{file}", :blue
-        end
-      end
-    end
-
-    desc :restore, "Restore your backed-up dotfiles"
-    method_option :force, :default => false, :type => :boolean, :aliases => '-f', :desc => "Backup existing dotfiles"
-    def restore
-      backup_list do |file|
-        filename = filename(file)
-        if options.force? || yes?("Are you sure you want to restore ~/#{filename}? [Yn]", :red)
-          if File.exists?(dotfile_location(filename))
-            remove_file dotfile_location(filename), :verbose => false
-          end
-          copy_file file, dotfile_location(filename), :verbose => false
-          say "Restoring up ~/#{filename}", :blue
+      Files.installed do |file, dot|
+        if options[:all] || yes?("Are you sure you want to remove ~/#{dot}? [Yn]", :blue)
+          remove_file Files.dotfile(file)
         end
       end
     end
 
     no_tasks do
 
-      def dotfile_location(file)
-        "#{home}/#{filename(file)}"
-      end
-
-      def no_extension(file)
-        file = file.split('.')
-        file.pop
-        file.join('.')
-      end
-
-      def home
-        Thor::Util.user_home
-      end
-
       def replace_link(dotfile, file)
-        remove_file dotfile
-        create_link dotfile, file
-      end
-
-      def dotfile_list
-        files = Dir["#{DOTIFY_PATH}/.*"]
-        files.delete_if { |f| File.directory? f }
-        if block_given?
-          files.each { |f| yield f }
-        else
-          files
-        end
-      end
-
-      def backup_list
-        files = Dir["#{DOTIFY_BACKUP_PATH}/.*"]
-        files.delete_if { |f| File.directory? f }
-        if block_given?
-          files.each { |f| yield f }
-        else
-          files
-        end
-      end
-
-      def filename(file)
-        file.split("/").last
-      end
-
-      def template?(file)
-        filename(file).match(/(tt|erb)$/)
+        remove_file dotfile, :verbose => false
+        create_link dotfile, file, :verbose => false
+        say_status :replace, dotfile
       end
 
     end

data/lib/dotify/config.rb

@@ -0,0 +1,90 @@
+require 'dotify'
+require 'thor/util'
+require 'yaml'
+
+module Dotify
+  class Config
+
+    DOTIFY_DIRNAME = '.dotify'
+    DOTIFY_BACKUP = '.backup'
+    #SHELLS = {
+    #  'zsh' => '/bin/zsh',
+    #  'bash' => '/bin/bash',
+    #  'sh' => '/bin/sh'
+    #}
+
+    class << self
+
+      #def shell=(shell)
+      #  if !SHELLS.keys.include?(shell)
+      #    raise NonValidShell, "You must specify a valid shell: #{SHELLS.keys.map(&:inspect).join(", ")}"
+      #  end
+      #  @shell = shell
+      #end
+
+      #def shell
+      #  @shell
+      #end
+
+      #def profile=(name)
+      #  @profile = name
+      #end
+
+      #def profile
+      #  @profile
+      #end
+
+      def dirname
+        @dirname ||= DOTIFY_DIRNAME
+      end
+
+      def path
+        File.join(home, dirname)
+      end
+
+      def backup
+        File.join(path, backup_dirname)
+      end
+
+      def backup_dirname
+        @backup ||= DOTIFY_BACKUP
+      end
+
+      def load_config!
+        #@config = File.exists?(config_file) ? (YAML.load_file(config_file) || {}) : {}
+        #symbolize_keys!(@config)
+        #@config.each do |key, value|
+        #  if !value.nil? && methods(false).map(&:to_s).include?("#{key}=")
+        #    self.__send__("#{key}=", value)
+        #  else
+        #    @config.delete(key)
+        #  end
+        #end
+        #@config
+      end
+
+      def config
+        @config || load_config!
+      end
+
+      def home
+        Thor::Util.user_home
+      end
+
+      private
+
+        def config_file
+          #File.join(home, '.dotrc')
+        end
+
+        def symbolize_keys!(opts)
+          sym_opts = {}
+          opts.each do |key, value|
+            sym_opts[key.to_sym] = value.is_a?(Hash) ? symbolize_keys!(value) : value
+          end
+          sym_opts
+        end
+
+    end
+  end
+end

data/lib/dotify/errors.rb

@@ -0,0 +1,3 @@
+module Dotify
+  class NonValidShell < StandardError; end
+end

data/lib/dotify/files.rb

@@ -0,0 +1,64 @@
+require 'dotify'
+require 'thor/actions'
+require 'thor/shell'
+
+Dotify::Config.load_config!
+
+module Dotify
+  class Files
+    class << self
+      include Thor::Shell
+      include Thor::Actions
+
+      def dots
+        @dots ||= file_list(File.join(dotify_path, "/.*"))
+        return @dots unless block_given?
+        @dots.each {|d| yield(d, file_name(d)) }
+      end
+
+      def installed
+        dots = self.dots.map { |f| file_name(f) }
+        installed = file_list(File.join(Config.home, ".*")).select do |i|
+          dots.include?(file_name(i))
+        end
+        return installed unless block_given?
+        installed.each {|i| yield(i, file_name(i)) }
+      end
+
+      def file_name(file)
+        file.split("/").last
+      end
+
+      def template?(file)
+        file_name(file).match(/(tt|erb)$/) ? true : false
+      end
+
+      def dotfile(file)
+        File.join(Config.home, file_name(file))
+      end
+
+      def link_dotfile(file)
+        FileUtils.ln_s(file_name(file), Config.home) == 0 ? true : false
+      end
+
+      def unlink_dotfile(file)
+        FileUtils.rm_rf File.join(Config.home, file_name(file))
+      end
+
+      private
+
+        def file_list(dir_glob)
+          filter_dot_directories!(Dir[dir_glob])
+        end
+
+        def filter_dot_directories!(files)
+          files.select { |f| !['.', '..'].include?(file_name(f)) }
+        end
+
+        def dotify_path
+          Config.path
+        end
+
+    end
+  end
+end

data/lib/dotify/version.rb

@@ -1,3 +1,3 @@
 module Dotify
-  VERSION = "0.0.3"
+  VERSION = "0.1"
 end

data/spec/dotify/cli_spec.rb

@@ -1,54 +1,8 @@
 require 'spec_helper'
+require 'dotify/config'
 require 'dotify/cli'
+require 'thor'
 
 describe Dotify::CLI do
-
-  let(:cli) { Dotify::CLI }
-  let(:dotify_path) { cli::DOTIFY_PATH }
-
-  before do
-    FileUtils.mkdir_p dotify_path
-  end
-
-  after do
-    FileUtils.rm_rf dotify_path
-  end
-
-  describe Dotify::CLI, "#setup" do
-    it "it should create the right directory" do
-      FileUtils.should_receive(:mkdir_p).with(dotify_path)
-      cli.new.setup
-    end
-  end
-
-  describe Dotify::CLI, "#dotfile_list" do
-    let(:c) { cli.new }
-    it "should pull the correct set of files" do
-      list = c.dotfile_list
-      list.count.should == 0
-    end
-  end
-
-  describe Dotify::CLI, "#filename" do
-    it "should return only the filename given a path" do
-      c = cli.new
-      c.filename("/Users/johndoe/filename").should == "filename"
-      c.filename("/Users/johndoe/..").should == ".."
-      c.filename("/Users/johndoe/.vimrc").should == ".vimrc"
-    end
-  end
-
-  describe Dotify::CLI, "#template?" do
-    it "should return true if the file ends in tt or erb" do
-      c = cli.new
-      c.template?("title.tt").should be_true
-      c.template?("title.erb").should be_true
-      c.template?("title.rb").should_not be_true
-      c.template?("title.rb").should_not be_true
-      c.template?("#{dotify_path}/title.rb").should_not be_true
-      c.template?("#{dotify_path}/tt.rb").should_not be_true
-      c.template?("#{dotify_path}/.vimrc.erb").should be_true
-    end
-  end
-
+  # add unit tests at a future date
 end

data/spec/dotify/config_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'dotify/errors'
+require 'dotify/config'
+
+describe Dotify::Config do
+  let(:fixtures) { File.join(%x{pwd}.chomp, 'spec/fixtures') }
+  before do
+    Fake.tearup
+    Dotify::Config.stub(:user_home) { Fake.root_path }
+    #Dotify::Config.stub(:config_file) { File.join(fixtures, '.dotrc-default') }
+    #Dotify::Config.load_config!
+  end
+  after do
+    Fake.teardown
+  end
+  describe "setters" do
+    #it "should be able to set the current shell (not actually yet used)" do
+    #  Dotify::Config.shell = 'zsh'
+    #  Dotify::Config.shell.should == 'zsh'
+    #  Dotify::Config.shell = 'bash'
+    #  Dotify::Config.shell.should == 'bash'
+    #end
+    #it "should raise an error if the shell specified does not exist" do
+    #  expect { Dotify::Config.shell = 'fake' }.to raise_error Dotify::NonValidShell
+    #end
+    #it "should be able to set the current profile name (not actually yet used)" do
+    #  Dotify::Config.profile = 'james'
+    #  Dotify::Config.profile.should == 'james'
+    #end
+    #it "should be able to show the dotify path" do
+    #  Dotify::Config.path.should == File.join(Dotify::Config.home, '.dotify')
+    #end
+    it "should be able to show the dotify path" do
+      Dotify::Config.path.should == File.join(Dotify::Config.home, '.dotify')
+    end
+    it "should be able to show the dotify backup path" do
+      Dotify::Config.backup.should == File.join(Dotify::Config.path, '.backup')
+    end
+  end
+  describe "config files" do
+    #before do
+    #  Dotify::Config.stub(:home) { Fake.root_path }
+    #  Dotify::Config.stub(:config_file) { File.join(fixtures, '.dotrc-mattbridges') }
+    #end
+    #it "should not try to assign improper config values" do
+    #  Dotify::Config.should_receive(:profile=)
+    #  Dotify::Config.should_receive(:shell=)
+    #  Dotify::Config.should_not_receive(:something_fake=)
+    #  Dotify::Config.load_config!
+    #end
+    #it "should load the config and set the variables" do
+    #  Dotify::Config.load_config!
+    #  Dotify::Config.profile.should == 'mattdbridges'
+    #  Dotify::Config.shell.should == 'zsh'
+    #end
+  end
+end

data/spec/dotify/files_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'dotify/files'
+require 'fileutils'
+
+describe Dotify::Files do
+  let(:fixtures) { File.join(%x{pwd}.chomp, 'spec/fixtures') }
+  before do
+    Fake.tearup
+    #Dotify::Config.stub(:config_file) { File.join(fixtures, '.dotrc-default') }
+    Dotify::Config.stub(:home) { Fake.root_path }
+    Dotify::Config.load_config!
+  end
+  after do
+    Fake.teardown
+  end
+  it "should respond to the right methods" do
+    Dotify::Files.should respond_to :dots
+    Dotify::Files.should respond_to :installed
+  end
+
+  it "should split a file_name correct" do
+    Dotify::Files.file_name("some/random/path/to/file.txt").should == 'file.txt'
+    Dotify::Files.file_name("another/path/no_extension").should == 'no_extension'
+  end
+
+  describe Dotify::Files, "#dotfile" do
+    it "should return the path to the file when it is linked in the root" do
+      Dotify::Files.dotfile(".vimrc").should == File.join(Dotify::Config.home, ".vimrc")
+      Dotify::Files.dotfile("/spec/home/.bashrc").should == File.join(Dotify::Config.home, ".bashrc")
+    end
+  end
+
+  describe Dotify::Files, "#dots" do
+    before do
+      Dotify::Files.stub(:file_list) do
+        ['/spec/test/.vimrc', '/spec/test/.bashrc', '/spec/test/.zshrc']
+      end
+    end
+    it "should return the list of dotfiles in the dotify path" do
+      files = Dotify::Files.dots.map { |f| Dotify::Files.file_name(f) }
+      files.should include '.vimrc'
+      files.should include '.bashrc'
+      files.should include '.zshrc'
+      files.should_not include '.' # current and upper directories
+      files.should_not include '..'
+    end
+    it "shoud yield the files if a block is given" do
+      files = Dotify::Files.dots.map { |d| [d, Dotify::Files.file_name(d)] }
+      expect { |b| Dotify::Files.dots(&b) }.to yield_successive_args(*files)
+    end
+  end
+
+  describe Dotify::Files, "#installed" do
+    before do
+      fake_root, dotify = Fake.paths
+      FileUtils.touch File.join(fake_root, '.vimrc')
+      FileUtils.touch File.join(fake_root, '.bashrc')
+    end
+    it "should return the list of installed dotfiles in the root path" do
+      installed = Dotify::Files.installed.map { |i| Dotify::Files.file_name(i) }
+      installed.should include '.vimrc'
+      installed.should include '.bashrc'
+      installed.should_not include '.zshrc'
+      installed.should_not include '.dotify'
+    end
+    it "shoud yield the installed files if a block is given" do
+      installed = Dotify::Files.installed.map { |i| [i, Dotify::Files.file_name(i)] }
+      expect { |b| Dotify::Files.installed(&b) }.to yield_successive_args(*installed)
+    end
+  end
+
+  describe Dotify::Files, "#template?" do
+    it "should return true if the string given is a .tt or .erb template" do
+      Dotify::Files.template?("testing.erb").should == true
+      Dotify::Files.template?("testing.tt").should == true
+      Dotify::Files.template?("/Users/fake/path/to/testing.tt").should == true
+      Dotify::Files.template?("/Users/another/fake/path/to/testing.erb").should == true
+    end
+    it "should return false if the string given is not a .tt or .erb template" do
+      Dotify::Files.template?(".tt.testing").should == false
+      Dotify::Files.template?("erbit.txt").should == false
+      Dotify::Files.template?(".erb.erbit.txt").should == false
+      Dotify::Files.template?("/Users/fake/path/to/testing.txt").should == false
+      Dotify::Files.template?("/Users/another/fake/path/to/testing.rb").should == false
+    end
+  end
+
+  describe Dotify::Files, "#link_dotfile" do
+    it "should receive a file and link it into the root path" do
+      first = File.join(Dotify::Files.send(:dotify_path), ".vimrc")
+      FileUtils.should_receive(:ln_s).with(Dotify::Files.file_name(first), Dotify::Config.home).once
+      Dotify::Files.link_dotfile first
+    end
+  end
+
+  describe Dotify::Files, "#unlink_dotfile" do
+    it "should receive a file and remove it from the root" do
+      first = "/spec/test/.file"
+      FileUtils.stub(:rm_rf).with(File.join(Dotify::Config.home, Dotify::Files.file_name(first))).once
+      Dotify::Files.unlink_dotfile first
+      FileUtils.unstub(:rm_rf)
+    end
+  end
+end

data/spec/fixtures/.dotrc-default

@@ -0,0 +1,2 @@
+profile: 'mattdbridges'
+shell: 'zsh'

data/spec/fixtures/.dotrc-mattbridges

@@ -0,0 +1,3 @@
+profile: 'mattdbridges'
+shell: 'zsh'
+does_nothing: 'another'

data/spec/spec_helper.rb

@@ -5,6 +5,9 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 $:.unshift File.expand_path("../../lib", __FILE__)
+require 'fileutils'
+Dir["./spec/support/**/*.rb"].each { |f| require f }
+
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true

data/spec/support/fake.rb

@@ -0,0 +1,39 @@
+require 'fileutils'
+
+class Fake
+
+  def self.paths
+    path = File.dirname(File.dirname(__FILE__))
+    fake_root = File.join(path, 'fake-root')
+    dotify = File.join(fake_root, '.dotify')
+    [fake_root, dotify]
+  end
+
+  def self.tearup
+    fake_root, dotify = paths
+    FileUtils.mkdir_p fake_root
+    reset
+  end
+
+  def self.teardown
+    fake_root, dotify = paths
+    FileUtils.rm_rf fake_root
+  end
+
+  def self.reset
+    fake_root, dotify = paths
+    FileUtils.mkdir_p dotify
+    FileUtils.touch File.join(dotify, '.vimrc')
+    FileUtils.touch File.join(dotify, '.bashrc')
+    FileUtils.touch File.join(dotify, '.zshrc')
+  end
+
+  def self.root_path
+    fake_root, dotify = paths
+    fake_root
+  end
+  def self.dotify_path
+    fake_root, dotify = paths
+    dotify
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dotify
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: '0.1'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-19 00:00:00.000000000 Z
+date: 2012-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -59,7 +59,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: A CLI Tool for managing your dotfiles and profiles.
+description: A CLI Tool for managing your dotfiles
 email:
 - mbridges.91@gmail.com
 executables:
@@ -78,9 +78,17 @@ files:
 - dotify.gemspec
 - lib/dotify.rb
 - lib/dotify/cli.rb
+- lib/dotify/config.rb
+- lib/dotify/errors.rb
+- lib/dotify/files.rb
 - lib/dotify/version.rb
 - spec/dotify/cli_spec.rb
+- spec/dotify/config_spec.rb
+- spec/dotify/files_spec.rb
+- spec/fixtures/.dotrc-default
+- spec/fixtures/.dotrc-mattbridges
 - spec/spec_helper.rb
+- spec/support/fake.rb
 homepage: https://github.com/mattdbridges/dotify
 licenses: []
 post_install_message: 
@@ -104,7 +112,12 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: A CLI Tool for managing your dotfiles and profiles.
+summary: A CLI Tool for managing your dotfiles
 test_files:
 - spec/dotify/cli_spec.rb
+- spec/dotify/config_spec.rb
+- spec/dotify/files_spec.rb
+- spec/fixtures/.dotrc-default
+- spec/fixtures/.dotrc-mattbridges
 - spec/spec_helper.rb
+- spec/support/fake.rb