pathological 0.2.1

data/.rvmrc

@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+
+# WARNING: DO NOT MANUALLY EDIT THIS FILE UNLESS YOU KNOW WHAT YOU ARE DOING.
+# This file was generated automatically using ofe/tools/rvmrc_create.sh (which is in turn a wrapper around the
+# rvm command rvm --rvmrc). It was generated in the following way:
+#
+#   $ rvmrc_create.sh use 1.9.2@pathological --create
+#
+# Please use rvmrc_create.sh if you want to change what this project rvmrc does.
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
+environment_id="ruby-1.9.2-p180@pathological"
+
+#
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficicent compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+#
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]] ; then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+
+  [[ -s ".rvm/hooks/after_use" ]] && . ".rvm/hooks/after_use"
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create use  "$environment_id"
+fi
+
+#
+# If you use an RVM gemset file to install a list of gems (*.gems), you can have
+# it be automatically loaded. Uncomment the following and adjust the filename if
+# necessary.
+#
+# filename=".gems"
+# if [[ -s "$filename" ]] ; then
+#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
+# fi
+
+#
+# If you use bundler and would like to run bundle each time you enter the
+# directory, you can uncomment the following code.
+#
+#   # Ensure that Bundler is installed. Install it if it is not.
+#   if ! command -v bundle >/dev/null; then
+#      printf "The rubygem 'bundler' is not installed. Installing it now.\n"
+#      gem install bundler
+#   fi
+#
+#   # Bundle while reducing excess noise.
+#   printf "Bundling your gems. This may take a few minutes on a fresh clone.\n"
+#   bundle | grep -v '^Using ' | grep -v ' is complete' | sed '/^$/d'
+#
+

data/.yardopts

@@ -0,0 +1 @@
+--no-private lib/pathological/base.rb - README.md LICENSE

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Dependencies are specified in pathological.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    pathological (0.1.4)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    fakefs (0.4.0)
+    minitest (2.5.1)
+    rdiscount (1.6.8)
+    rr (1.0.3)
+    scope (0.2.3)
+      minitest
+    yard (0.7.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fakefs
+  pathological!
+  rdiscount (~> 1.6.8)
+  rr (>= 1.0.3)
+  scope (>= 0.2.3)
+  yard (~> 0.7.2)

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Ooyala, Inc.
+
+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,167 @@
+Pathological
+============
+
+Pathological is a Ruby tool that provides a lightweight mechanism for managing your project's load path.
+
+The problem
+-----------
+
+When you're writing a gem, you don't have to worry about paths much, because Rubygems makes sure that `lib/`
+makes it into your path for you. On the other hand, if you have large Ruby projects which aren't organized as
+gems, you may encounter some of the following problems:
+
+  * If you don't have relative requires, you have to run your project from the project root.
+  * If you want relative requires, you have something nasty like this in your code:
+
+        require File.expand_path(File.join(File.dirname(__FILE__), 'myfile'))
+
+  * Ruby 1.9.2 breaks your load path if you are expecting `.` to be in it. You might have to use
+    `require_relative` or similar to remedy this.
+  * You have symlinks to shared libraries or non-gemified vendor code living all over your project in order
+    to keep your load paths sane.
+
+Pathological provides one way to manage these issues.
+
+Using pathological
+------------------
+
+Getting started with pathological is easy. First, make a file called `Pathfile` at your project root:
+
+    $ cd path/to/myproject
+    $ touch Pathfile
+
+Now require the gem at the start of any executable ruby file:
+
+    #!/usr/bin/env ruby
+
+    require "rubygems" # If you're using 1.8
+    require "pathological"
+    # other requires...
+
+Now your project root will be in your load path. If your project has, for example, `lib/foo.rb`, then `require
+lib/foo` will work in any of your ruby files. This works because when Pathological is required it will search
+up the directory tree until it finds a `Pathfile`. (It will raise an error if there this cannot be found).
+
+`Pathfile`s should be kept in version control.
+
+Adding other paths to your load path
+------------------------------------
+
+To add more paths to your load path, just put the paths in your `Pathfile`. The paths are relative to the
+location of the `Pathfile`. The paths will be inserted in the order they appear; the project root itself will
+be first. If any of the paths are not valid directories, then an exception will be raised when Pathological is
+required.
+
+#### Example
+
+Suppose that you have a directory structure like this:
+
+    repos/
+    |-shared_lib/
+    | `-common.rb
+    `-my_project/
+      |-Pathfile
+      |-run_my_project.rb
+      `-foo.rb
+
+and that `Pathfile` contains the following:
+
+    ../shared_lib
+
+Then inside `run_my_project.rb`:
+
+    require "rubygems"
+    require "pathological"
+    require "foo"
+    require "common"
+    # ...
+
+Installation
+------------
+
+Pathological is packaged as a Rubygem and hence can be trivially installed with
+
+    $ gem install pathological
+
+Advanced usage
+--------------
+
+In some cases, you might want slightly different behavior. This customization is done through the use of
+custom modes. You may use any combination of modes.
+
+#### debug
+
+This adds debugging statements to `STDOUT` that explain what Pathological is doing.
+
+#### excluderoot
+
+In this mode, the project root (where the `Pathfile` is located) is not added to the load path (so only paths
+specified *in* the `Pathfile` will be loaded).
+
+#### noexceptions
+
+This is used if you don't want to raise exceptions if you have bad paths (i.e. non-existent paths or not
+directories) in your `Pathfile`.
+
+#### bundlerize
+
+Bundlerize mode enables Bundler to work with your project regardless of your current directory, in the same
+way as Pathological, by attempting to set the `BUNDLE_GEMFILE` environment variable to match the directory
+where the `Pathfile` is located. Note that you have to run this before requiring `bundler/setup`. Also, this
+will not take effect if you are running with `bundle exec`.
+
+#### parentdir
+
+This mode makes Pathological add the unique parents of all paths it finds (instead of the paths themselves).
+The purpose of parentdir is to enable Pathological to work in a drop-in fashion with legacy code written with
+all requires being relative to the root of the codebase. Note that this will allow one to require files
+located in any child of the parents, not just from the directories specified in the `Pathfile`. This mode
+should be avoided if possible.
+
+There are two ways to specify modes. First, you can enable any modes you want using the Pathological API:
+
+    require "pathological/base"
+    Pathological.debug_mode
+    Pathological.parentdir_mode
+    Pathological.add_paths!
+
+A quicker way is also provided: if you only need to use one special mode, then there is a dedicated file you
+can require:
+
+    require "pathological/bundlerize"
+
+Public API
+----------
+
+For even more configurable custom integration with Pathological, a public API is provided. See the generated
+documentation for details on the following public methods:
+
+    Pathological#add_paths!
+    Pathological#find_load_paths
+    Pathological#find_pathfile
+    Pathological#reset!
+
+Authors
+-------
+
+Pathological was written by the following Ooyala engineers:
+
+* [Daniel MacDougall](mailto:dmac@ooyala.com)
+* [Caleb Spare](mailto:caleb@ooyala.com)
+* [Sami Abu-El-Haija](mailto:sami@ooyala.com)
+
+Credits
+-------
+
+  * Harry Robertson for the idea to *not* use a dot-prefixed configuration file
+
+Contributing
+------------
+
+If you would like to commit a patch, great! Just do the usual github pull request stuff and we'll check it
+out.
+
+License
+-------
+
+Pathological is licensed under the MIT license.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler"
+Bundler::GemHelper.install_tasks

data/TODO.md

@@ -0,0 +1,70 @@
+TODO
+====
+
+Tasks
+-----
+
+  * Bundler compatibility.
+  * Push to the Ooyala github account; release on rubygems.org
+  * Mode for adding one directory above given paths to the current.
+  * Public API:
+    * Get all loaded files that come from Pathological directories
+
+Design decisions
+----------------
+
+  * Should we allow for including other Pathfiles? Proposed syntaxes:
+
+        include path/to/other/Pathfile
+        import path/to/other/Pathfile   # Rakefile
+        i path/to/other/Pathfile
+        source path/to/other/Pathfile   # Bash
+        . path/to/other/Pathfile        # Bash
+        path/to/other/Pathfile          # Distinguishable from regular path if Pathfile is not a directory
+
+    **Not needed now --Caleb**
+
+  * Do we like `>` to signify directives? Alternatives:
+
+        > exclude-root # Current syntax
+        exclude-root  # Only problem is if you want to include a directory with the same name as a directive
+
+    We could also prefix each type of line to make things unambiguous:
+
+        p path/to/lib/
+        d exclude-root
+
+    **Fine for now --Caleb**
+
+  * Right now there's a small problem with comments: if your path includes the character `#`, then the rest
+    will be chopped off (interpreted as a comment). We could remedy this by only allowing for comments to
+    start at the beginning of lines:
+
+        # Yes
+        ../lib/ # No
+
+    **Let's leave this alone for now; probably a non-issue --Caleb**
+
+  * Right our require paths tend to look like this (using `shared_lib/` as an example):
+
+    ``` ruby
+    require "shared_lib/utils/foo_util"
+    ```
+
+    To support this, you would need your `Pathfile` to include the directory *above* `shared_lib/`. The
+    downside of this is that it doesn't play well with the idea of using our `Pathfile`s to tell our deploy
+    scripts what to include. We could potentially add a new construct to allow the user to specify which
+    subdirectories they would be using. Example (just off the top of my head):
+
+        path/to/repo/dir/{shared_lib, common, vendor}
+
+    However, we'd still have to add `path/to/repo/dir` to the `$LOAD_PATH`, so the only way to enforce this at
+    require time would be to use a custom `require`. This is all quite a high cost to pay in terms of design
+    simplicity, but yet being able to use Pathfiles as a single place to document what dependencies to pull in
+    seems very appealing. Any ideas?
+
+    **After chatting with some people, we're going to leave this as is and truncate the `shared_lib` from our
+    paths. --Caleb**
+
+    **Actually, I think I'm going to add an optional mode to add one directory _above_ to the load path
+    instead of the given path, in order to accomomdate this use case. --Caleb**

data/lib/pathological.rb

@@ -0,0 +1,3 @@
+require "pathological/base"
+
+Pathological.add_paths!

data/lib/pathological/base.rb

@@ -0,0 +1,192 @@
+require "pathname"
+
+module Pathological
+  PATHFILE_NAME = "Pathfile"
+
+  class PathologicalException < RuntimeError; end
+  class NoPathfileException < PathologicalException; end
+
+  # Add paths to the load path.
+  #
+  # @param [String] load_path the load path to use.
+  # @param [Array<String>] paths the array of new load paths (if +nil+, the result of {find_load_paths}).
+  def self.add_paths!(load_path = $LOAD_PATH, paths = nil)
+    begin
+      paths ||= find_load_paths
+    rescue NoPathfileException
+      STDERR.puts "Warning: using Pathological, but no Pathfile was found."
+      return
+    end
+    paths.each do |path|
+      if load_path.include? path
+        debug "Skipping <#{path}>, which is already in the load path."
+      else
+        debug "Adding <#{path}> to load path."
+        load_path << path
+        @@loaded_paths << path
+      end
+    end
+  end
+
+  # For some pathfile, parse it and find all the load paths that it references.
+  #
+  # @param [String, nil] pathfile the pathfile to inspect. Uses {find_pathfile} if +nil+.
+  # @return [Array<String>] the resulting array of paths.
+  def self.find_load_paths(pathfile = nil)
+    pathfile ||= find_pathfile
+    raise NoPathfileException unless pathfile
+    begin
+      pathfile_handle = File.open(pathfile)
+    rescue Errno::ENOENT
+      raise NoPathfileException
+    rescue
+      raise PathologicalException, "There was an error opening the pathfile <#{pathfile}>."
+    end
+    parse_pathfile(pathfile_handle)
+  end
+
+  # Find the pathfile by searching up from a starting directory. Symlinks are expanded out.
+  #
+  # @param [String] directory the starting directory. Defaults to the directory containing the running file.
+  # @return [String, nil] the absolute path to the pathfile (if it exists), otherwise +nil+.
+  def self.find_pathfile(directory = nil)
+    # If we're in IRB, use the working directory as the root of the search path for the Pathfile.
+    if $0 != __FILE__ && $0 == "irb"
+      directory = Dir.pwd
+      debug "In IRB -- using the cwd (#{directory}) as the search root for Pathfile."
+    end
+    return nil if directory && !File.directory?(directory)
+    # Find the full, absolute path of this directory, resolving symlinks. If no directory was given, use the
+    # directory where the executed file resides.
+    full_path = real_path(directory || $0)
+    current_path = directory ? full_path : File.dirname(full_path)
+    loop do
+      debug "Searching <#{current_path}> for Pathfile."
+      pathfile = File.join(current_path, PATHFILE_NAME)
+      if File.file? pathfile
+        debug "Pathfile found: <#{pathfile}>."
+        return pathfile
+      end
+      new_path = File.dirname current_path
+      if new_path == current_path
+        debug "Reached filesystem root, but no Pathfile found."
+        return nil
+      end
+      current_path = new_path
+    end
+  end
+
+  # Find all loaded ruby files that come from directories added to the load path by Pathological. This is only
+  # available in Ruby 1.9 due to the behavior of +$"+. This method works in a "best guess" fashion by
+  # determining the +$LOAD_PATH+ entry to which loaded file corresponds.
+  #
+  # @return [Array<String>] the array of paths
+  def self.find_loaded_files
+    unless RUBY_VERSION =~ /^1\.9/
+      raise PathologicalException, "#find_loaded_files is only available in Ruby 1.9."
+    end
+    $".select { |file| @@loaded_paths.any? { ... } }
+  end
+
+  # Convenience functions for the various modes in which Pathological may run.
+
+  def self.debug_mode; @@debug = true; end
+  def self.bundlerize_mode
+    pathfile = Pathological.find_pathfile
+    raise NoPathfileException unless pathfile
+    bundle_gemfile = File.join(File.dirname(pathfile), "Gemfile")
+    unless File.file? bundle_gemfile
+      raise PathologicalException, "No Gemfile found in #{File.dirname(pathfile)}."
+    end
+    ENV["BUNDLE_GEMFILE"] = bundle_gemfile
+  end
+  def self.parentdir_mode; @@add_parents = true; end
+  def self.noexceptions_mode; @@no_exceptions = true; end
+  def self.excluderoot_mode; @@exclude_root = true; end
+
+  # Reset all Pathological options (useful if you want to require a different Pathfile)
+  def self.reset!
+    # Debug mode -- print out information about load paths
+    @@debug = false
+    # Parentdir mode -- add unique parents of specified directories.
+    @@add_parents = false
+    # Noexceptions mode -- don't raise exceptions if the Pathfile contains bad paths
+    @@no_exceptions = false
+    # Excluderoot mode -- don't add the project root (where the Pathfile lives) to the load path
+    @@exclude_root = false
+
+    @@loaded_paths ||= []
+    @@loaded_paths.each { |path| $LOAD_PATH.delete path }
+    @@loaded_paths = []
+  end
+
+  # private module methods
+
+  # Print debugging info
+  #
+  # @private
+  # @param [String] message the debugging message
+  # @return [void]
+  def self.debug(message); puts "[Pathological Debug] >> #{message}" if @@debug; end
+
+  # Turn a path into an absolute path with no useless parts and no symlinks.
+  #
+  # @private
+  # @param [String] the path
+  # @return [String] the absolute real path
+  def self.real_path(path); Pathname.new(path).realpath.to_s; end
+
+  # Parse a pathfile and return the appropriate paths.
+  #
+  # @private
+  # @param [IO] pathfile handle to the pathfile to parse
+  # @return [Array<String>] array of paths found
+  def self.parse_pathfile(pathfile)
+    root = File.dirname(real_path(pathfile.path))
+    raw_paths = [root]
+    pathfile.each do |line|
+      # Trim comments
+      line = line.split(/#/, 2)[0].strip
+      next if line.empty?
+      raw_path = File.expand_path(File.join(root, line.strip))
+      raw_paths << (@@add_parents ? File.dirname(raw_path) : raw_path)
+    end
+
+    paths = []
+    raw_paths.each do |path|
+      unless File.directory? path
+        unless @@no_exceptions
+          raise PathologicalException, "Bad path in Pathfile: #{path}"
+        end
+        debug "Ignoring non-existent path: #{path}"
+        next
+      end
+      next if @@exclude_root && File.expand_path(path) == File.expand_path(root)
+      paths << path
+    end
+    @@exclude_root ? paths.reject { |path| File.expand_path(path) == File.expand_path(root) } : paths
+  end
+
+  # Determine whether a path is a (strict) descendent of another path
+  #
+  # @private
+  # @param [String] ancestor_path the path of the prospective ancestor
+  # @param [String] descendent_path the path of the prospective descendent
+  # @return [Boolean] whether descendent_path is some strict descendent of ancestor_path
+  def self.is_descendent?(ancestor_path, descendent_path)
+    # Delete trailing slash to match File#dirname
+    ancestor_path = ancestor_path[0..-2] if ancestor_path.size > 1 && ancestor_path.end_with? "/"
+    current_path = File.dirname(descendent_path)
+    previous_path = nil
+    until current_path == previous_path
+      return true if current_path == ancestor_path
+      previous_path, current_path = current_path, File.dirname(current_path)
+    end
+    false
+  end
+
+  private_class_method :debug, :real_path, :parse_pathfile
+
+  # Reset options
+  Pathological.reset!
+end

data/lib/pathological/bundlerize.rb

@@ -0,0 +1,9 @@
+# Make bundler compatible with Pathological (that is, enable Bundler projects to be run from anywhere as
+# Pathological allows) by setting the BUNDLE_GEMFILE env variable.
+#
+# To use this, you *must* require pathological/bundlerize before you require bundler/setup.
+
+require "pathological/base"
+
+Pathological.bundlerize_mode
+Pathological.add_paths!

data/lib/pathological/debug.rb

@@ -0,0 +1,4 @@
+require "pathological/base"
+
+Pathological.debug_mode
+Pathological.add_paths!

data/lib/pathological/excluderoot.rb

@@ -0,0 +1,4 @@
+require "pathological/base"
+
+Pathological.excluderoot_mode
+Pathological.add_paths!

data/lib/pathological/noexceptions.rb

@@ -0,0 +1,4 @@
+require "pathological/base"
+
+Pathological.noexceptions_mode
+Pathological.add_paths!

data/lib/pathological/parentdir.rb

@@ -0,0 +1,8 @@
+# In parentdir mode, Pathological will not add the individual specified paths to $LOAD_PATH, but will instead
+# add the unique parents of the specified paths. This is to enable compatibility with legacy code where
+# require paths are all written relative to a common repository root.
+
+require "pathological/base"
+
+Pathological.parentdir_mode
+Pathological.add_paths!

data/lib/pathological/version.rb

@@ -0,0 +1,3 @@
+module Pathological
+  VERSION = "0.2.1"
+end

data/pathological.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.expand_path("../lib", __FILE__)
+require "pathological/version"
+
+Gem::Specification.new do |s|
+  s.name = "pathological"
+  s.version = Pathological::VERSION
+  s.platform    = Gem::Platform::RUBY
+
+  s.required_rubygems_version = Gem::Requirement.new(">=0") if s.respond_to? :required_rubygems_version=
+  s.specification_version = 2 if s.respond_to? :specification_version=
+
+  s.authors = "Daniel MacDougall", "Caleb Spare"
+  s.email = "dmac@ooyala.com", "caleb@ooyala.com"
+  s.homepage = "http://www.ooyala.com"
+  s.rubyforge_project = "pathological"
+
+  s.summary = "A nice way to manage your project's require paths."
+  s.description = <<-DESCRIPTION
+    Pathological provides a way to manage a project's require paths by using a small config file that
+    indicates all directories to include in the load path.
+  DESCRIPTION
+
+  s.files = `git ls-files`.split("\n").reject { |f| f == ".gitignore" }
+  s.require_paths = ["lib"]
+
+  # Require rr >= 1.0.3 and scope >= 0.2.3 for mutual compatibility.
+  s.add_development_dependency "rr", ">= 1.0.3"
+  s.add_development_dependency "scope", ">= 0.2.3"
+  s.add_development_dependency "yard", "~> 0.7.2"
+  s.add_development_dependency "rdiscount", "~> 1.6.8"
+  s.add_development_dependency "fakefs"
+end

data/test/pathological/base_test.rb

@@ -0,0 +1,180 @@
+require "rubygems"
+require "scope"
+require "rr"
+require "minitest/autorun"
+require "stringio"
+require "fakefs/safe"
+
+# It's kind of funny that we need to do this hack, given that Pathological is intended to work around it...
+$:.unshift(File.join(File.dirname(__FILE__), "../../lib"))
+require "pathological/base"
+
+module Pathological
+  class BaseTest < Scope::TestCase
+    include RR::Adapters::MiniTest
+    def assert_load_path(expected_load_path)
+      assert_equal expected_load_path.uniq.sort, @load_path.uniq.sort
+    end
+
+    context "Pathological" do
+      setup_once { FakeFS.activate! }
+      setup do
+        Pathological.reset!
+        @load_path = []
+        FakeFS::FileSystem.clear
+        # FakeFS has not implemented the necessary calls for Pathname#realpath to work.
+        stub(Pathological).real_path(anything) { |p| p }
+      end
+      teardown_once { FakeFS.deactivate! }
+
+      context "#add_paths!" do
+        should "not raise an error but print a warning when there's no pathfile" do
+          mock(Pathological).find_pathfile { nil }
+          mock(STDERR).puts(anything) { |m| assert_match /^Warning/, m }
+          Pathological.add_paths! @load_path
+          assert_load_path []
+        end
+
+        should "append the requested paths" do
+          paths = ["foo"]
+          Pathological.add_paths! @load_path, paths
+          assert_load_path paths
+        end
+
+        should "append the paths that #find_load_paths finds" do
+          paths = ["foo"]
+          mock(Pathological).find_load_paths { paths }
+          Pathological.add_paths! @load_path
+          assert_load_path paths
+        end
+      end
+
+      context "#find_load_paths" do
+        should "raise a NoPathfileException on a nil pathfile" do
+          mock(Pathological).find_pathfile { nil }
+          assert_raises(NoPathfileException) { Pathological.find_load_paths(nil) }
+        end
+
+        should "use #find_pathfile to find the Pathfile and #parse_pathfile to parse it." do
+          paths = ["path1"]
+          mock(Pathological).find_pathfile { "foo" }
+          mock(File).open("foo") { "bar" }
+          mock(Pathological).parse_pathfile("bar") { paths }
+          assert_equal paths, Pathological.find_load_paths
+        end
+      end
+
+      context "#find_pathfile" do
+        setup do
+          @working_directory = "/foo/bar/baz"
+          FileUtils.mkdir_p @working_directory
+          FileUtils.cd @working_directory
+        end
+
+        should "find a pathfile in this directory" do
+          pathfile = "/foo/bar/baz/Pathfile"
+          FileUtils.touch pathfile
+          assert_equal pathfile, Pathological.find_pathfile(@working_directory)
+        end
+
+        should "find a pathfile in a parent directory" do
+          pathfile = "/foo/bar/Pathfile"
+          FileUtils.touch pathfile
+          assert_equal pathfile, Pathological.find_pathfile(@working_directory)
+        end
+
+        should "find a pathfile at the root" do
+          pathfile = "/Pathfile"
+          FileUtils.touch pathfile
+          assert_equal pathfile, Pathological.find_pathfile(@working_directory)
+        end
+
+        should "locate a pathfile in the real path even if we're running from a symlinked directory" do
+          pathfile = "/foo/bar/baz/Pathfile"
+          FileUtils.touch pathfile
+          FileUtils.touch "/Pathfile" # Shouldn't find this one
+          symlinked_directory = "/foo/bar/quux"
+          FileUtils.ln_s @working_directory, symlinked_directory
+          stub(Pathological).real_path(anything) { |path| path.gsub("quux", "baz") }
+          assert_equal pathfile, Pathological.find_pathfile(@working_directory)
+        end
+      end
+
+      context "loading pathological" do
+        setup do
+          @pathfile_contents = ""
+          @pathfile = "/Pathfile"
+          $0 = "/my_file"
+          FileUtils.touch @pathfile
+          FileUtils.cd "/"
+        end
+
+        # Load in pathfile contents and load Pathological
+        def load_and_run!
+          File.open(@pathfile, "w") { |f| f.write(@pathfile_contents) }
+          Pathological.add_paths!(@load_path)
+        end
+
+        should "use an empty Pathfile correctly" do
+          load_and_run!
+          assert_load_path ["/"]
+        end
+
+        should "add some paths as appropriate" do
+          paths = ["/foo/bar", "/baz"]
+          paths.each do |path|
+            FileUtils.mkdir_p path
+            @pathfile_contents << "#{path}\n"
+          end
+          load_and_run!
+          assert_load_path(paths << "/")
+        end
+
+        should "throw exceptions on bad load paths" do
+          path = "/foo/bar"
+          @pathfile_contents << "#{path}"
+          assert_raises(PathologicalException) { load_and_run! }
+        end
+
+        should "print some debug info in debug mode" do
+          Pathological.debug_mode
+          mock(Pathological).puts(anything).at_least(3)
+          Pathological.add_paths!
+        end
+
+        should "set $BUNDLE_GEMFILE correctly in bundlerize mode" do
+          FileUtils.touch "/Gemfile"
+          Pathological.bundlerize_mode
+          Pathological.add_paths!
+          assert_equal "/Gemfile", ENV["BUNDLE_GEMFILE"]
+        end
+
+        should "add the correct directories in parentdir mode" do
+          paths = ["/foo/bar/baz1", "/foo/bar/baz2", "/foo/quux"]
+          paths.each { |path| FileUtils.mkdir_p path }
+          @pathfile_contents = paths.join("\n")
+          Pathological.parentdir_mode
+          load_and_run!
+          assert_load_path ["/", "/foo/bar", "/foo"]
+        end
+
+        should "not raise exceptions on bad paths in noexceptions mode" do
+          path = "/foo/bar"
+          @pathfile_contents << path
+          Pathological.noexceptions_mode
+          load_and_run!
+          assert_load_path ["/"]
+        end
+
+        should "not add the project root in excluderoot mode" do
+          path = "/foo/bar"
+          FileUtils.mkdir_p path
+          @pathfile_contents << path
+          Pathological.excluderoot_mode
+          load_and_run!
+          assert_load_path ["/foo/bar"]
+        end
+      end
+    end
+  end
+end

data/test/unit.watchr.rb

@@ -0,0 +1,10 @@
+# Watchr script for unit tests
+
+def run_test(test)
+  system("bundle exec ruby #{test}")
+end
+
+watch(/^test\/.*_test\.rb/) { |md| run_test(md[0]) }
+watch(/^lib\/(.*)\.rb/) { |md| run_test("test/#{md[1]}_test.rb") }
+
+Signal.trap("INT") { abort("\n") }

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: pathological
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+  prerelease: 
+platform: ruby
+authors:
+- Daniel MacDougall
+- Caleb Spare
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-09 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: &70277329396620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :development
+  prerelease: false
+  version_requirements: *70277329396620
+- !ruby/object:Gem::Dependency
+  name: scope
+  requirement: &70277329396080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :development
+  prerelease: false
+  version_requirements: *70277329396080
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70277329395580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+  type: :development
+  prerelease: false
+  version_requirements: *70277329395580
+- !ruby/object:Gem::Dependency
+  name: rdiscount
+  requirement: &70277329395080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.8
+  type: :development
+  prerelease: false
+  version_requirements: *70277329395080
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: &70277329394700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70277329394700
+description: ! "    Pathological provides a way to manage a project's require paths
+  by using a small config file that\n    indicates all directories to include in the
+  load path.\n"
+email:
+- dmac@ooyala.com
+- caleb@ooyala.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .rvmrc
+- .yardopts
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- TODO.md
+- lib/pathological.rb
+- lib/pathological/base.rb
+- lib/pathological/bundlerize.rb
+- lib/pathological/debug.rb
+- lib/pathological/excluderoot.rb
+- lib/pathological/noexceptions.rb
+- lib/pathological/parentdir.rb
+- lib/pathological/version.rb
+- pathological.gemspec
+- test/pathological/base_test.rb
+- test/unit.watchr.rb
+homepage: http://www.ooyala.com
+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: pathological
+rubygems_version: 1.8.7
+signing_key: 
+specification_version: 2
+summary: A nice way to manage your project's require paths.
+test_files: []