dotify 0.5.1 → 0.6.0

data/lib/dotify/errors.rb

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

data/lib/dotify/files.rb

@@ -1,4 +1,3 @@
-require 'dotify'
 require 'thor/actions'
 require 'thor/shell'
 
@@ -7,55 +6,51 @@ Dotify::Config.load_config!
 module Dotify
   class Files
     class << self
-      include Thor::Shell
-      include Thor::Actions
+      # All
+      #
+      # Pulls an array of Units from the home
+      # directory.
+      def all
+        @all ||= List.home
+      end
 
+      # Linked files are those files which have a
+      # symbolic link pointing to the Dotify file.
       def linked
-        @linked ||= FileList.dotify
-        return @linked unless block_given?
-        @linked.each {|d| yield(d, filename(d)) }
+        links = self.all.select { |f| f.linked? }
+        return links unless block_given?
+        links.each {|u| yield u }
       end
 
+      # Unlinked files are, of course, the opposite
+      # of linked files. These are Dotify files which
+      # Have no home dir files that are linked to them.
       def unlinked
-        linked = self.linked.map { |d| filename(d) }
-        installed = self.installed.map {|i| filename(i)}
-        unlinked = (linked - installed).map{|f| dotfile(f) }
-        return unlinked unless block_given?
-        unlinked.each {|u| yield(u, filename(u)) }
-      end
-
-      def installed
-        linked = self.linked.map { |f| filename(f) }
-        installed = FileList.home.select do |d|
-          linked.include?(filename(d))
-        end
-        return installed unless block_given?
-        installed.each {|i| yield(i, filename(i)) }
+        unl = self.all.select { |f| !f.linked? }
+        return unl unless block_given?
+        unl.each {|u| yield u }
       end
 
+      # Uninstalled dotfiles are the dotfiles in the home
+      # directory that have not been loaded into Dotify or
+      # linked to the corresponding Dotify path.
       def uninstalled
-        linked = self.linked.map { |f| filename(f) }
-        installed = FileList.home.select do |d|
-          !linked.include?(filename(d))
-        end
-        return installed unless block_given?
-        installed.each {|i| yield(i, filename(i)) }
+        uni = self.all.select { |f| !f.added? && !f.linked? }
+        return uni unless block_given?
+        uni.each {|u| yield u }
       end
 
       def filename(file)
-        %r{([^<>:"\/\\\|\?\*]*)\Z}.match(file).to_s
-      end
-
-      def template?(file)
-        filename(file).match(/(tt|erb)\Z/) ? true : false
+        File.basename(file)
       end
 
-      def dotfile(file)
-        File.join(Config.home, filename(file))
+      def dotfile(file = nil)
+        file.nil? ? Config.home : File.join(Config.home, filename(file))
       end
+      alias :home :dotfile
 
-      def dotify(file)
-        File.join(Config.path, filename(file))
+      def dotify(file = nil)
+        file.nil? ? Config.path : File.join(Config.path, filename(file))
       end
 
       def link_dotfile(file)
@@ -63,7 +58,7 @@ module Dotify
       end
 
       def unlink_dotfile(file)
-        FileUtils.rm_rf File.join(Config.home, filename(file))
+        FileUtils.rm_rf dotfile(file)
       end
 
     end

data/lib/dotify/list.rb

@@ -0,0 +1,36 @@
+require 'dotify'
+
+module Dotify
+  class List
+    class << self
+
+      def home
+        result = units(Files.dotfile('.*'))
+        filter_ignore_files!(result, :dotfiles)
+      end
+
+      def dotify
+        result = units(Files.dotify('.*'))
+        filter_ignore_files!(result, :dotify)
+      end
+
+      def units(glob)
+        filter_dot_directories! Dir[glob].map{ |file| Unit.new(file) }
+      end
+
+      def filter_dot_directories!(units)
+        [*units].delete_if { |f| %w[. ..].include? f.filename }
+      end
+
+      def filter_ignore_files!(units, ignore)
+        ignoring = Config.ignore(ignore)
+        [*units].delete_if { |f| ignoring.include?(f.filename) }
+      end
+
+      def filenames(units)
+        units.map(&:filename)
+      end
+
+    end
+  end
+end

data/lib/dotify/unit.rb

@@ -0,0 +1,91 @@
+require 'dotify/errors'
+
+module Dotify
+
+  class NoSymlink; end
+
+  module Actions
+
+    # Link the file from the home directory into Dotify
+    def link
+      return false if !in_home_dir? || linked?
+      if in_home_dir? && !in_dotify?
+        FileUtils.cp_r(self.dotfile, self.dotify, :verbose => false)
+      end
+      FileUtils.rm_rf(self.dotfile, :verbose => false)
+      FileUtils.ln_sf(self.dotify, self.dotfile, :verbose => false)
+      return true
+    end
+
+    # Unlink the file from Dotify and replace it into the home directory.
+    def unlink
+      return false unless linked?
+      FileUtils.rm_rf(self.dotfile, :verbose => false)
+      FileUtils.cp_r(self.dotify, self.dotfile, :verbose => false)
+      FileUtils.rm_rf(self.dotify, :verbose => false)
+      return true
+    end
+
+  end
+
+  class Unit
+
+    include Actions
+
+    # Attributes on the file itself
+    attr_accessor :filename, :dotify, :dotfile
+
+    # Attributes about the file's status in the filesystem
+    attr_accessor :linked, :added
+
+    def initialize(file)
+      @filename = File.basename(file)
+      self
+    end
+
+    def dotify
+      @dotify ||= Files.dotify(@filename)
+    end
+
+    def dotfile
+      @dotfile ||= Files.dotfile(@filename)
+    end
+
+    def added?
+      in_dotify? && !linked_to_dotify?
+    end
+
+    def linked?
+      in_dotify? && linked_to_dotify?
+    end
+
+    def in_dotify?
+      File.exists?(dotify)
+    end
+
+    def in_home_dir?
+      File.exists?(dotfile)
+    end
+
+    def to_s
+      self.filename
+    end
+
+    def inspect
+      "#<Dotify::Unit @filename='#{@filename}' @added=#{added?} @linked=#{linked?}>"
+    end
+
+    def linked_to_dotify?
+      self.symlink == dotify
+    end
+
+    def symlink
+      begin
+        File.readlink dotfile
+      rescue
+        NoSymlink
+      end
+    end
+
+  end
+end

data/lib/dotify/version.rb

@@ -1,3 +1,3 @@
 module Dotify
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/spec/dotify/cli_spec.rb

@@ -1,7 +1,69 @@
 require 'spec_helper'
-require 'dotify/cli'
 require 'thor'
 
-describe Dotify::CLI do
-  # add unit tests at a future date
+module Dotify
+  describe CLI do
+    let!(:cli) { CLI.new }
+    before do
+      Dotify.stub(:installed?).and_return true
+      cli.stub(:exec)
+    end
+
+    describe CLI, "#edit" do
+      let(:unit) { double('unit', :linked? => true, :dotify => '/tmp/dotify/.vimrc') }
+      before { Unit.stub(:new).and_return(unit) }
+      it "should open the editor with the passed file" do
+        cli.should_receive(:exec).with([Config.editor, unit.dotify].join(" "))
+        cli.edit('.vimrc')
+      end
+      it "should  the editor with the passed file" do
+        cli.should_receive(:save)
+        cli.stub(:options).and_return({ :save => true })
+        cli.edit '.vimrc'
+      end
+      it "should not edit the file if it has not been linked" do
+        unit.stub(:linked?).and_return false
+        cli.should_receive(:say).with("'#{unit}' has not been linked by Dotify. Please run `dotify link #{unit}` to edit this file.", :blue)
+        cli.edit('.vimrc')
+      end
+    end
+
+    describe CLI, "#link" do
+      it "should loop through all unlinked files" do
+        Files.should_receive(:unlinked)
+        cli.link
+      end
+      it "should relink all of the files located in Dotify" do
+        Files.should_not_receive(:unlinked)
+        Files.should_receive(:linked)
+        cli.stub(:options).and_return({ :relink => true })
+        cli.link
+      end
+      it "attempt to link one single file" do
+        cli.should_receive(:link_file).with(an_instance_of(Unit), {})
+        cli.link('.vimrc')
+      end
+      it "should output a warning if Dotify is not installed" do
+        Dotify.stub(:installed?).and_return false
+        cli.should_receive(:not_setup_warning).once
+        cli.link
+      end
+    end
+
+    describe CLI, "#unlink" do
+      it "should loop through all unlinked files" do
+        Files.should_receive(:linked)
+        cli.unlink
+      end
+      it "attempt to link one single file" do
+        cli.should_receive(:unlink_file).with(an_instance_of(Unit), {})
+        cli.unlink('.vimrc')
+      end
+      it "should output a warning if Dotify is not installed" do
+        Dotify.stub(:installed?).and_return false
+        cli.should_receive(:not_setup_warning).once
+        cli.unlink
+      end
+    end
+  end
 end

data/spec/dotify/config_spec.rb

@@ -1,67 +1,76 @@
 require 'spec_helper'
-require 'dotify/errors'
-require 'dotify/config'
 
-describe Dotify::Config do
-  describe Dotify::Config, "#installed?" do
-    it "should return false if Dotify has not been setup" do
-      File.should_receive(:directory?).with(File.join(Dotify::Config.home, Dotify::Config.dirname)).and_return(false)
-      Dotify::Config.installed?.should == false
-    end
-    it "should return true if Dotify has been setup" do
-      File.should_receive(:directory?).with(File.join(Dotify::Config.home, Dotify::Config.dirname)).and_return(true)
-      Dotify::Config.installed?.should == true
-    end
-  end
-  describe "options" do
-    before do
-      Dotify::Config.stub(:config)  do
-        { :ignore => { :dotfiles => %w[.gemrc], :dotify => %w[.gitmodule] } }
+module Dotify
+  describe Config do
+    before {
+      Config.unstub(:home)
+      Thor::Util.stub(:user_home).and_return '/home/tmp'
+    }
+    describe Config, "#installed?" do
+      it "should return true if Dotify has been setup" do
+        File.should_receive(:exists?).with(Config.path).and_return(true)
+        File.should_receive(:directory?).with(Config.path).and_return(true)
+        Config.installed?.should == true
       end
-    end
-    it "should be able to show the home path" do
-      Dotify::Config.home.should == Thor::Util.user_home
-    end
-    it "should be able to show the dotify path" do
-      Dotify::Config.path.should == File.join(Dotify::Config.home, '.dotify')
-    end
-    it "should set a default editor" do
-      Dotify::Config.editor.should == Dotify::Config::EDITOR
-    end
-    it "should allow a custom editor" do
-      Dotify::Config.stub(:config)  do
-        { :editor => 'subl' }
+      it "should return false if Dotify has not been setup" do
+        File.should_receive(:exists?).with(Config.path).and_return(true)
+        File.should_receive(:directory?).with(Config.path).and_return(false)
+        Config.installed?.should == false
       end
-      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'
+    describe Config, "#home" do
+      it "should return the home directory when called without a filename" do
+        Config.home.should == Thor::Util.user_home
+      end
     end
-  end
 
-  describe "ignore files" do
-    before do
-      Dotify::Config.stub(:config)  do
-        { :ignore => { :dotfiles => %w[.gemrc], :dotify => %w[.gitmodule] } }
+    describe "options" do
+      before do
+        Config.stub(:config)  do
+          { :ignore => { :dotfiles => %w[.gemrc], :dotify => %w[.gitmodule] } }
+        end
+      end
+      it "should be able to show the dotify path" do
+        Config.path.should == File.join(Config.home, '.dotify')
+      end
+      it "should set a default editor" do
+        Config.editor.should == Config::EDITOR
+      end
+      it "should allow a custom editor" do
+        Config.stub(:config)  do
+          { :editor => 'subl' }
+        end
+        Config.editor.should == 'subl'
       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'
+
+    describe Config, "#file" do
+      it "should return the right page" do
+        Config.file.should == '/home/tmp/.dotrc'
+      end
     end
-    it "should retrieve the list of dotify files to ignore" do
-      Dotify::Config.ignore(:dotify).should include '.gitmodule'
+
+    describe "ignore files" do
+      before do
+        Config.stub(:config)  do
+          { :ignore => { :dotfiles => %w[.gemrc], :dotify => %w[.gitmodule] } }
+        end
+      end
+      it "should have a default set of dotfiles" do
+        Config.stub(:config).and_return({})
+        Config.ignore(:dotify).should include '.git'
+        Config.ignore(:dotify).should include '.gitmodule'
+        Config.ignore(:dotfiles).should include '.dropbox'
+        Config.ignore(:dotfiles).should include '.Trash'
+        Config.ignore(:dotfiles).should include '.dotify'
+      end
+      it "should retrieve the list of dotfiles to ignore in the home directory" do
+        Config.ignore(:dotfiles).should include '.gemrc'
+      end
+      it "should retrieve the list of dotify files to ignore" do
+        Config.ignore(:dotify).should include '.gitmodule'
+      end
     end
   end
 end

data/spec/dotify/files_spec.rb

@@ -1,156 +1,116 @@
 require 'spec_helper'
-require 'dotify/config'
-require 'dotify/files'
-require 'fileutils'
 
-describe Dotify::Files do
+module Dotify
+  describe Files do
 
-  describe "methods" do
-    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
-    end
-    it "should respond to unlinked" do
-      Dotify::Files.should respond_to :unlinked
-    end
-  end
-
-  it "should split a filename correct" do
-    Dotify::Files.filename("some/random/path/to/file.txt").should == 'file.txt'
-    Dotify::Files.filename("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::Config.stub(:home).and_return '/home'
-      Dotify::Files.dotfile(".vimrc").should == '/home/.vimrc'
-      Dotify::Files.dotfile("/spec/home/.bashrc").should == '/home/.bashrc'
+    let(:home_files) {
+      [
+        @bashrc = double('unit1', :filename => '.bashrc', :added? => true, :linked? => false),
+        @gitconfig = double('unit2', :filename => '.gitconfig', :added? => false, :linked? => false),
+        @vimrc = double('unit3', :filename => '.vimrc', :added? => true, :linked? => true),
+      ]
+    }
+    describe "methods" do
+      %w[all linked unlinked uninstalled].each do |name|
+        it "should respond to #{name}" do
+          Files.should respond_to name
+        end
+      end
     end
-  end
 
-  describe Dotify::Files, "#dotify" do
-    it "should return the path to the file when it is linked in the root" do
-      Dotify::Config.stub(:path).and_return '/tmp'
-      Dotify::Files.dotify(".vimrc").should == '/tmp/.vimrc'
-      Dotify::Files.dotify("/spec/home/.bashrc").should == '/tmp/.bashrc'
+    describe Files, "#all" do
+      it "should pull the right files from List.home" do
+        files = [stub, stub, stub]
+        List.stub(:home).and_return files
+        Files.all.should == files
+      end
     end
-  end
 
-  describe Dotify::Files, "#linked" do
-    before do
-      Dotify::FileList.stub(:dotify) do
-        ['/spec/test/.bash_profile', '/spec/test/.bashrc', '/spec/test/.zshrc']
+    describe Files, "#linked" do
+      before do
+        Files.stub(:all).and_return home_files
+      end
+      let(:filenames) { Files.linked }
+      it "should return the right Units" do
+        filenames.should include @vimrc
+        filenames.should_not include @gitconfig
+        filenames.should_not include @bashrc
+      end
+      it "should yield the correct Units" do
+        expect { |b| Files.linked(&b) }.to yield_successive_args(*filenames)
       end
     end
-    let!(:files) { Dotify::Files.linked }
-    it "should return the list of dotfiles in the dotify path" do
-      files.map! { |f| Dotify::Files.filename(f) }
-      files.should include '.bash_profile'
-      files.should include '.bashrc'
-      files.should include '.zshrc'
-    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.linked(&b) }.to yield_successive_args(*yields)
-    end
-  end
 
-  describe Dotify::Files, "#unlinked" do
-    before do
-      Dotify::Files.stub(:linked) do
-        ['/spec/test/.vimrc', '/spec/test/.bashrc', '/spec/test/.zshrc']
+    describe Files, "#unlinked" do
+      before do
+        Files.stub(:all).and_return home_files
       end
-      Dotify::Files.stub(:installed) do
-        ['/root/test/.bashrc', '/root/test/.zshrc']
+      let(:filenames) { Files.unlinked }
+      it "should return the right Units" do
+        filenames.should include @gitconfig
+        filenames.should include @bashrc
+        filenames.should_not include @vimrc
+      end
+      it "should yield the correct Units" do
+        expect { |b| Files.unlinked(&b) }.to yield_successive_args(*filenames)
       end
     end
-    it "should return the list of unlinked dotfiles in the root path" do
-      unlinked = Dotify::Files.unlinked.map { |u| Dotify::Files.filename(u) }
-      unlinked.should include '.vimrc'
-      unlinked.should_not include '.bashrc'
-    end
-    it "shoud yield the unlinked files if a block is given" do
-      unlinked = Dotify::Files.unlinked.map { |u| [u, Dotify::Files.filename(u)] }
-      expect { |b| Dotify::Files.unlinked(&b) }.to yield_successive_args(*unlinked)
-    end
-  end
 
-  describe Dotify::Files, "#installed" do
-    before do
-      Dotify::Files.stub(:linked) do
-        %w[/spec/test/.zshrc /spec/test/.bashrc /spec/test/.vimrc /spec/test/.dotify]
+    describe Files, "#uninstalled" do
+      before do
+        Files.stub(:all).and_return home_files
       end
-      Dotify::FileList.stub(:home) do
-        %w[/root/test/.bashrc /root/test/.vimrc]
+      let(:filenames) { Files.uninstalled }
+      it "should return the right Units" do
+        filenames.should include @gitconfig
+        filenames.should_not include @bashrc
+        filenames.should_not include @vimrc
+      end
+      it "should yield the correct Units" do
+        expect { |b| Files.uninstalled(&b) }.to yield_successive_args(*filenames)
       end
     end
-    it "should return the list of installed dotfiles in the root path" do
-      installed = Dotify::Files.installed.map { |i| Dotify::Files.filename(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.filename(i)] }
-      expect { |b| Dotify::Files.installed(&b) }.to yield_successive_args(*installed)
+
+    it "should split a filename correct" do
+      Files.filename("some/random/path/to/file.txt").should == 'file.txt'
+      Files.filename("another/path/no_extension").should == 'no_extension'
     end
-  end
 
-  describe Dotify::Files, "#uninstalled" do
-    before do
-      Dotify::Files.stub(:linked) do
-        %w[/spec/test/.zshrc /spec/test/.bashrc /spec/test/.vimrc /spec/test/.dotify]
+    describe Files, "#home" do
+      it "should point to the home directory" do
+        Files.home.should == '/tmp/home'
       end
-      Dotify::FileList.stub(:home) do
-        %w[/root/test/.zshrc /root/test/.bashrc /root/test/.pryrc /root/test/.dropbox]
+      it "should return a absolute path to the file in the home directory" do
+        Files.home(".vimrc").should == '/tmp/home/.vimrc'
+        Files.home("/spec/home/.bashrc").should == '/tmp/home/.bashrc'
       end
     end
-    it "should return the list of uninstalled dotfiles in the root path" do
-      uninstalled = Dotify::Files.uninstalled.map { |i| Dotify::Files.filename(i) }
-      uninstalled.should_not include '.zshrc'
-      uninstalled.should_not include '.bashrc'
-      uninstalled.should include '.pryrc'
-      uninstalled.should include '.dropbox'
-    end
-    it "shoud yield the installed files if a block is given" do
-      uninstalled = Dotify::Files.uninstalled.map { |i| [i, Dotify::Files.filename(i)] }
-      expect { |b| Dotify::Files.uninstalled(&b) }.to yield_successive_args(*uninstalled)
-    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
+    describe Files, "#dotify" do
+      it "should point to the Dotify directory" do
+        Files.dotify.should == '/tmp/home/.dotify'
+      end
+      it "should return a absolute path to the file in Dotify" do
+        Files.dotify(".vimrc").should == '/tmp/home/.dotify/.vimrc'
+        Files.dotify("/spec/home/.bashrc").should == '/tmp/home/.dotify/.bashrc'
+      end
     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::Config.path, ".vimrc")
-      FileUtils.should_receive(:ln_s).with(Dotify::Files.filename(first), Dotify::Config.home).once
-      Dotify::Files.link_dotfile first
+    describe Files, "#link_dotfile" do
+      it "should receive a file and link it into the root path" do
+        first = File.join(Config.path, ".vimrc")
+        FileUtils.should_receive(:ln_s).with(Files.filename(first), Config.home).once
+        Files.link_dotfile first
+      end
     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.filename(first))).once
-      Dotify::Files.unlink_dotfile first
-      FileUtils.unstub(:rm_rf)
+    describe 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(Config.home, Files.filename(first))).once
+        Files.unlink_dotfile first
+        FileUtils.unstub(:rm_rf)
+      end
     end
   end
 end