homesick 1.1.5 → 2.0.0

data/lib/homesick/utils.rb

@@ -1,29 +1,14 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
 require 'pathname'
 
 module Homesick
   # Various utility methods that are used by Homesick
   module Utils
-    QUIETABLE = [:say_status]
-
-    PRETENDABLE = [:system]
-
-    QUIETABLE.each do |method_name|
-      define_method(method_name) do |*args|
-        super(*args) unless options[:quiet]
-      end
-    end
-
-    PRETENDABLE.each do |method_name|
-      define_method(method_name) do |*args|
-        super(*args) unless options[:pretend]
-      end
-    end
-
     protected
 
     def home_dir
-      @home_dir ||= Pathname.new(ENV['HOME'] || '~').realpath
+      @home_dir ||= Pathname.new(Dir.home).realpath
     end
 
     def repos_dir
@@ -36,8 +21,9 @@ module Homesick
 
     def check_castle_existance(name, action)
       return if castle_dir(name).exist?
+
       say_status :error,
-                 "Could not #{action} #{name}, expected #{castle_dir(name)} exist and contain dotfiles",
+                 "Could not #{action} #{name}, expected #{castle_dir(name)} to exist and contain dotfiles",
                  :red
       exit(1)
     end
@@ -115,7 +101,7 @@ module Homesick
     def subdir_remove(castle, path)
       subdir_filepath = subdir_file(castle)
       if subdir_filepath.exist?
-        lines = IO.readlines(subdir_filepath).delete_if do |line|
+        lines = File.readlines(subdir_filepath).delete_if do |line|
           line == "#{path}\n"
         end
         File.open(subdir_filepath, 'w') { |manfile| manfile.puts lines }
@@ -149,44 +135,48 @@ module Homesick
     end
 
     def collision_accepted?(destination, source)
-      fail "Arguments must be instances of Pathname, #{destination.class.name} and #{source.class.name} given" unless destination.instance_of?(Pathname) && source.instance_of?(Pathname)
-      options[:force] || shell.file_collision(destination) { File.binread(source) }
-    end
+      unless destination.instance_of?(Pathname) && source.instance_of?(Pathname)
+        raise 'Arguments must be instances of Pathname, ' \
+              "#{destination.class.name} and #{source.class.name} given"
+      end
 
-    def each_file(castle, basedir, subdirs)
-      absolute_basedir = Pathname.new(basedir).expand_path
-      inside basedir do
-        files = Pathname.glob('{.*,*}').reject do |a|
-          ['.', '..'].include?(a.to_s)
-        end
-        files.each do |path|
-          absolute_path = path.expand_path
-          castle_home = castle_dir(castle)
-
-          # make ignore dirs
-          ignore_dirs = []
-          subdirs.each do |subdir|
-            # ignore all parent of each line in subdir file
-            Pathname.new(subdir).ascend do |p|
-              ignore_dirs.push(p)
-            end
-          end
+      options[:force] || shell.file_collision(destination) { source }
+    end
 
-          # ignore dirs written in subdir file
-          matched = false
-          ignore_dirs.uniq.each do |ignore_dir|
-            if absolute_path == castle_home.join(ignore_dir)
-              matched = true
-              break
-            end
-          end
-          next if matched
+    def clone_from_uri(uri, destination)
+      if File.exist?(uri)
+        uri_path = Pathname.new(uri).expand_path
+        raise "Castle already cloned to #{uri_path}" if uri_path.to_s.start_with?(repos_dir.to_s)
+
+        destination = uri_path.basename if destination.nil?
+        ln_s uri_path, destination
+      elsif uri =~ GITHUB_NAME_REPO_PATTERN
+        destination = Pathname.new(uri).basename if destination.nil?
+        git_clone "https://github.com/#{Regexp.last_match[1]}.git",
+                  destination: destination
+      elsif uri =~ /%r([^%r]*?)(\.git)?\Z/ || uri =~ /[^:]+:([^:]+)(\.git)?\Z/
+        destination = Pathname.new(Regexp.last_match[1].gsub(/\.git$/, '')).basename if destination.nil?
+        git_clone uri, destination: destination
+      else
+        raise "Unknown URI format: #{uri}"
+      end
 
-          relative_dir = absolute_basedir.relative_path_from(castle_home)
-          home_path = home_dir.join(relative_dir).join(path)
+      destination
+    end
 
-          yield(absolute_path, home_path)
-        end
+    def handle_existing_track_target(castle, absolute_path, castle_path, relative_dir, file, target)
+      if absolute_path.directory?
+        move_dir_contents(target, absolute_path)
+        absolute_path.rmtree
+        subdir_remove(castle, relative_dir + file.basename)
+      elsif more_recent? absolute_path, target
+        target.delete
+        mv absolute_path, castle_path
+      else
+        say_status(:track,
+                   "#{target} already exists, and is more recent than #{file}. " \
+                   "Run 'homesick SYMLINK CASTLE' to create symlinks.",
+                   :blue)
       end
     end
 
@@ -212,5 +202,57 @@ module Homesick
 
       rc(path)
     end
+
+    def each_file(castle, basedir, subdirs)
+      absolute_basedir = Pathname.new(basedir).expand_path
+      castle_home = castle_dir(castle)
+      inside basedir do |destination_root|
+        FileUtils.cd(destination_root) unless destination_root == FileUtils.pwd
+        files = Pathname.glob('*', File::FNM_DOTMATCH)
+                        .reject { |a| ['.', '..'].include?(a.to_s) }
+                        .reject { |path| matches_ignored_dir? castle_home, path.expand_path, subdirs }
+        files.each do |path|
+          absolute_path = path.expand_path
+
+          relative_dir = absolute_basedir.relative_path_from(castle_home)
+          home_path = home_dir.join(relative_dir).join(path)
+
+          yield(absolute_path, home_path)
+        end
+      end
+    end
+
+    def matches_ignored_dir?(castle_home, absolute_path, subdirs)
+      # make ignore dirs
+      ignore_dirs = []
+      subdirs.each do |subdir|
+        # ignore all parent of each line in subdir file
+        Pathname.new(subdir).ascend do |p|
+          ignore_dirs.push(p)
+        end
+      end
+
+      # ignore dirs written in subdir file
+      ignore_dirs.uniq.each do |ignore_dir|
+        return true if absolute_path == castle_home.join(ignore_dir)
+      end
+      false
+    end
+
+    def configure_symlinks_diff
+      # Hack in support for diffing symlinks
+      # Also adds support for checking if destination or content is a directory
+      shell_metaclass = class << shell; self; end
+      shell_metaclass.send(:define_method, :show_diff) do |destination, source|
+        destination = Pathname.new(destination)
+        source = Pathname.new(source)
+        return 'Unable to create diff: destination or content is a directory' \
+          if destination.directory? || source.directory?
+        return super(destination, File.binread(source)) unless destination.symlink?
+
+        say "- #{destination.readlink}", :red, true
+        say "+ #{source.expand_path}", :green, true
+      end
+    end
   end
 end

data/lib/homesick/version.rb

@@ -1,11 +1,12 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
 module Homesick
   # A representation of Homesick's version number in constants, including a
   # String of the entire version number
   module Version
-    MAJOR = 1
-    MINOR = 1
-    PATCH = 5
+    MAJOR = 2
+    MINOR = 0
+    PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

data/lib/homesick.rb

@@ -1,9 +1,12 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
 require 'homesick/actions/file_actions'
 require 'homesick/actions/git_actions'
 require 'homesick/version'
+require 'homesick/rc'
 require 'homesick/utils'
 require 'homesick/cli'
+require 'fileutils'
 
 # Homesick's top-level module
 module Homesick
@@ -11,4 +14,19 @@ module Homesick
   SUBDIR_FILENAME = '.homesick_subdir'
 
   DEFAULT_CASTLE_NAME = 'dotfiles'
+  QUIETABLE = [:say_status].freeze
+
+  PRETENDABLE = [:system].freeze
+
+  QUIETABLE.each do |method_name|
+    define_method(method_name) do |*args|
+      super(*args) unless options[:quiet]
+    end
+  end
+
+  PRETENDABLE.each do |method_name|
+    define_method(method_name) do |*args|
+      super(*args) unless options[:pretend]
+    end
+  end
 end

data/spec/homesick_cli_spec.rb

@@ -1,4 +1,5 @@
-# -*- encoding : utf-8 -*-
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'capture-output'
 require 'pathname'
@@ -158,8 +159,8 @@ describe Homesick::CLI do
 
     it 'accepts a destination', :focus do
       expect(homesick).to receive(:git_clone)
-      .with('https://github.com/wfarr/dotfiles.git',
-            destination: Pathname.new('other-name'))
+        .with('https://github.com/wfarr/dotfiles.git',
+              destination: Pathname.new('other-name'))
 
       homesick.clone 'wfarr/dotfiles', 'other-name'
     end
@@ -168,6 +169,14 @@ describe Homesick::CLI do
   describe 'rc' do
     let(:castle) { given_castle('glencairn') }
 
+    context 'when no .homesickrc is present' do
+      it 'does nothing' do
+        expect_any_instance_of(Thor::Shell::Basic).not_to receive(:yes?)
+        expect(homesick).not_to receive(:say_status).with('eval', anything)
+        homesick.rc castle
+      end
+    end
+
     context 'when told to do so' do
       before do
         expect_any_instance_of(Thor::Shell::Basic).to receive(:yes?).with(be_a(String)).and_return(true)
@@ -246,6 +255,34 @@ describe Homesick::CLI do
       expect(home.join('bin').readlink).to eq(dotfile)
     end
 
+    context 'when a conflict exists' do
+      it 'does not replace the existing file when collision is declined' do
+        dotfile = castle.file('.some_dotfile')
+        existing = home.file('.some_dotfile', 'original content')
+
+        allow(homesick.shell).to receive(:file_collision).and_return(false)
+
+        homesick.link('glencairn')
+
+        expect(existing.symlink?).to eq(false)
+        expect(existing.read).to eq('original content')
+        _ = dotfile # ensure castle file exists
+      end
+
+      it 'replaces the existing file when collision is accepted' do
+        dotfile = castle.file('.some_dotfile')
+        existing = home.file('.some_dotfile', 'original content')
+
+        allow(homesick.shell).to receive(:file_collision).and_return(true)
+
+        homesick.link('glencairn')
+
+        expect(home.join('.some_dotfile').symlink?).to eq(true)
+        expect(home.join('.some_dotfile').readlink).to eq(dotfile)
+        _ = existing # ensure conflicting file was created
+      end
+    end
+
     context 'when forced' do
       let(:homesick) { Homesick::CLI.new [], force: true }
 
@@ -331,6 +368,32 @@ describe Homesick::CLI do
         expect(home.join('.some_dotfile').readlink).to eq(dotfile)
       end
     end
+
+    context 'when call and some files conflict' do
+      it 'shows differences for conflicting text files' do
+        contents = { castle: 'castle has new content', home: 'home already has content' }
+
+        dotfile = castle.file('text')
+        File.write(dotfile.to_s, contents[:castle])
+        File.write(home.join('text').to_s, contents[:home])
+        message = Capture.stdout { homesick.shell.show_diff(home.join('text'), dotfile) }
+        expect(message.b).to match(/- ?#{contents[:home]}\n.*\+ ?#{contents[:castle]}$/m)
+      end
+      it 'shows message or differences for conflicting binary files' do
+        # content which contains NULL character, without any parentheses, braces, ...
+        contents = { castle: (0..255).step(30).map(&:chr).join, home: (0..255).step(30).reverse_each.map(&:chr).join }
+
+        dotfile = castle.file('binary')
+        File.write(dotfile.to_s, contents[:castle])
+        File.write(home.join('binary').to_s, contents[:home])
+        message = Capture.stdout { homesick.shell.show_diff(home.join('binary'), dotfile) }
+        if homesick.shell.is_a?(Thor::Shell::Color)
+          expect(message.b).to match(/- ?#{contents[:home]}\n.*\+ ?#{contents[:castle]}$/m)
+        elsif homesick.shell.is_a?(Thor::Shell::Basic)
+          expect(message.b).to match(/^Binary files .+ differ$/)
+        end
+      end
+    end
   end
 
   describe 'unlink' do
@@ -446,7 +509,7 @@ describe Homesick::CLI do
       some_rc_file = home.file '.some_rc_file'
       homesick.track(some_rc_file.to_s, 'castle_repo')
       text = Capture.stdout { homesick.status('castle_repo') }
-      expect(text).to match(%r{Changes to be committed:.*new file:\s*home\/.some_rc_file}m)
+      expect(text).to match(%r{Changes to be committed:.*new file:\s*home/.some_rc_file}m)
     end
   end
 
@@ -498,9 +561,9 @@ describe Homesick::CLI do
 
     it 'prints an error message when trying to pull a non-existant castle' do
       expect(homesick).to receive('say_status').once
-        .with(:error,
-              /Could not pull castle_repo, expected .* exist and contain dotfiles/,
-              :red)
+                                               .with(:error,
+                                                     /Could not pull castle_repo, expected .* to exist and contain dotfiles/,
+                                                     :red)
       expect { homesick.pull 'castle_repo' }.to raise_error(SystemExit)
     end
 
@@ -510,9 +573,9 @@ describe Homesick::CLI do
         given_castle('glencairn')
         allow(homesick).to receive(:system).exactly(2).times.with('git pull --quiet')
         allow(homesick).to receive(:system).exactly(2).times
-          .with('git submodule --quiet init')
+                                           .with('git submodule --quiet init')
         allow(homesick).to receive(:system).exactly(2).times
-          .with('git submodule --quiet update --init --recursive >/dev/null 2>&1')
+                                           .with('git submodule --quiet update --init --recursive >/dev/null 2>&1')
         Capture.stdout do
           Capture.stderr { homesick.invoke 'pull', [], all: true }
         end
@@ -529,7 +592,7 @@ describe Homesick::CLI do
 
     it 'prints an error message when trying to push a non-existant castle' do
       expect(homesick).to receive('say_status').once
-        .with(:error, /Could not push castle_repo, expected .* exist and contain dotfiles/, :red)
+                                               .with(:error, /Could not push castle_repo, expected .* to exist and contain dotfiles/, :red)
       expect { homesick.push 'castle_repo' }.to raise_error(SystemExit)
     end
   end
@@ -681,23 +744,21 @@ describe Homesick::CLI do
     it "cd's to the root directory of the given castle" do
       given_castle('castle_repo')
       expect(homesick).to receive('inside').once.with(kind_of(Pathname)).and_yield
-      expect(homesick).to receive('system').once.with(ENV['SHELL'])
+      expect(homesick).to receive('system').once.with(ENV.fetch('SHELL', nil))
       Capture.stdout { homesick.cd 'castle_repo' }
     end
 
     it 'returns an error message when the given castle does not exist' do
       expect(homesick).to receive('say_status').once
-        .with(:error, /Could not cd castle_repo, expected .* exist and contain dotfiles/, :red)
+                                               .with(:error, /Could not cd castle_repo, expected .* to exist and contain dotfiles/, :red)
       expect { homesick.cd 'castle_repo' }.to raise_error(SystemExit)
     end
   end
 
   describe 'open' do
     it 'opens the system default editor in the root of the given castle' do
-      # Make sure calls to ENV use default values for most things...
-      allow(ENV).to receive(:[]).and_call_original
       # Set a default value for 'EDITOR' just in case none is set
-      allow(ENV).to receive(:[]).with('EDITOR').and_return('vim')
+      allow(ENV).to receive(:fetch).with('EDITOR', nil).and_return('vim')
       given_castle 'castle_repo'
       expect(homesick).to receive('inside').once.with(kind_of(Pathname)).and_yield
       expect(homesick).to receive('system').once.with('vim .')
@@ -706,17 +767,17 @@ describe Homesick::CLI do
 
     it 'returns an error message when the $EDITOR environment variable is not set' do
       # Set the default editor to make sure it fails.
-      allow(ENV).to receive(:[]).with('EDITOR').and_return(nil)
+      allow(ENV).to receive(:fetch).with('EDITOR', nil).and_return(nil)
       expect(homesick).to receive('say_status').once
-        .with(:error, 'The $EDITOR environment variable must be set to use this command', :red)
+                                               .with(:error, 'The $EDITOR environment variable must be set to use this command', :red)
       expect { homesick.open 'castle_repo' }.to raise_error(SystemExit)
     end
 
     it 'returns an error message when the given castle does not exist' do
       # Set a default just in case none is set
-      allow(ENV).to receive(:[]).with('EDITOR').and_return('vim')
+      allow(ENV).to receive(:fetch).with('EDITOR', nil).and_return('vim')
       allow(homesick).to receive('say_status').once
-        .with(:error, /Could not open castle_repo, expected .* exist and contain dotfiles/, :red)
+                                              .with(:error, /Could not open castle_repo, expected .* to exist and contain dotfiles/, :red)
       expect { homesick.open 'castle_repo' }.to raise_error(SystemExit)
     end
   end
@@ -735,7 +796,7 @@ describe Homesick::CLI do
     it 'executes a single command with no arguments inside a given castle' do
       allow(homesick).to receive('inside').once.with(kind_of(Pathname)).and_yield
       allow(homesick).to receive('say_status').once
-        .with(be_a(String), be_a(String), :green)
+                                              .with(be_a(String), be_a(String), :green)
       allow(homesick).to receive('system').once.with('ls')
       Capture.stdout { homesick.exec 'castle_repo', 'ls' }
     end
@@ -743,14 +804,14 @@ describe Homesick::CLI do
     it 'executes a single command with arguments inside a given castle' do
       allow(homesick).to receive('inside').once.with(kind_of(Pathname)).and_yield
       allow(homesick).to receive('say_status').once
-        .with(be_a(String), be_a(String), :green)
+                                              .with(be_a(String), be_a(String), :green)
       allow(homesick).to receive('system').once.with('ls -la')
       Capture.stdout { homesick.exec 'castle_repo', 'ls', '-la' }
     end
 
     it 'raises an error when the method is called without a command' do
       allow(homesick).to receive('say_status').once
-        .with(:error, be_a(String), :red)
+                                              .with(:error, be_a(String), :red)
       allow(homesick).to receive('exit').once.with(1)
       Capture.stdout { homesick.exec 'castle_repo' }
     end
@@ -758,9 +819,9 @@ describe Homesick::CLI do
     context 'pretend' do
       it 'does not execute a command when the pretend option is passed' do
         allow(homesick).to receive('say_status').once
-          .with(be_a(String), match(/.*Would execute.*/), :green)
+                                                .with(be_a(String), match(/.*Would execute.*/), :green)
         expect(homesick).to receive('system').never
-        Capture.stdout { homesick.invoke 'exec', %w(castle_repo ls -la), pretend: true }
+        Capture.stdout { homesick.invoke 'exec', %w[castle_repo ls -la], pretend: true }
       end
     end
 
@@ -768,8 +829,8 @@ describe Homesick::CLI do
       it 'does not print status information when quiet is passed' do
         expect(homesick).to receive('say_status').never
         allow(homesick).to receive('system').once
-          .with('ls -la')
-        Capture.stdout { homesick.invoke 'exec', %w(castle_repo ls -la), quiet: true }
+                                            .with('ls -la')
+        Capture.stdout { homesick.invoke 'exec', %w[castle_repo ls -la], quiet: true }
       end
     end
   end
@@ -783,7 +844,7 @@ describe Homesick::CLI do
     it 'executes a command without arguments inside the root of each cloned castle' do
       allow(homesick).to receive('inside_each_castle').exactly(:twice).and_yield('castle_repo').and_yield('another_castle_repo')
       allow(homesick).to receive('say_status').at_least(:once)
-        .with(be_a(String), be_a(String), :green)
+                                              .with(be_a(String), be_a(String), :green)
       allow(homesick).to receive('system').at_least(:once).with('ls')
       Capture.stdout { homesick.exec_all 'ls' }
     end
@@ -791,14 +852,14 @@ describe Homesick::CLI do
     it 'executes a command with arguments inside the root of each cloned castle' do
       allow(homesick).to receive('inside_each_castle').exactly(:twice).and_yield('castle_repo').and_yield('another_castle_repo')
       allow(homesick).to receive('say_status').at_least(:once)
-        .with(be_a(String), be_a(String), :green)
+                                              .with(be_a(String), be_a(String), :green)
       allow(homesick).to receive('system').at_least(:once).with('ls -la')
       Capture.stdout { homesick.exec_all 'ls', '-la' }
     end
 
     it 'raises an error when the method is called without a command' do
       allow(homesick).to receive('say_status').once
-        .with(:error, be_a(String), :red)
+                                              .with(:error, be_a(String), :red)
       allow(homesick).to receive('exit').once.with(1)
       Capture.stdout { homesick.exec_all }
     end
@@ -806,9 +867,9 @@ describe Homesick::CLI do
     context 'pretend' do
       it 'does not execute a command when the pretend option is passed' do
         allow(homesick).to receive('say_status').at_least(:once)
-          .with(be_a(String), match(/.*Would execute.*/), :green)
+                                                .with(be_a(String), match(/.*Would execute.*/), :green)
         expect(homesick).to receive('system').never
-        Capture.stdout { homesick.invoke 'exec_all', %w(ls -la), pretend: true }
+        Capture.stdout { homesick.invoke 'exec_all', %w[ls -la], pretend: true }
       end
     end
 
@@ -816,8 +877,8 @@ describe Homesick::CLI do
       it 'does not print status information when quiet is passed' do
         expect(homesick).to receive('say_status').never
         allow(homesick).to receive('system').at_least(:once)
-          .with('ls -la')
-        Capture.stdout { homesick.invoke 'exec_all', %w(ls -la), quiet: true }
+                                            .with('ls -la')
+        Capture.stdout { homesick.invoke 'exec_all', %w[ls -la], quiet: true }
       end
     end
   end

data/spec/homesick_rc_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+require 'pathname'
+
+describe Homesick::RC::Context do
+  let(:tmpdir) { Pathname.new(Dir.mktmpdir) }
+  let(:home) { tmpdir } # satisfies spec_helper's global ENV['HOME'] hook
+  after { tmpdir.rmtree }
+
+  # RC::Context does not emit say_status; suppress the global silence! hook.
+  def silence!; end
+
+  subject(:context) { described_class.new(tmpdir) }
+
+  describe '#castle_path' do
+    it 'returns a Pathname equal to the given castle path' do
+      expect(context.castle_path).to eq(tmpdir)
+    end
+
+    it 'returns a Pathname instance' do
+      expect(context.castle_path).to be_a(Pathname)
+    end
+
+    it 'accepts a string path and coerces it to Pathname' do
+      ctx = described_class.new(tmpdir.to_s)
+      expect(ctx.castle_path).to eq(tmpdir)
+    end
+  end
+
+  describe '#run' do
+    it 'executes the given shell command and returns true on success' do
+      marker = tmpdir.join('ran')
+      result = context.run("touch #{marker}")
+      expect(result).to be(true)
+      expect(marker).to exist
+    end
+
+    it 'returns false when the command fails' do
+      result = context.run('false')
+      expect(result).to be(false)
+    end
+  end
+
+  describe 'instance_eval isolation' do
+    it 'does not expose Homesick::CLI methods to the script' do
+      # check_castle_existance is a CLI method; the context should not have it
+      expect { context.instance_eval('check_castle_existance("x", "y")', __FILE__, __LINE__) }
+        .to raise_error(NoMethodError)
+    end
+
+    it 'allows standard Ruby file operations' do
+      marker = tmpdir.join('from_script')
+      context.instance_eval { File.write(marker.to_s, 'ok') }
+      expect(marker.read).to eq('ok')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,4 @@
-require 'coveralls'
-Coveralls.wear!
+# frozen_string_literal: true
 
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))