dotify 0.2.0 → 0.3.0

data/lib/dotify/file_list.rb

@@ -0,0 +1,41 @@
+require 'dotify'
+require 'dotify/config'
+
+module Dotify
+  class FileList
+    class << self
+
+      def home
+        result = paths(File.join(Config.home, '.*'))
+        filter_ignore_files!(result, :dotfiles)
+      end
+
+      def dotify
+        result = paths(File.join(Config.path, '.*'))
+        filter_ignore_files!(result, :dotify)
+      end
+
+      def list(glob)
+        filenames(paths(glob))
+      end
+
+      def paths(glob)
+        filter_dot_directories!(Dir[glob])
+      end
+
+      def filter_dot_directories!(files)
+        files.select { |f| !['.', '..'].include?(Files.filename(f)) }
+      end
+
+      def filter_ignore_files!(files, ignore)
+        ignoring = Config.ignore(ignore)
+        files.select { |f| !ignoring.include?(Files.filename(f)) }
+      end
+
+      def filenames(files)
+        files.map { |f| Files.filename(f) }
+      end
+
+    end
+  end
+end

data/lib/dotify/files.rb

@@ -11,62 +11,61 @@ module Dotify
       include Thor::Actions
 
       def dots
-        @dots ||= file_list(File.join(Config.path, "/.*"))
+        @dots ||= FileList.dotify
         return @dots unless block_given?
-        @dots.each {|d| yield(d, file_name(d)) }
+        @dots.each {|d| yield(d, filename(d)) }
+      end
+
+      def unlinked
+        dots = self.dots.map { |d| filename(d) }
+        installed = self.installed.map {|i| filename(i)}
+        unlinked = (dots - 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| file_name(f) }
-        installed = file_list(File.join(Config.home, ".*")).select do |i|
-          dots.include?(file_name(i))
+        dots = self.dots.map { |f| filename(f) }
+        installed = FileList.home.select do |d|
+          dots.include?(filename(d))
         end
         return installed unless block_given?
-        installed.each {|i| yield(i, file_name(i)) }
+        installed.each {|i| yield(i, filename(i)) }
       end
 
-      def unlinked
-        dots = self.dots.map { |f| file_name(f) }
-        installed = self.installed.map {|f| file_name(f)}
-        unlinked = (dots - installed).map{|f| dotfile(f) }
-        return unlinked unless block_given?
-        unlinked.each {|u| yield(u, file_name(u)) }
+      def uninstalled
+        dots = self.dots.map { |f| filename(f) }
+        installed = FileList.home.select do |d|
+          !dots.include?(filename(d))
+        end
+        return installed unless block_given?
+        installed.each {|i| yield(i, filename(i)) }
       end
 
-      def file_name(file)
-        file.split("/").last
+      def filename(file)
+        %r{([^<>:"\/\\\|\?\*]*)\Z}.match(file).to_s
       end
 
       def template?(file)
-        file_name(file).match(/(tt|erb)$/) ? true : false
+        filename(file).match(/(tt|erb)\Z/) ? true : false
       end
 
       def dotfile(file)
-        File.join(Config.home, file_name(file))
+        File.join(Config.home, filename(file))
       end
 
       def dotify(file)
-        File.join(Config.path, file_name(file))
+        File.join(Config.path, filename(file))
       end
 
       def link_dotfile(file)
-        FileUtils.ln_s(file_name(file), Config.home) == 0 ? true : false
+        FileUtils.ln_s(filename(file), Config.home) == 0 ? true : false
       end
 
       def unlink_dotfile(file)
-        FileUtils.rm_rf File.join(Config.home, file_name(file))
+        FileUtils.rm_rf File.join(Config.home, filename(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
-
     end
   end
 end

data/lib/dotify/version.rb

@@ -1,3 +1,3 @@
 module Dotify
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/dotify/version_checker.rb

@@ -0,0 +1,29 @@
+require 'json'
+require 'net/http'
+
+module Dotify
+  class VersionChecker
+    class << self
+      def run_check!
+        if @version.nil?
+          resp = Net::HTTP.get('rubygems.org', '/api/v1/versions/dotify.json')
+          json = JSON.parse(resp)
+          @version = json.map { |v| v['number'] }.max
+        end
+        @version
+      end
+
+      def current?
+        Dotify::VERSION == self.version
+      end
+
+      def out_of_date?
+        !current?
+      end
+
+      def version
+        @version || self.run_check!
+      end
+    end
+  end
+end

data/spec/dotify/cli_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'dotify/config'
 require 'dotify/cli'
 require 'thor'
 

data/spec/dotify/config_spec.rb

@@ -3,55 +3,35 @@ 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
+  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 "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
+  describe "options" do
+    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 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
+  describe "ignore files" do
+    before do
+      Dotify::Config.stub(:config)  do
+        { :ignore => { :dotfiles => %w[.gemrc], :dotify => %w[.gitmodule] } }
+      end
+    end
+    it "should retrieve the list of dotfiles to ignore in the home directory" do
+      Dotify::Config.ignore(:dotfiles).should include '.gemrc'
+    end
+    it "should retrieve the list of dotify files to ignore" do
+      Dotify::Config.ignore(:dotify).should include '.gitmodule'
+    end
   end
 end

data/spec/dotify/file_list_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'dotify/config'
+require 'dotify/file_list'
+
+describe Dotify::FileList do
+
+  describe Dotify::FileList, "#home" do
+    before do
+      Dotify::Config.stub(:home).and_return("/home/test")
+    end
+    it "should call FileList#list with the correct path" do
+      Dotify::FileList.should_receive(:paths) \
+        .with("/home/test/.*").once \
+        .and_return(['/root/test/.vimrc', '/root/test/.bashrc', '/root/test/.zshrc'])
+      Dotify::FileList.home
+    end
+    it "should drop files that have been specified to be ignored" do
+      Dotify::FileList.stub(:paths) do
+        ['/root/test/.gitconfig', '/root/test/.vimrc', '/root/test/.bashrc', '/root/test/.zshrc']
+      end
+      Dotify::Config.stub(:ignore).with(:dotfiles).and_return %w[.zshrc .vimrc]
+      result = Dotify::FileList.home
+      result.should include '/root/test/.bashrc'
+      result.should include '/root/test/.gitconfig'
+      result.should_not include '/root/test/.zshrc'
+      result.should_not include '/root/test/.vimrc'
+    end
+  end
+
+  describe Dotify::FileList, "#dotify" do
+    it "should call FileList#list with the correct path" do
+      Dotify::Config.stub(:path).and_return("/home/test/.dotify")
+      Dotify::FileList.should_receive(:paths) \
+        .with("/home/test/.dotify/.*").once \
+        .and_return(['/spec/test/.vimrc', '/spec/test/.bashrc', '/spec/test/.zshrc'])
+      Dotify::FileList.dotify
+    end
+    it "should drop files that have been specified to be ignored" do
+      Dotify::FileList.stub(:paths) do
+        ['/dotify/test/.gitconfig', '/dotify/test/.vimrc', '/dotify/test/.bashrc', '/dotify/test/.zshrc']
+      end
+      Dotify::Config.stub(:ignore).with(:dotify).and_return %w[.gitconfig .bashrc]
+      result = Dotify::FileList.dotify
+      result.should include '/dotify/test/.vimrc'
+      result.should include '/dotify/test/.zshrc'
+      result.should_not include '/dotify/test/.bashrc'
+      result.should_not include '/dotify/test/.gitconfig'
+    end
+  end
+
+  describe Dotify::FileList, "#list" do
+    let(:glob) { '/spec/test/.*' }
+    it "should pull the glob of dotfiles from a directory" do
+      Dir.should_receive(:[]).with(glob).and_return(%w[. .. /spec/test/.vimrc /spec/test/.bashrc /spec/test/.zshrc])
+      Dotify::FileList.list(glob)
+    end
+    describe "return values" do
+      before do
+        Dir.stub(:[]).with(glob).and_return(%w[. .. /spec/test/.vimrc /spec/test/.bashrc /spec/test/.zshrc])
+      end
+      let(:files) { Dotify::FileList.list(glob) }
+      it "should return the right filenames" do
+        files.should include '.vimrc'
+        files.should include '.bashrc'
+        files.should include '.zshrc'
+      end
+      it "should filter out . and .. directories" do
+        files.should_not include '.'
+        files.should_not include '..'
+      end
+    end
+  end
+
+  describe Dotify::FileList, "#paths" do
+    let(:glob) { '/spec/test/.*' }
+    it "should pull the glob of dotfiles from a directory" do
+      Dir.should_receive(:[]).with(glob).and_return(%w[. .. /spec/test/.vimrc /spec/test/.bashrc /spec/test/.zshrc])
+      Dotify::FileList.paths(glob)
+    end
+    describe "return values" do
+      before do
+        Dir.stub(:[]).with(glob).and_return(%w[. .. /spec/test/.vimrc /spec/test/.bashrc /spec/test/.zshrc])
+      end
+      let(:files) { Dotify::FileList.paths(glob) }
+      it "should return the right directories" do
+        files.should include '/spec/test/.vimrc'
+        files.should include '/spec/test/.bashrc'
+        files.should include '/spec/test/.zshrc'
+      end
+      it "should filter out . and .. directories" do
+        files = Dotify::FileList.paths(glob)
+        files.should_not include '.'
+        files.should_not include '..'
+      end
+    end
+  end
+
+  describe Dotify::FileList, "#filenames" do
+    let(:files) { %w[/spec/test/.vimrc /spec/test/.bashrc /spec/test/.zshrc] }
+    it "should use Files#filename to change the files" do
+      Dotify::Files.should_receive(:filename).exactly(files.count).times
+      Dotify::FileList.filenames(files)
+    end
+    it "return only" do
+      result = Dotify::FileList.filenames(files)
+      result.should include '.vimrc'
+      result.should include '.bashrc'
+      result.should include '.zshrc'
+    end
+  end
+
+
+end

data/spec/dotify/files_spec.rb

@@ -4,25 +4,22 @@ 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
+  describe "methods" do
+    it "should respond to dots" do
+      Dotify::Files.should respond_to :dots
+    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 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'
+  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
@@ -41,21 +38,21 @@ describe Dotify::Files do
 
   describe Dotify::Files, "#dots" do
     before do
-      Dotify::Files.stub(:file_list) do
-        ['/spec/test/.vimrc', '/spec/test/.bashrc', '/spec/test/.zshrc']
+      Dotify::FileList.stub(:dotify) do
+        ['/spec/test/.bash_profile', '/spec/test/.bashrc', '/spec/test/.zshrc']
       end
     end
+    let!(:files) { Dotify::Files.dots }
     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
+      files.map! { |f| Dotify::Files.filename(f) }
+      files.should include '.bash_profile'
       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)
+      yields = files.map { |f| [f, Dotify::Files.filename(f)] }
+      expect { |b| Dotify::Files.dots(&b) }.to yield_successive_args(*yields)
     end
   end
 
@@ -69,35 +66,60 @@ describe Dotify::Files do
       end
     end
     it "should return the list of unlinked dotfiles in the root path" do
-      unlinked = Dotify::Files.unlinked.map { |u| Dotify::Files.file_name(u) }
+      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.file_name(u)] }
+      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
-      fake_root, dotify = Fake.paths
-      FileUtils.touch File.join(fake_root, '.vimrc')
-      FileUtils.touch File.join(fake_root, '.bashrc')
+      Dotify::Files.stub(:dots) do
+        %w[/spec/test/.zshrc /spec/test/.bashrc /spec/test/.vimrc /spec/test/.dotify]
+      end
+      Dotify::FileList.stub(:home) do
+        %w[/root/test/.bashrc /root/test/.vimrc]
+      end
     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 = 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.file_name(i)] }
+      installed = Dotify::Files.installed.map { |i| [i, Dotify::Files.filename(i)] }
       expect { |b| Dotify::Files.installed(&b) }.to yield_successive_args(*installed)
     end
   end
 
+  describe Dotify::Files, "#uninstalled" do
+    before do
+      Dotify::Files.stub(:dots) do
+        %w[/spec/test/.zshrc /spec/test/.bashrc /spec/test/.vimrc /spec/test/.dotify]
+      end
+      Dotify::FileList.stub(:home) do
+        %w[/root/test/.zshrc /root/test/.bashrc /root/test/.pryrc /root/test/.dropbox]
+      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
@@ -117,7 +139,7 @@ describe Dotify::Files do
   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.file_name(first), Dotify::Config.home).once
+      FileUtils.should_receive(:ln_s).with(Dotify::Files.filename(first), Dotify::Config.home).once
       Dotify::Files.link_dotfile first
     end
   end
@@ -125,7 +147,7 @@ describe Dotify::Files do
   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
+      FileUtils.stub(:rm_rf).with(File.join(Dotify::Config.home, Dotify::Files.filename(first))).once
       Dotify::Files.unlink_dotfile first
       FileUtils.unstub(:rm_rf)
     end