yap 6.2.2-6+b2 / usr / share / Yap / uri.pl

/*  Part of SWI-Prolog

    Author:        Jan Wielemaker
    E-mail:        J.Wielemaker@cs.vu.nl
    WWW:           http://www.swi-prolog.org
    Copyright (C): 2009, VU University Amsterdam

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    As a special exception, if you link this library with other files,
    compiled with a Free Software compiler, to produce an executable, this
    library does not by itself cause the resulting executable to be covered
    by the GNU General Public License. This exception does not however
    invalidate any other reasons why the executable file might be covered by
    the GNU General Public License.
*/

:- module(uri,
	  [ uri_components/2,		% ?URI, ?Components
	    uri_data/3,			% ?Field, +Components, ?Data
	    uri_data/4,			% +Field, +Components, -Data, -New

	    uri_normalized/2,		% +URI, -NormalizedURI
	    uri_normalized_iri/2,	% +URI, -NormalizedIRI
	    uri_normalized/3,		% +URI, +Base, -NormalizedURI
	    uri_normalized_iri/3,	% +URI, +Base, -NormalizedIRI
	    uri_resolve/3,		% +URI, +Base, -AbsURI
	    uri_is_global/1,		% +URI
	    uri_query_components/2,	% ?QueryString, ?NameValueList
	    uri_authority_components/2,	% ?Authority, ?Components
	    uri_authority_data/3,	% ?Field, ?Components, ?Data
					% Encoding
	    uri_encoded/3,		% +Component, ?Value, ?Encoded
	    uri_file_name/2,		% ?URI, ?Path
	    uri_iri/2			% ?URI, ?IRI
	  ]).

:- use_module(library(shlib)).

:- use_foreign_library(foreign(uri)).

/** <module> Process URIs

This  library  provides   high-performance    C-based   primitives   for
manipulating URIs. We decided for a  C-based implementation for the much
better performance on raw character  manipulation. Notably, URI handling
primitives are used in  time-critical  parts   of  RDF  processing. This
implementation is based on RFC-3986:

	http://labs.apache.org/webarch/uri/rfc/rfc3986.html

The URI processing in this library is  rather liberal. That is, we break
URIs according to the rules, but we  do not validate that the components
are valid. Also, percent-decoding for IRIs   is  liberal. It first tries
UTF-8; then ISO-Latin-1 and finally accepts %-characters verbatim.

Earlier experience has shown that strict   enforcement of the URI syntax
results in many errors that  are   accepted  by  many other web-document
processing tools.
*/

%%	uri_components(+URI, -Components) is det.
%%	uri_components(-URI, +Components) is det.
%
%	Break a URI  into  its  5   basic  components  according  to the
%	RFC-3986 regular expression:
%
%	    ==
%	    ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
%	     12            3  4          5       6  7        8 9
%	    ==
%
%	@param Components is a term uri_components(Scheme, Authority,
%	Path, Search, Fragment).  See uri_data/3 for accessing this
%	structure.

%%	uri_data(?Field, +Components, ?Data) is semidet.
%
%	Provide access the uri_component structure.  Defined field-names
%	are: =scheme=, =authority=, =path=, =search= and =fragment=

uri_data(scheme,    uri_components(S, _, _, _, _), S).
uri_data(authority, uri_components(_, A, _, _, _), A).
uri_data(path,	    uri_components(_, _, P, _, _), P).
uri_data(search,    uri_components(_, _, _, S, _), S).
uri_data(fragment,  uri_components(_, _, _, _, F), F).

%%	uri_data(+Field, +Components, +Data, -NewComponents) is semidet.
%
%	NewComponents is the same as Components with Field set to Data.

uri_data(scheme,    uri_components(_, A, P, Q, F), S,
		    uri_components(S, A, P, Q, F)).
uri_data(authority, uri_components(S, _, P, Q, F), A,
		    uri_components(S, A, P, Q, F)).
uri_data(path,      uri_components(S, A, _, Q, F), P,
		    uri_components(S, A, P, Q, F)).
uri_data(search,    uri_components(S, A, P, _, F), Q,
		    uri_components(S, A, P, Q, F)).
uri_data(fragment,  uri_components(S, A, P, Q, _), F,
		    uri_components(S, A, P, Q, F)).

%%	uri_normalized(+URI, -NormalizedURI) is det.
%
%	NormalizedURI is the normalized form   of  URI. Normalization is
%	syntactic and involves the following steps:
%
%	    * 6.2.2.1. Case Normalization
%	    * 6.2.2.2. Percent-Encoding Normalization
%	    * 6.2.2.3. Path Segment Normalization

%%	uri_normalized_iri(+URI, -NormalizedIRI) is det.
%
%	As uri_normalized/2, but percent-encoding is translated into IRI
%	Unicode characters. The translation  is   liberal:  valid  UTF-8
%	sequences  of  %-encoded  bytes  are    mapped  to  the  Unicode
%	character. Other %XX-sequences are mapped   to the corresponding
%	ISO-Latin-1 character and sole % characters are left untouched.
%
%	@see uri_iri/2.


%%	uri_is_global(+URI) is semidet.
%
%	True if URI has a scheme. The semantics  is the same as the code
%	below, but the implementation is more   efficient as it does not
%	need to parse the  other  components,   nor  needs  to  bind the
%	scheme.
%
%	==
%	uri_is_global(URI) :-
%		uri_components(URI, Components),
%		uri_data(Components, scheme, Scheme),
%		nonvar(Scheme).
%	==

%%	uri_resolve(+URI, +Base, -GlobalURI) is det.
%
%	Resolve a possibly local URI relative   to Base. This implements
%	http://labs.apache.org/webarch/uri/rfc/rfc3986.html#relative-transform

%%	uri_normalized(+URI, +Base, -NormalizedGlobalURI) is det.
%
%	NormalizedGlobalURI is the normalized global version of URI.
%	Behaves as if defined by:
%
%	==
%	uri_normalized(URI, Base, NormalizedGlobalURI) :-
%		uri_resolve(URI, Base, GlobalURI),
%		uri_normalized(GlobalURI, NormalizedGlobalURI).
%	==

%%	uri_normalized_iri(+URI, +Base, -NormalizedGlobalIRI) is det.
%
%	NormalizedGlobalIRI is the normalized global IRI of URI. Behaves
%	as if defined by:
%
%	==
%	uri_normalized(URI, Base, NormalizedGlobalIRI) :-
%		uri_resolve(URI, Base, GlobalURI),
%		uri_normalized_iri(GlobalURI, NormalizedGlobalIRI).
%	==

%%	uri_query_components(+String, -Query) is det.
%%	uri_query_components(-String, +Query) is det.
%
%	Perform encoding and decoding of an URI query string. Query is a
%	list of fully decoded (Unicode) Name=Value pairs. In mode (-,+),
%	query elements of the forms Name(Value)  and Name-Value are also
%	accepted to enhance interoperability with   the option and pairs
%	libraries.  E.g.
%
%	==
%	?- uri_query_components(QS, [a=b, c('d+w'), n-'VU Amsterdam']).
%	QS = 'a=b&c=d%2Bw&n=VU%20Amsterdam'.
%
%	?- uri_query_components('a=b&c=d%2Bw&n=VU%20Amsterdam', Q).
%	Q = [a=b, c='d+w', n='VU Amsterdam'].
%	==


%%	uri_authority_components(+Authority, -Components) is det.
%%	uri_authority_components(-Authority, +Components) is det.
%
%	Break-down the authority component of a   URI. The fields of the
%	structure Components can be accessed using uri_authority_data/3.

%%	uri_authority_data(+Field, ?Components, ?Data) is semidet.
%
%	Provide access the uri_authority  structure. Defined field-names
%	are: =user=, =password=, =host= and =port=

uri_authority_data(user,     uri_authority(U, _, _, _), U).
uri_authority_data(password, uri_authority(_, P, _, _), P).
uri_authority_data(host,     uri_authority(_, _, H, _), H).
uri_authority_data(port,     uri_authority(_, _, _, P), P).


%%	uri_encoded(+Component, +Value, -Encoded) is det.
%%	uri_encoded(+Component, -Value, +Encoded) is det.
%
%	Encoded  is  the  URI   encoding    for   Value.  When  encoding
%	(Value->Encoded), Component specifies the   URI  component where
%	the value is used. It  is   one  of =query_value=, =fragment= or
%	=path=.  Besides  alphanumerical  characters,    the   following
%	characters are passed verbatim (the  set   is  split  in logical
%	groups according to RFC3986).
%
%	    $ query_value, fragment :
%	    "-._~" | "!$'()*,;" | ":@" | "/?"
%	    $ path :
%	    "-._~" | "!$&'()*,;=" | ":@" | "/"


%%	uri_iri(+URI, -IRI) is det.
%%	uri_iri(-URI, +IRI) is det.
%
%	Convert between a URI, encoded in US-ASCII and an IRI. An IRI is
%	a fully expanded  Unicode  string.   Unicode  strings  are first
%	encoded into UTF-8, after which %-encoding takes place.
%
%	@error syntax_error(Culprit) in mode (+,-) if URI is not a
%	legally percent-encoded UTF-8 string.


%%	uri_file_name(+URI, -FileName) is semidet.
%%	uri_file_name(-URI, +FileName) is det.
%
%	Convert between a URI and a   local  file_name. This protocol is
%	covered by RFC 1738. Please note   that file-URIs use _absolute_
%	paths. The mode (-, +) translates  a possible relative path into
%	an absolute one.

uri_file_name(URI, FileName) :-
	nonvar(URI), !,
	uri_components(URI, Components),
	uri_data(scheme, Components, file),
	(   uri_data(authority, Components, '')
	->  true
	;   uri_data(authority, Components, localhost)
	),
	uri_data(path, Components, FileNameEnc),
	uri_encoded(path, FileName0, FileNameEnc),
	delete_leading_slash(FileName0, FileName).
uri_file_name(URI, FileName) :-
	nonvar(FileName), !,
	absolute_file_name(FileName, Path0),
	ensure_leading_slash(Path0, Path),
	uri_encoded(path, Path, PathEnc),
	uri_data(scheme, Components, file),
	uri_data(authority, Components, ''),
	uri_data(path, Components, PathEnc),
	uri_components(URI, Components).

%%	ensure_leading_slash(+WinPath, -Path).
%%	delete_leading_slash(+Path, -WinPath).
%
%	Deal with the fact that absolute paths   in Windows start with a
%	drive letter rather than a  /.  For   URIs  we  need a path that
%	starts with a /.

ensure_leading_slash(Path, SlashPath) :-
	(   sub_atom(Path, 0, _, _, /)
	->  SlashPath = Path
	;   atom_concat(/, Path, SlashPath)
	).

:- if(current_prolog_flag(windows, true)).
delete_leading_slash(Path, WinPath) :-
	atom_concat(/, WinPath, Path),
	is_absolute_file_name(WinPath), !.
:- endif.
delete_leading_slash(Path, Path).