formated files and resolved token links

Author: Laschoking

nemo-language-server/src/language_server/lsp_component.rs

@@ -66,9 +66,10 @@ where
 {
     fn identifier(&self) -> Option<LSPIdentifier> {
         let scope = match self.context() {
-            ParserContext::Number | ParserContext::EncodedNumber | ParserContext::Variable | ParserContext::RdfLiteral => {
-                Some(ParserContext::Rule)
-            }
+            ParserContext::Number
+            | ParserContext::EncodedNumber
+            | ParserContext::Variable
+            | ParserContext::RdfLiteral => Some(ParserContext::Rule),
             ParserContext::Iri
             | ParserContext::Constant
             | ParserContext::String

nemo-physical/src/function/definitions/casting.rs

@@ -33,15 +33,14 @@ impl UnaryFunction for CastingIntoInteger64 {
             | crate::datavalues::ValueDomain::Iri
             | crate::datavalues::ValueDomain::LanguageTaggedString => None,
             crate::datavalues::ValueDomain::PlainString | crate::datavalues::ValueDomain::Other => {
-
                 let lex_val = parameter.lexical_value();
 
                 // Handle decimal, binary (0b), octal (0o) and hexadecimal (0x) encoded strings
                 let result = match &lex_val[0..2] {
-                    "0b" => {<i64>::from_str_radix(&lex_val[2..],2).ok()?},
-                    "0o" => {<i64>::from_str_radix(&lex_val[2..],8).ok()?},
-                    "0x" => {<i64>::from_str_radix(&lex_val[2..],16).ok()?},
-                    _ => {lex_val.parse::<i64>().ok()?},
+                    "0b" => <i64>::from_str_radix(&lex_val[2..], 2).ok()?,
+                    "0o" => <i64>::from_str_radix(&lex_val[2..], 8).ok()?,
+                    "0x" => <i64>::from_str_radix(&lex_val[2..], 16).ok()?,
+                    _ => lex_val.parse::<i64>().ok()?,
                 };
 
                 Some(AnyDataValue::new_integer_from_i64(result))

nemo/src/parser/ast/expression.rs

@@ -4,7 +4,8 @@ pub mod basic;
 pub mod complex;
 
 use basic::{
-    blank::Blank, boolean::Boolean, constant::Constant, number::Number, enc_number::EncodedNumber,rdf_literal::RdfLiteral, string::StringLiteral, variable::Variable
+    blank::Blank, boolean::Boolean, constant::Constant, enc_number::EncodedNumber, number::Number,
+    rdf_literal::RdfLiteral, string::StringLiteral, variable::Variable,
 };
 use complex::{
     aggregation::Aggregation, arithmetic::Arithmetic, atom::Atom, fstring::FormatString, map::Map,

nemo/src/parser/ast/expression/basic.rs

@@ -3,9 +3,9 @@
 pub mod blank;
 pub mod boolean;
 pub mod constant;
+pub mod enc_number;
 pub mod iri;
 pub mod number;
 pub mod rdf_literal;
 pub mod string;
 pub mod variable;
-pub mod enc_number;

nemo/src/parser/ast/expression/basic/enc_number.rs

@@ -2,10 +2,7 @@
 #![allow(missing_docs)]
 
 use enum_assoc::Assoc;
-use nom::{
-    branch::alt,
-    sequence::preceded,
-};
+use nom::{branch::alt, sequence::preceded};
 
 use crate::parser::{
     ast::{
@@ -16,7 +13,7 @@ use crate::parser::{
     span::Span,
     ParserInput, ParserResult,
 };
-use num::{BigInt,Num};
+use num::{BigInt, Num};
 
 #[derive(Assoc, Debug, Clone, Copy, PartialEq, Eq)]
 #[func(pub fn token(token: &TokenKind) -> Option<Self>)]
@@ -44,7 +41,7 @@ impl Encoding {
 }
 
 #[derive(Debug)]
-pub struct EncodedNumber<'a>{
+pub struct EncodedNumber<'a> {
     /// [Span] associated with this node
     span: Span<'a>,
     /// The prefix of the encoded number
@@ -53,7 +50,6 @@ pub struct EncodedNumber<'a>{
     suffix: Token<'a>,
 }
 
-
 /// Value of [EncodedNumber]
 #[derive(Debug)]
 pub enum NumberValue {
@@ -64,52 +60,42 @@ pub enum NumberValue {
 }
 
 impl<'a> EncodedNumber<'a> {
-
     /// Removes the binary prefix (0b) and returns the binary suffix
     fn parse_binary(input: ParserInput<'a>) -> ParserResult<'a, (Encoding, Token<'a>)> {
-        preceded(Token::binary_prefix, Token::bin_number)(input).map(
-            |(remaining, bin_digits)| {
-                (remaining,(Encoding::Binary,bin_digits))
-        })
+        preceded(Token::binary_prefix, Token::bin_number)(input)
+            .map(|(remaining, bin_digits)| (remaining, (Encoding::Binary, bin_digits)))
     }
 
-
     /// Removes the octal prefix (0o) and returns the octal suffix
     fn parse_octal(input: ParserInput<'a>) -> ParserResult<'a, (Encoding, Token<'a>)> {
-        preceded(Token::octal_prefix, Token::oct_number)(input).map(
-            |(remaining, oct_digits)| {
-                (remaining,(Encoding::Octal,oct_digits))
-        })
+        preceded(Token::octal_prefix, Token::oct_number)(input)
+            .map(|(remaining, oct_digits)| (remaining, (Encoding::Octal, oct_digits)))
     }
 
     /// Removes the hex prefix (0x) and returns the hex suffix
     fn parse_hex(input: ParserInput<'a>) -> ParserResult<'a, (Encoding, Token<'a>)> {
-        preceded(Token::hex_prefix, Token::hex_number)(input).map(
-            |(remaining, hex_chars)| {
-                (remaining,(Encoding::Hexadecimal,hex_chars))
-        })
+        preceded(Token::hex_prefix, Token::hex_number)(input)
+            .map(|(remaining, hex_chars)| (remaining, (Encoding::Hexadecimal, hex_chars)))
     }
 
-
     /// Return the value of this number, represented as a [NumberValue].
     pub fn value(&self) -> NumberValue {
-        let string = format!("{}{}",self.prefix.print(),self.suffix);
+        let string = format!("{}{}", self.prefix.print(), self.suffix);
 
         // Retrieves the base of encoded number based on [Encoding]
         let nr_encoding = self.prefix.radix();
         let span = &self.suffix.span();
         let suffix = span.fragment();
-        
+
         // Returns decoded number as <i64> if it is not too big
-        // Otherwise, return string representation of the decoded number 
+        // Otherwise, return string representation of the decoded number
         if let Ok(integer) = <i64>::from_str_radix(suffix, nr_encoding) {
             return NumberValue::Integer(integer);
-        }else if let Ok(bigint) = <BigInt as Num>::from_str_radix(suffix, nr_encoding) {
+        } else if let Ok(bigint) = <BigInt as Num>::from_str_radix(suffix, nr_encoding) {
             return NumberValue::Large(bigint.to_string());
         }
         NumberValue::Large(string)
     }
-
 }
 
 const CONTEXT: ParserContext = ParserContext::EncodedNumber;
@@ -131,26 +117,20 @@ impl<'a> ProgramAST<'a> for EncodedNumber<'a> {
 
         context(
             CONTEXT,
-            alt((
-                Self::parse_binary,
-                Self::parse_octal,
-                Self::parse_hex,
-            )),
+            alt((Self::parse_binary, Self::parse_octal, Self::parse_hex)),
         )(input)
-        .map(
-            |(rest, (prefix,suffix))| {
-                let rest_span = rest.span;
-
-                (
-                    rest,
-                    EncodedNumber {
-                        span: input_span.until_rest(&rest_span),
-                        prefix,
-                        suffix,
-                    },
-                )
-            },
-        )
+        .map(|(rest, (prefix, suffix))| {
+            let rest_span = rest.span;
+
+            (
+                rest,
+                EncodedNumber {
+                    span: input_span.until_rest(&rest_span),
+                    prefix,
+                    suffix,
+                },
+            )
+        })
     }
 
     fn context(&self) -> ParserContext {
@@ -163,32 +143,35 @@ mod test {
     use nom::combinator::all_consuming;
 
     use crate::parser::{
-        ast::{expression::basic::enc_number::{EncodedNumber,NumberValue}, ProgramAST},
+        ast::{
+            expression::basic::enc_number::{EncodedNumber, NumberValue},
+            ProgramAST,
+        },
         ParserInput, ParserState,
     };
 
     #[test]
     fn parse_numbers() {
         let valid_numbers = vec![
-            ("0x11",17),
-            ("0o11",9),
-            ("0b11",3),
-            ("0xAB2CE",701134),
-            ("0xab2ce",701134),
-            ("0o777",511),
-            ("0b01010101",85),
+            ("0x11", 17),
+            ("0o11", 9),
+            ("0b11", 3),
+            ("0xAB2CE", 701134),
+            ("0xab2ce", 701134),
+            ("0o777", 511),
+            ("0b01010101", 85),
         ];
 
-        let invalid_numbers = vec!["0xG", "0o8", "0b2", "0x","0b", "0o"];
+        let invalid_numbers = vec!["0xG", "0o8", "0b2", "0x", "0b", "0o"];
 
         for (valid, exp_value) in valid_numbers {
             let input = ParserInput::new(valid, ParserState::default());
             let result = all_consuming(EncodedNumber::parse)(input);
             assert!(result.is_ok());
 
             if let Ok((_, ast_node)) = result {
-                if let NumberValue::Integer(integer) = ast_node.value(){
-                    assert_eq!(integer,exp_value);
+                if let NumberValue::Integer(integer) = ast_node.value() {
+                    assert_eq!(integer, exp_value);
                 }
             };
         }

nemo/src/parser/ast/token.rs

@@ -7,8 +7,10 @@ use enum_assoc::Assoc;
 
 use nom::{
     branch::alt,
-    bytes::complete::{is_a, is_not, tag, take_until,take_while1},
-    character::complete::{alpha1, alphanumeric1, digit1, multispace1, space0, space1, oct_digit1, hex_digit1},
+    bytes::complete::{is_a, is_not, tag, take_until, take_while1},
+    character::complete::{
+        alpha1, alphanumeric1, digit1, hex_digit1, multispace1, oct_digit1, space0, space1,
+    },
     combinator::{map, opt, recognize, verify},
     multi::many0,
     sequence::pair,
@@ -331,7 +333,6 @@ macro_rules! string_token {
     };
 }
 
-
 impl<'a> Token<'a> {
     /// Return the [Span] of this token.
     pub fn span(&self) -> Span<'a> {
@@ -500,22 +501,24 @@ impl<'a> Token<'a> {
     }
 
     //  The built-in bin_digit1 can be used, once nom is updated to version 8.0.0-alpha2
-    /// Parse [TokenKind:BinaryPrefix] 
+    /// Parse binary number consisting of [TokenKind::BinaryPrefix] and [TokenKind::BinarySuffix]
     pub fn bin_number(input: ParserInput<'a>) -> ParserResult<'a, Token<'a>> {
-        context(ParserContext::token(TokenKind::BinarySuffix), take_while1(|c| c == '0' || c == '1'))(input).map(
-            |(rest_input, result)| {
-                (
-                    rest_input,
-                    Token {
-                        span: result.span,
-                        kind: TokenKind::BinarySuffix,
-                    },
-                )
-            },
-        )
+        context(
+            ParserContext::token(TokenKind::BinarySuffix),
+            take_while1(|c| c == '0' || c == '1'),
+        )(input)
+        .map(|(rest_input, result)| {
+            (
+                rest_input,
+                Token {
+                    span: result.span,
+                    kind: TokenKind::BinarySuffix,
+                },
+            )
+        })
     }
 
-    /// Parse [TokenKind:OctalPrefix].
+    /// Parse binary number consisting of [TokenKind::OctalPrefix] and [TokenKind::OctalSuffix]
     pub fn oct_number(input: ParserInput<'a>) -> ParserResult<'a, Token<'a>> {
         context(ParserContext::token(TokenKind::OctalSuffix), oct_digit1)(input).map(
             |(rest_input, result)| {
@@ -530,7 +533,7 @@ impl<'a> Token<'a> {
         )
     }
 
-    /// Parse [TokenKindHexNumber].
+    /// Parse binary number consisting of [TokenKind::HexPrefix] and [TokenKind::HexSuffix]
     pub fn hex_number(input: ParserInput<'a>) -> ParserResult<'a, Token<'a>> {
         context(ParserContext::token(TokenKind::HexSuffix), hex_digit1)(input).map(
             |(rest_input, result)| {

nemo/src/rule_model/translation/basic.rs

@@ -3,8 +3,8 @@
 pub(super) mod blank;
 pub(super) mod boolean;
 pub(super) mod constant;
-pub(super) mod number;
 pub(super) mod enc_number;
+pub(super) mod number;
 pub(super) mod rdf;
 pub(super) mod string;
 pub(super) mod variable;

nemo/src/rule_model/translation/term.rs

@@ -15,7 +15,8 @@ use crate::{
 use super::{
     basic::{
         blank::BlankLiteral, boolean::BooleanLiteral, constant::ConstantLiteral,
-        number::NumberLiteral,enc_number::EncodedNumberLiteral, rdf::RdfLiteral, string::StringLiteral,
+        enc_number::EncodedNumberLiteral, number::NumberLiteral, rdf::RdfLiteral,
+        string::StringLiteral,
     },
     complex::{
         arithmetic::ArithmeticOperation, fstring::FormatStringLiteral,
@@ -50,9 +51,9 @@ impl TranslationComponent for Term {
             ast::expression::Expression::Number(number) => {
                 Term::from(NumberLiteral::build_component(translation, number)?.into_inner())
             }
-            ast::expression::Expression::EncodedNumber(enc_number) => {
-                Term::from(EncodedNumberLiteral::build_component(translation, enc_number)?.into_inner())
-            }
+            ast::expression::Expression::EncodedNumber(enc_number) => Term::from(
+                EncodedNumberLiteral::build_component(translation, enc_number)?.into_inner(),
+            ),
             ast::expression::Expression::RdfLiteral(rdf_literal) => {
                 Term::from(RdfLiteral::build_component(translation, rdf_literal)?.into_inner())
             }