def test_differ_with_spans(self): parser = FluentParser() strings = [ ("foo = Foo", "foo = Foo"), ("foo = { $arg }", "foo = { $arg }"), ] messages = [(parser.parse_entry(a), parser.parse_entry(b)) for a, b in strings] for a, b in messages: self.assertFalse(a.equals(b, ignored_fields=None))
def test_parser_without_spans(self): parser = FluentParser(with_spans=False) strings = [ ("foo = Foo", "foo = Foo"), ("foo = Foo", "foo = Foo"), ("foo = { $arg }", "foo = { $arg }"), ] messages = [(parser.parse_entry(a), parser.parse_entry(b)) for a, b in strings] for a, b in messages: self.assertTrue(a.equals(b))
def test_default_behavior(self): parser = FluentParser() strings = [ ("foo = Foo", "foo = Foo"), ("foo = Foo", "foo = Foo"), ("foo = { $arg }", "foo = { $arg }"), ] messages = [(parser.parse_entry(a), parser.parse_entry(b)) for a, b in strings] for a, b in messages: self.assertTrue(a.equals(b))
class TestOrderEquals(unittest.TestCase): def setUp(self): self.parser = FluentParser() def parse_ftl_entry(self, string): return self.parser.parse_entry(dedent_ftl(string)) def test_attributes(self): message1 = self.parse_ftl_entry("""\ foo .attr1 = Attr1 .attr2 = Attr2 """) message2 = self.parse_ftl_entry("""\ foo .attr2 = Attr2 .attr1 = Attr1 """) self.assertTrue(message1.equals(message2)) self.assertTrue(message2.equals(message1)) def test_variants(self): message1 = self.parse_ftl_entry("""\ foo = { $num -> [a] A *[b] B } """) message2 = self.parse_ftl_entry("""\ foo = { $num -> *[b] B [a] A } """) self.assertTrue(message1.equals(message2)) self.assertTrue(message2.equals(message1)) def test_variants_with_numbers(self): message1 = self.parse_ftl_entry("""\ foo = { $num -> [1] A *[b] B } """) message2 = self.parse_ftl_entry("""\ foo = { $num -> *[b] B [1] A } """) self.assertTrue(message1.equals(message2)) self.assertTrue(message2.equals(message1))
class TestIgnoredFields(unittest.TestCase): def setUp(self): self.parser = FluentParser() def parse_ftl_entry(self, string): return self.parser.parse_entry(dedent_ftl(string)) def test_ignore_value(self): a = self.parse_ftl_entry("foo = Foo") b = self.parse_ftl_entry("foo = Bar") self.assertTrue(a.equals(b, ignored_fields=['value'])) def test_ignore_value_span(self): a = self.parse_ftl_entry("foo = Foo") b = self.parse_ftl_entry("foo = Foobar") self.assertTrue(a.equals(b, ignored_fields=['span', 'value'])) self.assertFalse(a.equals(b, ignored_fields=['value'])) def test_ignore_comments(self): a = self.parse_ftl_entry("""\ # Comment A foo = Foo """) b = self.parse_ftl_entry("""\ # Comment B foo = Foo """) c = self.parse_ftl_entry("""\ # Comment CC foo = Foo """) self.assertTrue(a.equals(b, ignored_fields=['comment'])) self.assertFalse(a.equals(c, ignored_fields=['comment'])) self.assertTrue(a.equals(c, ignored_fields=['comment', 'span']))
class TestEntryEqualToSelf(unittest.TestCase): def setUp(self): self.parser = FluentParser() def parse_ftl_entry(self, string): return self.parser.parse_entry(dedent_ftl(string)) def test_same_simple_message(self): message1 = self.parse_ftl_entry("""\ foo = Foo """) self.assertTrue(message1.equals(message1)) self.assertTrue(message1.equals(message1.clone())) def test_same_selector_message(self): message1 = self.parse_ftl_entry("""\ foo = { $num -> [one] One [two] Two [few] Few [many] Many *[other] Other } """) self.assertTrue(message1.equals(message1)) self.assertTrue(message1.equals(message1.clone())) def test_same_complex_placeable_message(self): message1 = self.parse_ftl_entry("""\ foo = Foo { NUMBER($num, style: "decimal") } Bar """) self.assertTrue(message1.equals(message1)) self.assertTrue(message1.equals(message1.clone())) def test_same_message_with_attribute(self): message1 = self.parse_ftl_entry("""\ foo = .attr = Attr """) self.assertTrue(message1.equals(message1)) self.assertTrue(message1.equals(message1.clone())) def test_same_message_with_attributes(self): message1 = self.parse_ftl_entry("""\ foo = .attr1 = Attr 1 .attr2 = Attr 2 """) self.assertTrue(message1.equals(message1)) self.assertTrue(message1.equals(message1.clone())) def test_same_junk(self): message1 = self.parse_ftl_entry("""\ foo = Foo { """) self.assertTrue(message1.equals(message1)) self.assertTrue(message1.equals(message1.clone()))
class TestParseEntry(unittest.TestCase): maxDiff = None def setUp(self): self.parser = FluentParser(with_spans=False) def test_simple_message(self): input = """\ foo = Foo """ output = { "comment": None, "value": { "elements": [{ "span": None, "type": "TextElement", "value": "Foo" }], "span": None, "type": "Pattern" }, "attributes": [], "type": "Message", "span": None, "id": { "span": None, "type": "Identifier", "name": "foo" } } message = self.parser.parse_entry(dedent_ftl(input)) self.assertEqual(message.to_json(), output) def test_ignore_attached_comment(self): input = """\ # Attached Comment foo = Foo """ output = { "comment": None, "value": { "elements": [{ "span": None, "type": "TextElement", "value": "Foo" }], "span": None, "type": "Pattern" }, "attributes": [], "type": "Message", "id": { "name": "foo", "span": None, "type": "Identifier" }, "span": None, "type": "Message" } message = self.parser.parse_entry(dedent_ftl(input)) self.assertEqual(message.to_json(), output) def test_return_junk(self): input = """\ # Attached Comment junk """ output = { "content": "junk\n", "annotations": [{ "arguments": ["="], "code": "E0003", "message": "Expected token: \"=\"", "span": { "end": 23, "start": 23, "type": "Span" }, "type": "Annotation" }], "span": None, "type": "Junk" } message = self.parser.parse_entry(dedent_ftl(input)) self.assertEqual(message.to_json(), output) def test_ignore_all_valid_comments(self): input = """\ # Attached Comment ## Group Comment ### Resource Comment foo = Foo """ output = { "comment": None, "value": { "elements": [{ "span": None, "type": "TextElement", "value": "Foo" }], "span": None, "type": "Pattern" }, "attributes": [], "span": None, "type": "Message", "id": { "name": "foo", "span": None, "type": "Identifier" } } message = self.parser.parse_entry(dedent_ftl(input)) self.assertEqual(message.to_json(), output) def test_do_not_ignore_invalid_comments(self): input = """\ # Attached Comment ##Invalid Comment """ output = { "content": "##Invalid Comment\n", "annotations": [{ "arguments": [" "], "code": "E0003", "message": "Expected token: \" \"", "span": { "end": 21, "start": 21, "type": "Span" }, "type": "Annotation" }], "span": None, "type": "Junk" } message = self.parser.parse_entry(dedent_ftl(input)) self.assertEqual(message.to_json(), output)
def parse_literal(input): parser = FluentParser(with_spans=False) ast = parser.parse_entry(input) expr = ast.value.elements[0].expression return expr.parse()