class Bundler::URI::FTP


is a good summary about the de facto spec.
the structure of its path. draft-hoffman-ftp-uri-04 is a draft but it
This class will be redesigned because of difference of implementations;
FTP Bundler::URI syntax is defined by RFC1738 section 3.2.

def self.build(args)


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

uri1.to_s # => "ftp://user:password@ftp.example.com/%2Fpath/file.zip;type=i"
'/path/file.zip', 'i'])
uri1 = Bundler::URI::FTP.build(['user:password', 'ftp.example.com', nil,

require 'bundler/vendor/uri/lib/uri'

Examples:

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

order [userinfo, host, port, path, typecode].
If an Array is used, the components must be passed in the

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

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

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

== Description
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

def self.new2(user, password, host, port, path, 

def self.new2(user, password, host, port, path,
              typecode = nil, arg_check = true) # :nodoc:
  # Do not use this method!  Not tested.  [Bug #7301]
  # This methods remains just for compatibility,
  # Keep it undocumented until the active maintainer is assigned.
  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

def check_typecode(v)


returns +true+ or +false+.
Validates typecode +v+, 
def check_typecode(v)
  if TYPECODE.include?(v)
    return true
  else
    raise InvalidComponentError,
      "bad typecode(expected #{TYPECODE.join(', ')}): #{v}"
  end
end

def initialize(scheme,


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

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

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

== Description
def initialize(scheme,
               userinfo, host, port, registry,
               path, opaque,
               query,
               fragment,
               parser = nil,
               arg_check = false)
  raise InvalidURIError unless path
  path = path.sub(/^\//,'')
  path.sub!(/^%2F/,'/')
  super(scheme, userinfo, host, port, registry, path, opaque,
        query, fragment, parser, arg_check)
  @typecode = nil
  if tmp = @path.index(TYPECODE_PREFIX)
    typecode = @path[tmp + TYPECODE_PREFIX.size..-1]
    @path = @path[0..tmp - 1]
    if arg_check
      self.typecode = typecode
    else
      self.set_typecode(typecode)
    end
  end
end

def merge(oth) # :nodoc:

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

def path


This method will then return "/pub/ruby".

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

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

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

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

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

Returns the path from an FTP Bundler::URI. 
def path
  return @path.sub(/^\//,'').sub(/^%2F/,'/')
end

def set_path(v)

Private setter for the path of the Bundler::URI::FTP. 
def set_path(v)
  super("/" + v.sub(/^\//, "%2F"))
end

def set_typecode(v)


See also Bundler::URI::FTP.typecode=.

Private setter for the typecode +v+. 
def set_typecode(v)
  @typecode = v
end

def to_s

Returns a String representation of the Bundler::URI::FTP. 
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

def typecode=(typecode)


#=> #
uri
uri.typecode = "i"
#=> #
uri = Bundler::URI.parse("ftp://john@ftp.example.com/my_file.img")

require 'bundler/vendor/uri/lib/uri'

== Usage

See also Bundler::URI::FTP.check_typecode.

(with validation).
Public setter for the typecode +v+

== Description

String
+v+::

== Args
def typecode=(typecode)
  check_typecode(typecode)
  set_typecode(typecode)
  typecode
end