dotrepo 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3731baa7ddeb1d596e711460693b68a99861b8f0
+  data.tar.gz: 220caf4af84fbbd39993a8374e3c77f8fcb71fd9
+SHA512:
+  metadata.gz: 245a836d8fefc3ec02827f67375d5ceff5f44387f2fc2dde11af556405a8b74a376445d7fb61a91417ffccdddfc0fe6def3537664d9a5237b2519052be0b2937
+  data.tar.gz: fe26393479992bb2016698801968dcb10791e4a9689aaf08415b7b29871558c37d1649ccad85b8e7725a0b1a76b4020c100feaeaf56bed5b65710770ee6abd92

data/bin/dotrepo

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/dotrepo/cli'
+Dotrepo::CLI.start

data/lib/dotrepo/cli.rb

@@ -0,0 +1,60 @@
+require 'thor'
+require 'dotrepo'
+
+module Dotrepo
+  class CLI < Thor
+
+    desc "version", "display version"
+    def version
+      say "Dotrepo::VERSION #{Dotrepo::VERSION}"
+    end
+
+    desc "info", "display current configuration"
+    def info
+      config = Dotrepo::ConfigFile.new
+      [:source, :destination].each do |attr|
+        shell.say_status "#{attr}:", config.send(attr), :bold
+      end
+    end
+
+    desc "setup", "setup your dotbox"
+    method_option :repo,
+                  aliases: "-r",
+                  desc: "repo to pull dotfiles from"
+    def setup
+      unless options[:repo]
+        shell.say_status "error", "you must specify a repo", :red
+        return
+      end
+
+      system "git clone #{options[:repo]} #{config.source}"
+      DotFileManager.new( config.source, config.destination ).symlink_dotfiles
+    end
+
+    desc "refresh", "update linked dotfiles"
+    def refresh
+      # runs the manager again to symlink new files & prune abandoned files
+      DotFileManager.new( config.source, config.destination ).symlink_dotfiles
+    end
+
+    dec "uninstall", "revert symlinked files to plain dotfiles"
+    def uninstall
+    end
+
+    desc "doctor", "analyze your setup for common issues"
+    def doctor
+      # do some smart checking based on info
+      # - does the source exist as a git repo
+      # - is the source up to date & free of modified files
+      # - does the source have any dotfiles
+      # - does the destination exist
+    end
+
+    private
+
+      def config
+        @_config ||= Dotrepo::ConfigFile.new
+      end
+
+  end
+end

data/lib/dotrepo/config_file.rb

@@ -0,0 +1,37 @@
+module Dotrepo
+  class ConfigFile
+    FILE_PATH = File.join( File.expand_path("~"), ".dotbox/config" )
+
+    attr_reader :data
+
+    def initialize
+      if File.exists? FILE_PATH
+        @data = defaults.merge YAML.load_file FILE_PATH
+      else
+        @data = defaults
+      end
+    end
+
+    def source
+      fetch_from_data "source"
+    end
+
+    def destination
+      fetch_from_data "destination"
+    end
+
+    private
+
+      def fetch_from_data key
+        data[key]
+      end
+
+      def defaults
+        {
+          "source"      => '~/.dotbox/box',
+          "destination" => '~/'
+        }
+      end
+
+  end
+end

data/lib/dotrepo/dot_file.rb

@@ -0,0 +1,47 @@
+module Dotrepo
+  class DotFile
+    attr_reader :path, :source, :destination
+
+    def initialize path, manager
+      @path        = path
+      @source      = File.join manager.source, path
+      @destination = File.join manager.destination, path
+    end
+
+    def source_exists?
+      File.exist? source
+    end
+
+    def destination_exists?
+      File.exist? destination
+    end
+
+    def backup_destination
+      File.rename( destination, "#{destination}.bak" )
+    end
+
+    def linked?
+      destination_exists? &&
+        File.symlink?(destination) &&
+        File.readlink(destination) == source
+    end
+
+    def symlink_to_destination
+      return if linked?
+
+      if destination_exists?
+        print "#{destination} exists. backup existing file and link? (y|n) "
+        input = $stdin.gets.chomp
+        return unless input.downcase == "y"
+
+        backup_destination
+      end
+      symlink_to_destination!
+    end
+
+    def symlink_to_destination!
+      File.symlink source, destination
+    end
+
+  end
+end

data/lib/dotrepo/dot_file_manager.rb

@@ -0,0 +1,25 @@
+module Dotrepo
+  class DotFileManager
+    attr_reader :source, :destination
+
+    def initialize source, destination
+      @source      = File.expand_path( source )
+      @destination = File.expand_path( destination )
+    end
+
+    def dotfiles
+      Dir.glob( File.join( source, '**/.*' ) )
+         .map { |f| f.sub( /#{source}\/?/, '' ) }
+         .reject { |f| f.match /.git/ }
+         .map { |path| DotFile.new( path, self ) }
+    end
+
+    def symlink_dotfiles
+      dotfiles.each do |df|
+        df.symlink_to_destination
+      end
+    end
+
+  end
+
+end

data/lib/dotrepo/version.rb

@@ -0,0 +1,3 @@
+module Dotrepo
+  VERSION = "0.0.1"
+end

data/lib/dotrepo.rb

@@ -0,0 +1,9 @@
+require 'yaml'
+
+require_relative 'dotrepo/dot_file'
+require_relative 'dotrepo/dot_file_manager'
+require_relative 'dotrepo/config_file'
+
+unless Dotrepo.const_get(:VERSION)
+  require_relative 'dotrepo/version'
+end

data/spec/lib/dotrepo/config_file_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Dotrepo::ConfigFile do
+
+  before :each do
+    allow( File ).to receive(:exists?)
+                 .with( Dotrepo::ConfigFile::FILE_PATH )
+                 .and_return( false )
+  end
+
+  describe "#initialize" do
+    it "uses data from config file if present" do
+      allow( File ).to receive(:exists?)
+                   .with( Dotrepo::ConfigFile::FILE_PATH )
+                   .and_return( true )
+
+      allow( YAML ).to receive(:load_file)
+                   .with( Dotrepo::ConfigFile::FILE_PATH )
+                   .and_return( { "source" => "source",
+                                  "destination" => "destination" })
+
+      expect( described_class.new.data ).to eq({ "source" => "source",
+                                                 "destination" => "destination" })
+    end
+
+    it "uses default data w/ no config file" do
+      expect( described_class.new.data ).to eq({ "source" => "~/.dotbox/box",
+                                                 "destination" => "~/" })
+    end
+  end
+
+  describe "#source" do
+    it "returns the 'source' from #data" do
+      expect( described_class.new.source ).to eq "~/.dotbox/box"
+    end
+  end
+
+  describe "#destination" do
+    it "returns the 'destination' from #data" do
+      expect( described_class.new.destination ).to eq "~/"
+    end
+  end
+
+end

data/spec/lib/dotrepo/dot_file_manager_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Dotrepo::DotFileManager do
+
+  after :each do
+    Given.cleanup!
+  end
+
+  describe "#initialize" do
+    it "sets given expanded source & destination" do
+      subject = Dotrepo::DotFileManager.new "source", "destination"
+
+      expect( subject.source ).to eq File.expand_path("source")
+      expect( subject.destination ).to eq File.expand_path("destination")
+    end
+  end
+
+  describe "#dotfiles" do
+    it "returns DotFiles" do
+      Given.file '.bashrc'
+      subject = Dotrepo::DotFileManager.new Given::TMP, "destination"
+
+      expect( subject.dotfiles.first ).to be_a Dotrepo::DotFile
+    end
+
+    it "returns an array of only dotfiles from source" do
+      Given.file '.bashrc'
+      Given.file 'foo_bar'
+      Given.file 'dir/.dot'
+      Given.file 'dir/file'
+      subject = Dotrepo::DotFileManager.new Given::TMP, "destination"
+
+      expect( subject.dotfiles.map { |df| df.path } ).to match_array [".bashrc","dir/.dot"]
+    end
+
+    it "ignores git related files" do
+      Given.file '.git/config'
+      Given.file '.gitignore'
+      subject = Dotrepo::DotFileManager.new Given::TMP, "destination"
+
+      expect( subject.dotfiles.map { |df| df.path } ).to be_empty
+    end
+  end
+
+  describe "#symlink_dotfiles" do
+    it "calls symlink_to_destination on each dotfile" do
+      dotfile_one = instance_double("Dotrepo::DotFile")
+      dotfile_two = instance_double("Dotrepo::DotFile")
+
+      subject = Dotrepo::DotFileManager.new "source", "destination"
+      allow( subject ).to receive(:dotfiles)
+                      .and_return [dotfile_one, dotfile_two]
+
+      expect( dotfile_one ).to receive(:symlink_to_destination)
+      expect( dotfile_two ).to receive(:symlink_to_destination)
+
+      subject.symlink_dotfiles
+    end
+  end
+
+end

data/spec/lib/dotrepo/dot_file_spec.rb

@@ -0,0 +1,248 @@
+require 'spec_helper'
+
+describe Dotrepo::DotFile do
+
+  describe "#initialize" do
+
+    let(:manager_double) {
+      instance_double("Dotrepo::DotFileManager",
+                      source: "/source",
+                      destination: "/destination" )
+    }
+    let(:subject) { Dotrepo::DotFile.new("/foo/bar", manager_double) }
+
+    it "sets the given path" do
+      expect( subject.path ).to eq "/foo/bar"
+    end
+
+    it "sets up source & destination" do
+      expect( subject.source ).to eq "/source/foo/bar"
+      expect( subject.destination ).to eq "/destination/foo/bar"
+    end
+
+  end
+
+  describe "#source_exists?" do
+
+    let(:manager_double) {
+      instance_double("Dotrepo::DotFileManager",
+                      source: "/source",
+                      destination: "/destination" )
+    }
+    let(:subject) { Dotrepo::DotFile.new("/foo/bar", manager_double) }
+
+    it "is true if source exists" do
+      allow( File ).to receive(:exist?).with("/source/foo/bar")
+                   .and_return(true)
+
+      expect( subject.source_exists? ).to be_truthy
+    end
+    it "is false if source doesn't exist" do
+      allow( File ).to receive(:exist?).with("/source/foo/bar")
+                   .and_return(false)
+
+      expect( subject.source_exists? ).to be_falsy
+    end
+  end
+
+  describe "#destination_exists?" do
+
+    let(:manager_double) {
+      double("Manager",
+              source: "/source",
+              destination: "/destination" )
+    }
+    let(:subject) { Dotrepo::DotFile.new("/foo/bar", manager_double) }
+
+    it "is true if destination exists" do
+      allow( File ).to receive(:exist?).with("/destination/foo/bar")
+                   .and_return(true)
+
+      expect( subject.destination_exists? ).to be_truthy
+    end
+    it "is false if destination doesn't exist" do
+      allow( File ).to receive(:exist?).with("/destination/foo/bar")
+                   .and_return(false)
+
+      expect( subject.destination_exists? ).to be_falsy
+    end
+  end
+
+  describe "#backup_destination" do
+    let(:manager_double) {
+      double("Manager",
+              source: "/source",
+              destination: "/destination" )
+    }
+    let(:subject) { Dotrepo::DotFile.new("/foo/bar", manager_double) }
+
+    it "moves destination file to backup name" do
+      expect( File ).to receive(:rename)
+                         .with("/destination/foo/bar", "/destination/foo/bar.bak")
+
+      subject.backup_destination
+    end
+  end
+
+  describe "linked?" do
+    let(:manager_double) {
+      double("Manager",
+              source: "/source",
+              destination: "/destination" )
+    }
+    let(:subject) { Dotrepo::DotFile.new("/foo/bar", manager_double) }
+
+
+    it "is false if destination doesn't exist" do
+      allow( File ).to receive(:exist?)
+                   .with("/destination/foo/bar")
+                   .and_return(false)
+
+      expect( subject.linked? ).to be_falsy
+    end
+
+    it "is true if destination is linked to source" do
+      allow( File ).to receive(:exist?)
+                   .with("/destination/foo/bar")
+                   .and_return(true)
+      allow( File ).to receive(:symlink?)
+                   .with("/destination/foo/bar")
+                   .and_return(true)
+      allow( File ).to receive(:readlink)
+                   .with("/destination/foo/bar")
+                   .and_return("/source/foo/bar")
+
+      expect( subject.linked? ).to be_truthy
+    end
+
+    it "is false if destination is a file" do
+      allow( File ).to receive(:exist?)
+                   .with("/destination/foo/bar")
+                   .and_return(true)
+      allow( File ).to receive(:symlink?)
+                   .with("/destination/foo/bar")
+                   .and_return(false)
+
+      expect( subject.linked? ).to be_falsy
+    end
+
+    it "is false if destination is linked not to source" do
+      allow( File ).to receive(:exist?)
+                   .with("/destination/foo/bar")
+                   .and_return(true)
+      allow( File ).to receive(:symlink?)
+                   .with("/destination/foo/bar")
+                   .and_return(true)
+      allow( File ).to receive(:readlink)
+                   .with("/destination/foo/bar")
+                   .and_return("/not/source/path")
+
+      expect( subject.linked? ).to be_falsy
+    end
+  end
+
+  describe "#symlink_to_destination!" do
+
+    let(:manager_double) {
+      double("Manager",
+              source: "/source",
+              destination: "/destination" )
+    }
+    let(:subject) { Dotrepo::DotFile.new("/foo/bar", manager_double) }
+
+    it "symlinks source to destination" do
+      expect( File ).to receive(:symlink)
+                    .with("/source/foo/bar","/destination/foo/bar")
+
+      subject.symlink_to_destination!
+    end
+  end
+
+  describe "#symlink_to_destination" do
+
+    let(:manager_double) {
+      double("Manager",
+              source: "/source",
+              destination: "/destination" )
+    }
+    let(:subject) {
+      described_class.new "foo/bar", manager_double
+    }
+
+    context "when already linked" do
+      it "skips linking" do
+        subject = described_class.new ".path", manager_double
+        allow( subject ).to receive(:linked?)
+                        .and_return(true)
+
+        expect( subject ).not_to receive(:symlink_to_destination!)
+        subject.symlink_to_destination
+      end
+    end
+
+    context "when destination exists as file" do
+
+      before :each do
+        allow( File ).to receive(:exist?).and_call_original
+        allow( File ).to receive(:exist?)
+                     .with("/destination/foo/bar")
+                     .and_return(true)
+        allow( subject ).to receive(:symlink_to_destination!) # just to kill it from trying to actually symlink anything
+      end
+
+      it "asks to backup or skip" do
+        out = CatchAndRelease::Catch.stdout do
+          CatchAndRelease::Release.stdin 'n' do
+            subject.symlink_to_destination
+          end
+        end
+
+        expect( out ).to match /^#{"/destination/foo/bar exists. backup existing file and link?"}/
+      end
+
+      context "user says skip" do
+        it "skips linking" do
+          expect( subject ).not_to receive(:symlink_to_destination!)
+
+          CatchAndRelease::Release.stdin 'n' do
+            subject.symlink_to_destination
+          end
+        end
+      end
+
+      context "user says backup" do
+        it "backs up destination file" do
+          expect( subject ).to receive(:backup_destination)
+
+          CatchAndRelease::Release.stdin 'y' do
+            subject.symlink_to_destination
+          end
+        end
+        it "symlinks to destination" do
+          allow( subject ).to receive(:backup_destination)
+          expect( subject ).to receive(:symlink_to_destination!)
+
+          CatchAndRelease::Release.stdin 'y' do
+            subject.symlink_to_destination
+          end
+        end
+      end
+    end
+
+    context "when destination doesn't exist" do
+
+      before :each do
+        allow( File ).to receive(:exist?)
+                     .with("/destination/foo/bar")
+                     .and_return(false)
+      end
+
+      it "symlinks file to destination" do
+        expect( subject ).to receive(:symlink_to_destination!)
+        subject.symlink_to_destination
+      end
+
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'rspec'
+require 'catch_and_release'
+require 'support/given'
+
+require 'pry'
+
+RSpec.configure do |c|
+  c.mock_with :rspec do |mocks|
+    mocks.verify_doubled_constant_names = true
+    mocks.verify_partial_doubles        = true
+  end
+end
+
+# for eating up stdout & stderr
+unless ENV['VERBOSE']
+  stdout  = StringIO.open('','w+')
+  $stdout = stdout
+
+  stderr  = StringIO.open('','w+')
+  $stderr = stderr
+end
+
+require 'dotrepo'

data/spec/support/given.rb

@@ -0,0 +1,28 @@
+module Given
+  ROOT = Dir.pwd
+  TMP  = File.join( Dir.pwd, 'tmp' )
+
+  class << self
+
+    def fixture name
+      cleanup!
+
+      `rsync -av ./spec/fixtures/#{name}/ #{TMP}/`
+      Dir.chdir TMP
+    end
+
+    def file name, content=''
+      file_path = File.join( TMP, name )
+      FileUtils.mkdir_p( File.dirname(file_path) )
+      File.open( file_path, 'w' ) do |file|
+        file.write content
+      end
+    end
+
+    def cleanup!
+      Dir.chdir ROOT
+      `rm -rf #{TMP}`
+    end
+
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: dotrepo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Steven Sloan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ' A simple manager for your dotfiles '
+email:
+- stevenosloan@gmail.com
+executables:
+- dotrepo
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/dotrepo
+- lib/dotrepo.rb
+- lib/dotrepo/cli.rb
+- lib/dotrepo/config_file.rb
+- lib/dotrepo/dot_file.rb
+- lib/dotrepo/dot_file_manager.rb
+- lib/dotrepo/version.rb
+- spec/lib/dotrepo/config_file_spec.rb
+- spec/lib/dotrepo/dot_file_manager_spec.rb
+- spec/lib/dotrepo/dot_file_spec.rb
+- spec/spec_helper.rb
+- spec/support/given.rb
+homepage: http://github.com/stevenosloan/dotrepo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A simple manager for your dotfiles
+test_files:
+- spec/lib/dotrepo/config_file_spec.rb
+- spec/lib/dotrepo/dot_file_manager_spec.rb
+- spec/lib/dotrepo/dot_file_spec.rb
+- spec/spec_helper.rb
+- spec/support/given.rb