URL parser: Difference between revisions

:* &nbsp; <nowiki> urn:oasis:names:specification:docbook:dtd:xml:4.1.2 </nowiki>

<br><br>

 

=={{header|ALGOL 68}}==

Uses the URI parser here: [[URL_parser/URI_parser_ALGOL68]].

 

 

PROC test uri parser = ( STRING uri )VOID:

; test uri parser( "https://bob:pass@example.com/place" )

; test uri parser( "http://example.com/?a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64" )

{{out}}

<pre>

 

</pre>

 

=={{header|C sharp|C#}}==

 

 

namespace RosettaUrlParse

}

}

 

=={{header|Elixir}}==

"foo://example.com:8042/over/there?name=ferret#nose",

"urn:example:animal:ferret:nose",

IO.puts "\n#{str}"

IO.inspect URI.parse(str)

 

{{out}}

<li>The System.URI class does some "Scheme-Based Normalization" (c/f rfc3986 section 6.2.3), i. e. it knows about certain

defaults for some schemes. With the test data this shows with the port numbers for http, ftp, ldap, mailto.</li></ul>

open System.Text.RegularExpressions

 

writeline " query:" (if u.Query.Length > 0 then u.Query.Substring(1) else "")

writeline " fragment:" (if u.Fragment.Length > 0 then u.Fragment.Substring(1) else "")

{{out}}

<pre style="height:3cm">

This uses Go's standard [https://golang.org/pkg/net/url/ <tt>net/url</tt>] package.

The [https://golang.org/src/net/url/url.go source code] for this package (excluding tests) is in a single file of ~720 lines.

 

import (

fmt.Println(" Fragment:", u.Fragment)

}

{{out}}

<pre>

Key: "c" Values: ["3" "4"]

Key: "d" Values: ["encoded"]

</pre>

 

Implementation:

 

({. ; ] }.~ 1+[)~ i.&m

)

export=. ;:'scheme user creds host port path query fragment'

(#~ 0<#@>@{:"1) (,. do each) export

 

Task examples:

 

┌────────┬─────────────┐

│scheme │foo │

├──────┼───────────────────────────────────────────────┤

│path │oasis:names:specification:docbook:dtd:xml:4.1.2│

 

Note that the <code>path</code> of the example <code>jdbc</code> uri is itself a uri which may be parsed:

 

┌──────┬──────────┐

│scheme│mysql │

├──────┼──────────┤

│path │/sakila │

 

Also, examples borrowed from the <code>go</code> implementation:

 

┌──────┬───────────┐

│scheme│ssh │

│ ││a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64││

│ │└─────────────────────────────────────────┘│

 

Note that escape decoding is left to the consumer (as well as decoding things like '+' as a replacement for the space character and determining the absolute significance of relative paths and the details of ip address parsing and so on...). This seems like a good match to the hierarchical nature of uri parsing. See [[URL_decoding#J|URL decoding]] for an implementation of escape decoding.

 

Note that w3c recommends a handling for query strings which differs from that of RFC-3986. For example, the use of <code>;</code> as replacement for the <code>&</code> delimiter, or the use of the query element name as the query element value when the <code>=</code> delimiter is omitted from the name/value pair. We do not implement that here, as it's not a part of this task. But that sort of implementation could be achieved by replacing the definition of <code>queryparts</code>. And, of course, other treatments of query strings are also possible, should that become necessary...

 

=={{header|JavaScript}}==

Here is an example, tested against the JavaScript engines of current versions of Chrome and Safari, of taking this 'Gordian knot' approach to the task:

 

 

var e = document.createElement('a'),

"https://bob:pass@example.com/place",

"http://example.com/?a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64"

 

Results of applying this approach in the JavaScript of Safari 8

{

"hash": "#nose",

"search": "?a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64"

}

 

=={{header|Julia}}==

This solution uses Julia's [https://github.com/JuliaWeb/URIParser.jl URIParser] package. The <code>detailview</code> function shows all of the non-empty components of the <code>URI</code> object created by this parser. No attempt is made to further parse more complex components, e.g. query or userinfo. Error detection is limited to indicating whether a string is parsable as a URI and providing a hint as to whether the <code>URI</code> is valid (according to this package's <code>isvalid</code> function).

const FIELDS = names(URI)

 

println(detailview(uri))

end

 

{{out}}

</pre>

 

{{out}}

<pre><|"Scheme" -> "foo", "User" -> None, "Domain" -> "example.com",

"Port" -> 8042, "Path" -> {"", "over", "there"},

"Query" -> {"name" -> "ferret"}, "Fragment" -> "nose"|></pre>

 

=={{header|Perl}}==

You can use the URI module from CPAN to parse URIs. Note that the output is a bit different: for example, you don't get the host from the <code>foo://</code> scheme, as host is only valid for schemes that define it.

use warnings;

use strict;

}

 

{{out}}

<pre>foo://example.com:8042/over/there?name=ferret#nose

scheme urn

path oasis:names:specification:docbook:dtd:xml:4.1.2</pre>

 

=={{header|Phix}}==

{{Out}}

<pre>

port : 8042

path : "/over/there"

query : "name=ferret"

fragment : "nose"

 

"ftp://ftp.is.co.za/rfc/rfc1808.txt"

scheme : "ftp"

domain : "ftp.is.co.za"

path : "/rfc/rfc1808.txt"

 

"http://www.ietf.org/rfc/rfc2396.txt#header1"

scheme : "http"

domain : "www.ietf.org"

path : "/rfc/rfc2396.txt"

fragment : "header1"

 

"mailto:John.Doe@example.com"

scheme : "mailto"

 

"news:comp.infosystems.www.servers.unix"

scheme : "news"

 

"tel:+1-816-555-1212"

scheme : "tel"

 

"telnet://192.0.2.16:80/"

port : 80

path : "/"

 

"ssh://alice@example.com"

scheme : "ssh"

domain : "example.com"

user : "alice"

 

"https://bob:pass@example.com/place"

scheme : "https"

domain : "example.com"

path : "/place"

user : "bob"

password : "pass"

 

"http://example.com/?a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64"

scheme : "http"

domain : "example.com"

path : "/"

query : "a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64"

</pre>

 

=={{header|PowerShell}}==

I was confused about the '''Path''' parameter. PowerShell returns '''LocalPath''', '''AbsolutePath''' and '''AbsoluteUri'''; I defaulted to '''LocalPath''', but all properties are returned in the <code>$parsedUrls</code> variable.

function Get-ParsedUrl

{

}

}

[string[]]$urls = @'

foo://example.com:8042/over/there?name=ferret#nose

 

$parsedUrls | Select-Object -Property Scheme, Port, Domain, Path, Query, Fragment | Format-Table

{{Out}}

<pre>

=={{header|Python}}==

Links to Python Documentation: v2: [https://docs.python.org/2/library/urlparse.html#module-urlparse], v3: [https://docs.python.org/3.4/library/urllib.parse.html]

 

url = up.urlparse('http://user:pass@example.com:8081/path/file.html;params?query1=1#fragment')

print('url.username = ', url.username)

print('url.password = ', url.password)

{{out}}

<pre>

url.username = user

url.password = pass

</pre>

 

Links: [http://docs.racket-lang.org/net/url.html?q=url#%28def._%28%28lib._net%2Furl-structs..rkt%29._url%29%29 <code>url</code> structure in Racket documentation].

 

(require racket/match net/url)

(define (debug-url-string U)

"tel:+1-816-555-1212"

"telnet://192.0.2.16:80/"

 

{{out}}

path bits: ("oasis:names:specification:docbook:dtd:xml:4.1.2")</pre>

 

 

=={{header|Ruby}}==

 

As you can see in the output below, the URI library doesn't parse all of these as recommended.

 

test_cases = [

puts " #{attr.rjust(8)} = #{uri.send(attr)}" if uri.send(attr)

end

{{out}}

<pre>foo://example.com:8042/over/there?name=ferret#nose

path = /

query = a=1&b=2+2&c=3&c=4&d=%65%6e%63%6F%64%65%64</pre>

 

=={{header|Tcl}}==

The <tt>uri</tt> package doesn't presently handle IPv6 syntx as used in the example: a bug and patch will be submitted presently ..

 

package require uri::urn

 

puts \n$uri

pdict [parse_uri $uri]

 

{{out}}

 

=={{header|VBScript}}==

Function parse_url(url)

parse_url = "URL: " & url

WScript.StdOut.WriteLine "-------------------------------"

WScript.StdOut.WriteLine parse_url("this code is messy, long, and needs a makeover!!!")

 

{{Out}}

URL: this code is messy, long, and needs a makeover!!!

Invalid!!!

</pre>