Module: N::UriUtils

Defined in:
lib/n/utils/uri.rb

Overview

UriUtils

Design:

Implement as a module to avoid class polution. You can still use Ruby’s advanced features to include the module in your class. Passing the object to act upon allows to check for nil, which isn’t possible if you use self.

The uris passed as parameters are typically strings.

Class Method Summary collapse

Class Method Details

.chomp_query_string(uri) ⇒ Object

Removes the query string from a uri

Input: the uri

Output: the chomped uri.



139
140
141
142
143
 
# File 'lib/n/utils/uri.rb', line 139

def self.chomp_query_string(uri)
	return nil unless uri
	query_string = self.get_query_string(uri)
	return uri.dup.chomp("?#{query_string}")
end

.decode(uri) ⇒ Object

Decode the uri components.

Raises:

  • (ArgumentError) 


30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/n/utils/uri.rb', line 30

def self.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 = N::StringUtils.extension_from_path(path)
		query_string = md[7]

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

		parameters = N::UriUtils.query_string_to_hash(query_string)
		path.gsub!(/\+/, " ")

		return [path, type, parameters, query_string]

	end # match

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

.get_query_string(uri) ⇒ Object

This method returns the query string of a uri

Input: the uri

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



119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/n/utils/uri.rb', line 119

def self.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_string(parameters) ⇒ Object

Given a hash with parameter/value pairs construct a standard query string. This method only encodes simple types (Numeric, String) to avoid query string polution with marshal, etc.

gmosx, FIXME: only numeric and strings are passed to the latest code, so update old code and optimize this!

Input: the parameter hash

Output: the query string



97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/n/utils/uri.rb', line 97

def self.hash_to_query_string(parameters)
	return nil unless parameters
	pairs = []
	parameters.each { |param, value|
		# only encode simple classes !

		if value.is_a?(Numeric) or value.is_a?(String)
			pairs << "#{param}=#{value}"
		end
	}
	return pairs.join(";")
end

.query_string_to_hash(query_string) ⇒ Object

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

Input: the query string

Output: hash of parameters, contains arrays for multivalued parameters (multiselect, checkboxes , etc) If no query string is provided (nil or “”) returns an empty hash.



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/n/utils/uri.rb', line 67

def self.query_string_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

.update_query_string(uri, parameters) ⇒ Object

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

Input: the uri to filter (String) hash of parameters to update

Output: the full updated query string

TODO:

optimize this a litle bit.



159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/n/utils/uri.rb', line 159

def self.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)

	if N::StringUtils.valid?(query_string)
		return "#{rest}?#{query_string}"
	else
		return rest
	end
end

.update_request_uri(request, parameters) ⇒ Object

TODO: find a better name. 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.



179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/n/utils/uri.rb', line 179

def self.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}"
end