dotify 0.4.0 → 0.5.0

data/README.md

@@ -24,49 +24,13 @@ It is highly recommended that you just install this gem manually since it is onl
 
 As dotify is a CLI tool, everything is done in the command line. Here are the current available methods for managing dotfiles.
 
-### Preparing your system for Dotify
+### Setting up and installing Dotify
 
-To setup Dotify, you must first run `dotify setup` in your terminal.
+To install Dotify, you must first run `dotify install` in your terminal.
 
-    $ dotify setup
+    $ dotify install
         create /Users/computer-user/.dotify
         create /Users/computer-user/.dotrc
-
-This will first create a `.dotify` directory in your home directory as well as a `.dotrc` file for Dotify configuration (yes, it is more dotfiles, but this is a good thing!).
-
-In order to install files from the home directory into Dotify, you must run the `install` task.
-
-### The .dotrc file
-
-The `.dotrc` file in your home directory serves as the configuration file for Dotify.
-
-#### Ignoring files
-
-When you are linking files in your Dotify directory, some files you do not want ever want to link (`.git`, `.gitmodules`, `.gitignore`, .etc) because they are used specifically for that directory (such as git versioning). You can configure Dotify to ignore these files when calling `dotify link` in the `.dotrc` in this way:
-
-    $ cat ~/.dotrc
-    ignore:
-      dotify:
-      - '.git'
-      - '.gitmodules'
-      - '.gitignore'
-
-The same can be done for the home directory when running `dotify setup`. There are some directories that you should not move around (`.dropbox`, `.rbenv`, `.rvm`) and do not want to accidentally attempt to move. You can do that in your `.dotrc` file as well:
-
-    $ cat ~/.dotrc
-    ignore:
-      dotfiles:
-      - '.dropbox'
-      - '.rbenv'
-      - '.rvm'
-
-More configuration options will likely be added in future versions, so be sure to check up here for your options.
-
-### Install Dotify
-
-Now that you have configured Dotify to your liking, you should now run `dotify install`.
-
-    $ dotify install
     Do you want to add .bash_history to Dotify? [Yn] n
     Do you want to add .bashrc to Dotify? [Yn] y
         create /Users/mattbridges/.dotify/.bashrc
@@ -76,6 +40,12 @@ Now that you have configured Dotify to your liking, you should now run `dotify i
         create /Users/mattbridges/.dotify/.zshrc
     ...
 
+This will first create a `.dotify` directory in your home directory as well as a `.dotrc` file for Dotify configuration (yes, it is more dotfiles, but this is a good thing!).
+
+During the installation process, a Vim instance will open with a sample `.dotrc` file for you to edit and configure if you desire. This will allow your configuration to be used prior to Dotify's full installation. See more about the `.dotrc` file in the [Configuration](https://github.com/mattdbridges/dotify/tree/cli-rewrite#configuration) section.
+
+Alternatively, you could run `dotify setup` to setup Dotify's configuration, followed by `dotify install` to add the initial files into Dotify.
+
 ### Add single files
 
 After you have setup Dotify, you can add files one by one if you did not add them during setup
@@ -99,31 +69,29 @@ If you do this and decide to change your mind, the file is still located in the
 This is the heart of the Dotify tool. This command will link the files within the `~/.dotify` directory into your home directory.
 
     $ dotify link
-    Do you want to link ~/.bashrc? [Yn] Y
-       create     /Users/computer-user/.bashrc
-    Do you want to link ~/.gemrc? [Yn] Y
-       identical  /Users/computer-user/.gemrc
-    Do you want to link ~/.gitconfig? [Yn] Y
-       create     /Users/computer-user/.gitconfig
-    Do you want to link ~/.gitignore? [Yn] Y
+    Do you want to link .bash_profile to the home directory? [Yn] Y
+          linked  /Users/mattbridges/.bash_profile
+    Do you want to link .dotrc to the home directory? [Yn] n
+    Do you want to link .gitconfig to the home directory? [Yn] Y
+          linked  /Users/mattbridges/.gitconfig
     ...
 
 You can also link files one-by-one by passing the filename to the `link` task.
 
     $ dotify link .bashrc
     Do you want to link ~/.bashrc? [Yn] Y
-       create /Users/computer-user/.bashrc
+          linked  /Users/mattbridges/.bashrc
 
 ### Unlink everything
 
 Don't want any of the dotfiles anymore? Well, I'm not one to question. Go ahead and wipe them out.
 
     $ dotify unlink
-    Are you sure you want to remove ~/.bashrc? [Yn] Y
-       remove  /Users/computer-user/.bashrc
-    Are you sure you want to remove ~/.gemrc? [Yn] Y
-       remove  /Users/computer-user/.gemrc
-    Are you sure you want to remove ~/.gitconfig? [Yn] n
+    Do you want to unlink .bashrc from the home directory? [Yn] y
+          unlinked  /Users/computer-user/.bashrc
+    Do you want to unlink .dotrc from the home directory? [Yn] n
+    Do you want to unlink .gemrc from the home directory? [Yn] y
+          unlinked  /Users/computer-user/.gemrc
     ...
 
 Should you run this horrid task accidentally, you can simply run `dotify link` again if you want to restore your previous settings.
@@ -134,16 +102,63 @@ By default, `unlink` loops through all of the Dotify files. You can also pass a
     Are you sure you want to remove ~/.bashrc? [Yn] Y
        remove /Users/mattbridges/.bashrc
 
-## Confused?
+## Versioning
+
+The whole purpose of this gem was to manage the dotfiles on your system. What better way to do this than under version control using [Git](http://git-scm.com/) and [Github](https://github.com)?
+
+* To version your Dotify installation, simple make `.dotify` a Git repository. If you don't know how to do that, I recommend you start reading [here](http://git-scm.com/book/en/Getting-Started).
+* Add your remote repository via `git remote add [NAME] [REPO]`.
+
+*From this point, you can manage your dotfiles entirely from Dotify.*
+
+* To edit a dotfile managed by Dotify, simple run `dotify edit [DOTFILE]` and replace **[DOTFILE]** with the name of the file you want to edit. This will open a Vim instance containing that file for editing.
+* Once you have saved your edits, simple run `dotify save` and Dotify will walk you through the steps of committing your changes and pushing them up to Github.
+
+## Configuration
+
+The `.dotrc` file in your home directory serves as the configuration file for Dotify. It is a [YAML](http://www.yaml.org/) formatted file.
+
+#### Dotify Editor
+
+When you run `dotify edit [DOTFILE]`, by default the file opens in Vim for editing. You can change this by adding this following to your `.dotrc` file.
+
+    editor: 'vi'
+    # or 'vim' or 'emacs' etc...
+
+Vim and Emacs are the only two editors that have been successfully used with this configuration option, but if you find another, please [let me know](https://github.com/mattdbridges/dotify/issues/new) and I will update the documentation.
+
+#### Ignoring files
+
+When you are linking files in your Dotify directory, some files you do not want ever want to link (`.git`, `.gitmodules`, `.gitignore`, .etc) because they are used specifically for that directory (such as git versioning). You can configure Dotify to ignore these files when calling `dotify link` in the `.dotrc` in this way:
+
+    $ cat ~/.dotrc
+    ignore:
+      dotify:
+      - '.git'
+      - '.gitmodules'
+      - '.gitignore'
+
+The same can be done for the home directory when running `dotify setup`. There are some directories that you should not move around (`.dropbox`, `.rbenv`, `.rvm`) and do not want to accidentally attempt to move. You can do that in your `.dotrc` file as well:
+
+    $ cat ~/.dotrc
+    ignore:
+      dotfiles:
+      - '.dropbox'
+      - '.rbenv'
+      - '.rvm'
+
+More configuration options will likely be added in future versions, so be sure to check up here for your options.
 
-Dotify can manages dotfiles from two different directions:
+## Clarifying the add/remove/link/unlink tasks
 
-1. `add` and `remove` both look in the user's home directory for dotfiles to manage
-2. `link` and `unlink` both look in the Dotify directory for dotfiles to manage.
+Here is a little clarification on the `add`/`remove`/`link`/`unlink` tasks.
 
-In other words, when the user has dotfiles in the home directory that he/she wants Dotify to manage, they would use `dotify add [FILENAME]` (or even `setup`) to instruct Dotify to manage those files.
+* `dotify add` adds one or more dotfiles in the users' home directory into Dotify.
+* `dotify remove` removes one or more linked dotfiles from Dotify and returns them to the home directory.
+* `dotify link` links one or more files added to Dotify into the home directory.
+* `dotify unlink` simply removes one or more home directory files that are linked into Dotify.
 
-On the other hand, if he/she has files that they have instructed Dotify to manage but have removed them from the home directory, they would use `link` and `unlink` to re-link them into the home directory.
+For instructions on how to use these methods, use `dotify help [TASK]` for further explanation.
 
 ## Not sure what to do?
 
@@ -151,12 +166,16 @@ This tool is powered by the amazing library, [Thor](http://whatisthor.com/). You
 
     $ dotify help
     Tasks:
-      dotify add [FILENAME]     # Add a single dotfile to the Dotify directory
-      dotify help [TASK]        # Describe available tasks or one specific task
-      dotify link               # Link up all of your dotfiles
-      dotify remove [FILENAME]  # Remove a single dotfile from Dotify
-      dotify setup              # Setup your system for Dotify to manage your dotfiles
-      dotify unlink             # Unlink all of your dotfiles
+      dotify add {{FILENAME}}     # Add a one or more dotfiles to Dotify. (FILENAME is optional)
+      dotify edit [FILE]          # Edit a dotify file
+      dotify help [TASK]          # Describe available tasks or one specific task
+      dotify install              # Install files from your home directory into Dotify
+      dotify link {{FILENAME}}    # Link up one or all of your dotfiles (FILENAME is optional)
+      dotify remove {{FILENAME}}  # Remove a single dotfile from Dotify (FILENAME is optional)
+      dotify save                 # Commit Dotify files and push to Github
+      dotify setup                # Setup your system for Dotify to manage your dotfiles
+      dotify unlink {{FILENAME}}  # Unlink one or all of your dotfiles (FILENAME is optional)
+      dotify version              # Check your Dotify version
 
 And if you want a little clarity on one of the command you can run `dotify help [TASK]` to find out what other options you have in the other tasks.
 

data/lib/dotify/cli.rb

@@ -32,24 +32,31 @@ module Dotify
     def save
       Dir.chdir(Config.path) do
         system 'git fetch'
-        uncommitted = `git status`.chomp.to_i != 2
+        uncommitted = `git status | wc -l`.chomp.to_i != 2
         if uncommitted
+          puts `git status` # show the status output
           message = !options[:message].nil? ? options[:message] : ask("Commit message:", :blue)
           system 'git add .'
           system "git commit -m '#{message.gsub(/[']/, '\\\\\'')}'"
-        end
-        if `git log origin/master.. --oneline | wc -l`.chomp.to_i != 0
-          say 'Pushing up to Github...', :blue
-          system 'git push origin master'
+          if `git log origin/master.. --oneline | wc -l`.chomp.to_i != 0
+            say 'Pushing up to Github...', :blue
+            system 'git push origin master'
+          end
+        else
+          say 'Dotify has nothing to save.', :blue
         end
       end
     end
 
-    desc :edit, "Edit a dotify file"
+    desc 'edit [FILE]', "Edit a dotify file"
     method_option :save, :aliases => '-s', :default => false, :type => :boolean, :require => true, :desc => "Save Dotify files and push to Github"
     def edit(filename)
-      system "#{Config.editor} #{Files.dotify(filename)}"
-      save if options[:save] == true
+      if Files.linked.include? Files.dotify(filename)
+        exec "#{Config.editor} #{Files.dotify(filename)}"
+        save if options[:save] == true
+      else
+        say "'#{Files.filename(filename)}' has not been linked by Dotify. Please run `dotify link #{Files.filename(filename)}` to edit this file.", :blue
+      end
     end
 
     desc :version, "Check your Dotify version"
@@ -67,95 +74,96 @@ module Dotify
     end
 
     desc :setup, "Setup your system for Dotify to manage your dotfiles"
-    method_option :install, :default => false, :type => :boolean, :aliases => '-i', :desc => "Run Dotify install right away. This does not allow for customizing your .dotrc file before attempting install files into Dotify."
-    method_option :verbose, :default => true, :type => :boolean, :aliases => '-v', :desc => "Setup Dotify with verbose output."
+    method_option :install, :type => :boolean, :default => true, :desc => "Install Dotify after setup"
+    method_option "edit-config", :type => :boolean, :default => true, :desc => "Edit Dotify's configuration."
+    method_options :verbose => true
     def setup
-      return say('Dotify has already been setup!', :blue) if Dotify.installed?
-      empty_directory(Config.path, :verbose => options[:verbose])
-      dotrc = File.join(Config.home, Config::DOTIFY_CONFIG)
-      template Config::DOTIFY_CONFIG, dotrc, :verbose => options[:verbose]
+      # Warn if Dotify is already setup
+      if !Dotify.installed?
+        say "Dotify is already setup", :blue
+      end
+
+      # Create the Dotify directory unless it already exists
+      unless File.exists?(Config.path)
+        empty_directory(Config.path, :verbose => options[:verbose])
+      end
+
+      # Create the Dotify config file unless it already exists
+      unless File.exists?(Config.file)
+        template '.dotrc', Config.file, :verbose => options[:verbose]
+      end
+
+      say "Editing config file...", :blue
+      sleep 1 # Give a little time for reading the message
+      invoke :edit, [Config.file]
+      say "Config file updated.", :blue
+
+      # Run install task if specified
       invoke :install if options[:install] == true
     end
 
     desc :install, "Install files from your home directory into Dotify"
-    method_option :link, :default => false, :type => :boolean, :aliases => '-l', :desc => "Link dotfiles when setup is complete"
     def install
       invoke :setup unless Dotify.installed?
-      Files.uninstalled do |path, file|
-        add_file(file, options.merge(:quiet => true)) unless Config.dirname == file
-      end
-      say "Dotify has been successfully setup.", :blue
-      if options[:link]
-        say "Linking up the new dotfiles...", :blue
-        invoke :link, nil, { :all => true }
-      end
+      invoke :add
     end
 
-    desc "add [FILENAME]", "Add a single dotfile to the Dotify directory"
-    method_option :force, :default => false, :type => :boolean, :aliases => '-f', :desc => "Add file without confirmation"
-    def add(file)
-      return not_setup_warning unless Dotify.installed?
-      add_file(file, options)
+    desc "add {{FILENAME}}", "Add a one or more dotfiles to Dotify. (FILENAME is optional)"
+    method_option :force, :type => :boolean, :default => false, :aliases => '-f', :desc => "Remove Dotify file(s) without confirmation"
+    def add(file=nil)
+      not_setup_warning unless Dotify.installed?
+      if file.nil?
+        Files.uninstalled { |path, file| add_dotify_file(file, options) }
+      else
+        add_dotify_file(file, options.merge(:single => true))
+      end
     end
 
-    desc "remove [FILENAME]", "Remove a single dotfile from Dotify"
-    long_desc <<-STRING
-      `dotify remove [FILENAME]` removes the dotfiles from the Dotify directory
-      and moves it back into the home directory. If you decide you want Dotify
-      to manage that file again, you can simply run `dotify add [FILENAME]` to
-      add it back again.
-    STRING
-    method_option :force, :default => false, :type => :boolean, :aliases => '-f', :desc => "Remove file without confirmation"
-    method_option :quiet, :default => false, :type => :boolean, :aliases => '-q', :desc => "Don't output anything"
-    def remove(file)
-      return not_setup_warning unless Dotify.installed?
-      if !File.exists?(Files.dotify(file))
-        say "Dotify is not currently managing ~/#{file}.", :blue unless options[:quiet] == true
-        return
-      end
-      if options[:force] == true || yes?("Are you sure you want to remove #{file} from Dotify? [Yn]", :yellow)
-        remove_file Files.dotfile(file), :verbose => false
-        copy_file Files.dotify(file), Files.dotfile(file), :verbose => false
-        remove_file Files.dotify(file), :verbose => false
-        say_status :removed, Files.dotify(file) unless options[:quiet] == true
+    desc "remove {{FILENAME}}", "Remove a single dotfile from Dotify (FILENAME is optional)"
+    long_desc <<-DESC
+      This removes the dotfiles from the Dotify directory and move \
+      it back into the home directory. If you decide you want Dotify \
+      to manage that file again, you can simply run `dotify add [FILENAME]` \
+      to add it back again.
+    DESC
+    method_option :force, :type => :boolean, :default => false, :aliases => '-f', :desc => "Remove Dotify file(s) without confirmation"
+    def remove(file=nil)
+      not_setup_warning unless Dotify.installed?
+      if file.nil?
+        Files.linked { |path, file| remove_dotify_file(file, options) }
+      else
+        remove_dotify_file(file, options)
       end
     end
 
     desc 'link {{FILENAME}}', "Link up one or all of your dotfiles (FILENAME is optional)"
-    method_option :all, :default => false, :type => :boolean, :aliases => '-a', :desc => "Link dotfiles without confirmation"
+    method_option :force, :default => false, :type => :boolean, :aliases => '-f', :desc => "Link dotfiles without confirmation"
     def link(file=nil)
-      return not_setup_warning unless Dotify.installed?
+      not_setup_warning unless Dotify.installed?
       if file.nil?
-        count = 0
-        Files.dots do |file, dot|
-          count += 1 if link_file(file, dot, options) == true
+        Files.unlinked do |path, file|
+          link_file(file, options)
         end
-        say "No files were linked.", :blue if count == 0
       else
-        link_file(file, Files.filename(file), options)
+        link_file(file, options)
       end
     end
 
     desc 'unlink {{FILENAME}}', "Unlink one or all of your dotfiles (FILENAME is optional)"
-    long_desc <<-STRING
-      `dotify unlink` removes the dotfiles from the home directory and preserves the
-      files in the Dotify directory. This allows you to simply run `dotify link` again
+    long_desc <<-DESC
+      This removes the dotfiles from the home directory and preserves the \
+      files in the Dotify directory. This allows you to simply run `dotify link` again \
       should you decide you want to relink anything to the Dotify files.
-    STRING
-    method_option :all, :default => false, :type => :boolean, :aliases => '-a', :desc => 'Remove all installed dotfiles without confirmation'
+    DESC
+    method_option :force, :default => false, :type => :boolean, :aliases => '-f', :desc => 'Remove all installed dotfiles without confirmation'
     def unlink(file = nil)
-      return not_setup_warning unless Dotify.installed?
+      not_setup_warning unless Dotify.installed?
       if file.nil?
-        count = 0
-        Files.installed do |file, dot|
-          if options[:all] || yes?("Are you sure you want to remove ~/#{dot}? [Yn]", :yellow)
-            unlink_file(file)
-            count += 1
-          end
+        Files.linked do |path, file|
+          unlink_file(file, options)
         end
-        say "No files were unlinked.", :blue if count == 0
       else
-        unlink_file(file)
+        unlink_file(file, options)
       end
     end
 
@@ -165,53 +173,78 @@ module Dotify
         say('Dotify has not been setup yet! You need to run \'dotify setup\' first.', :yellow)
       end
 
-      def unlink_file(file)
-        remove_file Files.dotfile(file)
-        return true
+      def unlink_file(file, options = {})
+        file = Files.filename(file)
+        dot = Files.dotfile(file)
+        dotify = Files.dotify(file)
+        if File.exists?(dot) && File.exists?(dotify)
+          if options[:force] == true || yes?("Do you want to unlink #{file} from the home directory? [Yn]", :blue)
+            FileUtils.rm_rf dot
+            say_status :unlinked, dot
+          end
+        else
+          say "'#{file}' does not exist in Dotify.", :blue
+        end
       end
 
-      def link_file(file, dot, options = {})
-        if options[:all]
-          if File.exists? Files.dotfile(file)
-            replace_link Files.dotfile(file), file
-          else
-            create_link Files.dotfile(file), file
+      def link_file(file, options = {})
+        file = Files.filename(file)
+        home = Files.dotfile(file)
+        path = Files.dotify(file)
+        status = case
+                 when !File.exists?(home) then :linked
+                 when File.exists?(home) then :replaced; end
+        if File.exists?(path)
+          if options[:force] == true || yes?("Do you want to link #{file} to the home directory? [Yn]", :blue)
+            FileUtils.rm_rf(home, :verbose => false)
+            FileUtils.ln_s(path, home, :verbose => false)
+            say_status status, home
           end
-          return true
         else
-          if yes?("Do you want to link ~/#{dot}? [Yn]", :yellow)
-            create_link Files.dotfile(file), file
-            return true
-          end
-          return false
+          say "'#{file}' does not exist in the home directory.", :blue
         end
-        return false
       end
 
-      def add_file(file, options = {})
+      def remove_dotify_file(file, options = {})
         file = Files.filename(file)
-        dotfile = Files.dotfile(file)
-        dotify_file = Files.dotify(file)
-
-        if !File.exist?(dotfile) || !File.identical?(dotfile, dotify_file)
-          if options[:force] == true || yes?("Do you want to add #{file} to Dotify? [Yn]", :yellow)
-            if File.directory?(dotfile)
-              FileUtils.rm_rf dotify_file
-              FileUtils.cp_r dotfile, dotify_file
-              say_status :create, dotify_file
+        home = Files.dotfile(file)
+        path = Files.dotify(file)
+        if File.exist?(home) && File.exist?(path)
+          if options[:force] == true || yes?("Do you want to remove #{file} from Dotify? [Yn]", :blue)
+            FileUtils.rm_rf(home, :verbose => false)
+            if File.directory? path
+              FileUtils.cp_r(path, home, :verbose => false)
             else
-              copy_file dotfile, dotify_file
+              FileUtils.cp(path, home, :verbose => false)
             end
+            FileUtils.rm_rf(path, :verbose => false)
+            say_status :removed, path
           end
+        elsif File.exist?(home) && !File.exist?(path)
+          say "The file '#{file}' is not managed by Dotify. Cannot remove.", :blue
         else
-          say "'#{file}' does not exist or is already installed in Dotify.", :blue unless options[:quiet] == true
+          say "The file '~/#{file}' does not exist", :blue
         end
       end
 
-      def replace_link(dotfile, file)
-        remove_file dotfile, :verbose => false
-        create_link dotfile, file, :verbose => false
-        say_status :replace, dotfile
+      def add_dotify_file(file, options = {})
+        file = Files.filename(file)
+        home = Files.dotfile(file)
+        path = Files.dotify(file)
+        if File.exist?(home)
+          if options[:force] == true || yes?("Do you want to add #{file} to Dotify? [Yn]", :blue)
+            if File.directory? home
+              FileUtils.cp_r(home, path, :verbose => false)
+            else
+              FileUtils.cp(home, path, :verbose => false)
+              say_status :adding, path
+            end
+          end
+        else
+          if options[:single] == true
+            say "The file '#{file}' doesn't exist or Dotify already manages it.", :blue
+          end
+        end
       end
 
     end

data/lib/dotify/config.rb

@@ -5,13 +5,18 @@ require 'yaml'
 module Dotify
   class Config
 
-    DOTIFY_DIRNAME = '.dotify'
-    DOTIFY_CONFIG = '.dotrc'
+    DIRNAME = '.dotify'
+    CONFIG_FILE = '.dotrc'
+    EDITOR = 'vim'
+    DEFAULT_IGNORE = {
+      :dotify => %w[.git .gitmodule],
+      :dotfiles => %w[.DS_Store .Trash .dropbox .dotify]
+    }
 
     class << self
 
       def dirname
-        @dirname ||= DOTIFY_DIRNAME
+        @dirname ||= DIRNAME
       end
 
       def installed?
@@ -23,16 +28,16 @@ module Dotify
       end
 
       def editor
-        config.fetch(:editor, 'vi')
+        config.fetch(:editor, 'vim')
       end
 
       def load_config!
-        config = File.exists?(config_file) ? (YAML.load_file(config_file) || {}) : {}
+        config = File.exists?(file) ? (YAML.load_file(file) || {}) : {}
         symbolize_keys!(config)
       end
 
       def ignore(what)
-        config.fetch(:ignore, {}).fetch(what, [])
+        (config.fetch(:ignore, {}).fetch(what, []) + DEFAULT_IGNORE.fetch(what, [])).uniq
       end
 
       def config
@@ -43,11 +48,11 @@ module Dotify
         Thor::Util.user_home
       end
 
-      private
+      def file
+        File.join(home, CONFIG_FILE)
+      end
 
-        def config_file
-          File.join(home, DOTIFY_CONFIG)
-        end
+      private
 
         def symbolize_keys!(opts)
           sym_opts = {}

data/lib/dotify/files.rb

@@ -10,33 +10,33 @@ module Dotify
       include Thor::Shell
       include Thor::Actions
 
-      def dots
-        @dots ||= FileList.dotify
-        return @dots unless block_given?
-        @dots.each {|d| yield(d, filename(d)) }
+      def linked
+        @linked ||= FileList.dotify
+        return @linked unless block_given?
+        @linked.each {|d| yield(d, filename(d)) }
       end
 
       def unlinked
-        dots = self.dots.map { |d| filename(d) }
+        linked = self.linked.map { |d| filename(d) }
         installed = self.installed.map {|i| filename(i)}
-        unlinked = (dots - installed).map{|f| dotfile(f) }
+        unlinked = (linked - installed).map{|f| dotfile(f) }
         return unlinked unless block_given?
         unlinked.each {|u| yield(u, filename(u)) }
       end
 
       def installed
-        dots = self.dots.map { |f| filename(f) }
+        linked = self.linked.map { |f| filename(f) }
         installed = FileList.home.select do |d|
-          dots.include?(filename(d))
+          linked.include?(filename(d))
         end
         return installed unless block_given?
         installed.each {|i| yield(i, filename(i)) }
       end
 
       def uninstalled
-        dots = self.dots.map { |f| filename(f) }
+        linked = self.linked.map { |f| filename(f) }
         installed = FileList.home.select do |d|
-          !dots.include?(filename(d))
+          !linked.include?(filename(d))
         end
         return installed unless block_given?
         installed.each {|i| yield(i, filename(i)) }

data/lib/dotify/version.rb

@@ -1,3 +1,3 @@
 module Dotify
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/spec/dotify/config_spec.rb

@@ -26,7 +26,7 @@ describe Dotify::Config do
       Dotify::Config.path.should == File.join(Dotify::Config.home, '.dotify')
     end
     it "should set a default editor" do
-      Dotify::Config.editor.should == 'vi'
+      Dotify::Config.editor.should == Dotify::Config::EDITOR
     end
     it "should allow a custom editor" do
       Dotify::Config.stub(:config)  do
@@ -35,12 +35,28 @@ describe Dotify::Config do
       Dotify::Config.editor.should == 'subl'
     end
   end
+
+  describe Dotify::Config, "#file" do
+    it "should return the right page" do
+      Dotify::Config.stub(:home).and_return('/tmp')
+      Dotify::Config.file.should == '/tmp/.dotrc'
+    end
+  end
+
   describe "ignore files" do
     before do
       Dotify::Config.stub(:config)  do
         { :ignore => { :dotfiles => %w[.gemrc], :dotify => %w[.gitmodule] } }
       end
     end
+    it "should have a default set of dotfiles" do
+      Dotify::Config.stub(:config).and_return({})
+      Dotify::Config.ignore(:dotify).should include '.git'
+      Dotify::Config.ignore(:dotify).should include '.gitmodule'
+      Dotify::Config.ignore(:dotfiles).should include '.dropbox'
+      Dotify::Config.ignore(:dotfiles).should include '.Trash'
+      Dotify::Config.ignore(:dotfiles).should include '.dotify'
+    end
     it "should retrieve the list of dotfiles to ignore in the home directory" do
       Dotify::Config.ignore(:dotfiles).should include '.gemrc'
     end

data/spec/dotify/files_spec.rb

@@ -6,8 +6,8 @@ require 'fileutils'
 describe Dotify::Files do
 
   describe "methods" do
-    it "should respond to dots" do
-      Dotify::Files.should respond_to :dots
+    it "should respond to linked" do
+      Dotify::Files.should respond_to :linked
     end
     it "should respond to installed" do
       Dotify::Files.should respond_to :installed
@@ -24,27 +24,28 @@ describe Dotify::Files do
 
   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")
+      Dotify::Config.stub(:home).and_return '/home'
+      Dotify::Files.dotfile(".vimrc").should == '/home/.vimrc'
+      Dotify::Files.dotfile("/spec/home/.bashrc").should == '/home/.bashrc'
     end
   end
 
   describe Dotify::Files, "#dotify" do
     it "should return the path to the file when it is linked in the root" do
-      Dotify::Files.dotify(".vimrc").should == File.join(Dotify::Config.path, ".vimrc")
-      Dotify::Files.dotify("/spec/home/.bashrc").should == File.join(Dotify::Config.path, ".bashrc")
+      Dotify::Config.stub(:path).and_return '/tmp'
+      Dotify::Files.dotify(".vimrc").should == '/tmp/.vimrc'
+      Dotify::Files.dotify("/spec/home/.bashrc").should == '/tmp/.bashrc'
     end
   end
 
-  describe Dotify::Files, "#dots" do
+  describe Dotify::Files, "#linked" do
     before do
       Dotify::FileList.stub(:dotify) do
         ['/spec/test/.bash_profile', '/spec/test/.bashrc', '/spec/test/.zshrc']
       end
     end
-    let!(:files) { Dotify::Files.dots }
+    let!(:files) { Dotify::Files.linked }
     it "should return the list of dotfiles in the dotify path" do
-      files
       files.map! { |f| Dotify::Files.filename(f) }
       files.should include '.bash_profile'
       files.should include '.bashrc'
@@ -52,13 +53,13 @@ describe Dotify::Files do
     end
     it "shoud yield the files if a block is given" do
       yields = files.map { |f| [f, Dotify::Files.filename(f)] }
-      expect { |b| Dotify::Files.dots(&b) }.to yield_successive_args(*yields)
+      expect { |b| Dotify::Files.linked(&b) }.to yield_successive_args(*yields)
     end
   end
 
   describe Dotify::Files, "#unlinked" do
     before do
-      Dotify::Files.stub(:dots) do
+      Dotify::Files.stub(:linked) do
         ['/spec/test/.vimrc', '/spec/test/.bashrc', '/spec/test/.zshrc']
       end
       Dotify::Files.stub(:installed) do
@@ -78,7 +79,7 @@ describe Dotify::Files do
 
   describe Dotify::Files, "#installed" do
     before do
-      Dotify::Files.stub(:dots) do
+      Dotify::Files.stub(:linked) do
         %w[/spec/test/.zshrc /spec/test/.bashrc /spec/test/.vimrc /spec/test/.dotify]
       end
       Dotify::FileList.stub(:home) do
@@ -100,7 +101,7 @@ describe Dotify::Files do
 
   describe Dotify::Files, "#uninstalled" do
     before do
-      Dotify::Files.stub(:dots) do
+      Dotify::Files.stub(:linked) do
         %w[/spec/test/.zshrc /spec/test/.bashrc /spec/test/.vimrc /spec/test/.dotify]
       end
       Dotify::FileList.stub(:home) do

data/spec/spec_helper.rb

@@ -5,7 +5,6 @@
 #
 # 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|

data/templates/.dotrc

@@ -1,3 +1,9 @@
+# Set the editor to use when editing Dotify dotfiles.
+#   Default: 'vim'
+#   Options: 'vi', 'vim', 'emacs', '[ANY OTHER TERMINAL BASED EDITOR]'
+#
+# editor: 'vi'
+#
 # Ignoring files in ~/.dotify when linking:
 #
 # ignore:
@@ -5,10 +11,7 @@
 #   - '.git'
 #   - '.gitignore'
 #   - '.gitmodules'
-#
-# Ignoring files in the home directory when linking:
-#
-# ignore:
+#   # Ignoring files in the home directory when linking:
 #   dotify:
 #   - '.rbenv'
 #   - '.rvm'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dotify
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-02 00:00:00.000000000 Z
+date: 2012-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor