source: extensions/gsdl-video/trunk/installed/cmdline/lib/ruby/1.8/uri/generic.rb@ 18425

Last change on this file since 18425 was 18425, checked in by davidb, 15 years ago

Video extension to Greenstone
File size: 23.6 KB
Line 
1#
2# = uri/generic.rb
3#
4# Author:: Akira Yamada <[email protected]>
5# License:: You can redistribute it and/or modify it under the same term as Ruby.
6# Revision:: $Id: generic.rb 11751 2007-02-15 07:45:04Z knu $
7#
8
9require 'uri/common'
10
11module URI
12
13 #
14 # Base class for all URI classes.
15 # Implements generic URI syntax as per RFC 2396.
16 #
17 class Generic
18 include URI
19 include REGEXP
20
21 DEFAULT_PORT = nil
22
23 #
24 # Returns default port
25 #
26 def self.default_port
27 self::DEFAULT_PORT
28 end
29
30 def default_port
31 self.class.default_port
32 end
33
34 COMPONENT = [
35 :scheme,
36 :userinfo, :host, :port, :registry,
37 :path, :opaque,
38 :query,
39 :fragment
40 ].freeze
41
42 #
43 # Components of the URI in the order.
44 #
45 def self.component
46 self::COMPONENT
47 end
48
49 USE_REGISTRY = false
50
51 #
52 # DOC: FIXME!
53 #
54 def self.use_registry
55 self::USE_REGISTRY
56 end
57
58 #
59 # == Synopsis
60 #
61 # See #new
62 #
63 # == Description
64 #
65 # At first, tries to create a new URI::Generic instance using
66 # URI::Generic::build. But, if exception URI::InvalidComponentError is raised,
67 # then it URI::Escape.escape all URI components and tries again.
68 #
69 #
70 def self.build2(args)
71 begin
72 return self.build(args)
73 rescue InvalidComponentError
74 if args.kind_of?(Array)
75 return self.build(args.collect{|x|
76 if x
77 URI.escape(x)
78 else
79 x
80 end
81 })
82 elsif args.kind_of?(Hash)
83 tmp = {}
84 args.each do |key, value|
85 tmp[key] = if value
86 URI.escape(value)
87 else
88 value
89 end
90 end
91 return self.build(tmp)
92 end
93 end
94 end
95
96 #
97 # == Synopsis
98 #
99 # See #new
100 #
101 # == Description
102 #
103 # Creates a new URI::Generic instance from components of URI::Generic
104 # with check. Components are: scheme, userinfo, host, port, registry, path,
105 # opaque, query and fragment. You can provide arguments either by an Array or a Hash.
106 # See #new for hash keys to use or for order of array items.
107 #
108 def self.build(args)
109 if args.kind_of?(Array) &&
110 args.size == ::URI::Generic::COMPONENT.size
111 tmp = args
112 elsif args.kind_of?(Hash)
113 tmp = ::URI::Generic::COMPONENT.collect do |c|
114 if args.include?(c)
115 args[c]
116 else
117 nil
118 end
119 end
120 else
121 raise ArgumentError,
122 "expected Array of or Hash of components of #{self.class} (#{self.class.component.join(', ')})"
123 end
124
125 tmp << true
126 return self.new(*tmp)
127 end
128 #
129 # == Args
130 #
131 # +scheme+::
132 # Protocol scheme, i.e. 'http','ftp','mailto' and so on.
133 # +userinfo+::
134 # User name and password, i.e. 'sdmitry:bla'
135 # +host+::
136 # Server host name
137 # +port+::
138 # Server port
139 # +registry+::
140 # DOC: FIXME!
141 # +path+::
142 # Path on server
143 # +opaque+::
144 # DOC: FIXME!
145 # +query+::
146 # Query data
147 # +fragment+::
148 # A part of URI after '#' sign
149 # +arg_check+::
150 # Check arguments [false by default]
151 #
152 # == Description
153 #
154 # Creates a new URI::Generic instance from ``generic'' components without check.
155 #
156 def initialize(scheme,
157 userinfo, host, port, registry,
158 path, opaque,
159 query,
160 fragment,
161 arg_check = false)
162 @scheme = nil
163 @user = nil
164 @password = nil
165 @host = nil
166 @port = nil
167 @path = nil
168 @query = nil
169 @opaque = nil
170 @registry = nil
171 @fragment = nil
172
173 if arg_check
174 self.scheme = scheme
175 self.userinfo = userinfo
176 self.host = host
177 self.port = port
178 self.path = path
179 self.query = query
180 self.opaque = opaque
181 self.registry = registry
182 self.fragment = fragment
183 else
184 self.set_scheme(scheme)
185 self.set_userinfo(userinfo)
186 self.set_host(host)
187 self.set_port(port)
188 self.set_path(path)
189 self.set_query(query)
190 self.set_opaque(opaque)
191 self.set_registry(registry)
192 self.set_fragment(fragment)
193 end
194 if @registry && !self.class.use_registry
195 raise InvalidURIError,
196 "the scheme #{@scheme} does not accept registry part: #{@registry} (or bad hostname?)"
197 end
198
199 @scheme.freeze if @scheme
200 self.set_path('') if !@path && !@opaque # (see RFC2396 Section 5.2)
201 self.set_port(self.default_port) if self.default_port && !@port
202 end
203 attr_reader :scheme
204 attr_reader :host
205 attr_reader :port
206 attr_reader :registry
207 attr_reader :path
208 attr_reader :query
209 attr_reader :opaque
210 attr_reader :fragment
211
212 # replace self by other URI object
213 def replace!(oth)
214 if self.class != oth.class
215 raise ArgumentError, "expected #{self.class} object"
216 end
217
218 component.each do |c|
219 self.__send__("#{c}=", oth.__send__(c))
220 end
221 end
222 private :replace!
223
224 def component
225 self.class.component
226 end
227
228 def check_scheme(v)
229 if v && SCHEME !~ v
230 raise InvalidComponentError,
231 "bad component(expected scheme component): #{v}"
232 end
233
234 return true
235 end
236 private :check_scheme
237
238 def set_scheme(v)
239 @scheme = v
240 end
241 protected :set_scheme
242
243 def scheme=(v)
244 check_scheme(v)
245 set_scheme(v)
246 v
247 end
248
249 def check_userinfo(user, password = nil)
250 if !password
251 user, password = split_userinfo(user)
252 end
253 check_user(user)
254 check_password(password, user)
255
256 return true
257 end
258 private :check_userinfo
259
260 def check_user(v)
261 if @registry || @opaque
262 raise InvalidURIError,
263 "can not set user with registry or opaque"
264 end
265
266 return v unless v
267
268 if USERINFO !~ v
269 raise InvalidComponentError,
270 "bad component(expected userinfo component or user component): #{v}"
271 end
272
273 return true
274 end
275 private :check_user
276
277 def check_password(v, user = @user)
278 if @registry || @opaque
279 raise InvalidURIError,
280 "can not set password with registry or opaque"
281 end
282 return v unless v
283
284 if !user
285 raise InvalidURIError,
286 "password component depends user component"
287 end
288
289 if USERINFO !~ v
290 raise InvalidComponentError,
291 "bad component(expected user component): #{v}"
292 end
293
294 return true
295 end
296 private :check_password
297
298 #
299 # Sets userinfo, argument is string like 'name:pass'
300 #
301 def userinfo=(userinfo)
302 if userinfo.nil?
303 return nil
304 end
305 check_userinfo(*userinfo)
306 set_userinfo(*userinfo)
307 # returns userinfo
308 end
309
310 def user=(user)
311 check_user(user)
312 set_user(user)
313 # returns user
314 end
315
316 def password=(password)
317 check_password(password)
318 set_password(password)
319 # returns password
320 end
321
322 def set_userinfo(user, password = nil)
323 unless password
324 user, password = split_userinfo(user)
325 end
326 @user = user
327 @password = password if password
328
329 [@user, @password]
330 end
331 protected :set_userinfo
332
333 def set_user(v)
334 set_userinfo(v, @password)
335 v
336 end
337 protected :set_user
338
339 def set_password(v)
340 @password = v
341 # returns v
342 end
343 protected :set_password
344
345 def split_userinfo(ui)
346 return nil, nil unless ui
347 user, password = ui.split(/:/, 2)
348
349 return user, password
350 end
351 private :split_userinfo
352
353 def escape_userpass(v)
354 v = URI.escape(v, /[@:\/]/o) # RFC 1738 section 3.1 #/
355 end
356 private :escape_userpass
357
358 def userinfo
359 if @user.nil?
360 nil
361 elsif @password.nil?
362 @user
363 else
364 @user + ':' + @password
365 end
366 end
367
368 def user
369 @user
370 end
371
372 def password
373 @password
374 end
375
376 def check_host(v)
377 return v unless v
378
379 if @registry || @opaque
380 raise InvalidURIError,
381 "can not set host with registry or opaque"
382 elsif HOST !~ v
383 raise InvalidComponentError,
384 "bad component(expected host component): #{v}"
385 end
386
387 return true
388 end
389 private :check_host
390
391 def set_host(v)
392 @host = v
393 end
394 protected :set_host
395
396 def host=(v)
397 check_host(v)
398 set_host(v)
399 v
400 end
401
402 def check_port(v)
403 return v unless v
404
405 if @registry || @opaque
406 raise InvalidURIError,
407 "can not set port with registry or opaque"
408 elsif !v.kind_of?(Fixnum) && PORT !~ v
409 raise InvalidComponentError,
410 "bad component(expected port component): #{v}"
411 end
412
413 return true
414 end
415 private :check_port
416
417 def set_port(v)
418 unless !v || v.kind_of?(Fixnum)
419 if v.empty?
420 v = nil
421 else
422 v = v.to_i
423 end
424 end
425 @port = v
426 end
427 protected :set_port
428
429 def port=(v)
430 check_port(v)
431 set_port(v)
432 port
433 end
434
435 def check_registry(v)
436 return v unless v
437
438 # raise if both server and registry are not nil, because:
439 # authority = server | reg_name
440 # server = [ [ userinfo "@" ] hostport ]
441 if @host || @port || @user # userinfo = @user + ':' + @password
442 raise InvalidURIError,
443 "can not set registry with host, port, or userinfo"
444 elsif v && REGISTRY !~ v
445 raise InvalidComponentError,
446 "bad component(expected registry component): #{v}"
447 end
448
449 return true
450 end
451 private :check_registry
452
453 def set_registry(v)
454 @registry = v
455 end
456 protected :set_registry
457
458 def registry=(v)
459 check_registry(v)
460 set_registry(v)
461 v
462 end
463
464 def check_path(v)
465 # raise if both hier and opaque are not nil, because:
466 # absoluteURI = scheme ":" ( hier_part | opaque_part )
467 # hier_part = ( net_path | abs_path ) [ "?" query ]
468 if v && @opaque
469 raise InvalidURIError,
470 "path conflicts with opaque"
471 end
472
473 if @scheme
474 if v && v != '' && ABS_PATH !~ v
475 raise InvalidComponentError,
476 "bad component(expected absolute path component): #{v}"
477 end
478 else
479 if v && v != '' && ABS_PATH !~ v && REL_PATH !~ v
480 raise InvalidComponentError,
481 "bad component(expected relative path component): #{v}"
482 end
483 end
484
485 return true
486 end
487 private :check_path
488
489 def set_path(v)
490 @path = v
491 end
492 protected :set_path
493
494 def path=(v)
495 check_path(v)
496 set_path(v)
497 v
498 end
499
500 def check_query(v)
501 return v unless v
502
503 # raise if both hier and opaque are not nil, because:
504 # absoluteURI = scheme ":" ( hier_part | opaque_part )
505 # hier_part = ( net_path | abs_path ) [ "?" query ]
506 if @opaque
507 raise InvalidURIError,
508 "query conflicts with opaque"
509 end
510
511 if v && v != '' && QUERY !~ v
512 raise InvalidComponentError,
513 "bad component(expected query component): #{v}"
514 end
515
516 return true
517 end
518 private :check_query
519
520 def set_query(v)
521 @query = v
522 end
523 protected :set_query
524
525 def query=(v)
526 check_query(v)
527 set_query(v)
528 v
529 end
530
531 def check_opaque(v)
532 return v unless v
533
534 # raise if both hier and opaque are not nil, because:
535 # absoluteURI = scheme ":" ( hier_part | opaque_part )
536 # hier_part = ( net_path | abs_path ) [ "?" query ]
537 if @host || @port || @user || @path # userinfo = @user + ':' + @password
538 raise InvalidURIError,
539 "can not set opaque with host, port, userinfo or path"
540 elsif v && OPAQUE !~ v
541 raise InvalidComponentError,
542 "bad component(expected opaque component): #{v}"
543 end
544
545 return true
546 end
547 private :check_opaque
548
549 def set_opaque(v)
550 @opaque = v
551 end
552 protected :set_opaque
553
554 def opaque=(v)
555 check_opaque(v)
556 set_opaque(v)
557 v
558 end
559
560 def check_fragment(v)
561 return v unless v
562
563 if v && v != '' && FRAGMENT !~ v
564 raise InvalidComponentError,
565 "bad component(expected fragment component): #{v}"
566 end
567
568 return true
569 end
570 private :check_fragment
571
572 def set_fragment(v)
573 @fragment = v
574 end
575 protected :set_fragment
576
577 def fragment=(v)
578 check_fragment(v)
579 set_fragment(v)
580 v
581 end
582
583 #
584 # Checks if URI has a path
585 #
586 def hierarchical?
587 if @path
588 true
589 else
590 false
591 end
592 end
593
594 #
595 # Checks if URI is an absolute one
596 #
597 def absolute?
598 if @scheme
599 true
600 else
601 false
602 end
603 end
604 alias absolute absolute?
605
606 #
607 # Checks if URI is relative
608 #
609 def relative?
610 !absolute?
611 end
612
613 def split_path(path)
614 path.split(%r{/+}, -1)
615 end
616 private :split_path
617
618 def merge_path(base, rel)
619 # RFC2396, Section 5.2, 5)
620 if rel[0] == ?/ #/
621 # RFC2396, Section 5.2, 5)
622 return rel
623
624 else
625 # RFC2396, Section 5.2, 6)
626 base_path = split_path(base)
627 rel_path = split_path(rel)
628
629 # RFC2396, Section 5.2, 6), a)
630 base_path << '' if base_path.last == '..'
631 while i = base_path.index('..')
632 base_path.slice!(i - 1, 2)
633 end
634 if base_path.empty?
635 base_path = [''] # keep '/' for root directory
636 else
637 base_path.pop
638 end
639
640 # RFC2396, Section 5.2, 6), c)
641 # RFC2396, Section 5.2, 6), d)
642 rel_path.push('') if rel_path.last == '.' || rel_path.last == '..'
643 rel_path.delete('.')
644
645 # RFC2396, Section 5.2, 6), e)
646 tmp = []
647 rel_path.each do |x|
648 if x == '..' &&
649 !(tmp.empty? || tmp.last == '..')
650 tmp.pop
651 else
652 tmp << x
653 end
654 end
655
656 add_trailer_slash = true
657 while x = tmp.shift
658 if x == '..' && base_path.size > 1
659 # RFC2396, Section 4
660 # a .. or . in an absolute path has no special meaning
661 base_path.pop
662 else
663 # if x == '..'
664 # valid absolute (but abnormal) path "/../..."
665 # else
666 # valid absolute path
667 # end
668 base_path << x
669 tmp.each {|t| base_path << t}
670 add_trailer_slash = false
671 break
672 end
673 end
674 base_path.push('') if add_trailer_slash
675
676 return base_path.join('/')
677 end
678 end
679 private :merge_path
680
681 #
682 # == Args
683 #
684 # +oth+::
685 # URI or String
686 #
687 # == Description
688 #
689 # Destructive form of #merge
690 #
691 # == Usage
692 #
693 # require 'uri'
694 #
695 # uri = URI.parse("http://my.example.com")
696 # uri.merge!("/main.rbx?page=1")
697 # p uri
698 # # => #<URI::HTTP:0x2021f3b0 URL:http://my.example.com/main.rbx?page=1>
699 #
700 def merge!(oth)
701 t = merge(oth)
702 if self == t
703 nil
704 else
705 replace!(t)
706 self
707 end
708 end
709
710 #
711 # == Args
712 #
713 # +oth+::
714 # URI or String
715 #
716 # == Description
717 #
718 # Merges two URI's.
719 #
720 # == Usage
721 #
722 # require 'uri'
723 #
724 # uri = URI.parse("http://my.example.com")
725 # p uri.merge("/main.rbx?page=1")
726 # # => #<URI::HTTP:0x2021f3b0 URL:http://my.example.com/main.rbx?page=1>
727 #
728 def merge(oth)
729 begin
730 base, rel = merge0(oth)
731 rescue
732 raise $!.class, $!.message
733 end
734
735 if base == rel
736 return base
737 end
738
739 authority = rel.userinfo || rel.host || rel.port
740
741 # RFC2396, Section 5.2, 2)
742 if (rel.path.nil? || rel.path.empty?) && !authority && !rel.query
743 base.set_fragment(rel.fragment) if rel.fragment
744 return base
745 end
746
747 base.set_query(nil)
748 base.set_fragment(nil)
749
750 # RFC2396, Section 5.2, 4)
751 if !authority
752 base.set_path(merge_path(base.path, rel.path)) if base.path && rel.path
753 else
754 # RFC2396, Section 5.2, 4)
755 base.set_path(rel.path) if rel.path
756 end
757
758 # RFC2396, Section 5.2, 7)
759 base.set_userinfo(rel.userinfo) if rel.userinfo
760 base.set_host(rel.host) if rel.host
761 base.set_port(rel.port) if rel.port
762 base.set_query(rel.query) if rel.query
763 base.set_fragment(rel.fragment) if rel.fragment
764
765 return base
766 end # merge
767 alias + merge
768
769 # return base and rel.
770 # you can modify `base', but can not `rel'.
771 def merge0(oth)
772 case oth
773 when Generic
774 when String
775 oth = URI.parse(oth)
776 else
777 raise ArgumentError,
778 "bad argument(expected URI object or URI string)"
779 end
780
781 if self.relative? && oth.relative?
782 raise BadURIError,
783 "both URI are relative"
784 end
785
786 if self.absolute? && oth.absolute?
787 #raise BadURIError,
788 # "both URI are absolute"
789 # hmm... should return oth for usability?
790 return oth, oth
791 end
792
793 if self.absolute?
794 return self.dup, oth
795 else
796 return oth, oth
797 end
798 end
799 private :merge0
800
801 def route_from_path(src, dst)
802 # RFC2396, Section 4.2
803 return '' if src == dst
804
805 src_path = split_path(src)
806 dst_path = split_path(dst)
807
808 # hmm... dst has abnormal absolute path,
809 # like "/./", "/../", "/x/../", ...
810 if dst_path.include?('..') ||
811 dst_path.include?('.')
812 return dst.dup
813 end
814
815 src_path.pop
816
817 # discard same parts
818 while dst_path.first == src_path.first
819 break if dst_path.empty?
820
821 src_path.shift
822 dst_path.shift
823 end
824
825 tmp = dst_path.join('/')
826
827 # calculate
828 if src_path.empty?
829 if tmp.empty?
830 return './'
831 elsif dst_path.first.include?(':') # (see RFC2396 Section 5)
832 return './' + tmp
833 else
834 return tmp
835 end
836 end
837
838 return '../' * src_path.size + tmp
839 end
840 private :route_from_path
841
842 def route_from0(oth)
843 case oth
844 when Generic
845 when String
846 oth = URI.parse(oth)
847 else
848 raise ArgumentError,
849 "bad argument(expected URI object or URI string)"
850 end
851
852 if self.relative?
853 raise BadURIError,
854 "relative URI: #{self}"
855 end
856 if oth.relative?
857 raise BadURIError,
858 "relative URI: #{oth}"
859 end
860
861 if self.scheme != oth.scheme
862 return self, self.dup
863 end
864 rel = URI::Generic.new(nil, # it is relative URI
865 self.userinfo, self.host, self.port,
866 self.registry, self.path, self.opaque,
867 self.query, self.fragment)
868
869 if rel.userinfo != oth.userinfo ||
870 rel.host.to_s.downcase != oth.host.to_s.downcase ||
871 rel.port != oth.port
872 if self.userinfo.nil? && self.host.nil?
873 return self, self.dup
874 end
875 rel.set_port(nil) if rel.port == oth.default_port
876 return rel, rel
877 end
878 rel.set_userinfo(nil)
879 rel.set_host(nil)
880 rel.set_port(nil)
881
882 if rel.path && rel.path == oth.path
883 rel.set_path('')
884 rel.set_query(nil) if rel.query == oth.query
885 return rel, rel
886 elsif rel.opaque && rel.opaque == oth.opaque
887 rel.set_opaque('')
888 rel.set_query(nil) if rel.query == oth.query
889 return rel, rel
890 end
891
892 # you can modify `rel', but can not `oth'.
893 return oth, rel
894 end
895 private :route_from0
896 #
897 # == Args
898 #
899 # +oth+::
900 # URI or String
901 #
902 # == Description
903 #
904 # Calculates relative path from oth to self
905 #
906 # == Usage
907 #
908 # require 'uri'
909 #
910 # uri = URI.parse('http://my.example.com/main.rbx?page=1')
911 # p uri.route_from('http://my.example.com')
912 # #=> #<URI::Generic:0x20218858 URL:/main.rbx?page=1>
913 #
914 def route_from(oth)
915 # you can modify `rel', but can not `oth'.
916 begin
917 oth, rel = route_from0(oth)
918 rescue
919 raise $!.class, $!.message
920 end
921 if oth == rel
922 return rel
923 end
924
925 rel.set_path(route_from_path(oth.path, self.path))
926 if rel.path == './' && self.query
927 # "./?foo" -> "?foo"
928 rel.set_path('')
929 end
930
931 return rel
932 end
933
934 alias - route_from
935
936 #
937 # == Args
938 #
939 # +oth+::
940 # URI or String
941 #
942 # == Description
943 #
944 # Calculates relative path to oth from self
945 #
946 # == Usage
947 #
948 # require 'uri'
949 #
950 # uri = URI.parse('http://my.example.com')
951 # p uri.route_to('http://my.example.com/main.rbx?page=1')
952 # #=> #<URI::Generic:0x2020c2f6 URL:/main.rbx?page=1>
953 #
954 def route_to(oth)
955 case oth
956 when Generic
957 when String
958 oth = URI.parse(oth)
959 else
960 raise ArgumentError,
961 "bad argument(expected URI object or URI string)"
962 end
963
964 oth.route_from(self)
965 end
966
967 #
968 # Returns normalized URI
969 #
970 def normalize
971 uri = dup
972 uri.normalize!
973 uri
974 end
975
976 #
977 # Destructive version of #normalize
978 #
979 def normalize!
980 if path && path == ''
981 set_path('/')
982 end
983 if host && host != host.downcase
984 set_host(self.host.downcase)
985 end
986 end
987
988 def path_query
989 str = @path
990 if @query
991 str += '?' + @query
992 end
993 str
994 end
995 private :path_query
996
997 #
998 # Constructs String from URI
999 #
1000 def to_s
1001 str = ''
1002 if @scheme
1003 str << @scheme
1004 str << ':'
1005 end
1006
1007 if @opaque
1008 str << @opaque
1009
1010 else
1011 if @registry
1012 str << @registry
1013 else
1014 if @host
1015 str << '//'
1016 end
1017 if self.userinfo
1018 str << self.userinfo
1019 str << '@'
1020 end
1021 if @host
1022 str << @host
1023 end
1024 if @port && @port != self.default_port
1025 str << ':'
1026 str << @port.to_s
1027 end
1028 end
1029
1030 str << path_query
1031 end
1032
1033 if @fragment
1034 str << '#'
1035 str << @fragment
1036 end
1037
1038 str
1039 end
1040
1041 #
1042 # Compares to URI's
1043 #
1044 def ==(oth)
1045 if self.class == oth.class
1046 self.normalize.component_ary == oth.normalize.component_ary
1047 else
1048 false
1049 end
1050 end
1051
1052 def hash
1053 self.component_ary.hash
1054 end
1055
1056 def eql?(oth)
1057 self.component_ary.eql?(oth.component_ary)
1058 end
1059
1060=begin
1061
1062--- URI::Generic#===(oth)
1063
1064=end
1065# def ===(oth)
1066# raise NotImplementedError
1067# end
1068
1069=begin
1070=end
1071 def component_ary
1072 component.collect do |x|
1073 self.send(x)
1074 end
1075 end
1076 protected :component_ary
1077
1078 # == Args
1079 #
1080 # +components+::
1081 # Multiple Symbol arguments defined in URI::HTTP
1082 #
1083 # == Description
1084 #
1085 # Selects specified components from URI
1086 #
1087 # == Usage
1088 #
1089 # require 'uri'
1090 #
1091 # uri = URI.parse('http://myuser:[email protected]/test.rbx')
1092 # p uri.select(:userinfo, :host, :path)
1093 # # => ["myuser:mypass", "my.example.com", "/test.rbx"]
1094 #
1095 def select(*components)
1096 components.collect do |c|
1097 if component.include?(c)
1098 self.send(c)
1099 else
1100 raise ArgumentError,
1101 "expected of components of #{self.class} (#{self.class.component.join(', ')})"
1102 end
1103 end
1104 end
1105
1106 def inspect
1107 sprintf("#<%s:%#0x URL:%s>", self.class.to_s, self.object_id, self.to_s)
1108 end
1109
1110 def coerce(oth)
1111 case oth
1112 when String
1113 oth = URI.parse(oth)
1114 else
1115 super
1116 end
1117
1118 return oth, self
1119 end
1120 end
1121end
Note: See TracBrowser for help on using the repository browser.