recls-ruby 2.12.0 → 2.12.0.1

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