some fixes

src/parser/parse_from_text/find_range.rs

@@ -22,16 +22,16 @@ enum FindRangeResult<'a> {
 /// 
 ///  - `ranges` a refernce to a slice of `RangeInclusive<u32>`
 fn find_range_for_char<'a>(code: u32, ranges: &[RangeInclusive<u32>]) -> FindRangeResult<'a> {
-    let index = HASHTAG_CONTENT_CHAR_RANGES.binary_search_by_key(&code, |range| *range.start());
+    let index = ranges.binary_search_by_key(&code, |range| *range.start());
     match index {
         Ok(_) => FindRangeResult::WasOnRangeStart,
         Err(index) => match index {
-            0 => FindRangeResult::Range(&HASHTAG_CONTENT_CHAR_RANGES[0]),
+            0 => FindRangeResult::Range(&ranges[0]),
             // Since `index` can never be 0, `index - 1` will never overflow. Furthermore, the
             // maximum value which the binary search function returns is `NUMBER_OF_RANGES`.
             // Therefore, `index - 1` will never panic if we index the array with it.
             #[allow(clippy::integer_arithmetic, clippy::indexing_slicing)]
-            index => FindRangeResult::Range(&HASHTAG_CONTENT_CHAR_RANGES[index - 1]),
+            index => FindRangeResult::Range(&ranges[index - 1]),
         },
     }
 }

src/parser/parse_from_text/hashtag_content_char_ranges.rs

@@ -1,3 +1,6 @@
+use std::ops::RangeInclusive;
+use crate::parser::parse_from_text::find_range::is_in_one_of_ranges;
+
 const NUMBER_OF_RANGES: usize = 850;
 
 /*
@@ -873,7 +876,7 @@ pub(crate) fn hashtag_content_char(c: char) -> bool {
     } else if matches!(c, '+' | '-' | '_') {
         true
     } else {
-        is_in_one_of_ranges(c, &[HASHTAG_CONTENT_CHAR_RANGES])
+        is_in_one_of_ranges(c, &HASHTAG_CONTENT_CHAR_RANGES[..])
     }
 }
 

src/parser/parse_from_text/link_element.rs

@@ -6,19 +6,27 @@ use nom::{
     bytes::{
         complete::{tag, take, take_while1, take_while},
     },
-    character::{is_digit, is_alphabetic as is_alpha, is_hex_digit, char},
+    character::{is_alphabetic as is_alpha, char},
     combinator::{peek, recognize, verify},
     sequence::{tuple, preceded},
+    multi::{many_m_n, count},
     AsChar, IResult,
 };
 use super::base_parsers::*;
 
 // Link syntax here is according to RFC 3986 & 3987 --Farooq
 
 
+fn is_hex_digit(c: char) -> bool {
+    c.is_ascii_hexdigit()
+}
+
+fn is_digit(c: char) -> bool {
+    c.is_digit()
+}
 
 // These ranges have been extracted from RFC3987, Page 8.
-const ucschar_ranges: [RangeInclusive<u32>, _] = [
+const ucschar_ranges: [RangeInclusive<u32>; 17] = [
     0xa0..=0xd7ff,
     0xF900..=0xFDCF,
     0xFDF0..=0xFFEF,
@@ -74,49 +82,49 @@ fn is_ipv4(c: char) -> bool {
 }
 
 fn ipv4(input: &str) -> IResult<&str, &str> {
-    let (input, possible_ipv4) = tuple(
+    let (input, ipv4_) = recognize(tuple((
         complete::u8,
         char('.'),
         complete::u8,
         char('.'),
         complete::u8,
         char('.'),
         complete::u8
-    )(input);
-    // This might be an IPv4
-    let inner_pair = separated_pair(take_while1(is_digit), char('.'), take_while1(is_digit));
-    let ((part0, part1), (part2, part3)) = separated_pair(inner_pair, char('.'), inner_pair)(input)?;
-    part0.parse::<u8>()?;
-    part1.parse::<u8>()?;
-    part2.parse::<u8>()?;
-    part3.parse::<u8>()?;
-    Ok((input, possible_ipv4))
+    )))(input)?;
+    Ok((input, ipv4_))
 }
 
 fn is_ireg_name(c: char) -> bool {
     is_iunreserved(c) || is_pct_encoded(c) || is_sub_delims(c)
 }
 
 fn h16(input: &str) -> IResult<&str, &str> {
-    take_while_m_n(1, 4, is_hex_digit)
+    take_while_m_n(1, 4, is_hex_digit)(input)
 }
 
 fn ls32(input: &str) -> IResult<&str, &str> {
-    alt(tuple(h16, char(':'), h16), ipv4)
+    alt((tuple((h16, char(':'), h16)), ipv4))(input)
 }
 
-fn ipv6(input: &str) -> IResult<&str, &str> {
-    let h16_and_period = tuple(h16, char(':'));
-    let double_period = tag("::");
-    tuple(
-        take_while_m_n(6, 6, h16_and_period),
-        alt(ls32, double_period),
-        take_while(5, 5, h16_and_period),
-        alt(ls32, opt(h16)),
-        double_period,
-        take_while(4, 4, h16_and_period),
-        alt(ls32, opt(tuple(take_while_m_n(0, 1, h16_and_period)
+fn h16_and_period(input: &str) -> IResult<&str, &str> {
+    tuple((h16, char(':')))(input)
+}
+
+fn double_period(input: &str) -> IResult<&str, &str> {
+    tag("::")(input)
+}
 
+fn ipv6(input: &str) -> IResult<&str, &str> {
+    alt((
+        recognize(tuple((count(h16_and_period, 6), ls32))),
+        recognize(tuple((double_period, many_m_n(5, 5, h16_and_period), ls32))),
+        recognize(tuple((opt(h16), double_period, many_m_n(4, 4, h16_and_period), ls32))),
+        recognize(tuple((opt(tuple((many_m_n(0, 1, h16_and_period), ))), double_period, count(h16_and_period, 3), ls32))),
+        recognize(tuple((opt(tuple((many_m_n(0, 2, h16_and_period), h16))), double_period, count(h16_and_period, 2), ls32))),
+        recognize(tuple((opt(tuple((many_m_n(0, 3, h16_and_period), h16))), double_period, count(h16_and_period, 1), ls32))),
+        recognize(tuple((opt(tuple((many_m_n(0, 4, h16_and_period), h16))), double_period, ls32))),
+        recognize(tuple((opt(tuple((many_m_n(0, 5, h16_and_period), h16))), double_period, h16))),
+        recognize(tuple((opt(tuple((many_m_n(0, 6, h16_and_period), h16))), double_period)))))(input)
 }
 
 
@@ -125,10 +133,9 @@ fn is_ipvfuture_last(c: char) -> bool {
 }
 
 fn ipvfuture(input: &str) -> IResult<&str, &str> {
-    tuple(char('v'), take_while_m_n(1, 1, is_hex_digit), char('.'), take_while_m_n(1, 1, is_ipvfuture_last))
+    tuple((char('v'), take_while_m_n(1, 1, is_hex_digit), char('.'), take_while_m_n(1, 1, is_ipvfuture_last)))(input)
 }
 
-
 fn ip_literal(input: &str) -> IResult<&str, &str> {
     delimited(char('['), alt(ipv6, ipvfuture), char(']'))(input)
 }
@@ -139,41 +146,42 @@ fn ip_literal(input: &str) -> IResult<&str, &str> {
 /// 
 /// Parse host. Returns the rest, the host string and a boolean indicating
 /// if it is IPvFuture or IPv6.
-fn parse_host(input: &str) -> IResult<&str, &str, bool> {
-    let (input, host) = ip_literal(input)?;
-    if host.is_some() {
-        // It got parsed, then it's an IP Literal meaning
-        // it's either IPv6 or IPvFuture
-        Ok((input, host.unwrap(), true))
-    } else {
-        let (input, host) = alt((ipv4, take_while(is_ireg_name)))(input)?;
-        Ok((input, host, false))
+fn parse_host(input: &str) -> IResult<&str, (&str, bool)> {
+    match ip_literal(input) {
+        Ok((input, host)) => {
+            // It got parsed, then it's an IP Literal meaning
+            // it's either IPv6 or IPvFuture
+            Ok((input, (host, true)))
+        }
+        Err(..) => {
+            let (input, host) = alt((ipv4, take_while(is_ireg_name)))(input)?;
+            Ok((input, (host, false)))
+        }
     }
 }
 
-fn iauthority(input: &str) -> IResult<&str, &str, &str, &str, bool> {
-    let (input, userinfo) = opt(take_while(is_userinfo), char('@'))(input);
-    let (input, host, is_ipvfuture) = parse_host(input);
-    let (input, port) = preceded(char(':'), take_while(is_digit))(input);
-    Ok((input, userinfo, host, port, is_ipv6))
+fn iauthority(input: &str) -> IResult<&str, (&str, &str, &str, bool)> {
+    let (input, userinfo) = opt(take_while(is_userinfo), char('@'))(input)?;
+    let (input, (host, is_ipv6_or_future)) = parse_host(input)?;
+    let (input, port) = preceded(char(':'), take_while(is_digit))(input)?;
+    Ok((input, (userinfo, host, port, is_ipv6_or_future)))
 }
 
-fn ihier_part(input: &str) -> IResult<&str, &str, &str, bool> {
-    let (input, authority) = preceded(tag("//"), iauthority)(input);
-    let (input, path) = alt(
+fn ihier_part(input: &str) -> IResult<&str, (&str, &str, &str, &str, bool)> {
+    let (input, (userinfo, host, port, is_ipv6_or_future)) = preceded(tag("//"), iauthority)(input)?;
+    let (input, path) = opt(alt(
         take_while(is_ipath_abempty),
-        char(''), // ipath-empty
         take_while(is_ipath_absolute),
         take_while(is_ipath_rootless)
-    )(input);
-    Ok((input, authority, path, is_ipvfuture))
+    ))(input)?;
+    Ok((input, (userinfo, host, port, path, is_ipv6_or_future)))
 }
 
 fn is_ipchar(c: char) -> bool {
     is_iunreserved(c) || is_pct_encoded(c) || is_sub_delims(c) || matches!(c, ':' | '@')
 }
 
-const IPRIVATE_RANGES: [RangeInclusive<u32>; _]  = [
+const IPRIVATE_RANGES: [RangeInclusive<u32>; 3]  = [
     0xe000..=0xf8ff,
     0xf0000..=0xffffd,
     0x100000..=0x10fffd,
@@ -211,17 +219,18 @@ fn is_alphanum_or_hyphen_minus(char: char) -> bool {
     }
 }
 
-fn link(input: &str) -> IResult<&str, Element, CustomError<&str>> {
+pub fn link(input: &str) -> IResult<&str, Element> {
     let (input, scheme) = scheme(input)?;
-    let (input, (userinfo, hostport, is_ipvfuture), path) = ihier_part(input)?;
+    let (input, (userinfo, host, port, path, is_ipv6_or_future)) = ihier_part(input)?;
     let (input, query) = opt(preceed(char('?'), take_while(is_query)))(input)?;
     let (input, fragment) = opt(preceed(char('#'), take_while(is_ifragment)))(input)?;
-    Element::Link {
+    let mut s = format!("{scheme}://{userinfo}@{host}:{port}{path}{query}{fragment}");
+    Ok((input, Element::Link {
         destination: LinkDestination {
-            target: input,
+            target: &s,
             hostname: Some(hostport),
-            punycode: ,
+            punycode: None,
             scheme: scheme
         }
-    }
+    }))
 }

src/parser/parse_from_text/markdown_elements.rs

@@ -1,6 +1,8 @@
 use crate::parser::parse_from_text::text_elements::email_address;
 
-use super::text_elements::{link, parse_text_element};
+use crate::parser::link_url::LinkDestination;
+use super::text_elements::parse_text_element;
+use crate::parser::parse_from_text::link_element::link;
 use super::Element;
 use super::{base_parsers::*, parse_all};
 ///! nom parsers for markdown elements

src/parser/parse_from_text/mod.rs

@@ -5,6 +5,8 @@ mod desktop_subset;
 pub mod hashtag_content_char_ranges;
 mod markdown_elements;
 mod text_elements;
+mod link_element;
+mod find_range;
 
 /// parses text elements such as links and email addresses, excluding markdown
 pub(crate) fn parse_only_text(input: &str) -> std::vec::Vec<Element> {

src/parser/parse_from_text/text_elements.rs

@@ -2,6 +2,7 @@
 use crate::parser::link_url::LinkDestination;
 
 use super::base_parsers::*;
+use super::link_element::link;
 use super::hashtag_content_char_ranges::hashtag_content_char;
 use super::Element;
 use crate::nom::{Offset, Slice};
@@ -98,6 +99,7 @@ fn not_link_part_char(c: char) -> bool {
     !matches!(c, ':' | '\n' | '\r' | '\t' | ' ')
 }
 
+/*
 fn link(input: &str) -> IResult<&str, (), CustomError<&str>> {
     let (input, _) = take_while1(link_scheme)(input)?;
 }
@@ -229,7 +231,7 @@ pub(crate) fn link(input: &str) -> IResult<&str, Element, CustomError<&str>> {
         Err(nom::Err::Error(CustomError::InvalidLink))
     }
 }
-
+*/
 fn is_allowed_bot_cmd_suggestion_char(char: char) -> bool {
     match char {
         '@' | '\\' | '_' | '/' | '.' | '-' => true,