pathological-v2 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2282cfdb2f31372fd8740f570abfaf4a9adb81480ea7f536e74a2bdfa48b894f
+  data.tar.gz: 394d74d57b85f8d461b15b5016b15e59b404b081bf22ea5195a9ef2ea74e81c7
+SHA512:
+  metadata.gz: d7fc1436cf05fa81fb3647b89d25fd82cfe78a40cce8e9c2313d514e25ff67df8edf1e027983347f087d926fb6e443f25a3114cbcd89d1cc0b65bd41cdc91f4e
+  data.tar.gz: ae0c8ace2fafd593eb2afea7b71d679a0bbe900a8d5acc7cce28f9e4b60964600aed3488479785f6d9c994140f7726932d1927f558767712856dd4a8f1a59b78

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - "2.3.0"

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/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,197 @@
+# Pathological
+
+Pathological is a Ruby tool that provides a lightweight mechanism for managing your project's load path.
+
+[![Build Status](https://secure.travis-ci.org/ooyala/pathological.png)](http://travis-ci.org/ooyala/pathological)
+
+## 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:
+
+``` ruby
+#!/usr/bin/env ruby
+
+require "bundler/setup" # If you're using bundler
+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 one cannot be found).
+
+Note that Pathological should be the first require in your main file so that it will be loaded first. An
+exception to this is when you're using Bundler, in which case you should `require bundler/setup` before
+Pathological (and of course you should have `gem "pathological"` in your `Gemfile`).
+
+`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`:
+
+``` ruby
+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:
+
+``` ruby
+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:
+
+``` ruby
+require "pathological/debug"
+```
+
+## 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!`
+* `Pathological#copy_outside_paths!`
+
+## Notes and gotchas
+
+Pathological is intended as a replacement for manually munging the load path in your application when you want
+to load code from other locations. If you can turn each of your dependencies into a gem and then use bundler
+to manage the dependencies, **do that instead**.
+
+Pathological does its best to figure out where the Pathfile it should use is located, based on the call stack.
+For instance, if you run `/foo/bar.rb` and that requires Pathological, then it will search for `/foo/Pathfile`
+and -- failing that -- `/Pathfile`. However, if `/foo/bar.rb` does not require Pathological, but loads a ruby
+file in `/baz/quux.rb`, and *that* file requires Pathological, then Pathological searches for `/baz/Pathfile`
+and then `/Pathfile`.
+
+Any code loading situation which does not preserve a sane load path will be incompatible with Pathological.
+For instance, if you `eval()` some code that requires Pathological, Pathological has no way of telling where
+that code originally lived, and will probably behave in an unexpected way. One place this commonly occurs is
+with rack webservers (e.g., Rackup, Unicorn) that load a `config.ru`. This file is `instance_eval`ed and so
+requiring Pathological from your `config.ru` will not work as expected. In these cases, require Pathological
+in your app directly.
+
+## 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)
+* [Evan Chan](mailto:ev@ooyala.com)
+
+## Credits
+
+* Harry Robertson for the idea to *not* use a dot-prefixed configuration file
+
+## Metadata
+
+* [Hosted on Github](https://github.com/ooyala/pathological)
+* [Rubygems page](https://rubygems.org/gems/pathological)
+* [Documentation](http://rubydoc.info/github/ooyala/pathological/master/frames)
+
+## Contributing
+
+If you would like to commit a patch, great! Just do the usual github pull request stuff and we'll check it
+out[.](http://www.randomkittengenerator.com/)
+
+## License
+
+Pathological is licensed under the MIT license.

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler"
+require "rake/testtask"
+
+Bundler::GemHelper.install_tasks
+
+task :test => ["test:units"]
+
+namespace :test do
+  Rake::TestTask.new(:units) do |task|
+    task.libs << "test"
+    task.test_files = FileList["test/unit/**/*_test.rb"]
+  end
+end
+
+task :default => ["test:units"]

data/TODO.md

@@ -0,0 +1,66 @@
+TODO
+====
+
+Tasks
+-----
+
+  * Get all loaded files that come from Pathological directories (probably only in 1.9)
+
+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,264 @@
+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 file requiring pathological resides.
+    full_path = real_path(directory || requiring_filename)
+    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
+
+  # Copies directories in pathfile to a destination, such that the destination has no references to
+  # directories outside of the destination in the load path.
+  #
+  # Hierarchy of destination directory:
+  #   destination/
+  #      Pathfile     # new paths
+  #      dependency_directory/
+  #         dependency1         # Copied from original location
+  #
+  # This is very useful for deployment, for example.
+  #
+  # @param [String] copy_outside_paths the directory to stage dependencies in
+  # @param [String] dependency_directory the subdir within destination to put dependencies in
+  # @param [String] pathfile_search_path the directory at which to begin the search for the Pathfile by
+  #                 walking up the directory tree
+  #
+  # TODO(ev): Break this function up into a set of more functional primitives
+  def self.copy_outside_paths!(destination, options = {})
+    options = { :dependency_directory => "pathological_dependencies" }.merge(options)
+    saved_exclude_root = @@exclude_root
+    begin
+      self.excluderoot_mode
+      pathfile = self.find_pathfile(options[:pathfile_search_path])
+      # Nothing to do if there's no Pathfile
+      return unless pathfile && File.file?(pathfile)
+
+      foreign_paths = self.find_load_paths(pathfile).uniq
+      return if foreign_paths.empty?
+
+      path_root = File.join(destination, options[:dependency_directory])
+      FileUtils.mkdir_p path_root
+
+      # Copy in each path and save the relative paths to write to the rewritten Pathfile. We copy each unique
+      # path into the folder not as the basename, but as the longest suffix of the path necessary to make it
+      # unique. (Otherwise this won't work if you have two entries with the same basename in the Pathfile,
+      # such as "foo/lib" and "bar/lib".)
+      common_prefix = find_longest_common_prefix(foreign_paths)
+      new_pathfile_paths = foreign_paths.map do |foreign_path|
+        path_short_name = foreign_path.gsub(/^#{common_prefix}/, "")
+        symlinked_name = File.join(path_root, path_short_name)
+        FileUtils.mkdir_p File.split(symlinked_name)[0]
+        debug "About to move #{foreign_path} to #{symlinked_name}..."
+        copy_directory(foreign_path, symlinked_name)
+        File.join(options[:dependency_directory], path_short_name)
+      end
+      # Overwrite the Pathfile with the new relative paths.
+      File.open(File.join(destination, "Pathfile"), "w") do |file|
+        new_pathfile_paths.each { |path| file.puts path }
+      end
+    ensure
+      @@exclude_root = saved_exclude_root
+    end
+  end
+
+  # Convenience functions for the various modes in which Pathological may run.
+
+  def self.debug_mode; @@debug = true; end
+  def self.bundlerize_mode
+    pathfile = self.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 = Pathname.new(line).absolute? ? line : File.expand_path(File.join(root, line))
+      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
+
+  # Find the longest common path prefix amongst a list of paths
+  #
+  # @private
+  # @param [List<String>] a list of paths
+  # @return [String] the longest common prefix, or "/"
+  def self.find_longest_common_prefix(paths)
+    if paths.size == 1
+      common_prefix = File.split(paths[0])[0]
+    else
+      common_prefix = "/"
+      paths[0].split("/").reject(&:empty?).each do |part|
+        new_prefix = "#{common_prefix}#{part}/"
+        break unless paths.all? { |path| path.start_with? new_prefix }
+        common_prefix = new_prefix
+      end
+    end
+    common_prefix
+  end
+
+  # Copies a directory and all its symlinks to a destination.
+  # @private
+  def self.copy_directory(source, dest)
+    rsync_command = "rsync -r --archive --links --copy-unsafe-links --delete #{source}/ '#{dest}'"
+    debug `#{rsync_command}`
+  end
+
+  # Searches the call stack for the file that required pathological. If no file can be found, falls back to
+  # the currently executing file ($0). This handles the case where the app was launched by another executable
+  # (rake, thin, etc.)
+  #
+  # @return [String] name of file requiring pathological, or the currently executing file.
+  def self.requiring_filename
+    # Match paths like .../gems/pathological-0.2.2.1/lib/pathological/base.rb and also
+    # .../gems/pathological-0.2.2.1/lib/pathological.rb
+    pathological_file_pattern = %r{/pathological(/[^/]+|)\.rb}
+    requiring_file = Kernel.caller.find do |stack_line|
+      trimed_ruby_version = RUBY_VERSION[0..3].to_f rescue 1.9
+      if trimed_ruby_version >= 1.9
+        # In Ruby >=1.9, top-level files will have the string "top (required)" included in the stack listing.
+        stack_line.include?("top (required)") && stack_line !~ pathological_file_pattern
+      else
+        # In Ruby <=1.8, top-level files are listed with their relative path and without a line number.
+        stack_line !~ /:\d+:in/ && stack_line !~ pathological_file_pattern
+      end
+    end
+    requiring_file ? requiring_file.match(/(.+):\d+/)[1] : $0 rescue $0
+  end
+
+  private_class_method :debug, :real_path, :parse_pathfile, :find_longest_common_prefix, :copy_directory
+
+  # 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.3.1"
+end

data/pathological.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.expand_path("../lib", __FILE__)
+require "pathological/version"
+
+Gem::Specification.new do |s|
+  s.name = "pathological-v2"
+  s.version = Pathological::VERSION
+  s.platform    = Gem::Platform::RUBY
+
+  s.required_rubygems_version = Gem::Requirement.new(">=2.3.0") if s.respond_to? :required_rubygems_version=
+  s.specification_version = 2 if s.respond_to? :specification_version=
+
+  s.authors = "Maheshwaran G"
+  s.email = "maheshwarang@brightcove.com"
+  s.homepage = "http://www.ooyala.com"
+  s.rubyforge_project = "pathological-v2"
+
+  s.summary = "A nice way to manage your project's require paths."
+  s.description = <<-DESCRIPTION
+    Extension of Pathological Gem to support Ruby > 1.9 version
+    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.4"
+  s.add_development_dependency "scope", "~> 0.2.3"
+  s.add_development_dependency "fakefs", "~> 0.4.0"
+  s.add_development_dependency "rake", "~>0.9.2.2"
+  s.add_development_dependency "minitest", "=4.3.3"
+  s.add_development_dependency "dedent"
+end

data/test/unit/pathological/base_test.rb

@@ -0,0 +1,296 @@
+require "rubygems"
+require "scope"
+require "rr"
+require "minitest/autorun"
+require "stringio"
+require "fakefs/safe"
+require "dedent"
+
+# 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 "#requiring_filename" do
+        setup do
+          @full_19_stacktrace = <<-EOS.dedent.split("\n").reject(&:empty?)
+            /Users/test/ruby/gems/1.9.1/gems/pathological-0.2.2.1/lib/pathological/base.rb:61:in `find_pathfile'
+            /Users/test/gems/pathological-0.2.2.1/lib/pathological/base.rb:36:in `find_load_paths'
+            /Users/test/gems/pathological-0.2.2.1/lib/pathological/base.rb:15:in `add_paths!'
+            /Users/test/gems/pathological-0.2.2.1/lib/pathological.rb:3:in `<top (required)>'
+            /Users/test/ruby/1.9.1/rubygems/custom_require.rb:59:in `require'
+            /Users/test/ruby/1.9.1/rubygems/custom_require.rb:59:in `rescue in require'
+            /Users/test/ruby/1.9.1/rubygems/custom_require.rb:35:in `require'
+            /Users/test/repos/pathological/test/rackup/app.rb:1:in `<top (required)>'
+            /Users/test/.rubies/1.9.2-p290/lib/ruby/site_ruby/1.9.1/rubygems/custom_require.rb:36:in `require'
+          EOS
+          @full_18_stacktrace = <<-EOS.dedent.split("\n").reject(&:empty?)
+            /Users/test/ruby/gems/1.8/gems/pathological-0.2.5/lib/pathological/base.rb:61:in `find_pathfile'
+            /Users/test/ruby/gems/1.8/gems/pathological-0.2.5/lib/pathological/base.rb:36:in `find_load_paths'
+            /Users/test/ruby/gems/1.8/gems/pathological-0.2.5/lib/pathological/base.rb:15:in `add_paths!'
+            /Users/test/ruby/gems/1.8/gems/pathological-0.2.5/lib/pathological.rb:3
+            /Users/test/ruby/site_ruby/1.8/rubygems/custom_require.rb:58:in `gem_original_require'
+            /Users/test/ruby/site_ruby/1.8/rubygems/custom_require.rb:58:in `require'
+            app.rb:2
+          EOS
+          @bad_stacktrace = <<-EOS.dedent.split("\n").reject(&:empty?)
+            /Users/test/repos/pathological/test/rackup/app.rb !!! `<top (required)>'
+          EOS
+          @empty_stacktrace = []
+        end
+
+        should "find root file from a stacktrace" do
+          if RUBY_VERSION.start_with?("1.9") || RUBY_VERSION.start_with?("2.3")
+            stub(Kernel).caller { @full_19_stacktrace }
+          else
+            stub(Kernel).caller { @full_18_stacktrace }
+          end
+          assert_equal "app.rb", File.basename(Pathological.requiring_filename)
+        end
+
+        should "return executing file from malformed stacktrace" do
+          stub(Kernel).caller { @bad_stacktrace }
+          assert Pathological.requiring_filename
+        end
+
+        should "return executing file if unable to find root file in stacktrace" do
+          stub(Kernel).caller { @empty_stacktrace }
+          assert Pathological.requiring_filename
+        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 "respect absolute paths" do
+          other = "/a/b"
+          @pathfile = "/src/Pathfile"
+          FileUtils.mkdir "/src"
+          FileUtils.mkdir_p other
+          FileUtils.touch @pathfile
+          File.open(@pathfile, "w") { |f| f.write(other) }
+          assert Pathological.find_load_paths("/src/Pathfile").include? other
+        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
+
+      context "#copy_outside_paths!" do
+        setup do
+          @destination = "/tmp/staging"
+          @pathfile = "/Pathfile"
+          FileUtils.cd "/"
+          FileUtils.mkdir_p @destination
+          @source_paths = ["/src/github1", "/src/moofoo"]
+          @source_paths.each { |src_dir| FileUtils.mkdir_p src_dir }
+        end
+
+        should "return immediately if there is no Pathfile" do
+          mock(Pathological).find_pathfile(nil) { nil }
+          Pathological.copy_outside_paths! @destination
+          refute File.directory?(File.join(@destination, "pathological_dependencies"))
+        end
+
+        should "return immediately if Pathfile is empty" do
+          File.open(@pathfile, "w") { |f| f.puts "\n# What the heck is this file?\n\n" }
+          Pathological.copy_outside_paths! @destination
+          refute File.directory?(File.join(@destination, "pathological_dependencies"))
+        end
+
+        should "copy source dirs as links and rewrite Pathfile" do
+          File.open(@pathfile, "w") { |f| f.puts @source_paths.join("\n") }
+
+          final_path = File.join(@destination, "pathological_dependencies")
+          @source_paths.each do |source_path|
+            mock(Pathological).copy_directory(source_path, final_path + source_path.gsub("/src", "")).once
+          end
+          Pathological.copy_outside_paths! @destination
+
+          assert File.directory?(final_path)
+          destination_paths = @source_paths.map do |source_path|
+            "pathological_dependencies#{source_path.gsub("/src", "")}"
+          end
+          assert_equal destination_paths, File.read(File.join(@destination, "Pathfile")).split("\n")
+        end
+
+        should "copy source dirs as links and rewrite Pathfile in a different directory" do
+          other = "other/dir"
+          FileUtils.mkdir_p other
+          File.open(File.join(other, "Pathfile"), "w") { |f| f.puts @source_paths.join("\n") }
+
+          final_path = File.join(@destination, "pathological_dependencies")
+          @source_paths.each do |source_path|
+            mock(Pathological).copy_directory(source_path, final_path + source_path.gsub("/src", "")).once
+          end
+          Pathological.copy_outside_paths! @destination, :pathfile_search_path => other
+
+          assert File.directory?(final_path)
+          destination_paths = @source_paths.map do |source_path|
+            "pathological_dependencies#{source_path.gsub("/src", "")}"
+          end
+          assert_equal destination_paths, File.read(File.join(@destination, "Pathfile")).split("\n")
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: pathological-v2
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Maheshwaran G
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+- !ruby/object:Gem::Dependency
+  name: scope
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.3.3
+- !ruby/object:Gem::Dependency
+  name: dedent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      Extension of Pathological Gem to support Ruby > 1.9 version
+      indicates all directories to include in the load path.
+email: maheshwarang@brightcove.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- 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/unit/pathological/base_test.rb
+homepage: http://www.ooyala.com
+licenses: []
+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: 2.3.0
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 2
+summary: A nice way to manage your project's require paths.
+test_files: []