module URI

Constants

KEY_VALUE_SEPARATOR

Public Instance Methods

cgi_escape(string) click to toggle source

CGI escape

TODO: How does this compare to URI.escape?

# File lib/facets/uri.rb, line 83
def cgi_escape(string)
  string.gsub(/([^ a-zA-Z0-9_.-]+)/n) do
    '%' + $1.unpack('H2' * $1.size).join('%').upcase
  end.tr(' ', '+')
end
cgi_parse(query) click to toggle source
# File lib/facets/uri.rb, line 97
def cgi_parse(query)
  params = Hash.new([].freeze)

  query.split(/[&;]/n).each do |pairs|
    key, value = pairs.split('=',2).collect{|v| cgi_unescape(v) }
    if params.has_key?(key)
      params[key].push(value)
    else
      params[key] = [value]
    end
  end

  params
end
cgi_unescape(string) click to toggle source
# File lib/facets/uri.rb, line 90
def cgi_unescape(string)
  string.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
    [$1.delete('%')].pack('H*')
  end
end
chomp_query_string(uri) click to toggle source

Removes the query string from a uri.

Returns the chomped uri.

# File lib/facets/uri.rb, line 135
def chomp_query_string(uri)
  return nil unless uri
  query_string = self.get_query_string(uri)
  return uri.dup.chomp("?#{query_string}")
end
decode(uri) click to toggle source

Decode the uri components.

# File lib/facets/uri.rb, line 11
def decode(uri)
  ## gmosx: hmm is this needed?
  ## guard against invalid filenames for example pictures with
  ## spaces uploaded by users
  escaped_uri = uri.gsub(/ /, "+")

  if md = URI::REGEXP::REL_URI.match(escaped_uri)
    path = "#{md[5]}#{md[6]}"
    type = File.extname(path)
    query_string = md[7]

    ## real_path = "#{$root_dir}/#{path}"

    parameters = URI.query_to_hash(query_string)
    path.gsub!(/\+/, " ")

    return [path, type, parameters, query_string]
  end

  ## this is usefull for uncovering bugs!
  raise ArgumentError.new("the parameter '#{uri}' is not a valid uri")
end
get_query_string(uri) click to toggle source

This method returns the query string of a uri

Input: the uri

Output: the query string. returns nil if no query string

# File lib/facets/uri.rb, line 120
def get_query_string(uri)
  return nil unless uri
  # gmosx: INVESTIGATE ruby's URI seems to differently handle
  # abs and rel uris.
  if md = URI::REGEXP::ABS_URI.match(uri)
    return md[8]
  elsif md = URI::REGEXP::REL_URI.match(uri)
    return md[7]
  end
  return nil
end
hash_to_query(parameters) click to toggle source

Given a hash with parameter/value pairs construct a standard query string.

URI.hash_to_query(:a => 1, :b => 2)
#=> "a=1;b=2"
# File lib/facets/uri.rb, line 69
def hash_to_query(parameters)
  return '' unless parameters
  pairs = []
  parameters.each do |param, value|
    pairs << "#{param}=#{cgi_escape(value.to_s)}"
  end
  return pairs.join(KEY_VALUE_SEPARATOR)
end
Also aliased as: hash_to_query_string
hash_to_query_string(parameters)
Alias for: hash_to_query
query_string_to_hash(query_string)
Alias for: query_to_hash
query_to_hash(query_string) click to toggle source

Extend the basic query string parser provided by the cgi module. converts single valued params (the most common case) to objects instead of arrays

Returns hash of parameters, contains arrays for multivalued parameters (multiselect, checkboxes , etc).

If no query string is provided (nil or “”) returns an empty hash.

# File lib/facets/uri.rb, line 42
def query_to_hash(query_string)
  return {} unless query_string

  query_parameters = cgi_parse(query_string)

  query_parameters.each { |key, val|
    ## replace the array with an object
    query_parameters[key] = val[0] if 1 == val.length
  }

  ## set default value to nil! cgi sets this to []
  query_parameters.default = nil

  return query_parameters
end
Also aliased as: query_string_to_hash
update_query_string(uri, parameters) click to toggle source

Get a uri and a hash of parameters. Inject the hash values as parameters in the query sting path. Returns the full uri.

uri - the uri to filter (String) parameter - hash of parameters to update

Returns the full updated query string.

TODO: optimize

# File lib/facets/uri.rb, line 150
def update_query_string(uri, parameters)
  query_string = self.get_query_string(uri)
  rest = uri.dup.gsub(/\?#{query_string}/, "")

  hash = self.query_string_to_hash(query_string)
  hash.update(parameters)
  query_string = self.hash_to_query_string(hash)

  unless query_string.blank?
    return "#{rest}?#{query_string}"
  else
    return rest
  end
end
update_request_uri(request, parameters) click to toggle source

Gets the request uri, injects extra parameters in the query string and returns a new uri. The request object is not modified. There is always a qs string so an extra test is skipped.

TODO: find a better name?

# File lib/facets/uri.rb, line 170
def update_request_uri(request, parameters)
  hash = request.parameters.dup()
  hash.update(parameters)

  ## use this in hash_to_querystring.
  query_string = hash.collect { |k, v|
    "#{k}=#{v}"
  }.join(";")

  ## return "#{request.translated_uri}?#{query_string}"
  return "#{request.path}?#{query_string}"
end