Module: Rigup::Utils::File

Defined in:
lib/rigup/utils/file.rb

Class Method Summary collapse

Class Method Details

.append_slash(aPath, aSep = nil) ⇒ Object 



18
19
20
21
 
# File 'lib/rigup/utils/file.rb', line 18

def append_slash(aPath, aSep=nil)
  aSep = sniff_seperator(aPath) unless aSep
  aPath.ensure_suffix(aSep)
end

.canonize_path(aPath, aRootPath = nil) ⇒ Object

takes a path and combines it with a root path (which defaults to Dir.pwd) unless it is absolute the final result is then expanded



65
66
67
68
69
 
# File 'lib/rigup/utils/file.rb', line 65

def canonize_path(aPath, aRootPath=nil)
  path = path_combine(aRootPath, aPath)
  path = real_path(path) if path
  path
end

.change_ext(aFile, aExt, aExtend = false) ⇒ Object 



121
122
123
 
# File 'lib/rigup/utils/file.rb', line 121

def change_ext(aFile, aExt, aExtend=false)
  no_extension(aFile, false)+(aExtend ? '.'+aExt+'.'+extension(aFile, false) : '.'+aExt)
end

.expand_magic_path(aPath, aBasePath = nil) ⇒ Object

allows special symbols in path currently only … supported, which looks upward in the filesystem for the following relative path from the basepath



81
82
83
84
85
86
87
88
 
# File 'lib/rigup/utils/file.rb', line 81

def expand_magic_path(aPath, aBasePath=nil)
  aBasePath ||= Dir.pwd
  path = aPath
  if path.begins_with?('...')
    rel_part = path.split3(/\.\.\.[\/\\]/)[2]
    path = find_upwards(aBasePath, rel_part)
  end
end

.extension(aFile, aExtended = true) ⇒ Object 



110
111
112
113
114
 
# File 'lib/rigup/utils/file.rb', line 110

def extension(aFile, aExtended=true)
  f = ::File.basename(aFile)
  dot = aExtended ? f.index('.') : f.rindex('.')
  return dot ? f[dot+1..-1] : f
end

.find_upwards(aStartPath, aPath) ⇒ Object 



71
72
73
74
75
76
77
 
# File 'lib/rigup/utils/file.rb', line 71

def find_upwards(aStartPath, aPath)
  curr_path = ::File.expand_path(aStartPath)
  while curr_path && !(test_path_exists = ::File.exists?(test_path = ::File.join(curr_path, aPath))) do
    curr_path = path_parent(curr_path)
  end
  curr_path && test_path_exists ? test_path : nil
end

.no_extension(aFile, aExtended = true) ⇒ Object 



116
117
118
119
 
# File 'lib/rigup/utils/file.rb', line 116

def no_extension(aFile, aExtended=true)
  ext = extension(aFile, aExtended)
  return aFile.chomp('.'+ext)
end

.path_combine(aBasePath, aPath) ⇒ Object 



52
53
54
55
56
 
# File 'lib/rigup/utils/file.rb', line 52

def path_combine(aBasePath, aPath)
  return aBasePath if !aPath
  return aPath if !aBasePath
  return path_relative?(aPath) ? ::File.join(aBasePath, aPath) : aPath
end

.path_debase(aPath, aBase) ⇒ Object

Remove base dir from given path. Result will be relative to base dir and not have a leading or trailing slash ‘/a/b/c’,‘/a’ = ‘b/c’ ‘/a/b/c’,‘/’ = ‘a/b/c’ ‘/’,‘/’ = ”



41
42
43
44
45
 
# File 'lib/rigup/utils/file.rb', line 41

def path_debase(aPath, aBase)
  aBase = append_slash(aBase)
  aPath = remove_slash(aPath) unless aPath=='/'
  aPath[0, aBase.length]==aBase ? aPath[aBase.length, aPath.length-aBase.length] : aPath
end

.path_parent(aPath) ⇒ Object 



90
91
92
93
 
# File 'lib/rigup/utils/file.rb', line 90

def path_parent(aPath)
  return nil if is_root_path?(aPath)
  append_slash(::File.dirname(remove_slash(expand_path(aPath))))
end

.path_parts(aPath) ⇒ Object 



105
106
107
108
 
# File 'lib/rigup/utils/file.rb', line 105

def path_parts(aPath)
  sep = sniff_seperator(aPath)
  aPath.split(sep)
end

.path_rebase(aPath, aOldBase, aNewBase) ⇒ Object 



47
48
49
50
 
# File 'lib/rigup/utils/file.rb', line 47

def path_rebase(aPath, aOldBase, aNewBase)
  rel_path = path_debase(aPath, aOldBase)
  append_slash(aNewBase)+rel_path
end

.real_path(aPath) ⇒ Object

make path real according to file system



59
60
61
 
# File 'lib/rigup/utils/file.rb', line 59

def real_path(aPath)
  (path = Pathname.new(::File.expand_path(aPath))) && path.realpath.to_s
end

.remove_slash(aPath) ⇒ Object 



23
24
25
26
27
 
# File 'lib/rigup/utils/file.rb', line 23

def remove_slash(aPath)
  last_char = aPath[-1, 1]
  aPath = aPath[0..-2] if last_char=='\\' || last_char=='/'
  return aPath
end

.simple_dir_name(aPath) ⇒ Object 



95
96
97
 
# File 'lib/rigup/utils/file.rb', line 95

def simple_dir_name(aPath)
  ::File.basename(remove_slash(aPath))
end

.simple_file_name(aPath) ⇒ Object 



99
100
101
102
103
 
# File 'lib/rigup/utils/file.rb', line 99

def simple_file_name(aPath)
  f = ::File.basename(aPath)
  dot = f.index('.')
  return dot ? f[0, dot] : f
end

.sniff_seperator(aPath) ⇒ Object 



9
10
11
12
13
14
15
16
 
# File 'lib/rigup/utils/file.rb', line 9

def sniff_seperator(aPath)
  result = 0.upto(aPath.length-1) do |i|
    char = aPath[i, 1]
    break char if char=='\\' || char=='/'
  end
  result = ::File::SEPARATOR if result==0
  return result
end