класс URI::Generic

# File lib/uri/generic.rb, line 114
def self.build(args)
  if args.kind_of?(Array) &&
      args.size == ::URI::Generic::COMPONENT.size
    tmp = args.dup
  elsif args.kind_of?(Hash)
    tmp = ::URI::Generic::COMPONENT.collect do |c|
      if args.include?(c)
        args[c]
      else
        nil
      end
    end
  else
    component = self.class.component rescue ::URI::Generic::COMPONENT
    raise ArgumentError,
    "expected Array of or Hash of components of #{self.class} (#{component.join(', ')})"
  end

  tmp << nil
  tmp << true
  return self.new(*tmp)
end

# File lib/uri/generic.rb, line 76
def self.build2(args)
  begin
    return self.build(args)
  rescue InvalidComponentError
    if args.kind_of?(Array)
      return self.build(args.collect{|x|
        if x.is_a?(String)
          DEFAULT_PARSER.escape(x)
        else
          x
        end
      })
    elsif args.kind_of?(Hash)
      tmp = {}
      args.each do |key, value|
        tmp[key] = if value
            DEFAULT_PARSER.escape(value)
          else
            value
          end
      end
      return self.build(tmp)
    end
  end
end

# File lib/uri/generic.rb, line 54
def self.component
  self::COMPONENT
end

# File lib/uri/generic.rb, line 29
def self.default_port
  self::DEFAULT_PORT
end

# File lib/uri/generic.rb, line 166
def initialize(scheme,
               userinfo, host, port, registry,
               path, opaque,
               query,
               fragment,
               parser = DEFAULT_PARSER,
               arg_check = false)
  @scheme = nil
  @user = nil
  @password = nil
  @host = nil
  @port = nil
  @path = nil
  @query = nil
  @opaque = nil
  @fragment = nil
  @parser = parser == DEFAULT_PARSER ? nil : parser

  if arg_check
    self.scheme = scheme
    self.userinfo = userinfo
    self.hostname = host
    self.port = port
    self.path = path
    self.query = query
    self.opaque = opaque
    self.fragment = fragment
  else
    self.set_scheme(scheme)
    self.set_userinfo(userinfo)
    self.set_host(host)
    self.set_port(port)
    self.set_path(path)
    self.query = query
    self.set_opaque(opaque)
    self.fragment=(fragment)
  end
  if registry
    raise InvalidURIError,
      "the scheme #{@scheme} does not accept registry part: #{registry} (or bad hostname?)"
  end

  @scheme.freeze if @scheme
  self.set_path('') if !@path && !@opaque # (see RFC2396 Section 5.2)
  self.set_port(self.default_port) if self.default_port && !@port
end

# File lib/uri/generic.rb, line 1413
def component_ary
  component.collect do |x|
    self.send(x)
  end
end

# File lib/uri/generic.rb, line 605
def set_host(v)
  @host = v
end

# File lib/uri/generic.rb, line 883
def set_opaque(v)
  @opaque = v
end

# File lib/uri/generic.rb, line 536
def set_password(v)
  @password = v
  # returns v
end

# File lib/uri/generic.rb, line 786
def set_path(v)
  @path = v
end

# File lib/uri/generic.rb, line 697
def set_port(v)
  v = v.empty? ? nil : v.to_i unless !v || v.kind_of?(Fixnum)
  @port = v
end

# File lib/uri/generic.rb, line 330
def set_scheme(v)
  @scheme = v ? v.downcase : v
end

# File lib/uri/generic.rb, line 526
def set_user(v)
  set_userinfo(v, @password)
  v
end

# File lib/uri/generic.rb, line 511
def set_userinfo(user, password = nil)
  unless password
    user, password = split_userinfo(user)
  end
  @user     = user
  @password = password if password

  [@user, @password]
end

# File lib/uri/generic.rb, line 586
def check_host(v)
  return v unless v

  if @opaque
    raise InvalidURIError,
      "can not set host with registry or opaque"
  elsif parser.regexp[:HOST] !~ v
    raise InvalidComponentError,
      "bad component(expected host component): #{v}"
  end

  return true
end

# File lib/uri/generic.rb, line 861
def check_opaque(v)
  return v unless v

  # raise if both hier and opaque are not nil, because:
  # absoluteURI   = scheme ":" ( hier_part | opaque_part )
  # hier_part     = ( net_path | abs_path ) [ "?" query ]
  if @host || @port || @user || @path  # userinfo = @user + ':' + @password
    raise InvalidURIError,
      "can not set opaque with host, port, userinfo or path"
  elsif v && parser.regexp[:OPAQUE] !~ v
    raise InvalidComponentError,
      "bad component(expected opaque component): #{v}"
  end

  return true
end

# File lib/uri/generic.rb, line 415
def check_password(v, user = @user)
  if @opaque
    raise InvalidURIError,
      "can not set password with opaque"
  end
  return v unless v

  if !user
    raise InvalidURIError,
      "password component depends user component"
  end

  if parser.regexp[:USERINFO] !~ v
    raise InvalidComponentError,
      "bad password component"
  end

  return true
end

# File lib/uri/generic.rb, line 754
def check_path(v)
  # raise if both hier and opaque are not nil, because:
  # absoluteURI   = scheme ":" ( hier_part | opaque_part )
  # hier_part     = ( net_path | abs_path ) [ "?" query ]
  if v && @opaque
    raise InvalidURIError,
      "path conflicts with opaque"
  end

  # If scheme is ftp, path may be relative.
  # See RFC 1738 section 3.2.2, and RFC 2396.
  if @scheme && @scheme != "ftp".freeze
    if v && v != ''.freeze && parser.regexp[:ABS_PATH] !~ v
      raise InvalidComponentError,
        "bad component(expected absolute path component): #{v}"
    end
  else
    if v && v != ''.freeze && parser.regexp[:ABS_PATH] !~ v &&
       parser.regexp[:REL_PATH] !~ v
      raise InvalidComponentError,
        "bad component(expected relative path component): #{v}"
    end
  end

  return true
end

# File lib/uri/generic.rb, line 678
def check_port(v)
  return v unless v

  if @opaque
    raise InvalidURIError,
      "can not set port with registry or opaque"
  elsif !v.kind_of?(Fixnum) && parser.regexp[:PORT] !~ v
    raise InvalidComponentError,
      "bad component(expected port component): #{v.inspect}"
  end

  return true
end

# File lib/uri/generic.rb, line 316
def check_scheme(v)
  if v && parser.regexp[:SCHEME] !~ v
    raise InvalidComponentError,
      "bad component(expected scheme component): #{v}"
  end

  return true
end

# File lib/uri/generic.rb, line 391
def check_user(v)
  if @opaque
    raise InvalidURIError,
      "can not set user with opaque"
  end

  return v unless v

  if parser.regexp[:USERINFO] !~ v
    raise InvalidComponentError,
      "bad component(expected userinfo component or user component): #{v}"
  end

  return true
end

# File lib/uri/generic.rb, line 373
def check_userinfo(user, password = nil)
  if !password
    user, password = split_userinfo(user)
  end
  check_user(user)
  check_password(password, user)

  return true
end

# File lib/uri/generic.rb, line 553
def escape_userpass(v)
  parser.escape(v, /[@:\/]/o) # RFC 1738 section 3.1 #/
end

# File lib/uri/generic.rb, line 1139
def merge0(oth)
  oth = parser.send(:convert_to_uri, oth)

  if self.relative? && oth.relative?
    raise BadURIError,
      "both URI are relative"
  end

  if self.absolute? && oth.absolute?
    #raise BadURIError,
    #  "both URI are absolute"
    # hmm... should return oth for usability?
    return oth, oth
  end

  if self.absolute?
    return self.dup, oth
  else
    return oth, oth
  end
end

# File lib/uri/generic.rb, line 986
def merge_path(base, rel)

  # RFC2396, Section 5.2, 5)
  # RFC2396, Section 5.2, 6)
  base_path = split_path(base)
  rel_path  = split_path(rel)

  # RFC2396, Section 5.2, 6), a)
  base_path << '' if base_path.last == '..'
  while i = base_path.index('..')
    base_path.slice!(i - 1, 2)
  end

  if (first = rel_path.first) and first.empty?
    base_path.clear
    rel_path.shift
  end

  # RFC2396, Section 5.2, 6), c)
  # RFC2396, Section 5.2, 6), d)
  rel_path.push('') if rel_path.last == '.' || rel_path.last == '..'
  rel_path.delete('.')

  # RFC2396, Section 5.2, 6), e)
  tmp = []
  rel_path.each do |x|
    if x == '..' &&
        !(tmp.empty? || tmp.last == '..')
      tmp.pop
    else
      tmp << x
    end
  end

  add_trailer_slash = !tmp.empty?
  if base_path.empty?
    base_path = [''] # keep '/' for root directory
  elsif add_trailer_slash
    base_path.pop
  end
  while x = tmp.shift
    if x == '..'
      # RFC2396, Section 4
      # a .. or . in an absolute path has no special meaning
      base_path.pop if base_path.size > 1
    else
      # if x == '..'
      #   valid absolute (but abnormal) path "/../..."
      # else
      #   valid absolute path
      # end
      base_path << x
      tmp.each {|t| base_path << t}
      add_trailer_slash = false
      break
    end
  end
  base_path.push('') if add_trailer_slash

  return base_path.join('/')
end

# File lib/uri/generic.rb, line 295
def replace!(oth)
  if self.class != oth.class
    raise ArgumentError, "expected #{self.class} object"
  end

  component.each do |c|
    self.__send__("#{c}=", oth.__send__(c))
  end
end

# File lib/uri/generic.rb, line 977
def split_path(path)
  path.split(%r{/+}, -1)
end

# File lib/uri/generic.rb, line 544
def split_userinfo(ui)
  return nil, nil unless ui
  user, password = ui.split(':'.freeze, 2)

  return user, password
end