recls-ruby 2.6.4

data/lib/recls/ximpl/windows.rb

@@ -0,0 +1,197 @@
+# ######################################################################### #
+# File:        recls/ximpl/windows.rb
+#
+# Purpose:     Windows-specific constructs for the recls library.
+#
+# Created:     19th February 2014
+# Updated:     29th December 2015
+#
+# Author:      Matthew Wilson
+#
+# Copyright (c) 2012-2015, Matthew Wilson and Synesis Software
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# ######################################################################### #
+
+
+require 'Win32API'
+
+module Recls
+
+	module Ximpl
+
+		class FileStat < File::Stat
+
+			private
+			GetFileAttributes			=	Win32API.new('kernel32', 'GetFileAttributes', [ 'P' ], 'I')
+			GetFileInformationByHandle	=	Win32API.new('kernel32', 'GetFileInformationByHandle', [ 'L', 'P' ], 'I')
+			GetShortPathName			=	Win32API.new('kernel32', 'GetShortPathName', [ 'P', 'P', 'L' ], 'L')
+			CreateFile					=	Win32API.new('kernel32', 'CreateFile', [ 'P', 'L', 'L', 'L', 'L', 'L', 'L' ], 'L')
+			CloseHandle					=	Win32API.new('kernel32', 'CloseHandle', [ 'L' ], 'L')
+			FILE_ATTRIBUTE_READONLY		=	0x00000001
+			FILE_ATTRIBUTE_HIDDEN		=	0x00000002
+			FILE_ATTRIBUTE_SYSTEM		=	0x00000004
+			FILE_ATTRIBUTE_DIRECTORY	=	0x00000010
+			FILE_ATTRIBUTE_ARCHIVE		=	0x00000020
+			FILE_ATTRIBUTE_DEVICE		=	0x00000040
+			FILE_ATTRIBUTE_NORMAL		=	0x00000080
+			FILE_ATTRIBUTE_TEMPORARY	=	0x00000100
+			FILE_ATTRIBUTE_COMPRESSED	=	0x00000800
+			FILE_ATTRIBUTE_ENCRYPTED	=	0x00004000
+
+			OPEN_EXISTING        		= 	0x00000003
+			FILE_FLAG_OVERLAPPED 		= 	0x40000000
+			NULL                 		= 	0x00000000
+			INVALID_HANDLE_VALUE		=	0xFFFFFFFF
+
+			MAX_PATH					=	260
+
+			BHFI_pack_string			=	'LQQQLLLLLL'
+
+			class ByHandleInformation
+
+				def initialize(path)
+
+					@volume_id	=	0
+					@file_index	=	0
+					@num_links	=	0
+
+					# for some reason not forcing this new string causes 'can't modify frozen string (TypeError)' (in Ruby 1.8.x)
+					hFile = CreateFile.call("#{path}", 0, 0, NULL, OPEN_EXISTING, 0, NULL);
+					if INVALID_HANDLE_VALUE != hFile
+
+						begin
+							bhfi	=	[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
+							bhfi	=	bhfi.pack(BHFI_pack_string)
+
+							if GetFileInformationByHandle.call(hFile, bhfi)
+
+								bhfi		=	bhfi.unpack(BHFI_pack_string)
+
+								@volume_id	=	bhfi[4]
+								@file_index	=	(bhfi[8] << 32) | bhfi[9]
+								@num_links	=	bhfi[7]
+							else
+							end
+						ensure
+							CloseHandle.call(hFile)
+						end
+					end
+				end
+
+				attr_reader :volume_id
+				attr_reader :file_index
+				attr_reader :num_links
+			end
+
+			private
+			def has_attribute_? (attr)
+
+				0 != (attr & @attributes)
+			end
+
+			private
+			def initialize(path)
+
+				@path = path
+
+				# for some reason not forcing this new string causes 'can't modify frozen string (TypeError)'
+				attributes = GetFileAttributes.call("#{path}")
+
+				if 0xffffffff == attributes
+					@attributes = 0
+				else
+					@attributes = attributes
+				end
+
+				super(path)
+
+				@by_handle_information = ByHandleInformation.new(path)
+
+				buff = ' ' * MAX_PATH
+				n = GetShortPathName.call(path, buff, buff.length)
+				@short_path = (0 == n) ? nil : buff[0...n]
+			end
+
+			public
+			attr_reader :attributes
+			attr_reader :path
+			attr_reader :by_handle_information
+			attr_reader :short_path
+
+			def hidden?
+
+				0 != (FILE_ATTRIBUTE_HIDDEN & @attributes)
+			end
+
+			# Windows-specific attributes
+
+			def system?
+
+				has_attribute_? FILE_ATTRIBUTE_SYSTEM
+			end
+
+			def archive?
+
+				has_attribute_? FILE_ATTRIBUTE_ARCHIVE
+			end
+
+			def device?
+
+				has_attribute_? FILE_ATTRIBUTE_DEVICE
+			end
+
+			def normal?
+
+				has_attribute_? FILE_ATTRIBUTE_NORMAL
+			end
+
+			def temporary?
+
+				has_attribute_? FILE_ATTRIBUTE_TEMPORARY
+			end
+
+			def compressed?
+
+				has_attribute_? FILE_ATTRIBUTE_COMPRESSED
+			end
+
+			def encrypted?
+
+				has_attribute_? FILE_ATTRIBUTE_ENCRYPTED
+			end
+
+
+			public
+			def FileStat.stat(path)
+
+				Recls::Ximpl::FileStat.new(path)
+			end
+		end
+	end
+end
+
+# ############################## end of file ############################# #
+

data/test/scratch/test_display_parts.rb

@@ -0,0 +1,40 @@
+#! /usr/bin/ruby
+#
+# test Recls entry methods
+
+$:.unshift File.join(File.dirname(__FILE__), '../..', 'lib')
+
+require 'recls'
+
+Recls::FileSearch.new(nil, nil, Recls::FILES | Recls::RECURSIVE).each do |fe|
+
+	puts
+	puts fe.path
+	puts fe.short_path
+	puts fe.directory_path
+	puts fe.drive
+	puts "".ljust(fe.drive.size) + fe.directory
+	puts "".ljust(fe.directory_path.size) + fe.file
+	puts "".ljust(fe.directory_path.size) + fe.file_short_name
+	puts "".ljust(fe.directory_path.size) + fe.stem
+	puts "".ljust(fe.directory_path.size + fe.stem.size) + fe.extension
+	n = fe.drive.size
+	fe.directory_parts.each do |part|
+
+	puts "".ljust(n) + part
+	n += part.size
+	end
+
+	puts fe.search_directory
+	puts "".ljust(fe.search_directory.size) + fe.search_relative_path
+	puts "".ljust(fe.search_directory.size) + fe.search_relative_directory_path
+	puts "".ljust(fe.search_directory.size) + fe.search_relative_directory
+
+	n = fe.search_directory.size
+	fe.search_relative_directory_parts.each do |part|
+
+	puts "".ljust(n) + part
+	n += part.size
+	end
+end
+

data/test/scratch/test_entry.rb

@@ -0,0 +1,81 @@
+#! /usr/bin/ruby
+#
+# test Recls entry methods
+
+$:.unshift File.join(File.dirname(__FILE__), '../..', 'lib')
+
+require 'recls'
+
+puts "PATH_NAME_SEPARATOR:\t[#{Recls::PATH_NAME_SEPARATOR}]"
+puts "PATH_SEPARATOR:\t[#{Recls::PATH_SEPARATOR}]"
+puts "WILDCARDS_ALL:\t[#{Recls::WILDCARDS_ALL}]"
+
+def show_entry f
+
+puts "entry:"
+puts "\t#{'(entry)'.ljust(20)}\t#{f}"
+puts "\t#{'f.path'.ljust(20)}\t#{f.path}"
+puts "\t#{'f.drive'.ljust(20)}\t#{f.drive}"
+puts "\t#{'f.directory_path'.ljust(20)}\t#{f.directory_path}"
+puts "\t#{'f.directory'.ljust(20)}\t#{f.directory}"
+directory_parts = f.directory_parts
+puts "\t#{'f.directory_parts'.ljust(20)}\t[#{directory_parts.size}]"
+directory_parts.each do |part|
+	puts "\t#{''.ljust(20)}\t\t#{part}"
+end
+search_relative_directory_parts = f.search_relative_directory_parts
+puts "\t#{'f.search_relative_directory_parts'.ljust(20)}\t[#{search_relative_directory_parts.size}]"
+search_relative_directory_parts.each do |part|
+	puts "\t#{''.ljust(20)}\t\t#{part}"
+end
+puts "\t#{'f.file_full_name'.ljust(20)}\t#{f.file_full_name}"
+puts "\t#{'f.file_short_name'.ljust(20)}\t#{f.file_short_name}"
+puts "\t#{'f.file_name_only'.ljust(20)}\t#{f.file_name_only}"
+puts "\t#{'f.stem'.ljust(20)}\t#{f.stem}"
+puts "\t#{'f.file_extension'.ljust(20)}\t#{f.file_extension}"
+puts "\t#{'f.search_directory'.ljust(20)}\t#{f.search_directory}"
+puts "\t#{'f.search_relative_path'.ljust(20)}\t#{f.search_relative_path}"
+puts "\t#{'f.search_relative_directory'.ljust(20)}\t#{f.search_relative_directory}"
+puts "\t#{'f.search_relative_directory_path'.ljust(20)}\t#{f.search_relative_directory_path}"
+
+puts "\t#{'f.size'.ljust(20)}\t#{f.size}"
+
+puts "\t#{'f.exist?'.ljust(20)}\t#{f.exist?}"
+puts "\t#{'f.hidden?'.ljust(20)}\t#{f.hidden?}"
+puts "\t#{'f.readonly?'.ljust(20)}\t#{f.readonly?}"
+puts "\t#{'f.directory?'.ljust(20)}\t#{f.directory?}"
+puts "\t#{'f.file?'.ljust(20)}\t#{f.file?}"
+puts "\t#{'f.socket?'.ljust(20)}\t#{f.socket?}"
+
+puts "\t#{'f.modification_time'.ljust(20)}\t#{f.modification_time}"
+puts "\t#{'f.last_access_time'.ljust(20)}\t#{f.last_access_time}"
+end
+
+puts
+puts "stat of '.':"
+show_entry Recls::stat '.'
+
+puts
+puts "stat of '~':"
+show_entry Recls::stat '~'
+
+puts
+puts "directories:"
+num_directories = 0
+Recls::FileSearch.new('.', '*', Recls::DIRECTORIES).each do |fe|
+
+	num_directories += 1
+	puts "\t[#{fe.search_relative_path}]"
+end
+puts "  #{num_directories} directories"
+
+puts
+puts "files:"
+num_files = 0
+Recls::FileSearch.new('.', '*.rb', Recls::RECURSIVE | Recls::FILES).each do |fe|
+
+	num_files += 1
+	puts "\t<#{fe.search_relative_path}>"
+end
+puts "  #{num_files} file(s)"
+

data/test/scratch/test_foreach.rb

@@ -0,0 +1,41 @@
+#! /usr/bin/ruby
+#
+# test Recls search methods
+
+$:.unshift File.join(File.dirname(__FILE__), '../..', 'lib')
+
+
+#require 'recls/util'
+require 'recls/foreach'
+#require 'recls'
+
+puts
+puts "with given block:"
+count_1 = 0
+Recls.foreach(Recls::FileSearch.new(nil, '*.rb', Recls::RECURSIVE)).each do |line, line_number, fe|
+
+	line		=	line.chomp
+	line_number	=	1 + line_number
+
+	puts "#{fe.search_relative_path}(#{line_number + 1}): #{line}"
+
+	count_1 += 1
+	break if 20 == count_1
+end
+
+puts
+puts "as returned enumerator:"
+e = Recls.foreach(Recls::FileSearch.new(nil, '*.rb', Recls::RECURSIVE))
+count_2 = 0
+e.each do |line, line_number, fe|
+
+	line		=	line.chomp
+	line_number	=	1 + line_number
+
+	puts "#{fe.search_relative_path}(#{line_number + 1}): #{line}"
+
+	count_2 += 1
+	break if 20 == count_2
+end
+
+

data/test/scratch/test_show_dev_and_ino.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/ruby
+#
+# Demonstrates use of dev and ino attributes
+
+$:.unshift File.join(File.dirname(__FILE__), '../..', 'lib')
+
+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}"
+end
+

data/test/scratch/test_show_hidden.rb

@@ -0,0 +1,30 @@
+#! /usr/bin/ruby
+#
+# Demonstrates search of hidden files
+
+$:.unshift File.join(File.dirname(__FILE__), '../..', 'lib')
+
+require 'recls'
+
+puts
+puts "Hidden directories:"
+Recls::FileSearch.new(nil, nil, Recls::RECURSIVE | Recls::DIRECTORIES | Recls::SHOW_HIDDEN).each do |fe|
+
+	puts "\t#{fe.search_relative_path}" if fe.hidden?
+end
+
+puts
+puts "Hidden files:"
+Recls::FileSearch.new(nil, nil, Recls::RECURSIVE | Recls::FILES | Recls::SHOW_HIDDEN).each do |fe|
+
+	puts "\t#{fe.search_relative_path}" if fe.hidden?
+end
+
+
+puts
+puts "Hidden directories & files:"
+Recls::FileSearch.new(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?
+end
+

data/test/unit/tc_recls_entries.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/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
+
+	def test_entries_in_directory_have_unique_names
+
+		entries			=	Recls::FileSearch.new('~', Recls::WILDCARDS_ALL, Recls::FILES).to_a
+
+		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
+
+		entries.each_with_index do |entry, index|
+
+			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)
+
+			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_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
+end
+