Module: Recls::Ximpl

Defined in:
lib/recls/ximpl/os.rb,
lib/recls/ximpl/unix.rb,
lib/recls/ximpl/util.rb,
lib/recls/ximpl/windows.rb

Defined Under Namespace

Modules: OS, Util Classes: FileStat

Class Method Summary collapse

Class Method Details

.absolute_path(path, refdir = nil) ⇒ Object

determines the absolute path of a given path



401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
 
# File 'lib/recls/ximpl/util.rb', line 401

def self.absolute_path(path, refdir = nil)

	case path
	when ::NilClass
		return nil
	when ::String
	when ::Recls::Entry
		path = path.to_s
	else
		raise TypeError, "parameter path ('#{path}') is of type #{path.class} must be an instance of #{::String} or #{::Recls::Entry}"
	end

	return '' if path.empty?

	f1_windows_root, f2_directory, f3_basename, dummy1, dummy2, dummy3, dummy4 = Util.split_path(path)

	if f2_directory =~ /^[\\\/]/
		return path
	end

	cwd = refdir ? refdir : Dir.getwd

	trailing_slash = Util.get_trailing_slash(path)

	if '.' == path
		return Util.trim_trailing_slash cwd
	elsif 2 == path.size and trailing_slash
		return Util.append_trailing_slash(cwd, path[1..1])
	end

	cwd = Util.append_trailing_slash(cwd)

	path = "#{cwd}#{path}"

	path = canonicalise_path path

	if trailing_slash
		path = Util.append_trailing_slash path, trailing_slash
	else
		path = Util.trim_trailing_slash path
	end

	path
end

.basename(path) ⇒ Object

obtains the basename of a path, e.g. the basename of

abc/def/ghi.jkl

or (on Windows)

C:\abc\def\ghi.jkl

is

ghi.jkl



454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
 
# File 'lib/recls/ximpl/util.rb', line 454

def self.basename(path)

	return nil if not path

	# NOTE: we don't implement in terms of split_path
	# because all but the UNC case work with just
	# detecting the last (back)slash

	if Recls::Ximpl::OS::OS_IS_WINDOWS
		wr, rem = Util.get_windows_root(path)

		if not rem
			return ''
		else
			path = rem
		end
	end

	if not path.is_a? String
		path = path.to_s
	end

	if path =~ /^.*[\/\\](.*)/
		$1
	else
		path
	end
end

.canonicalise_path(path) ⇒ Object

Canonicalises a path

Note: contains a trailing slash if, in the context of the given path, the last element of the canonicalised path is a directory unequivocally



383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
 
# File 'lib/recls/ximpl/util.rb', line 383

def self.canonicalise_path(path)

	return nil if not path
	return '' if path.empty?

	f1_windows_root, f2_directory, f3_basename, dummy1, dummy2, directory_parts, dummy3 = Util.split_path(path)

	if not f2_directory
		canonicalised_directory = nil
	else
		canonicalised_directory, consume_basename = Util.canonicalise_parts(directory_parts, f3_basename)
		f3_basename = nil if consume_basename
	end

	return "#{f1_windows_root}#{canonicalised_directory}#{f3_basename}"
end

.combine_paths(origin, path, options) ⇒ Object 



602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
 
# File 'lib/recls/ximpl/util.rb', line 602

def self.combine_paths(origin, path, options)

	f1_windows_root, f2_directory, f3_basename, dummy1, dummy2, dummy3, dummy4 = Util.split_path(path)

#			return path if f1_windows_root
	return path if f2_directory && Util.is_path_name_separator(f2_directory[0])

	r	=	File.join origin, path

	if options[:clean_path]

		r = Pathname.new(r).cleanpath
	end

	r
end

.derive_relative_path(origin, path) ⇒ Object

obtains the relative path of a given path and a reference directory



548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
 
# File 'lib/recls/ximpl/util.rb', line 548

def self.derive_relative_path(origin, path)

	return nil if path.nil?
	return nil if path.empty?
	return path if origin.nil?
	return path if origin.empty?

	path			=	self.canonicalise_path path
	origin			=	self.canonicalise_path origin

	path_splits		=	Util.split_path(path)
	origin_splits	=	Util.split_path(origin)

	# if different windows root, then cannot provide relative
	if path_splits[0] and origin_splits[0]
		return path if path_splits[0] != origin_splits[0]
	end

	trailing_slash	=	Util.get_trailing_slash(path)

	path_parts		=	path_splits[6]
	origin_parts	=	origin_splits[6]

	while true

		break if path_parts.empty?
		break if origin_parts.empty?

		path_part	=	path_parts[0]
		origin_part	=	origin_parts[0]

		if 1 == path_parts.size || 1 == origin_parts.size
			path_part	=	Util.append_trailing_slash(path_part)
			origin_part	=	Util.append_trailing_slash(origin_part)
		end

		if path_part == origin_part
			path_parts.shift
			origin_parts.shift
		else
			break
		end
	end

	return ".#{trailing_slash}" if path_parts.empty? and origin_parts.empty?

	# at this point, all reference parts should be converted into '..'

	return origin_parts.map { |rp| '..' }.join('/') if path_parts.empty?

	return '../' * origin_parts.size + path_parts.join('')
end

.dir_entries_maybe(dir, flags) ⇒ Object

Elicits the contents of the given directory, or, if the flag STOP_ON_ACCESS_FAILURE is specified throws an exception if the directory does not exist

Some known conditions:

  • (Mac OSX) /dev/fd/<N> - some of these stat() as directories but

    Dir.new fails with ENOTDIR



629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
 
# File 'lib/recls/ximpl/util.rb', line 629

def self.dir_entries_maybe(dir, flags)

	begin

		Dir.new(dir).to_a

	rescue SystemCallError => x

		# TODO this should be filtered up and/or logged

		if(0 != (STOP_ON_ACCESS_FAILURE & flags))
			raise
		end

		return []
	end
end

.directory_from_directory_path(directory_path) ⇒ Object

obtains the directory from the directory path



519
520
521
522
523
524
 
# File 'lib/recls/ximpl/util.rb', line 519

def self.directory_from_directory_path(directory_path)

	wr, rem =  Util.get_windows_root(directory_path)

	rem
end

.directory_parts_from_directory(directory) ⇒ Object

obtains the directory parts from a directory



527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
 
# File 'lib/recls/ximpl/util.rb', line 527

def self.directory_parts_from_directory(directory)

	return nil if not directory

	directory_parts = []

	until directory.empty?
		if directory =~ /^([^\\\/]*[\\\/])/
			directory_parts << $1
			directory = $'
		else
			directory_parts << directory
			directory = ''
		end
	end

	directory_parts
end

.file_ext(path) ⇒ Object

obtains the file extension of a basename, e.g. the file_ext of

ghi.jkl

is

.jkl



488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
 
# File 'lib/recls/ximpl/util.rb', line 488

def self.file_ext(path)

	return nil if not path

	use_split_path = false

	if Recls::Ximpl::OS::OS_IS_WINDOWS
		if path.include? ?\\
			use_split_path = true
		end
	end

	if path.include? ?/
		use_split_path = true
	end

	if use_split_path
		ext = Util.split_path(path)[4]
	else
		if path =~ /^.*(\.[^.]*)$/
			ext = $1
		else
			ext = nil
		end
	end

	return ext ? ext : ''
end