Class: URI::FTP

Inherits:
Generic show all
Defined in:
lib/uri/ftp.rb

Overview

FTP URI syntax is defined by RFC1738 section 3.2.

Constant Summary collapse

DEFAULT_PORT = 
21
COMPONENT = 
[
  :scheme, 
  :userinfo, :host, :port,
  :path, :typecode
].freeze
TYPECODE =

Typecode is “a”, “i” or “d”.

  • “a” indicates a text file (the FTP command was ASCII)

  • “i” indicates a binary file (FTP command IMAGE)

  • “d” indicates the contents of a directory should be displayed

['a', 'i', 'd'].freeze
TYPECODE_PREFIX = 
';type='.freeze

Constants inherited from Generic

Generic::USE_REGISTRY

Constants included from REGEXP

REGEXP::ABS_PATH, REGEXP::ABS_URI, REGEXP::ABS_URI_REF, REGEXP::ESCAPED, REGEXP::FRAGMENT, REGEXP::HOST, REGEXP::OPAQUE, REGEXP::PORT, REGEXP::QUERY, REGEXP::REGISTRY, REGEXP::REL_PATH, REGEXP::REL_URI, REGEXP::REL_URI_REF, REGEXP::SCHEME, REGEXP::UNSAFE, REGEXP::URI_REF, REGEXP::USERINFO

Constants included from URI

VERSION, VERSION_CODE

Instance Attribute Summary collapse

Attributes inherited from Generic

#fragment, #host, #opaque, #port, #query, #registry, #scheme

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Generic

#==, #absolute?, build2, #coerce, component, #component, #default_port, default_port, #eql?, #hash, #hierarchical?, #inspect, #merge!, #normalize, #normalize!, #password, #password=, #relative?, #route_from, #route_to, #select, use_registry, #user, #user=, #userinfo, #userinfo=

Methods included from URI

extract, join, parse, regexp, split

Methods included from Escape

#escape, #unescape

Constructor Details

#initialize(*arg) ⇒ FTP

Description

Creates a new URI::FTP object from generic URL components with no syntax checking.

Unlike build(), this method does not escape the path component as required by RFC1738; instead it is treated as per RFC2396.

Arguments are scheme, userinfo, host, port, registry, path, opaque, query and fragment, in that order.



115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/uri/ftp.rb', line 115

def initialize(*arg)
  super(*arg)
  @typecode = nil
  tmp = @path.index(TYPECODE_PREFIX)
  if tmp
    typecode = @path[tmp + TYPECODE_PREFIX.size..-1]
    self.set_path(@path[0..tmp - 1])
    
    if arg[-1]
      self.typecode = typecode
    else
      self.set_typecode(typecode)
    end
  end
end

Instance Attribute Details

#typecode ⇒ Object

Returns the value of attribute typecode.



130
131
132
 
# File 'lib/uri/ftp.rb', line 130

def typecode
  @typecode
end

Class Method Details

.build(args) ⇒ Object

Description

Creates a new URI::FTP object from components, with syntax checking.

The components accepted are userinfo, host, port, path and typecode.

The components should be provided either as an Array, or as a Hash with keys formed by preceding the component names with a colon.

If an Array is used, the components must be passed in the order

userinfo, host, port, path, typecode

If the path supplied is absolute, it will be escaped in order to make it absolute in the URI. Examples:

require 'uri'

uri = URI::FTP.build(['user:password', 'ftp.example.com', nil, 
  '/path/file.> zip', 'i'])
puts uri.to_s  ->  ftp://user:[email protected]/%2Fpath/file.zip;type=a

uri2 = URI::FTP.build({:host => 'ftp.example.com', 
  :path => 'ruby/src'})
puts uri2.to_s  ->  ftp://ftp.example.com/ruby/src



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/uri/ftp.rb', line 78

def self.build(args)

  # Fix the incoming path to be generic URL syntax
  # FTP path  ->  URL path
  # foo/bar       /foo/bar
  # /foo/bar      /%2Ffoo/bar
  #
  if args.kind_of?(Array)
    args[3] = '/' + args[3].sub(/^\//, '%2F')
  else
    args[:path] = '/' + args[:path].sub(/^\//, '%2F')
  end

  tmp = Util::make_components_hash(self, args)

  if tmp[:typecode]
    if tmp[:typecode].size == 1
      tmp[:typecode] = TYPECODE_PREFIX + tmp[:typecode] 
    end
    tmp[:path] << tmp[:typecode]
  end

  return super(tmp)
end

.new2(user, password, host, port, path, typecode = nil, arg_check = true) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/uri/ftp.rb', line 34

def self.new2(user, password, host, port, path, 
              typecode = nil, arg_check = true)
  typecode = nil if typecode.size == 0
  if typecode && !TYPECODE.include?(typecode)
    raise ArgumentError,
      "bad typecode is specified: #{typecode}"
  end

  # do escape

  self.new('ftp',
           [user, password], 
           host, port, nil, 
           typecode ? path + TYPECODE_PREFIX + typecode : path, 
           nil, nil, nil, arg_check)
end

Instance Method Details

#merge(oth) ⇒ Object

:nodoc:



153
154
155
156
157
158
159
160
 
# File 'lib/uri/ftp.rb', line 153

def merge(oth) # :nodoc:
  tmp = super(oth)
  if self != tmp
    tmp.set_typecode(oth.typecode)
  end

  return tmp
end

#path ⇒ Object

Returns the path from an FTP URI.

RFC 1738 specifically states that the path for an FTP URI does not include the / which separates the URI path from the URI host. Example:

ftp://ftp.example.com/pub/ruby

The above URI indicates that the client should connect to ftp.example.com then cd pub/ruby from the initial login directory.

If you want to cd to an absolute directory, you must include an escaped / (%2F) in the path. Example:

ftp://ftp.example.com/%2Fpub/ruby

This method will then return “/pub/ruby”



179
180
181
 
# File 'lib/uri/ftp.rb', line 179

def path
  return @path.sub(/^\//,'').sub(/^%2F/i,'/')
end

#to_s ⇒ Object 



183
184
185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/uri/ftp.rb', line 183

def to_s
  save_path = nil
  if @typecode
    save_path = @path
    @path = @path + TYPECODE_PREFIX + @typecode
  end
  str = super
  if @typecode
    @path = save_path
  end

  return str
end