ignorance 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ignorance.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Joel Helbling
+
+MIT License
+
+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/README.md

@@ -0,0 +1,151 @@
+# Ignorance
+
+Ensures specified files are ignored by Git, Mercurial or SVN.
+
+## Use Case
+
+You've created a utility to be used by others' projects which generates
+or uses files and directories which ought not be committed/pushed/shared
+with the world.
+
+Ignorance helps your code be considerate of its users by protecting
+their sensitive information.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ignorance'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ignorance
+
+## Usage
+
+If you'd like to warn users and fellow developers to add certain artifacts
+to the project's ignore file, you can include this somewhere in your runtime:
+
+```ruby
+include Ignorance
+
+advise_ignorance '.myfile'
+```
+
+Assuming those files are not in the project's .gitignore file, when
+the code is run, your program will output the following to STDERR
+(but not halt):
+
+```
+WARNING: please add ".myfile" to this project's .gitignore file!
+```
+
+If ignoring those files is really critical, you can halt with an exception:
+
+```ruby
+guard_ignorance 'mydir/'
+```
+
+You can even prompt the user, offering to automatically add the pertinent
+files to the ignore file:
+
+```ruby
+negotiate_ignorance 'some_file.md'
+```
+
+And finally, if ignorance is absolutely critical, you can silently add
+tokens to the project's ignore file:
+
+```ruby
+guarantee_ignorance! 'mydir/'
+```
+
+You can also use Ignorance directly (with out including the module).
+Shorter method names are provided for that purpose:
+
+```ruby
+Ignorance.advise '.myfile'
+Ignorance.guard 'some_other_file.txt'
+Ignorance.negotiate 'family_phone_numbers.yaml'
+Ignorance.guarantee! 'bank_login.cfg'
+```
+
+## When Ignorance Works
+
+Ignorance works on the ignore files of any and all detected repository types.
+If .git is present, .gitignore is managed.  If .hg then .hgignore,
+if .svn, .svnignore.  For Git and Mercurial, parent directories will also
+be searched for a repository root.
+
+Ignorance does nothing when one of two conditions exist:
+
+1. All specified tokens are already ignored
+2. The current directory is not within a repository
+
+Ignorance's repo detection is based on the current working directory (e.g.
+Dir.getwd, usually the directory where the code was launched).  It presumes
+the common dev-time situation wherein a program is launched from within its
+project dir.
+
+This means that if your code uses Ignorance, and others use your code, repo
+and ignore file detection will happen relative to their project directory.
+
+## Adding a Comment
+
+The #negotiate and #guarantee! methods (and their longer counterparts)
+accept an optional comment parameter:
+
+```ruby
+negotiate_ignorance 'api_token.yml', 'added by HandyBankUtil'
+```
+
+This will add the following to the ignore file (assuming 'api_token.yml'
+wasn't already ignored):
+
+```
+# added by HandyBankUtil
+api_token.yml
+
+```
+
+If the supplied comment was already in the ignore file (suppose you
+negotiated several tokens with the same comment), the new token will be
+added to the bottom of that section.  So if the ignore file already had
+this:
+
+```
+# added by HandyBankUtil
+secret_info.txt
+
+```
+
+The above example would result in this in the ignore file:
+
+```
+# added by HandyBankUtil
+secret_info.txt
+api_token.yml
+
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Do you love Ignorance, and want to make it even better?
+
+Here's some stuff I ain't figured out yet:
+
+- *Support for globs & regexes*: If you `gaurd_ignorance 'myfile.private'` and
+  the ignore file contains a glob or regex which would cause that to be ignored,
+  Ignorance will raise an error anyway.
+- *Support for other version control systems.*  Visual SourceSafe can't use
+  Ignorance.  Does that seem right to you?

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/ignorance.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ignorance/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "ignorance"
+  gem.version       = Ignorance::VERSION
+  gem.authors       = ["Joel Helbling"]
+  gem.email         = ["joel@joelhelbling.com"]
+  gem.description   = %q{Ensures specified files are ignored by Git, Mercurial or SVN.}
+  gem.summary       = %q{Ignorance helps your code be considerate of its users by protecting sensitive information from version control.}
+  gem.homepage      = "http://github.com/joelhelbling/ignorance"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'highline', '~> 1.6.15'
+
+  gem.add_development_dependency 'rspec',   '~> 2.12.0'
+  gem.add_development_dependency 'fakefs',  '~> 0.4.2'
+  gem.add_development_dependency 'pry',     '~> 0.9.11.4'
+end

data/lib/ignorance.rb

@@ -0,0 +1,85 @@
+require 'highline'
+require 'ignorance/version'
+
+require 'ignorance/git_ignore_file'
+require 'ignorance/hg_ignore_file'
+require 'ignorance/svn_ignore_file'
+
+module Ignorance
+
+  class << self
+    def advise(token)
+      active_ignore_files.each do |ignore_file|
+        warning token, ignore_file unless ignore_file.ignored?(token)
+      end
+    end
+
+    def guard(token)
+      active_ignore_files.each do |ignore_file|
+        unless ignore_file.ignored?(token)
+          raise IgnorefileError.new "Please add \"#{token}\" to this project's #{ignore_file.name} file!"
+        end
+      end
+    end
+
+    def negotiate(token, comment=nil)
+      active_ignore_files.each do |ignore_file|
+        unless ignore_file.ignored?(token)
+          msg = "would you like me to add #{token} to this project's #{ignore_file.name} file automatically?"
+          if agree? msg
+            guarantee! token, comment
+            puts "Added \"#{token}\" to this project's #{ignore_file.name} file."
+          else
+            warning token, ignore_file
+          end
+        end
+      end
+    end
+
+    def guarantee!(token, comment=nil)
+      active_ignore_files.each do |ignore_file|
+        unless ignore_file.ignored?(token)
+          ignore_file.ignore! token, comment
+        end
+      end
+    end
+
+    private
+
+    def warning(token, ignore_file)
+      warn "WARNING: please add \"#{token}\" to this project's #{ignore_file.name} file!"
+    end
+
+    def active_ignore_files
+      ignore_files.select(&:its_a_repo?)
+    end
+
+    def ignore_files
+      [GitIgnoreFile.new, HgIgnoreFile.new, SvnIgnoreFile.new]
+    end
+
+    def agree?(msg)
+      HighLine.new.agree("#{msg}  [Y]es/[n]o?  ")
+    end
+
+  end
+
+  def advise_ignorance(token)
+    Ignorance.advise token, comment
+  end
+
+  def guard_ignorance(token)
+    Ignorance.guard token, comment
+  end
+
+  def negotiate_ignorance(token, comment=nil)
+    Ignorance.negotiate token, comment
+  end
+
+  def guarantee_ignorance!(token, comment=nil)
+    Ignorance.guarantee! token, comment
+  end
+
+  class IgnorefileError < IOError; end
+
+end

data/lib/ignorance/git_ignore_file.rb

@@ -0,0 +1,33 @@
+require 'ignorance/ignore_file'
+require 'ignorance/project_oriented_vcs'
+
+module Ignorance
+  class GitIgnoreFile < IgnoreFile
+    attr_reader :ignore_file, :repo_dir
+
+    include ProjectOrientedVCS
+
+    def initialize
+      @ignore_file = '.gitignore'
+      @repo_dir    = '.git'
+    end
+
+    private
+
+    def ignored
+      (file_contents + user_ignore_file_contents).reject do |t|
+        t.match /^\#/
+      end.map(&:chomp)
+    end
+
+    def user_ignore_file_contents
+      File.exists?(user_ignore_file) ? File.readlines(user_ignore_file) : []
+    end
+
+    def user_ignore_file
+      @user_ignore_file ||= `git config --global --get core.excludesfile`.chomp
+    end
+
+  end
+end
+

data/lib/ignorance/hg_ignore_file.rb

@@ -0,0 +1,16 @@
+require 'ignorance/ignore_file'
+require 'ignorance/project_oriented_vcs'
+
+module Ignorance
+  class HgIgnoreFile < IgnoreFile
+    attr_reader :ignore_file, :repo_dir
+
+    include ProjectOrientedVCS
+
+    def initialize
+      @ignore_file = '.hgignore'
+      @repo_dir    = '.hg'
+    end
+
+  end
+end

data/lib/ignorance/ignore_file.rb

@@ -0,0 +1,96 @@
+module Ignorance
+  class IgnoreFile
+
+    def name
+      ignore_file
+    end
+
+    def exists?
+      File.exists? ignore_file
+    end
+
+    def its_a_repo?
+      Dir.exists? repo_dir
+    end
+
+    def ignored?(token)
+      ignored.include? token
+    end
+
+    def included?(token)
+      file_contents.include? token
+    end
+
+    def ignore!(token, comment=nil)
+      return true if ignored?(token)
+      if comment
+        anchor = commentified comment
+        if included? anchor
+          insert_after anchor, token
+        else
+          append "\n"
+          append anchor
+          append token
+        end
+      else # There's no comment
+        append token
+      end
+
+      write_ignore_file
+    end
+
+    private
+
+    def ignored
+      file_contents.reject{ |t| t.match /^\#/ }.map(&:chomp)
+    end
+
+    def file_contents
+      @file_contents ||= exists? ? File.readlines(ignore_file) : []
+    end
+
+    def insert_at(index, token)
+      file_contents.insert(index, token)
+    end
+
+    def append(token)
+      insert_at(file_contents.size, token)
+    end
+
+    def insert_after(anchor, token)
+      insert_index = file_contents.find_index(anchor) + 1
+      insert_index += 1 until here_is_good?(insert_index)
+      insert_at insert_index, token
+    end
+
+    def here_is_good?(insert_index)
+      at_maximum?(insert_index) || blank_line_at?(insert_index)
+    end
+
+    def at_maximum?(insert_index)
+      insert_index >= file_contents.size
+    end
+
+    def blank_line_at?(insert_index)
+      file_contents[insert_index].match(/^[\s\n]*$/)
+    end
+
+    def commentified(comment)
+      "# " + comment.gsub(/^\s*\#\s*/, '')
+    end
+
+    def printified(line)
+      line.chomp + "\n"
+    end
+
+    def write_ignore_file
+      File.open(ignore_file, 'w') do |fh|
+        file_contents.each do |line|
+          fh.write printified line
+        end
+      end
+    end
+
+  end
+end
+

data/lib/ignorance/project_oriented_vcs.rb

@@ -0,0 +1,14 @@
+module Ignorance
+  module ProjectOrientedVCS
+
+    def its_a_repo?
+      path = Dir.getwd.scan(/\/[^\/]+/).map{|p| p[1..-1]}
+      repo_found = false
+      until (repo_found = Dir.exists?(File.join("/", path, @repo_dir))) || path.empty?
+        path.pop
+      end
+      repo_found
+    end
+
+  end
+end

data/lib/ignorance/svn_ignore_file.rb

@@ -0,0 +1,13 @@
+require 'ignorance/ignore_file'
+
+module Ignorance
+  class SvnIgnoreFile < IgnoreFile
+    attr_reader :ignore_file, :repo_dir
+
+    def initialize
+      @ignore_file = '.svnignore'
+      @repo_dir    = '.svn'
+    end
+
+  end
+end

data/lib/ignorance/version.rb

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

data/spec/ignorefile_helpers.rb

@@ -0,0 +1,25 @@
+module IgnorefileHelpers
+
+  def ignorefile_write(contents)
+    File.open(ignore_file, 'w') do |fh|
+      fh.write contents
+    end
+  end
+
+  def ignorefile_lines
+    File.readlines(ignore_file)
+  end
+
+  def ignored_tokens
+    ignorefile_lines.map(&:chomp)
+  end
+
+  def ignorefile_contents
+    File.read(ignore_file)
+  end
+
+  def mk_repo_dir
+    Dir.mkdir repo_dir
+  end
+
+end

data/spec/io_helpers.rb

@@ -0,0 +1,32 @@
+require 'stringio'
+
+module IOHelpers
+
+  def output_from
+    $stdout = $stderr = fake_io
+    yield
+    fake_io.string
+  ensure
+    $stdout = STDOUT; $stderr = STDERR
+  end
+
+  def user_types(input, &block)
+    $stdin = StringIO.new input
+    output_from &block
+  ensure
+    $stdin = STDIN
+  end
+
+  def stdout_from(&block)
+    output_from &block
+  end
+
+  def stderr_from(&block)
+    output_from &block
+  end
+
+  def fake_io
+    @fake_io ||= StringIO.new
+  end
+
+end

data/spec/lib/ignorance/git_ignore_file_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'ignorance/git_ignore_file'
+
+module Ignorance
+  describe GitIgnoreFile, :fakefs do
+
+    let(:ignore_file) { '.gitignore' }
+    let(:repo_dir)    { '.git'       }
+
+    it_should_behave_like "an ignore file"
+    it_should_behave_like "a project-oriented VCS"
+
+    context "when the user's gitignore file includes the token" do
+      let(:token) { "foofile.md" }
+      let(:user_ignore_file) { '~/.gitignore' }
+      before do
+        ignorefile_write %w[other stuff here].join("\n")
+        File.open(user_ignore_file, 'w') do |fh|
+          fh.write "#{token}\n"
+        end
+        subject.stub(:user_ignore_file).and_return(user_ignore_file)
+      end
+
+      specify "then the file is ignored" do
+        File.read('~/.gitignore').should match /#{token}/
+        subject.ignored?(token).should be_true
+      end
+    end
+
+  end
+end

data/spec/lib/ignorance/hg_ignore_file_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'ignorance/hg_ignore_file'
+
+module Ignorance
+  describe HgIgnoreFile, :fakefs do
+
+    let(:ignore_file) { '.hgignore' }
+    let(:repo_dir)    { '.hg'       }
+
+    it_should_behave_like "an ignore file"
+    it_should_behave_like "a project-oriented VCS"
+
+  end
+end

data/spec/lib/ignorance/ignore_file_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'ignorance/ignore_file'
+require 'ignorance/git_ignore_file'
+
+module Ignorance
+  describe IgnoreFile do
+
+    it { should respond_to :name, :exists?, :its_a_repo?, :ignored?, :ignore! }
+
+  end
+end

data/spec/lib/ignorance/svn_ignore_file_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'ignorance/svn_ignore_file'
+
+module Ignorance
+  describe SvnIgnoreFile, :fakefs do
+
+    let(:ignore_file) { '.svnignore' }
+    let(:repo_dir)    { '.svn'       }
+
+    it_should_behave_like "an ignore file"
+
+  end
+end
+

data/spec/lib/ignorance_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'ignorance'
+
+describe Ignorance do
+
+  describe "class methods (e.g. Ingorance.guard...)" do
+    subject { Ignorance }
+    it { should respond_to :advise, :guard, :negotiate, :guarantee! }
+  end
+
+  describe "when included" do
+    before do
+      class TestIncluder
+        include Ignorance
+      end
+    end
+    subject { TestIncluder.new }
+
+    it do
+      should respond_to :advise_ignorance,
+                        :guard_ignorance,
+                        :negotiate_ignorance,
+                        :guarantee_ignorance!
+    end
+  end
+
+  context "with Git" do
+    let(:ignore_file) { '.gitignore' }
+    let(:repo_dir)    { '.git'       }
+
+    it_should_behave_like Ignorance
+  end
+
+  context "with Mercurial" do
+    let(:ignore_file) { '.hgignore' }
+    let(:repo_dir)    { '.hg'       }
+
+    it_should_behave_like Ignorance
+
+  end
+
+  context "with SVN" do
+    let(:ignore_file) { '.svnignore' }
+    let(:repo_dir)    { '.svn'       }
+
+    it_should_behave_like Ignorance
+
+  end
+end

data/spec/shared_examples/for_ignorance.rb

@@ -0,0 +1,93 @@
+shared_examples Ignorance do
+
+  context "So anyway...", :fakefs do
+    before            { mk_repo_dir  }
+    let(:token)       { "foo.rb"     }
+
+    describe "::advise", :capture_io do
+
+      context "token is already in ignore file" do
+        before { ignorefile_write "#{token}\n" }
+
+        it "does not warn" do
+          expect( stderr_from { Ignorance.advise token } ).to be_empty
+        end
+      end
+
+      context "token is NOT in ignore file" do
+        before { ignorefile_write "something-else.txt\n" }
+
+        it "prints warn (STDERR)" do
+          expect( stderr_from { Ignorance.advise token } ).to match /WARNING:.*add "#{token}" to .*#{ignore_file}/
+        end
+      end
+    end
+
+    describe "::guard" do
+      context "token is already in ignore file" do
+        before { ignorefile_write "#{token}\n" }
+
+        specify "no error is raised" do
+          expect { Ignorance.guard token }.to_not raise_error
+        end
+      end
+
+      context "token is NOT in ignore file" do
+        before { ignorefile_write "something-else.txt\n" }
+
+        it "raises an error" do
+          expect { Ignorance.guard token }.to raise_error Ignorance::IgnorefileError, /add "#{token}" to .*#{ignore_file}/
+        end
+      end
+    end
+
+    describe "::negotiate", :capture_io do
+
+      context "token is already in ignore file" do
+        before { ignorefile_write "#{token}\n" }
+
+        it "does nothing" do
+          expect( stdout_from { Ignorance.negotiate token } ).to be_empty
+        end
+      end
+
+      context "token is NOT in ignore file" do
+        before { ignorefile_write "stuff.txt\n" }
+
+        context "user agrees (y)" do
+          specify do
+            expect( user_types("y") { Ignorance.negotiate token } ).to match /added "#{token}"/i
+          end
+        end
+
+        context "user disagrees (n)" do
+          specify do
+            expect( user_types("n") { Ignorance.negotiate token } ).to match /WARNING:.*add "#{token}" to .*#{ignore_file}/
+          end
+        end
+      end
+    end
+
+    describe "::guarantee!" do
+      context "token is already in ignore file" do
+        before { ignorefile_write "#{token}\n" }
+
+        it "does not change the ignore file" do
+          Ignorance.guarantee! token, "a comment"
+          ignorefile_contents.should == "#{token}\n"
+        end
+      end
+
+      context "token is NOT in ignore file" do
+        before { ignorefile_write "stuff.txt\n" }
+
+        it "adds to the ignore file" do
+          Ignorance.guarantee! token, "a comment"
+          ignorefile_contents.should == "stuff.txt\n\n# a comment\n#{token}\n"
+        end
+      end
+    end
+
+  end
+
+end

data/spec/shared_examples/for_ignore_files.rb

@@ -0,0 +1,147 @@
+module Ignorance
+  shared_examples "an ignore file" do
+
+    it { should respond_to :name, :exists?, :its_a_repo?, :ignored?, :ignore! }
+    its(:name) { should == ignore_file }
+
+    describe "#exists?" do
+
+      context "when the ignore file does NOT exist" do
+        it { should_not exist }
+      end
+
+      context "when the ignore file DOES exist" do
+        before { ignorefile_write "" }
+        it     { should exist        }
+      end
+
+    end
+
+
+    describe "#its_a_repo?" do
+
+      context "when the repo subdirectory does NOT exist" do
+        it { should_not be_its_a_repo }
+      end
+
+      context "when the repo subdirectory DOES exist" do
+        before { Dir.mkdir repo_dir   }
+        it     { should be_its_a_repo }
+      end
+
+    end
+
+    describe "#ignored?" do
+      let(:token) { "foofile.txt" }
+
+      context "when the ignore file doesn't exist" do
+        specify "then the file is not ignored, duh" do
+          subject.should_not exist
+          subject.ignored?(token).should == false
+        end
+      end
+
+      context "when the ignore file does exist" do
+
+        context "when the ignore file doesn't include the token" do
+          before { ignorefile_write %w[other stuff here].join("\n") }
+          it     { should_not be_ignored(token)                    }
+        end
+
+        context "when the ignore file DOES include the token" do
+          before { ignorefile_write ["other", token+"", "stuff"].join("\n") }
+          it     { should be_ignored(token)                                 }
+        end
+      end
+
+    end
+
+
+    describe "#ignore!" do
+      let(:token) { "foofile.txt" }
+
+      context "there is no ignore file" do
+        it "writes to the ignore file" do
+          subject.should_not exist
+          subject.ignore! token
+          ignored_tokens.should include token
+        end
+      end
+
+      context "there is already an ignore file" do
+        before { ignorefile_write "*.swp\n" }
+        specify do
+          ignored_tokens.should include '*.swp'
+          subject.ignore! token
+          ignored_tokens.should include '*.swp'
+        end
+      end
+
+      context "the token is already in the ignore file" do
+        let(:content) { "other\n#{token}\nstuff\n" }
+        before { ignorefile_write content }
+
+        it "doesn't write to the ignore file" do
+          File.any_instance.should_not_receive(:write)
+          subject.ignore!(token)
+          ignored_tokens.should include token
+        end
+      end
+
+      context "with a comment" do
+        context "when the comment wasn't already in the file" do
+          specify do
+            subject.ignore! token, "# hide these files!"
+            ignorefile_contents.should match /# hide these files!\n#{token}\n/
+          end
+        end
+
+        context "when the comment was already in the file" do
+          let(:comment) { "hide these files!" }
+
+          context "comment is the last line of the file" do
+            before { ignorefile_write "\n# #{comment}\n" }
+
+            specify do
+              subject.ignore! token, comment
+              ignorefile_contents.should match /# #{comment}\n#{token}\n/
+            end
+          end
+
+          context "when the comment has other tokens after it" do
+            before do
+              ignorefile_write <<-IGNORE
+# #{comment}
+barfile.md
+
+other-things
+              IGNORE
+            end
+            let(:expected) { Regexp.new /# #{comment}\nbarfile\.md\n#{token}\n\nother-things/ }
+
+            specify do
+              subject.ignore! token, comment
+              ignorefile_contents.should match expected
+            end
+          end
+
+          context "when comment has other tokens at end of file" do
+            before do
+              ignorefile_write <<-IGNORE
+# #{comment}
+barfile.md
+              IGNORE
+            end
+            let(:expected) { Regexp.new /# #{comment}\nbarfile\.md\n#{token}\n/ }
+
+            specify do
+              subject.ignore! token, comment
+              ignorefile_contents.should match expected
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/shared_examples/for_project_oriented_vcs.rb

@@ -0,0 +1,26 @@
+shared_examples "a project-oriented VCS" do
+
+  describe "#its_a_repo?", :fakefs do
+    context "pwd is a subdirectory of the repo root" do
+      before do
+        mk_repo_dir
+        Dir.mkdir 'lib'
+        Dir.mkdir 'lib/other'
+        Dir.chdir 'lib/other'
+      end
+
+      it { should be_its_a_repo }
+    end
+
+    context "pwd is not the subdirectory of any repo" do
+      before do
+        Dir.mkdir 'lib'
+        Dir.mkdir 'lib/other'
+        Dir.chdir 'lib/other'
+      end
+
+      it { should_not be_its_a_repo }
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'fakefs/spec_helpers'
+require File.join(File.dirname(__FILE__), 'ignorefile_helpers')
+require File.join(File.dirname(__FILE__), 'io_helpers')
+
+here = File.dirname(__FILE__)
+
+$LOAD_PATH.unshift(File.expand_path(File.join(here, '..', '..', 'lib')))
+
+Dir[File.join(here, "shared_examples") + "/**/*.rb"].sort.map{|f| File.basename f }.map{|f| "shared_examples/#{f}"}.each {|f| require f}
+
+RSpec.configure do |cfg|
+  cfg.treat_symbols_as_metadata_keys_with_true_values = true
+  cfg.include FakeFS::SpecHelpers, fakefs: true
+  cfg.include IgnorefileHelpers, fakefs: true
+  cfg.include IOHelpers, capture_io: true
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: ignorance
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Joel Helbling
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.15
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.11.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.11.4
+description: Ensures specified files are ignored by Git, Mercurial or SVN.
+email:
+- joel@joelhelbling.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ignorance.gemspec
+- lib/ignorance.rb
+- lib/ignorance/git_ignore_file.rb
+- lib/ignorance/hg_ignore_file.rb
+- lib/ignorance/ignore_file.rb
+- lib/ignorance/project_oriented_vcs.rb
+- lib/ignorance/svn_ignore_file.rb
+- lib/ignorance/version.rb
+- spec/ignorefile_helpers.rb
+- spec/io_helpers.rb
+- spec/lib/ignorance/git_ignore_file_spec.rb
+- spec/lib/ignorance/hg_ignore_file_spec.rb
+- spec/lib/ignorance/ignore_file_spec.rb
+- spec/lib/ignorance/svn_ignore_file_spec.rb
+- spec/lib/ignorance_spec.rb
+- spec/shared_examples/for_ignorance.rb
+- spec/shared_examples/for_ignore_files.rb
+- spec/shared_examples/for_project_oriented_vcs.rb
+- spec/spec_helper.rb
+homepage: http://github.com/joelhelbling/ignorance
+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.24
+signing_key: 
+specification_version: 3
+summary: Ignorance helps your code be considerate of its users by protecting sensitive
+  information from version control.
+test_files:
+- spec/ignorefile_helpers.rb
+- spec/io_helpers.rb
+- spec/lib/ignorance/git_ignore_file_spec.rb
+- spec/lib/ignorance/hg_ignore_file_spec.rb
+- spec/lib/ignorance/ignore_file_spec.rb
+- spec/lib/ignorance/svn_ignore_file_spec.rb
+- spec/lib/ignorance_spec.rb
+- spec/shared_examples/for_ignorance.rb
+- spec/shared_examples/for_ignore_files.rb
+- spec/shared_examples/for_project_oriented_vcs.rb
+- spec/spec_helper.rb