Add private messages (#38)

zbraniecki · web-flow · commit 5b3382e0a2a0 · 2017-12-20T01:36:40.000-08:00
diff --git a/src/syntax/errors/list.rs b/src/syntax/errors/list.rs
@@ -34,6 +34,9 @@ pub enum ErrorKind {
     ForbiddenWhitespace,
     ForbiddenCallee,
     ForbiddenKey,
+    ForbiddenPrivateAttributeExpression,
+    ForbiddenPublicAttributeExpression,
+    ForbiddenVariantExpression,
 }
 
 pub fn get_error_desc(err: &ErrorKind) -> (&'static str, String, &'static str) {
@@ -69,17 +72,17 @@ pub fn get_error_desc(err: &ErrorKind) -> (&'static str, String, &'static str) {
         }
         ErrorKind::ForbiddenWhitespace => (
             "E0007",
-            "keyword cannot end with a whitespace".to_owned(),
+            "Keyword cannot end with a whitespace".to_owned(),
             "",
         ),
         ErrorKind::ForbiddenCallee => (
             "E0008",
-            "a callee has to be a simple identifier".to_owned(),
+            "The callee has to be a simple, upper-case, identifier".to_owned(),
             "",
         ),
         ErrorKind::ForbiddenKey => (
             "E0009",
-            "a key has to be a simple identifier".to_owned(),
+            "The key has to be a simple identifier".to_owned(),
             "",
         ),
         ErrorKind::MissingDefaultVariant => (
@@ -88,9 +91,24 @@ pub fn get_error_desc(err: &ErrorKind) -> (&'static str, String, &'static str) {
             "",
         ),
         ErrorKind::MissingVariants => (
-            "E0010",
+            "E0011",
             "Expected at least one variant after \"->\".".to_owned(),
             "",
         ),
+        ErrorKind::ForbiddenPrivateAttributeExpression => (
+            "E0012",
+            "Attributes of private messages cannot be used as placeables.".to_owned(),
+            "",
+        ),
+        ErrorKind::ForbiddenPublicAttributeExpression => (
+            "E0013",
+            "Attributes of public messages cannot be used as selectors.".to_owned(),
+            "",
+        ),
+        ErrorKind::ForbiddenVariantExpression => (
+            "E0014",
+            "Variants cannot be used as selectors.".to_owned(),
+            "",
+        ),
     }
 }
diff --git a/src/syntax/ftlstream.rs b/src/syntax/ftlstream.rs
@@ -14,13 +14,14 @@ pub trait FTLParserStream<I> {
     where
         F: Fn(char) -> bool;
 
-    fn is_id_start(&mut self) -> bool;
+    fn is_char_id_start(&mut self, ch: Option<char>) -> bool;
+    fn is_message_id_start(&mut self) -> bool;
     fn is_peek_next_line_indented(&mut self) -> bool;
     fn is_peek_next_line_variant_start(&mut self) -> bool;
     fn is_peek_next_line_attribute_start(&mut self) -> bool;
     fn is_peek_next_line_pattern(&mut self) -> bool;
     fn skip_to_next_entry_start(&mut self);
-    fn take_id_start(&mut self) -> Result<char>;
+    fn take_id_start(&mut self, allow_private: bool) -> Result<char>;
     fn take_id_char(&mut self) -> Option<char>;
     fn take_symb_char(&mut self) -> Option<char>;
     fn take_digit(&mut self) -> Option<char>;
@@ -91,14 +92,21 @@ where
         None
     }
 
-    fn is_id_start(&mut self) -> bool {
-        if let Some(ch) = self.ch {
-            return match ch {
-                'a'...'z' | 'A'...'Z' | '_' => true,
-                _ => false,
-            };
+    fn is_char_id_start(&mut self, ch: Option<char>) -> bool {
+        match ch {
+            Some('a'...'z') | Some('A'...'Z') => true,
+            _ => false,
         }
-        false
+    }
+
+    fn is_message_id_start(&mut self) -> bool {
+        if let Some('-') = self.ch {
+            self.peek();
+        }
+        let ch = self.current_peek();
+        let is_id = self.is_char_id_start(ch);
+        self.reset_peek();
+        is_id
     }
 
     fn is_peek_next_line_indented(&mut self) -> bool {
@@ -196,7 +204,7 @@ where
     fn skip_to_next_entry_start(&mut self) {
         while let Some(_) = self.next() {
             if self.current_is('\n') && !self.peek_char_is('\n')
-                && (self.next() == None || self.is_id_start() || self.current_is('/')
+                && (self.next() == None || self.is_message_id_start() || self.current_is('/')
                     || self.current_is('[') || self.peek_char_is('/')
                     || self.peek_char_is('['))
             {
@@ -205,17 +213,23 @@ where
         }
     }
 
-    fn take_id_start(&mut self) -> Result<char> {
+    fn take_id_start(&mut self, allow_private: bool) -> Result<char> {
         let closure = |x| match x {
-            'a'...'z' | 'A'...'Z' | '_' => true,
+            'a'...'z' | 'A'...'Z' => true,
+            '-' => allow_private,
             _ => false,
         };
 
-        match self.take_char(closure) {
-            Some(ch) => Ok(ch),
-            None => error!(ErrorKind::ExpectedCharRange {
-                range: String::from("'a'...'z' | 'A'...'Z' | '_'"),
-            }),
+        if let Some(ch) = self.take_char(closure) {
+            Ok(ch)
+        } else if allow_private {
+            error!(ErrorKind::ExpectedCharRange {
+                range: String::from("'a'...'z' | 'A'...'Z'"),
+            })
+        } else {
+            error!(ErrorKind::ExpectedCharRange {
+                range: String::from("'a'...'z' | 'A'...'Z' | '-'"),
+            })
         }
     }
 
diff --git a/src/syntax/parser.rs b/src/syntax/parser.rs
@@ -80,7 +80,7 @@ where
         return Ok(get_section(ps, comment)?);
     }
 
-    if ps.is_id_start() {
+    if ps.is_message_id_start() {
         return Ok(get_message(ps, comment)?);
     }
 
@@ -150,7 +150,7 @@ fn get_message<I>(ps: &mut ParserStream<I>, comment: Option<ast::Comment>) -> Re
 where
     I: Iterator<Item = char>,
 {
-    let id = get_identifier(ps)?;
+    let id = get_private_identifier(ps)?;
 
     ps.skip_line_ws();
 
@@ -196,7 +196,7 @@ where
 
         ps.expect_char('.')?;
 
-        let key = get_identifier(ps)?;
+        let key = get_public_identifier(ps)?;
 
         ps.skip_line_ws();
 
@@ -222,13 +222,27 @@ where
     Ok(attributes)
 }
 
-fn get_identifier<I>(ps: &mut ParserStream<I>) -> Result<ast::Identifier>
+fn get_private_identifier<I>(ps: &mut ParserStream<I>) -> Result<ast::Identifier>
+where
+    I: Iterator<Item = char>,
+{
+    get_identifier(ps, true)
+}
+
+fn get_public_identifier<I>(ps: &mut ParserStream<I>) -> Result<ast::Identifier>
+where
+    I: Iterator<Item = char>,
+{
+    get_identifier(ps, false)
+}
+
+fn get_identifier<I>(ps: &mut ParserStream<I>, allow_private: bool) -> Result<ast::Identifier>
 where
     I: Iterator<Item = char>,
 {
     let mut name = String::new();
 
-    name.push(ps.take_id_start()?);
+    name.push(ps.take_id_start(allow_private)?);
 
     while let Some(ch) = ps.take_id_char() {
         name.push(ch);
@@ -315,7 +329,7 @@ where
 {
     let mut name = String::new();
 
-    name.push(ps.take_id_start()?);
+    name.push(ps.take_id_start(false)?);
 
     while let Some(ch) = ps.take_symb_char() {
         name.push(ch);
@@ -490,6 +504,13 @@ where
 
     if ps.current_is('-') {
         if let Some('>') = ps.peek() {
+            if let ast::Expression::AttributeExpression { ref id, .. } = selector {
+                if !id.name.starts_with('-') {
+                    return error!(ErrorKind::ForbiddenPublicAttributeExpression);
+                }
+            } else if let ast::Expression::VariantExpression { .. } = selector {
+                return error!(ErrorKind::ForbiddenVariantExpression);
+            }
             ps.next();
             ps.next();
 
@@ -512,6 +533,12 @@ where
         } else {
             ps.reset_peek();
         }
+    } else {
+        if let ast::Expression::AttributeExpression { ref id, .. } = selector {
+            if id.name.starts_with('-') {
+                return error!(ErrorKind::ForbiddenPrivateAttributeExpression);
+            }
+        }
     }
 
     Ok(selector)
@@ -527,7 +554,7 @@ where
         ast::Expression::MessageReference { id } => match ps.ch {
             Some('.') => {
                 ps.next();
-                let attr = get_identifier(ps)?;
+                let attr = get_public_identifier(ps)?;
                 Ok(ast::Expression::AttributeExpression { id, name: attr })
             }
             Some('[') => {
@@ -538,6 +565,9 @@ where
                 Ok(ast::Expression::VariantExpression { id, key: key })
             }
             Some('(') => {
+                if id.name.starts_with('-') || id.name.chars().any(|c| c.is_lowercase()) {
+                    return error!(ErrorKind::ForbiddenCallee);
+                }
                 ps.next();
                 let args = get_call_args(ps)?;
                 ps.expect_char(')')?;
@@ -642,20 +672,31 @@ where
 {
     if let Some(ch) = ps.current() {
         let exp = match ch {
-            '0'...'9' | '-' => ast::Expression::NumberExpression {
+            '0'...'9' => ast::Expression::NumberExpression {
                 value: get_number(ps)?,
             },
+            '-' => if let Some('0'...'9') = ps.peek() {
+                ps.reset_peek();
+                ast::Expression::NumberExpression {
+                    value: get_number(ps)?,
+                }
+            } else {
+                ps.reset_peek();
+                ast::Expression::MessageReference {
+                    id: get_private_identifier(ps)?,
+                }
+            },
             '"' => ast::Expression::StringExpression {
                 value: get_string(ps)?,
             },
             '$' => {
                 ps.next();
                 ast::Expression::ExternalArgument {
-                    id: get_identifier(ps)?,
+                    id: get_public_identifier(ps)?,
                 }
             }
             _ => ast::Expression::MessageReference {
-                id: get_identifier(ps)?,
+                id: get_private_identifier(ps)?,
             },
         };
         Ok(exp)
diff --git a/tests/fixtures/parser/ftl/06-placeables01.ftl b/tests/fixtures/parser/ftl/06-placeables01.ftl
@@ -21,24 +21,24 @@ key7 = { LIST($user1, $user2) }
 
 key9 = { LEN(2, 2.5, -3.12, -1.00) }
 
-key11 = { len() }
+key11 = { LEN() }
 
-key12 = { len(1) }
+key12 = { LEN(1) }
 
-key13 = { len(-1) }
+key13 = { LEN(-1) }
 
-key14 = { len($foo) }
+key14 = { LEN($foo) }
 
-key15 = { len(foo) }
+key15 = { LEN(foo) }
 
-key19 = { len(bar: 1) }
+key19 = { LEN(bar: 1) }
 
-key20 = { len(bar: -1) }
+key20 = { LEN(bar: -1) }
 
-key21 = { len(bar: "user") }
+key21 = { LEN(bar: "user") }
 
 key22 = { brand-name[masculine] }
 
-key23 = { number(style: "percent") }
+key23 = { NUMBER(style: "percent") }
 
-key24 = { number($num, style: "percent", foo: "bar") }
+key24 = { NUMBER_SPECIAL($num, style: "percent", foo: "bar") }
diff --git a/tests/fixtures/parser/ftl/07-private.ftl b/tests/fixtures/parser/ftl/07-private.ftl
@@ -0,0 +1,11 @@
+-brand-short-name = Firefox
+    .gender = masculine
+
+key = Test { -brand-short-name }
+
+key2 = Test { -brand-short-name.gender ->
+    [masculine] Foo
+   *[feminine] Foo 2
+ }
+
+key3 = Test { -brand[one] }
diff --git a/tests/fixtures/parser/ftl/errors/08-private.ftl b/tests/fixtures/parser/ftl/errors/08-private.ftl
@@ -0,0 +1,12 @@
+
+key =
+    { $foo ->
+        [one] Foo
+       *[-other] Foo 2
+    }
+
+key2 = { $-foo }
+
+key3 = { -brand.gender }
+
+key4 = { -brand() }
diff --git a/tests/resolve_select_expression.rs b/tests/resolve_select_expression.rs
diff --git a/tests/syntax/errors.rs b/tests/syntax/errors.rs
