polka 0.0.0

data/.gitignore

@@ -0,0 +1 @@
+Guardfile

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+
+gem "thor"
+gem "colorize"
+
+group :development, :test do
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,22 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    colorize (0.5.8)
+    diff-lcs (1.1.3)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.2)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.2)
+    thor (0.16.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  colorize
+  rspec
+  thor

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Michi Huber
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/bin/polka

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "thor"
+require "polka"
+
+Polka::Cli.start

data/lib/polka/bootstrapper.rb

@@ -0,0 +1,99 @@
+module Polka
+  class Bootstrapper
+    def initialize(home_dir, dotfile_dir)
+      @home_dir = home_dir
+      @dotfile_dir = dotfile_dir
+      DotfileGroup.all_files = dotfiles_in_dotfile_dir
+
+      symlinking = lambda { |dest, src| FileUtils.ln_s(dest, src) }
+      copying = lambda { |dest, src| FileUtils.cp(dest, src) }
+
+      @symlink = DotfileGroup.new(symlinking, "  Symlinking files".light_blue)
+      @copy = DotfileGroup.new(copying, "  Copying files".light_blue)
+      @parsed_copy = DotfileGroup.new(Operations::ParsedCopying, "  Parsing and copying files".light_blue)
+      @inclusive_groups = [@symlink, @copy, @parsed_copy]
+      @exclude = DotfileGroup.new
+      exclude("Dotfile")
+    end
+
+    def self.from_dotfile(dotfile, home_dir)
+      bootstrapper = new(home_dir, File.expand_path(File.dirname(dotfile)))
+      bootstrapper.instance_eval(dotfile.read)
+
+      return bootstrapper
+    end
+
+    # TODO: the structure of copy and the rest is the same,
+    # refactor into one method?
+    [:symlink, :exclude].each do |var|
+      define_method(var) do |*files|
+        group = instance_variable_get("@#{var}")
+        if file_with_options?(files)
+          add_file_with_options_to_group(files, group)
+        else
+          group.add_all_other_files if files.delete(:all_other_files)
+          add_files_to_group(files, group)
+        end
+      end
+    end
+
+    def copy(*files)
+      if file_with_options?(files)
+        group = erb?(files[0]) ? @parsed_copy : @copy
+        add_file_with_options_to_group(files, group)
+      else
+        error_msg  = "Cannot copy :all_other_files, please copy files explicitly."
+        raise ArgumentError, error_msg if files.include?(:all_other_files)
+
+        erb = files.select { |fn| erb?(fn) }
+        not_erb = files - erb
+        add_files_to_group(not_erb, @copy)
+        erb_dotfiles = erb.map { |erbfile| create_dotfile(erbfile, File.basename(erbfile, '.erb')) }
+        @parsed_copy.add(erb_dotfiles) unless erb_dotfiles.empty?
+      end
+    end
+
+    def setup
+      Polka.log "\nStarting Dotfile Setup with Polka...\n".green
+      @inclusive_groups.each(&:setup)
+      Polka.log "\nSetup completed. Enjoy!\n".green
+    end
+
+    private
+    def add_files_to_group(files, group)
+      dotfiles = files.map { |fn| create_dotfile(fn) }
+      group.add(dotfiles) unless dotfiles.empty?
+    end
+
+    def add_file_with_options_to_group(file_with_options, group)
+      filename = file_with_options[0]
+      homename = file_with_options[1][:as]
+
+      group.add([create_dotfile(filename, homename)])
+    end
+
+    def erb?(filename)
+      filename =~ /\.erb$/
+    end
+
+    def file_with_options?(files)
+      return false unless files.size == 2 && files.last.class == Hash && files.last[:as]
+      unless files[0] == :all_other_files
+        return true
+      else
+        raise ArgumentError, "Cannot add :all_other_files with :as options"
+      end
+    end
+
+    def dotfiles_in_dotfile_dir
+      files = Dir.new(@dotfile_dir).entries - %w(.. .)
+      files.map { |fn| create_dotfile(fn) }
+    end
+
+    def create_dotfile(filename, homename=nil)
+      dotfile_path = File.join(@dotfile_dir, filename)
+      home_path = File.join(@home_dir, homename || filename)
+      Dotfile.new(dotfile_path, home_path)
+    end
+  end
+end

data/lib/polka/cli.rb

@@ -0,0 +1,12 @@
+module Polka
+  class Cli < Thor
+    desc "setup", "sets up your dotfiles according to the instructions in Dotfile"
+    def setup(home_dir=nil, dotfile_dir=nil)
+      dotfile_path = dotfile_dir ? File.join(dotfile_dir, "Dotfile") : "Dotfile"
+      home_path = home_dir || ENV['HOME']
+      dotfile_path = File.expand_path(dotfile_path)
+      home_path = File.expand_path(home_path)
+      File.open(dotfile_path) { |the_dotfile| Bootstrapper.from_dotfile(the_dotfile, home_path).setup }
+    end
+  end
+end

data/lib/polka/dotfile.rb

@@ -0,0 +1,39 @@
+class FileNotPresentError < StandardError; end
+
+class Dotfile
+  def initialize(path, home_path)
+    raise FileNotPresentError, "Could not find file at #{path}." unless File.exists?(path)
+    @path = path
+    @home_path = home_path
+  end
+
+  def setup(operation)
+    backup if File.exists?(@home_path)
+    operation.call(@path, @home_path)
+    Polka.log "    #{@path} set up as #{@home_path}"
+  end
+
+  def backup
+    Polka.log "    Backing up: ".light_yellow + "#{@home_path} => #{backup_dir}"
+    FileUtils.mkdir_p(backup_dir) unless File.exists?(backup_dir)
+    FileUtils.mv(@home_path, backup_dir)
+  end
+
+  def hash
+    @path.hash
+  end
+
+  def eql?(other)
+    hash == other.hash
+  end
+
+  def self.backup_dir(home_path)
+    dir = File.join(".polka_backup", Time.now.strftime("%F_%T"))
+    @@backup_dir ||= File.join(home_path, dir)
+  end
+
+  private
+  def backup_dir
+    Dotfile.backup_dir(File.dirname(@home_path))
+  end
+end

data/lib/polka/dotfile_group.rb

@@ -0,0 +1,50 @@
+class AllOtherFilesAlreadyAdded < StandardError; end
+class FileAlreadyAddedError < StandardError; end
+
+class DotfileGroup
+  @@all_files = []
+  @@grouped_files = []
+  @@all_other_files_added = false
+
+  def self.all_files=(files)
+    @@all_files = files
+    @@grouped_files = []
+    @@all_other_files_added = false
+  end
+
+  def self.remaining_files
+    @@all_files - @@grouped_files
+  end
+
+  def initialize(operation=nil, setup_msg=nil)
+    @operation = operation
+    @setup_message = setup_msg
+    @files = []
+    @all_other_files = false
+  end
+
+  def add(new_files)
+    raise FileAlreadyAddedError if new_files.any? { |f| @@grouped_files.include?(f) }
+    @@grouped_files += new_files
+    @files += new_files
+  end
+
+  def add_all_other_files
+    raise AllOtherFilesAlreadyAdded if @@all_other_files_added
+    @@all_other_files_added = true
+    @all_other_files = true
+  end
+
+  def files
+    if @all_other_files
+      DotfileGroup.remaining_files + @files
+    else
+      @files
+    end
+  end
+
+  def setup
+    Polka.log @setup_message unless files.empty?
+    files.each { |f| f.setup(@operation) }
+  end
+end

data/lib/polka/operations/parsed_copying.rb

@@ -0,0 +1,49 @@
+module Polka
+  module Operations
+    class ParsedCopying
+      def self.call(file, dest)
+        copier = new(file, dest)
+        copier.run
+      end
+
+      def initialize(file, dest)
+        @file = file
+        @dest = dest
+      end
+
+      def run
+        write(result)
+      end
+
+      private
+      def result
+        personal = context
+        erb.result(binding)
+      end
+
+      def write(result)
+        File.open(dest_without_erb, "w") { |f| f.write(result) }
+      end
+
+      def dest_without_erb
+        @dest.gsub(/\.erb$/, "")
+      end
+
+      def yaml_file
+        File.join(File.dirname(@file), 'personal.yml')
+      end
+
+      def context_name
+        File.basename(@file, ".erb")
+      end
+
+      def context
+        YAML.load_file(yaml_file)[context_name]
+      end
+
+      def erb
+        ERB.new(File.open(@file) { |f| f.read })
+      end
+    end
+  end
+end

data/lib/polka/version.rb

@@ -0,0 +1,3 @@
+module Polka
+  VERSION = '0.0.0'
+end

data/lib/polka.rb

@@ -0,0 +1,17 @@
+require "yaml"
+require "erb"
+
+require "thor"
+require "colorize"
+
+require_relative "polka/cli"
+require_relative "polka/bootstrapper"
+require_relative "polka/dotfile"
+require_relative "polka/dotfile_group"
+require_relative "polka/operations/parsed_copying"
+
+module Polka
+  def self.log(msg)
+    puts msg
+  end
+end

data/polka.gemspec

@@ -0,0 +1,22 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'polka/version'
+
+Gem::Specification.new do |s|
+  s.name        = "polka"
+  s.version     = Polka::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Michi Huber"]
+  s.email       = ["michi.huber@gmail.com"]
+  s.homepage    = "http://github.com/michihuber/polka"
+  s.summary     = ""
+  s.description = "Easy Dotfile Management"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "thor", ">=0.16.0"
+  s.add_dependency "colorize", "0.5.8"
+  s.add_development_dependency 'rspec', '~> 2.11'
+end

data/spec/polka/bootstrapper_spec.rb

@@ -0,0 +1,101 @@
+require 'colorize'
+require_relative "../../lib/polka/bootstrapper.rb"
+class Dotfile; end
+class DotfileGroup; end
+module Operations
+  class ParsedCopying; end
+end
+
+describe Polka::Bootstrapper do
+  subject(:bs) { Polka::Bootstrapper.new('home', 'home/.polka') }
+  let(:copy_group) { double(:copies) }
+  let(:symlink_group) { double(:symlinks) }
+  let(:excluded_group) { double(:excluded) }
+  let(:parsed_copy_group) { double(:parsed_copy) }
+
+  before do
+    Dir.stub(:new) { double(entries: %w(. .. blah)) }
+    blah_dotfile = double
+    the_dotfile = double(:Dotfile)
+    Dotfile.should_receive(:new).with('home/.polka/blah', 'home/blah').and_return(blah_dotfile)
+    Dotfile.should_receive(:new).with('home/.polka/Dotfile', 'home/Dotfile').and_return(the_dotfile)
+    excluded_group.should_receive(:add).with([the_dotfile])
+    DotfileGroup.should_receive(:all_files=).with([blah_dotfile])
+    DotfileGroup.stub(:new).and_return(symlink_group, copy_group, parsed_copy_group, excluded_group)
+  end
+
+  describe "#setup" do
+    it "sets up the symlink group" do
+      Polka.stub(:log)
+      copy_group.should_receive(:setup)
+      symlink_group.should_receive(:setup)
+      parsed_copy_group.should_receive(:setup)
+      bs.setup
+    end
+  end
+
+  describe "#symlink, #exclude, #copy" do
+    describe "addings files without options" do
+      let(:hello_dotfile) { double(:hello_dotfile) }
+      before { Dotfile.stub(:new) { hello_dotfile } }
+
+      it "adds to the symlink group" do
+        symlink_group.should_receive(:add).with([hello_dotfile])
+        bs.symlink "hello"
+      end
+
+      it "adds to the exclude group" do
+        excluded_group.should_receive(:add).with([hello_dotfile])
+        bs.exclude "hello"
+      end
+
+      describe "#copy" do
+        it "cannot copy :all_other_files" do
+          expect { bs.copy :all_other_files }.to raise_error(ArgumentError)
+        end
+
+        it "can copy files with aliases" do
+          alias_dotfile = double(:alias_dotfile)
+          Dotfile.should_receive(:new).with("home/.polka/hello", "home/ciao").and_return(alias_dotfile)
+          copy_group.should_receive(:add).with([alias_dotfile])
+          bs.copy("hello", as: "ciao")
+        end
+
+        it "adds to the copy group" do
+          copy_group.should_receive(:add).with([hello_dotfile])
+          bs.copy "hello"
+        end
+
+        it "adds to the parsed_copy group if file has erb extension (without extension on target)" do
+          Dotfile.should_receive(:new).with("home/.polka/hello.erb", "home/hello").and_return(hello_dotfile)
+          parsed_copy_group.should_receive(:add).with([hello_dotfile])
+          bs.copy "hello.erb"
+        end
+      end
+    end
+
+    describe ":all_other_files" do
+      it "adds :all_other_files" do
+        symlink_group.should_receive(:add_all_other_files)
+        bs.symlink :all_other_files
+      end
+
+      it "adds :all_other_files" do
+        excluded_group.should_receive(:add_all_other_files)
+        bs.exclude :all_other_files
+      end
+
+      it "cannot add :all_other_files with an alias" do
+        expect { bs.symlink(:all_other_files, as: 'something') }.to raise_error(ArgumentError)
+      end
+    end
+
+    it "adds file with home_dir_path if specified" do
+      alias_dotfile = double(:alias_dotfile)
+      Dotfile.should_receive(:new).with("home/.polka/.testrc", "home/.onerc").and_return(alias_dotfile)
+      symlink_group.should_receive(:add).with([alias_dotfile])
+      bs.symlink(".testrc", as: ".onerc")
+    end
+  end
+end
+

data/spec/polka/cli_spec.rb

@@ -0,0 +1,26 @@
+require "thor"
+require_relative "../../lib/polka/cli.rb"
+class Polka::Bootstrapper; end
+
+describe Polka::Cli do
+  describe "#setup" do
+    let(:the_dotfile) { double }
+    let(:bootstrapper) { double(:bootstrapper, setup: "works") }
+
+    it "initializes a bootstrapper with the Dotfile (and the target dir)" do
+      File.stub(:open).and_yield(the_dotfile)
+      Polka::Bootstrapper.should_receive(:from_dotfile).with(the_dotfile, File.expand_path(ENV['HOME'])).and_return(bootstrapper)
+      bootstrapper.setup.should == "works"
+
+      Polka::Cli.new.setup
+    end
+
+    it "accepts home_dir and dotfile_dir as optional arguments" do
+      File.stub(:open).and_yield(the_dotfile)
+      Polka::Bootstrapper.should_receive(:from_dotfile).with(the_dotfile, File.expand_path("home")).and_return(bootstrapper)
+      bootstrapper.setup.should == "works"
+
+      Polka::Cli.new.setup("home", "home/.polka")
+    end
+  end
+end

data/spec/polka/dotfile_group_spec.rb

@@ -0,0 +1,38 @@
+require_relative "../../lib/polka/dotfile_group.rb"
+
+describe DotfileGroup do
+  subject(:group) { DotfileGroup.new }
+  1.upto(3) { |n| fn = "file#{n}".to_sym; let(fn) { double(fn) } }
+
+  before do
+    DotfileGroup.all_files = [file1, file2, file3]
+  end
+
+  describe "#add" do
+    it "adds dotfiles" do
+      group.add([file1, file2])
+      group.files.should == [file1, file2]
+    end
+
+    it "can only add each file once" do
+      group.add([file1])
+      expect { group.add([file1]) }.to raise_error(FileAlreadyAddedError)
+    end
+  end
+
+  describe "#add_all_other_files" do
+    let(:other_group) { DotfileGroup.new }
+
+    it "adds all other files to the group" do
+      group.add([file1])
+      group.add_all_other_files
+      other_group.add([file3])
+      group.files.should == [file2, file1]
+    end
+
+    it "can only be called once" do
+      group.add_all_other_files
+      expect {other_group.add_all_other_files }.to raise_error(AllOtherFilesAlreadyAdded)
+    end
+  end
+end

data/spec/polka/dotfile_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe Dotfile do
+  describe "#setup", :integrated_with_files do
+    set_up_testdirs
+
+    def home_path(filename)
+      File.join(home_dir, filename)
+    end
+
+    def dotfile_path(filename)
+      File.join(dotfile_dir, filename)
+    end
+
+    it "raises if dotfile does not exist" do
+      expect { Dotfile.new(dotfile_path('.testrc'), "irrelevant") }.to raise_error(FileNotPresentError)
+    end
+
+    it "yields to a given operation" do
+      Polka.stub(:log)
+      FileUtils.touch(dotfile_path('.testrc'))
+      df = Dotfile.new(dotfile_path('.testrc'), home_path('.testrc'))
+      df.setup(lambda { |dest, src| FileUtils.ln_s(dest, src) })
+      Dir.new(home_dir).entries.should == %w(. .. .dotfile_dir .testrc)
+    end
+
+    context "the homedir already contains the file" do
+      it "backs up into a backup dir" do
+        Time.stub(:now) { Time.new(2222, 2, 2, 2, 22, 22) }
+        FileUtils.touch(home_path('.testrc'))
+        FileUtils.touch(dotfile_path('.testrc'))
+        df = Dotfile.new(dotfile_path('.testrc'), home_path('.testrc'))
+        Polka.stub(:log)
+        df.setup(lambda { |a, b| FileUtils.cp(a, b) })
+        Dir.new(home_dir).entries.should == %w(. .. .dotfile_dir .polka_backup .testrc)
+        Dir.new(File.join(home_dir, '.polka_backup')).entries.should == %w(. .. 2222-02-02_02:22:22)
+      end
+    end
+  end
+
+  describe "equality" do
+    before { File.stub(:exists?) { true } }
+
+    it "regards dotfiles as equal if they share the same dotfile dir path" do
+      df1 = Dotfile.new("home/df1", "blah")
+      df2 = Dotfile.new("home/df1", "foo")
+      df1.eql?(df2).should == true
+    end
+
+    it "substracts equal dotfiles in array substraction" do
+      df1 = Dotfile.new("home/df1", "blah")
+      df2 = Dotfile.new("home/df1", "foo")
+      ([df1] - [df2]).should == []
+    end
+  end
+end

data/spec/polka/operations/parsed_copying_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Polka::Operations::ParsedCopying, :integrated_with_files do
+  set_up_testdirs
+
+  it "parses the erb file and copys the result without the extension" do
+    File.open(File.join(dotfile_dir, "blah.erb"), "w") { |f| f.write("hello <%= personal['name'] %>") }
+    File.open(File.join(dotfile_dir, "personal.yml"), "w") { |f| f.write("blah:\n  name: ray stanz") }
+
+    Polka::Operations::ParsedCopying.call(File.join(dotfile_dir, "blah.erb"), File.join(home_dir, "foo.erb"))
+    File.open(File.join(home_dir, "foo")) { |f| f.read }.should == "hello ray stanz"
+  end
+end

data/spec/polka_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe "polka", :integrated_with_files do
+  set_up_testdirs
+
+  before { Polka.stub(:log) }
+
+  it "provides a DSL to manage your dotfile setup" do
+    setup_dotfiles %w(.onerc .tworc .threerc .nodotfile copyrc)
+    setup_the_dotfile <<-EOF
+      symlink :all_other_files
+      symlink ".onerc", ".tworc"
+      copy "copyrc"
+      exclude ".nodotfile"
+    EOF
+    Cli.new.setup(home_dir, dotfile_dir)
+    dir_entries = Dir.new(home_dir).entries
+    dir_entries.should == %w(. .. .dotfile_dir .onerc .threerc .tworc copyrc)
+    File.symlink?(File.join(home_dir, '.onerc')).should == true
+    File.symlink?(File.join(home_dir, 'copyrc')).should == false
+  end
+
+  it "backs up existing files in your homedir" do
+    Time.stub(:now) { Time.new(2222, 2, 2, 2, 22, 22) }
+    setup_dotfiles %w(.onerc)
+    setup_the_dotfile("symlink '.onerc'")
+    FileUtils.touch(File.join(home_dir, '.onerc'))
+    Cli.new.setup(home_dir, dotfile_dir)
+    Dir.new(home_dir).entries.should == %w(. .. .dotfile_dir .onerc .polka_backup)
+    Dir.new(File.join(home_dir, ".polka_backup", "2222-02-02_02:22:22")).entries.should == %w(. .. .onerc)
+  end
+
+  it "copys a parsed version of erb files" do
+    setup_the_dotfile("copy '.inforc.erb'")
+    setup_file_with_content("personal.yml", ".inforc:\n  name: peter venkman")
+    setup_file_with_content(".inforc.erb", "hello <%= personal['name'] %>")
+    Cli.new.setup(home_dir, dotfile_dir)
+    File.open(File.join(home_dir, '.inforc')) { |f| f.read }.should == "hello peter venkman"
+  end
+
+  def setup_file_with_content(name, content)
+    File.open(File.join(dotfile_dir, name), "w") { |f| f.write(content) }
+  end
+
+  def setup_the_dotfile(content)
+    setup_file_with_content("Dotfile", content)
+  end
+
+  def setup_dotfiles(files)
+    files.each { |fn| FileUtils.touch(File.join(dotfile_dir, fn)) }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require_relative "../lib/polka"
+include Polka
+
+module FileSetupHelper
+  def set_up_testdirs
+    let(:home_dir) { "home_dir" }
+    let(:dotfile_dir) { "home_dir/.dotfile_dir" }
+
+    before do
+      FileUtils.mkdir(home_dir)
+      FileUtils.mkdir(dotfile_dir)
+    end
+
+    after do
+      FileUtils.rm_rf(home_dir)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.extend FileSetupHelper, :integrated_with_files
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: polka
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Michi Huber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &70162070820700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70162070820700
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: &70162070820180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.5.8
+  type: :runtime
+  prerelease: false
+  version_requirements: *70162070820180
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70162070819580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.11'
+  type: :development
+  prerelease: false
+  version_requirements: *70162070819580
+description: Easy Dotfile Management
+email:
+- michi.huber@gmail.com
+executables:
+- polka
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- bin/polka
+- lib/polka.rb
+- lib/polka/bootstrapper.rb
+- lib/polka/cli.rb
+- lib/polka/dotfile.rb
+- lib/polka/dotfile_group.rb
+- lib/polka/operations/parsed_copying.rb
+- lib/polka/version.rb
+- polka.gemspec
+- spec/polka/bootstrapper_spec.rb
+- spec/polka/cli_spec.rb
+- spec/polka/dotfile_group_spec.rb
+- spec/polka/dotfile_spec.rb
+- spec/polka/operations/parsed_copying_spec.rb
+- spec/polka_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/michihuber/polka
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: ''
+test_files:
+- spec/polka/bootstrapper_spec.rb
+- spec/polka/cli_spec.rb
+- spec/polka/dotfile_group_spec.rb
+- spec/polka/dotfile_spec.rb
+- spec/polka/operations/parsed_copying_spec.rb
+- spec/polka_spec.rb
+- spec/spec_helper.rb