Find URI in text: Difference between revisions

{{libheader| System.RegularExpressions}}

{{Trans|Go}}

program Find_URI_in_text;

 

 

Readln;

{{out}}

<pre>

<br>

The regexp package in the Go standard library is not fully compatible with PCRE and is unable to compile the regular expression used here. A third party library has therefore been used instead which is a PCRE shim for Go.

 

import (

fmt.Println()

}

 

{{out}}

Delimited examples of the form ''<URI>'' or ''"URI"'' will be correctly parse in any event. Handling of other possibly ambiguous examples that include valid URI characters is done by the 'findURItext' and 'disambURI' procedures. All candidate URIs are returned since once information is removed it will be lost and may be difficult for a user to reconstruct. This solution deals with all of the trailing character and balance considerations.

 

every write(findURItext("this URI contains an illegal character, parentheses_

and a misplaced full stop:\n_

procedure pctencode() #: match 1 % encoded single byte character

suspend ="%" || tab(any(HEXDIGITS)) || tab(any(HEXDIGITS))

 

Output:<pre>stop:

 

The following uses essentially the same regular expression as is used in the [[#Tcl]] article (as of June 2015), and the results using the given input text are identical. Note in particular that scheme-only strings such as "stop:" are not extracted.

# output: a stream of URIs

# Each input string may contain more than one URI.

# Example: read in a file of arbitrary text and

# produce a stream of the URIs that are identified.

 

{{out}}

http://en.wikipedia.org/wiki/Erich_Kästner_(camera_designer).

http://mediawiki.org/).

ftp://domain.name/path(unbalanced_brackets/ending.in.dot.

ftp://domain.name/path/embedded?punct/uation.

 

=={{header|Julia}}==

The Julia URI parser treats stop: and here: as schemes with an empty path. Looking at the RFC this seems

technically correct except that the schemes "stop:" and "here:" do not exist, whereas http: and ftp: do.

 

function findvalidURI(txt)

println(result)

end

<pre>

stop:

=={{header|Kotlin}}==

The regular expression used here is essentially the same as the one in the Tcl entry. However, the flag expression (?U) is needed to enable matching of Unicode characters. Without this only ASCII characters are matched.

 

val pattern =

println()

}

 

{{out}}

</pre>

 

Using the built-in text parser

full stop:

http://en.wikipedia.org/wiki/Erich_Kästner_(camera_designer). (which

leading junk ftp://domain.name/dangling_close_paren)

if you have other interesting URIs for testing, please add them

{{out}}

<pre>{"http://en.wikipedia.org/wiki/Erich_Kästner_(camera_designer). (which",

=={{header|Objeck}}==

Used a regex instead of writing a parser.

use RegEx;

 

};

}

 

<pre>

=={{header|Perl}}==

Only covers whatever Regexp::Common::URI supports.

 

use strict;

ftp://domain.name/path(unbalanced_brackets/ending.in.dot.

leading junk ftp://domain.name/path/embedded?punct/uation.

{{out}}

<pre>URI(s) found.

 

=={{header|Phix}}==

 

=={{header|PHP}}==

Trivial example using PHP's built-in filter_var() function (which does not support IRIs).

'this URI contains an illegal character, parentheses and a misplaced full stop:',

'http://en.wikipedia.org/wiki/Erich_Kästner_(camera_designer). (which is handled by http://mediawiki.org/).',

}

}

{{Out}}

<pre>

 

=={{header|Pike}}==

http://en.wikipedia.org/wiki/Erich_Kästner_(camera_designer).

which is handled by http://mediawiki.org/).

"ftp://domain.name/dangling_close_paren)",

"here:"

 

=={{header|Racket}}==

{{trans|Tcl}}

 

 

(define sample

;; ALPHA = %x41-5A / %x61-7A ; A-Z / a-z

(unless (= 228 (char->integer #\ä))

 

{{out}}

(formerly Perl 6)

This needs an installed URI distribution. {{works with|Rakudo|2018.03}}

use IETF::RFC_Grammar::URI;

 

say $/[*-1];

say "We matched $/[*-1], which is a $/[*-1].^name() at position $/[*-1].from() to $/[*-1].to()"

 

Like most of the solutions here it does not comply to IRI but only to URI:

 

=={{header|REXX}}==

$$= 'this URI contains an illegal character, parentheses and a misplaced full stop:',

'http://en.wikipedia.org/wiki/Erich_Kästner_(camera_designer). (which is handled by http://mediawiki.org/).',

end /*while*/ /* [↑] scan the text for URI's. */

/*▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀*/

{{out|output|text=&nbsp; when using the internal default inputs:}}

<pre>

 

=={{header|Ruby}}==

require 'uri'

 

puts URI.extract(str, ["http", "https"])

 

{{Output}}

<pre>

=={{header|Tcl}}==

This uses regular expressions to do the matching. It doesn't match a URL without a scheme (too problematic in general text) and it requires more than ''just'' the scheme too, but apart from that it matches slightly too broad a range of strings (though not usually problematically much). Matches some IRIs correctly too, but does not tackle the <tt>&lt;bracketed&gt;</tt> form (especially not if it includes extra spaces).

# This is an ERE with embedded comments. Rare, but useful with something

# this complex.

}

regexp -inline -all {*}$args -- $URI $text

;Demonstrating<nowiki>:</nowiki>

Note that the last line of output is showing that we haven't just extracted the URI substrings, but can also get the match positions within the text.

this URI contains an illegal character, parentheses and a misplaced full stop:

http://en.wikipedia.org/wiki/Erich_Kästner_(camera_designer). (which is handled by http://mediawiki.org/).

 

puts [join [findURIs $sample] \n]

{{out}}

<pre>

 

=={{header|TXR}}==

@(local x y)@\

@(cases)@\

@ (end)

@ (end)

 

Test file:

{{libheader|Wren-pattern}}

Wren's simple pattern matcher lacks the sophistication of regular expressions and I've had to make considerable simplifications to the search pattern needed for complete URI/IRI matching whilst still doing enough to identify the ones embedded in the sample text for this task.

 

var text = """

System.print("\nIRI's found:\n")

matches = p.findAll(text)

 

{{out}}