Class: Pathname

10
11
12
13
14
15
16
17
18
19
20
21
22
23

# File 'opal/stdlib/pathname.rb', line 10
def initialize(path)
 if Pathname  === path
 @path = path.path.to_s
 elsif path.respond_to?(:to_path)
 @path = path.to_path
 elsif path.is_a?(String )
 @path = path
 elsif path.nil?
 raise TypeError, 'no implicit conversion of nil into String'
 else
 raise TypeError, "no implicit conversion of #{path.class} into String"
 end
 raise ArgumentError if @path == "0円"
end

29
30
31

# File 'opal/stdlib/pathname.rb', line 29
def path
 @path
end

25
26
27

# File 'opal/stdlib/pathname.rb', line 25
def self.pwd
 new(Dir .pwd )
end

87
88
89
90

# File 'opal/stdlib/pathname.rb', line 87
def +(other)
 other = Pathname .new (other) unless Pathname  === other
 Pathname .new (plus(@path, other.to_s))
end

166
167
168

# File 'opal/stdlib/pathname.rb', line 166
def <=>(other)
 path <=> other.path
end

31
32
33

# File 'opal/stdlib/pathname.rb', line 31
def ==(other)
 other.path == @path
end

35
36
37

# File 'opal/stdlib/pathname.rb', line 35
def absolute?
 !relative?
end

154
155
156

# File 'opal/stdlib/pathname.rb', line 154
def basename
 Pathname .new (File .basename(@path))
end

47
48
49
50
51
52
53
54
55

# File 'opal/stdlib/pathname.rb', line 47
def chop_basename(path) # :nodoc:
 base = File .basename(path)
 # ruby uses /^#{SEPARATOR_PAT}?$/o but having issues with interpolation
 if Regexp .new("^#{Pathname ::SEPARATOR_PAT .source}?$") =~ base
 return nil
 else
 return path[0, path.rindex(base)], base
 end
end

71
72
73

# File 'opal/stdlib/pathname.rb', line 71
def cleanpath
 `return Opal.normalize(#{@path})`
end

158
159
160

# File 'opal/stdlib/pathname.rb', line 158
def directory?
 File .directory? (@path)
end

150
151
152

# File 'opal/stdlib/pathname.rb', line 150
def dirname
 Pathname .new (File .dirname(@path))
end

213
214
215

# File 'opal/stdlib/pathname.rb', line 213
def entries
 Dir .entries (@path).map { |f| self.class.new(f) }
end

83
84
85

# File 'opal/stdlib/pathname.rb', line 83
def expand_path
 Pathname .new (File .expand_path(@path))
end

162
163
164

# File 'opal/stdlib/pathname.rb', line 162
def extname
 File .extname(@path)
end

79
80
81

# File 'opal/stdlib/pathname.rb', line 79
def hash
 @path.hash
end

133
134
135
136
137
138
139
140
141
142
143
144

# File 'opal/stdlib/pathname.rb', line 133
def join(*args)
 return self if args.empty?
 result = args.pop
 result = Pathname .new (result) unless Pathname  === result
 return result if result.absolute?
 args.reverse_each do |arg|
 arg = Pathname .new (arg) unless Pathname  === arg
 result = arg + result
 return result if result.absolute?
 end
 self + result
end

61
62
63
64
65

# File 'opal/stdlib/pathname.rb', line 61
def parent
 new_path = @path.sub(%r{/([^/]+/?$)}, '')
 new_path = absolute? ? '/' : '.' if new_path == ''
 Pathname .new (new_path)
end

92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

# File 'opal/stdlib/pathname.rb', line 92
def plus(path1, path2) # -> path # :nodoc:
 prefix2 = path2
 index_list2 = []
 basename_list2 = []
 while (r2 = chop_basename(prefix2))
 prefix2, basename2 = r2
 index_list2.unshift prefix2.length
 basename_list2.unshift basename2
 end
 return path2 if prefix2 != ''
 prefix1 = path1
 while true
 while !basename_list2.empty? && basename_list2.first == '.'
 index_list2.shift
 basename_list2.shift
 end
 break unless (r1 = chop_basename(prefix1))
 prefix1, basename1 = r1
 next if basename1 == '.'
 if basename1 == '..' || basename_list2.empty? || basename_list2.first != '..'
 prefix1 += basename1
 break
 end
 index_list2.shift
 basename_list2.shift
 end
 r1 = chop_basename(prefix1)
 if !r1 && /#{SEPARATOR_PAT }/ =~ File .basename(prefix1)
 while !basename_list2.empty? && basename_list2.first == '..'
 index_list2.shift
 basename_list2.shift
 end
 end
 if !basename_list2.empty?
 suffix2 = path2[index_list2.first..-1]
 r1 ? File .join (prefix1, suffix2) : prefix1 + suffix2
 else
 r1 ? prefix1 : File .dirname(prefix1)
 end
end

39
40
41
42
43
44
45

# File 'opal/stdlib/pathname.rb', line 39
def relative?
 path = @path
 while (r = chop_basename(path))
 path, = r
 end
 path == ''
end

177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211

# File 'opal/stdlib/pathname.rb', line 177
def relative_path_from(base_directory)
 dest_directory = cleanpath.to_s
 base_directory = base_directory.cleanpath.to_s
 dest_prefix = dest_directory
 dest_names = []
 while (r = chop_basename(dest_prefix))
 dest_prefix, basename = r
 dest_names.unshift basename if basename != '.'
 end
 base_prefix = base_directory
 base_names = []
 while (r = chop_basename(base_prefix))
 base_prefix, basename = r
 base_names.unshift basename if basename != '.'
 end
 unless SAME_PATHS [dest_prefix, base_prefix]
 raise ArgumentError, "different prefix: #{dest_prefix.inspect} and #{base_directory.inspect}"
 end
 while !dest_names.empty? &&
 !base_names.empty? &&
 SAME_PATHS [dest_names.first, base_names.first]
 dest_names.shift
 base_names.shift
 end
 if base_names.include? '..'
 raise ArgumentError, "base_directory has ..: #{base_directory.inspect}"
 end
 base_names.fill('..')
 relpath_names = base_names + dest_names
 if relpath_names.empty?
 Pathname .new ('.')
 else
 Pathname .new (File .join (*relpath_names))
 end
end

57
58
59

# File 'opal/stdlib/pathname.rb', line 57
def root?
 @path == '/'
end

146
147
148

# File 'opal/stdlib/pathname.rb', line 146
def split
 [dirname, basename]
end

67
68
69

# File 'opal/stdlib/pathname.rb', line 67
def sub(*args)
 Pathname .new (@path.sub(*args))
end

75
76
77

# File 'opal/stdlib/pathname.rb', line 75
def to_path
 @path
end

219
220
221

# File 'opal/stdlib/pathname.rb', line 219
def to_path
 @path
end

220
221
222

# File 'opal/stdlib/pathname.rb', line 220
def to_path
 @path
end