pathname2 1.6.5 → 1.7.0

data/pathname2.gemspec

@@ -2,30 +2,19 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name        = 'pathname2'
-  spec.version     = '1.6.5'
+  spec.version     = '1.7.0'
   spec.author      = 'Daniel J. Berger'
   spec.license     = 'Artistic 2.0'
   spec.email       = 'djberg96@gmail.com'
-  spec.homepage    = 'http://www.rubyforge.org/projects/shards'
+  spec.homepage    = 'https://github.com/djberg96/pathname2'
   spec.summary     = 'An alternate implementation of the Pathname class'
   spec.files       = Dir['**/*'].reject{ |f| f.include?('git') }
 
   spec.extra_rdoc_files  = ['README', 'CHANGES', 'MANIFEST']
-  spec.rubyforge_project = 'shards'
 
   spec.add_dependency('facade')
   spec.add_development_dependency('test-unit')
-
-  if File::ALT_SEPARATOR
-    spec.test_file = 'test/test_pathname_windows.rb'
-    spec.add_dependency('windows-pr')
-    spec.platform = Gem::Platform::CURRENT
-    spec.platform.cpu = 'universal'
-    spec.platform.version = nil
-    spec.original_platform = spec.platform # See rubygems issue #147
-  else
-    spec.test_file = 'test/test_pathname.rb'
-  end
+  spec.add_development_dependency('rake')
 
   spec.description = <<-EOF
     The pathname2 library provides an implementation of the Pathname

data/test/test_pathname.rb

@@ -1,17 +1,13 @@
 ##############################################################################
 # test_pathname.rb
 #
-# Test suite for the pathname package (Unix). This test suite should be run
-# via the Rake tasks, i.e. 'rake test_pr' to test the pure Ruby version, or
-# 'rake test_c' to test the C version.
+# Test suite for the pathname library on unixy platforms. This test suite
+# should be run via the test rake task.
 ##############################################################################
 require 'pathname2'
 require 'rbconfig'
-include Config
-
-require 'rubygems'
-gem 'test-unit'
-require 'test/unit'
+require 'test-unit'
+include RbConfig
 
 class MyPathname < Pathname; end
 
@@ -72,7 +68,7 @@ class TC_Pathname < Test::Unit::TestCase
   end
 
   def test_version
-    assert_equal('1.6.5', Pathname::VERSION)
+    assert_equal('1.7.0', Pathname::VERSION)
   end
 
   def test_file_url_path
@@ -222,11 +218,12 @@ class TC_Pathname < Test::Unit::TestCase
     assert_nothing_raised{ @cur_path.children }
     assert_kind_of(Array, @cur_path.children)
 
-    children = @cur_path.children.sort.reject{ |f| f.include?('CVS') }
+    children = @cur_path.children.sort.reject{ |f| f.include?('git') || f.include?('.swp') }
     assert_equal(
        [
           Dir.pwd + '/test_pathname.rb',
-          Dir.pwd + '/test_pathname_windows.rb'
+          Dir.pwd + '/test_version.rb',
+          Dir.pwd + '/windows'
        ],
        children.sort
     )
@@ -235,8 +232,8 @@ class TC_Pathname < Test::Unit::TestCase
   def test_children_without_directory
     assert_nothing_raised{ @cur_path.children(false) }
 
-    children = @cur_path.children(false).reject{ |f| f.include?('CVS') }
-    assert_equal(['test_pathname.rb', 'test_pathname_windows.rb'], children.sort)
+    children = @cur_path.children(false).reject{ |f| f.include?('git') || f.include?('.swp') }
+    assert_equal(['test_pathname.rb', 'test_version.rb', 'windows'], children.sort)
   end
 
   def test_unc
@@ -416,8 +413,12 @@ class TC_Pathname < Test::Unit::TestCase
     methods = FileUtils.public_instance_methods
     methods -= File.methods(false)
     methods -= Dir.methods(false)
-    methods.delete_if{ |m| m =~ /stream/ }
-    methods.delete('identical?')
+    methods.delete_if{ |m| m.to_s =~ /stream/ }
+    methods.delete(:identical?)
+    methods.delete(:sh)
+    methods.delete(:ruby)
+    methods.delete(:safe_ln)
+    methods.delete(:split_all)
 
     methods.each{ |method|
       assert_respond_to(@abs_path, method.to_sym)

data/test/test_version.rb

@@ -0,0 +1,13 @@
+########################################################################
+# test_version.rb
+#
+# Universal test file that tests for the proper version number.
+########################################################################
+require 'pathname2'
+require 'test-unit'
+
+class TC_Pathname_Version < Test::Unit::TestCase
+  test "version is set to expected value" do
+    assert_equal('1.7.0', Pathname::VERSION)
+  end
+end

data/test/windows/test_append.rb

@@ -0,0 +1,59 @@
+########################################################################
+# test_append.rb
+#
+# Test suite for the Pathname#append method.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Append < Test::Unit::TestCase
+  def setup
+    @abs_path = Pathname.new("C:\\foo\\bar")
+    @rel_path = Pathname.new("foo\\bar\\baz")
+  end
+
+  def assert_pathname_plus(a, b, c)
+    a = Pathname.new(a)
+    b = Pathname.new(b)
+    c = Pathname.new(c)
+    assert_equal(a, b + c)
+  end
+
+  test "appending a string to an absolute path works as expected" do
+    assert_pathname_plus("C:\\a\\b", "C:\\a", "b")
+    assert_pathname_plus("C:\\b", "a", "C:\\b")
+    assert_pathname_plus("a\\b", "a", "b")
+    assert_pathname_plus("C:\\b", "C:\\a", "..\\b")
+    assert_pathname_plus("C:\\a\\b", "C:\\a\\.", "\\b")
+    assert_pathname_plus("C:\\a\\b.txt", "C:\\a", "b.txt")
+  end
+
+  test "appending a string to a UNC path works as expected" do
+    assert_pathname_plus("\\\\foo\\bar", "\\\\foo", "bar")
+    assert_pathname_plus("\\\\foo", "\\\\", "foo")
+    assert_pathname_plus("\\\\", "\\\\", "")
+    assert_pathname_plus("\\\\foo\\baz", "\\\\foo\\bar", "\\..\\baz")
+    assert_pathname_plus("\\\\", "\\\\", "..\\..\\..\\..")
+  end
+
+  test "appending a plain string to a path works as expected" do
+    assert_nothing_raised{ @abs_path + "bar" }
+    assert_equal('C:\foo\bar\baz', @abs_path + 'baz')
+    assert_equal('C:\foo\bar', @abs_path)
+  end
+
+  test "appending an absolute path results in that absolute path" do
+    assert_pathname_plus('C:\foo\bar', @rel_path, @abs_path)
+  end
+
+  test "neither receiver nor argument are modified" do
+    assert_nothing_raised{ @abs_path + @rel_path }
+    assert_equal('C:\foo\bar\foo\bar\baz', @abs_path + @rel_path)
+    assert_equal('C:\foo\bar', @abs_path)
+    assert_equal('foo\bar\baz', @rel_path)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_aref.rb

@@ -0,0 +1,37 @@
+########################################################################
+# test_aref.rb
+#
+# Test suite for the Pathname#[] method.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Aref < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:/Program Files/Windows NT/Accessories")
+  end
+
+  test "[] with index works as expected" do
+    assert_equal("C:", @path[0])
+    assert_equal("Program Files", @path[1])
+    assert_equal("Accessories", @path[-1])
+    assert_nil(@path[10])
+  end
+
+  test "[] with range argument works as expected" do
+    assert_equal("C:\\Program Files", @path[0..1])
+    assert_equal("C:\\Program Files\\Windows NT", @path[0..2])
+    assert_equal("Program Files\\Windows NT", @path[1..2])
+    #assert_equal(@path, @path[0..-1]) # TODO: Spews tons of warnings
+  end
+
+  test "[] with index and length works as expected" do
+    assert_equal("C:", @path[0,1])
+    assert_equal("C:\\Program Files", @path[0,2])
+    assert_equal("Program Files\\Windows NT", @path[1,2])
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_ascend.rb

@@ -0,0 +1,51 @@
+########################################################################
+# test_ascend.rb
+#
+# Test suite for the Pathname#ascend method.
+########################################################################
+require 'pathname2'
+require 'test-unit'
+
+class TC_Pathname_Ascend < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:\\foo\\bar\\baz")
+  end
+
+  test "ascend basic functionality" do
+    assert_respond_to(@path, :ascend)
+    assert_nothing_raised{ @path.ascend{} }
+  end
+
+  test "ascend works as expected on a standard absolute path" do
+    array = []
+    @path.ascend{ |e| array << e }
+    assert_equal('C:\foo\bar\baz', array[0])
+    assert_equal('C:\foo\bar', array[1])
+    assert_equal('C:\foo', array[2])
+    assert_equal('C:', array[3])
+  end
+
+  test "ascend works as expected on a UNC path" do
+    array = []
+    Pathname.new('//foo/bar/baz').ascend{ |e| array << e }
+    assert_equal("\\\\foo\\bar\\baz", array[0])
+    assert_equal("\\\\foo\\bar", array[1])
+  end
+
+  test "ascend works as expected on a relative path" do
+    array = []
+    Pathname.new('foo/bar/baz').ascend{ |e| array << e }
+    assert_equal('foo\bar\baz', array[0])
+    assert_equal('foo\bar', array[1])
+    assert_equal('foo', array[2])
+  end
+
+  test "ascend does not modify the receiver" do
+    @path.ascend{}
+    assert_equal('C:\foo\bar\baz', @path)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_children.rb

@@ -0,0 +1,42 @@
+########################################################################
+# test_children.rb
+#
+# Test suite for the Pathname#children method.
+########################################################################
+require 'pathname2'
+require 'test-unit'
+
+class TC_Pathname_Children < Test::Unit::TestCase
+  def setup
+    @dir  = 'foo'
+    @path = Pathname.new(File.dirname(File.dirname(__FILE__)))
+
+    Dir.mkdir(@dir)
+    Dir.chdir(@dir){
+      FileUtils.touch('alpha')
+      FileUtils.touch('beta')
+      FileUtils.touch('gamma')
+    }
+  end
+
+  test "children basic functionality" do
+    assert_respond_to(@path, :children)
+    assert_nothing_raised{ @path.children{} }
+    assert_kind_of(Array, @path.children)
+  end
+
+  test "children method returns expected results" do
+    path = Pathname.new(@dir)
+    assert_equal(%w[foo\alpha foo\beta foo\gamma], path.children)
+  end
+
+  test "each result of the children method is a Pathname object" do
+    path = Pathname.new(@dir)
+    assert_kind_of(Pathname, path.children.first)
+  end
+
+  def teardown
+    FileUtils.rm_rf(@dir) if File.exist?(@dir)
+    @path = nil
+  end
+end

data/test/windows/test_clean.rb

@@ -0,0 +1,50 @@
+########################################################################
+# test_clean.rb
+#
+# Test suite for the Pathname#clean method.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_Clean < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:\\foo\\..\\bar\\.\\baz")
+  end
+
+  test "clean basic functionality" do
+    assert_respond_to(@path, :clean)
+    assert_nothing_raised{ @path.clean }
+    assert_kind_of(Pathname, @path.clean)
+  end
+
+  test "clean returns expected results for unclean paths" do
+    assert_equal("C:\\a\\c", Pathname.new("C:\\a\\.\\b\\..\\c").clean)
+    assert_equal("C:\\a", Pathname.new("C:\\.\\a").clean)
+    assert_equal("C:\\a\\b", Pathname.new("C:\\a\\.\\b").clean)
+    assert_equal("C:\\b", Pathname.new("C:\\a\\..\\b").clean)
+    assert_equal("C:\\a", Pathname.new("C:\\a\\.").clean)
+    assert_equal("C:\\d", Pathname.new("C:\\..\\..\\..\\d").clean)
+  end
+
+  test "clean returns already clean paths unmodified" do
+    assert_equal("C:\\", Pathname.new("C:\\").clean)
+    assert_equal("C:\\a", Pathname.new("C:\\a").clean)
+    assert_equal("C:\\a\\", Pathname.new("C:\\a\\").clean)
+    assert_equal("\\\\foo\\bar", Pathname.new("\\\\foo\\bar").clean)
+    assert_equal("a", Pathname.new("a").clean)
+  end
+
+  test "clean returns a slash for . and .." do
+    assert_equal("\\", Pathname.new(".").clean)
+    assert_equal("\\", Pathname.new("..").clean)
+  end
+
+  test "clean does not modify receiver" do
+    @path.clean
+    assert_equal("C:\\foo\\..\\bar\\.\\baz", @path)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_clean_bang.rb

@@ -0,0 +1,50 @@
+########################################################################
+# test_clean_bang.rb
+#
+# Test suite for the Pathname#clean! method.
+########################################################################
+require 'test-unit'
+require 'pathname2'
+
+class TC_Pathname_CleanBang < Test::Unit::TestCase
+  def setup
+    @path = Pathname.new("C:\\foo\\..\\bar\\.\\baz")
+  end
+
+  test "clean basic functionality" do
+    assert_respond_to(@path, :clean!)
+    assert_nothing_raised{ @path.clean! }
+    assert_kind_of(Pathname, @path.clean!)
+  end
+
+  test "clean returns expected results for unclean paths" do
+    assert_equal("C:\\a\\c", Pathname.new("C:\\a\\.\\b\\..\\c").clean!)
+    assert_equal("C:\\a", Pathname.new("C:\\.\\a").clean!)
+    assert_equal("C:\\a\\b", Pathname.new("C:\\a\\.\\b").clean!)
+    assert_equal("C:\\b", Pathname.new("C:\\a\\..\\b").clean!)
+    assert_equal("C:\\a", Pathname.new("C:\\a\\.").clean!)
+    assert_equal("C:\\d", Pathname.new("C:\\..\\..\\..\\d").clean!)
+  end
+
+  test "clean returns already clean paths unmodified" do
+    assert_equal("C:\\", Pathname.new("C:\\").clean!)
+    assert_equal("C:\\a", Pathname.new("C:\\a").clean!)
+    assert_equal("C:\\a\\", Pathname.new("C:\\a\\").clean!)
+    assert_equal("\\\\foo\\bar", Pathname.new("\\\\foo\\bar").clean!)
+    assert_equal("a", Pathname.new("a").clean!)
+  end
+
+  test "clean returns a slash for . and .." do
+    assert_equal("\\", Pathname.new(".").clean!)
+    assert_equal("\\", Pathname.new("..").clean!)
+  end
+
+  test "clean! modifies receiver" do
+    @path.clean!
+    assert_equal("C:\\bar\\baz", @path)
+  end
+
+  def teardown
+    @path = nil
+  end
+end

data/test/windows/test_constructor.rb

@@ -0,0 +1,48 @@
+########################################################################
+# test_constructor.rb
+#
+# Various tests for the Pathname.new method.
+########################################################################
+require 'pathname2'
+require 'test-unit'
+
+class TC_Pathname_Constructor < Test::Unit::TestCase
+  def setup
+    @abs_path = "C:/Users"
+    @rel_path = "Users"
+    @url_path = "file:///C:/Documents%20and%20Settings"
+  end
+
+  test "constructor handles absolute paths properly" do
+    assert_nothing_raised{ Pathname.new(@abs_path) }
+    assert_equal("C:\\Users", Pathname.new(@abs_path).to_s)
+  end
+
+  test "constructor handles relative paths properly" do
+    assert_nothing_raised{ Pathname.new(@rel_path) }
+    assert_equal("Users", Pathname.new(@rel_path).to_s)
+  end
+
+  test "constructor handles file URL's properly" do
+    assert_nothing_raised{ Pathname.new(@url_path) }
+    assert_equal("C:\\Documents and Settings", Pathname.new(@url_path).to_s)
+  end
+
+  test "constructor returns a Pathname object" do
+    assert_kind_of(Pathname, Pathname.new(@abs_path))
+  end
+
+  test "constructor handles frozen arguments without issue" do
+    assert_nothing_raised{ Pathname.new(@abs_path.freeze) }
+  end
+
+  test "constructor raises an error if string argument is too long" do
+    assert_raise(ArgumentError){ Pathname.new("foo" * 1000) }
+  end
+
+  def teardown
+    @url_path = nil
+    @rel_path = nil
+    @abs_path = nil
+  end
+end