recls-ruby 2.11.0.3 → 2.12.0

data/test/scratch/test_pattern_arrays.rb

@@ -6,9 +6,9 @@ $:.unshift File.join(File.dirname(__FILE__), '../..', 'lib')
 
 require 'recls'
 
-root_dir    = File.join(File.dirname(__FILE__), '../..')
-patterns_a  = %w{ *.rb *.md }
-patterns_s  = patterns_a.join('|')
+root_dir	=	File.join(File.dirname(__FILE__), '../..')
+patterns_a	=	%w{ *.rb *.md }
+patterns_s	=	patterns_a.join('|')
 
 
 puts
@@ -16,7 +16,7 @@ puts "Searching for pattern string '#{patterns_s}':"
 
 Recls::FileSearch.new(root_dir, patterns_s, Recls::FILES | Recls::RECURSIVE).each do |fe|
 
-  puts fe.search_relative_path
+	puts fe.search_relative_path
 end
 
 
@@ -26,7 +26,7 @@ puts "Searching for pattern array '#{patterns_a}':"
 
 Recls::FileSearch.new(root_dir, patterns_a, Recls::FILES | Recls::RECURSIVE).each do |fe|
 
-  puts fe.search_relative_path
+	puts fe.search_relative_path
 end
 
 

data/test/scratch/test_show_dev_and_ino.rb

@@ -8,6 +8,6 @@ require 'recls'
 
 Recls::FileSearch.new('.', Recls::WILDCARDS_ALL, Recls::FILES | Recls::RECURSIVE).each do |fe|
 
-  puts "#{fe.search_relative_path}\t#{fe.dev}\t#{fe.ino}\t#{fe.nlink}"
+	puts "#{fe.search_relative_path}\t#{fe.dev}\t#{fe.ino}\t#{fe.nlink}"
 end
 

data/test/scratch/test_show_hidden.rb

@@ -10,14 +10,14 @@ puts
 puts "Hidden directories:"
 Recls.file_rsearch(nil, nil, Recls::DIRECTORIES | Recls::SHOW_HIDDEN).each do |fe|
 
-  puts "\t#{fe.search_relative_path}" if fe.hidden?
+	puts "\t#{fe.search_relative_path}" if fe.hidden?
 end
 
 puts
 puts "Hidden files:"
 Recls.file_search(nil, nil, Recls::RECURSIVE | Recls::FILES | Recls::SHOW_HIDDEN).each do |fe|
 
-  puts "\t#{fe.search_relative_path}" if fe.hidden?
+	puts "\t#{fe.search_relative_path}" if fe.hidden?
 end
 
 
@@ -25,6 +25,6 @@ puts
 puts "Hidden directories & files:"
 Recls.file_search(nil, nil, Recls::RECURSIVE | Recls::DIRECTORIES | Recls::FILES | Recls::MARK_DIRECTORIES | Recls::SHOW_HIDDEN).each do |fe|
 
-  puts "\t#{fe.search_relative_path}" if fe.hidden?
+	puts "\t#{fe.search_relative_path}" if fe.hidden?
 end
 

data/test/unit/tc_recls_entries.rb

@@ -1,55 +1,55 @@
-#! /usr/bin/env ruby
+#!/usr/bin/env ruby
 #
 # test Recls entries
 
 $:.unshift File.join(File.dirname(__FILE__), '../..', 'lib')
 
+
 require 'recls'
 
 require 'test/unit'
 
-
 class Test_Recls_entries < Test::Unit::TestCase
 
-  unless defined? assert_false
-    def assert_false arg0, *args
-      assert !arg0, *args
-    end
-  end
+	unless defined? assert_false
+		def assert_false arg0, *args
+			assert !arg0, *args
+		end
+	end
 
-  def test_entries_in_directory_have_unique_names
+	def test_entries_in_directory_have_unique_names
 
-    entries         = Recls::FileSearch.new('~', Recls::WILDCARDS_ALL, Recls::FILES).to_a
+		entries			=	Recls::FileSearch.new('~', Recls::WILDCARDS_ALL, Recls::FILES).to_a
 
-    hashed_entries  = Hash[entries.each_with_index.map { |fe, index| [ fe, index] }]
+		hashed_entries	=	Hash[entries.each_with_index.map { |fe, index| [ fe, index] }]
 
-    # ensure that no duplicates in hash (and hence Entry.hash and Entry.<=> work)
-    assert_equal entries.size, hashed_entries.size
+		# ensure that no duplicates in hash (and hence Entry.hash and Entry.<=> work)
+		assert_equal entries.size, hashed_entries.size
 
-    entries.each_with_index do |entry, index|
+		entries.each_with_index do |entry, index|
 
-      entry_a = entries[index]
-      entry_b = Recls.stat(entries[index].path)
+			entry_a			=	entries[index]
+			entry_b			=	Recls.stat(entries[index].path)
 
-      # ensure that different entry instances representing the same path evaluate
-      # equal (and hence Entry.eq? and Entry.== work)
+			# ensure that different entry instances representing the same path evaluate
+			# equal (and hence Entry.eq? and Entry.== work)
 
-      assert entry_a.eql? entry_a
-      assert entry_a.eql? entry_b
-      assert_false entry_a.eql? entry_a.path
-      assert_false entry_a.eql? entry_b.path
+			assert entry_a.eql? entry_a
+			assert entry_a.eql? entry_b
+			assert_false entry_a.eql? entry_a.path
+			assert_false entry_a.eql? entry_b.path
 
-      assert_equal entry_a, entry_a
-      assert_equal entry_a, entry_b
-      assert_equal entry_a, entry_a.path
-      assert_equal entry_a, entry_b.path
+			assert_equal entry_a, entry_a
+			assert_equal entry_a, entry_b
+			assert_equal entry_a, entry_a.path
+			assert_equal entry_a, entry_b.path
 
-      assert_same entry_a, entries[index]
-      assert_not_same entry_a, entry_b
+			assert_same entry_a, entries[index]
+			assert_not_same entry_a, entry_b
 
-      assert_equal index, hashed_entries[entry_a]
-      assert_equal index, hashed_entries[entry_b]
-    end
-  end
+			assert_equal index, hashed_entries[entry_a]
+			assert_equal index, hashed_entries[entry_b]
+		end
+	end
 end
 

data/test/unit/tc_recls_entry.rb

@@ -1,40 +1,40 @@
-#! /usr/bin/env ruby
+#!/usr/bin/env ruby
 #
 # test Recls entries
 
 $:.unshift File.join(File.dirname(__FILE__), '../..', 'lib')
 
+
 require 'recls'
 
 require 'test/unit'
 
-
 class Test_Recls_entry < Test::Unit::TestCase
 
-  unless defined? assert_false
-    def assert_false arg0, *args
-      assert !arg0, *args
-    end
-  end
+	unless defined? assert_false
+		def assert_false arg0, *args
+			assert !arg0, *args
+		end
+	end
 
-  def setup
+	def setup
 
-    @cwd = Dir.pwd
-  end
+		@cwd = Dir.pwd
+	end
 
-  def test_entry_does_not_mark_directory
+	def test_entry_does_not_mark_directory
 
-    cwd = Recls.stat @cwd
+		cwd	=	Recls.stat @cwd
 
-    assert_equal @cwd, cwd.path
-  end
+		assert_equal @cwd, cwd.path
+	end
 
-  def test_entry_does_mark_directory
+	def test_entry_does_mark_directory
 
-    cwd = Recls.stat @cwd, Recls::MARK_DIRECTORIES
+		cwd	=	Recls.stat @cwd, Recls::MARK_DIRECTORIES
 
-    # assert_equal "#{@cwd}#{Recls::PATH_NAME_SEPARATOR}", cwd.path
-    assert_equal "#{@cwd}/", cwd.path
-  end
+#		assert_equal "#{@cwd}#{Recls::PATH_NAME_SEPARATOR}", cwd.path
+		assert_equal "#{@cwd}/", cwd.path
+	end
 end
 

data/test/unit/tc_recls_file_search.rb

@@ -4,65 +4,65 @@
 
 $:.unshift File.join(File.dirname(__FILE__), '../..', 'lib')
 
+
 require 'recls'
 
 require 'test/unit'
 
-
 class Test_Recls_FileSearch_class < Test::Unit::TestCase
 
-  def test_construction
+	def test_construction
 
-    fs = Recls::FileSearch.new(nil, nil, 0)
+		fs = Recls::FileSearch.new(nil, nil, 0)
 
-    assert_not_nil(fs)
+		assert_not_nil(fs)
 
-  end # def test_construction
+	end # def test_construction
 
-  def test_construction_1
+	def test_construction_1
 
-    fs = Recls::FileSearch.new('abc', '*c', Recls::FILES)
+		fs = Recls::FileSearch.new('abc', '*c', Recls::FILES)
 
-    assert_not_nil(fs)
-    assert_equal('abc', fs.search_root)
-    assert_equal(['*c'], fs.patterns)
+		assert_not_nil(fs)
+		assert_equal('abc', fs.search_root)
+		assert_equal(['*c'], fs.patterns)
   if not defined? RECLS_NO_OBSOLETE
-    assert_equal('abc', fs.searchRoot)
-    assert_equal(['*c'], fs.pattern)
+		assert_equal('abc', fs.searchRoot)
+		assert_equal(['*c'], fs.pattern)
   end
-    assert_equal(Recls::FILES, fs.flags)
+		assert_equal(Recls::FILES, fs.flags)
 
-  end # def test_construction_1
+	end # def test_construction_1
 
-  def test_construction_2
+	def test_construction_2
 
-    fs = Recls::FileSearch.new('def', '*c', 0)
+		fs = Recls::FileSearch.new('def', '*c', 0)
 
-    assert_not_nil(fs)
-    assert_equal('def', fs.search_root)
-    assert_equal(['*c'], fs.patterns)
+		assert_not_nil(fs)
+		assert_equal('def', fs.search_root)
+		assert_equal(['*c'], fs.patterns)
   if not defined? RECLS_NO_OBSOLETE
-    assert_equal('def', fs.searchRoot)
-    assert_equal(['*c'], fs.pattern)
+		assert_equal('def', fs.searchRoot)
+		assert_equal(['*c'], fs.pattern)
   end
-    assert_equal(Recls::FILES, fs.flags)
+		assert_equal(Recls::FILES, fs.flags)
 
-  end # def test_construction_2
+	end # def test_construction_2
 
-  def test_construction_3
+	def test_construction_3
 
-    fs = Recls::FileSearch.new('ghi', '*c', Recls::DIRECTORIES)
+		fs = Recls::FileSearch.new('ghi', '*c', Recls::DIRECTORIES)
 
-    assert_not_nil(fs)
-    assert_equal('ghi', fs.search_root)
-    assert_equal(['*c'], fs.patterns)
+		assert_not_nil(fs)
+		assert_equal('ghi', fs.search_root)
+		assert_equal(['*c'], fs.patterns)
   if not defined? RECLS_NO_OBSOLETE
-    assert_equal('ghi', fs.searchRoot)
-    assert_equal(['*c'], fs.pattern)
+		assert_equal('ghi', fs.searchRoot)
+		assert_equal(['*c'], fs.pattern)
   end
-    assert_equal(Recls::DIRECTORIES, fs.flags)
+		assert_equal(Recls::DIRECTORIES, fs.flags)
 
-  end # def test_construction_3
+	end # def test_construction_3
 
 end
 

data/test/unit/tc_recls_module.rb

@@ -4,72 +4,72 @@
 
 $:.unshift File.join(File.dirname(__FILE__), '../..', 'lib')
 
+
 require 'recls'
 
 require 'test/unit'
 
-
 class Test_Recls_constants < Test::Unit::TestCase
 
-  private
-  @@OS_IS_WINDOWS = Recls::Ximpl::OS::OS_IS_WINDOWS
+	private
+	@@OS_IS_WINDOWS = Recls::Ximpl::OS::OS_IS_WINDOWS
 
-  public
+	public
 
 
-  def test_PATH_NAME_SEPARATOR
+	def test_PATH_NAME_SEPARATOR
 
-    expected = @@OS_IS_WINDOWS ? '\\' : '/'
+		expected = @@OS_IS_WINDOWS ? '\\' : '/'
 
-    assert_equal(expected, Recls::PATH_NAME_SEPARATOR)
+		assert_equal(expected, Recls::PATH_NAME_SEPARATOR)
 
-  end # def test_PATH_NAME_SEPARATOR
+	end # def test_PATH_NAME_SEPARATOR
 
   if not defined? RECLS_NO_OBSOLETE
 
-  def test_pathNameSeparator
+	def test_pathNameSeparator
 
-    assert_equal(Recls::PATH_NAME_SEPARATOR, Recls::pathNameSeparator)
+		assert_equal(Recls::PATH_NAME_SEPARATOR, Recls::pathNameSeparator)
 
-  end # def test_pathNameSeparator
+	end # def test_pathNameSeparator
 
   end
 
-  def test_PATH_SEPARATOR
+	def test_PATH_SEPARATOR
 
-    expected = @@OS_IS_WINDOWS ? ';' : ':'
+		expected = @@OS_IS_WINDOWS ? ';' : ':'
 
-    assert_equal(expected, Recls::PATH_SEPARATOR)
+		assert_equal(expected, Recls::PATH_SEPARATOR)
 
-  end # def test_PATH_SEPARATOR
+	end # def test_PATH_SEPARATOR
 
   if not defined? RECLS_NO_OBSOLETE
 
-  def test_pathSeparator
+	def test_pathSeparator
 
-    assert_equal(Recls::PATH_SEPARATOR, Recls::pathSeparator)
+		assert_equal(Recls::PATH_SEPARATOR, Recls::pathSeparator)
 
-  end # def test_pathSeparator
+	end # def test_pathSeparator
 
   end
 
 
 
-  def test_WILDCARDS_ALL
+	def test_WILDCARDS_ALL
 
-    #expected = @@OS_IS_WINDOWS ? '*.*' : '*'
+		#expected = @@OS_IS_WINDOWS ? '*.*' : '*'
 
-    assert_equal('*', Recls::WILDCARDS_ALL)
+		assert_equal('*', Recls::WILDCARDS_ALL)
 
-  end # def test_WILDCARDS_ALL
+	end # def test_WILDCARDS_ALL
 
   if not defined? RECLS_NO_OBSOLETE
 
-  def test_wildcardsAll
+	def test_wildcardsAll
 
-    assert_equal(Recls::WILDCARDS_ALL, Recls::wildcardsAll)
+		assert_equal(Recls::WILDCARDS_ALL, Recls::wildcardsAll)
 
-  end # def test_wildcardsAll
+	end # def test_wildcardsAll
 
   end