Fall back to msgId.attrName when attribute is not found (#370)

Author: stasm

fluent/src/resolver.js

@@ -199,7 +199,7 @@ function MessageReference(scope, {name, attr}) {
       return Type(scope, attribute);
     }
     scope.errors.push(new ReferenceError(`Unknown attribute: ${attr}`));
-    return Type(scope, message);
+    return new FluentNone(`${name}.${attr}`);
   }
 
   return Type(scope, message);
@@ -225,7 +225,7 @@ function TermReference(scope, {name, attr, args}) {
       return Type(local, attribute);
     }
     scope.errors.push(new ReferenceError(`Unknown attribute: ${attr}`));
-    return Type(local, term);
+    return new FluentNone(`${id}.${attr}`);
   }
 
   return Type(local, term);
@@ -250,7 +250,7 @@ function FunctionReference(scope, {name, args}) {
     return func(...getArguments(scope, args));
   } catch (e) {
     // XXX Report errors.
-    return new FluentNone();
+    return new FluentNone(`${name}()`);
   }
 }
 

fluent/test/attributes_test.js

@@ -30,34 +30,34 @@ suite('Attributes', function() {
       `);
     });
 
-    test('falls back gracefully for entities with string values and no attributes', function() {
+    test('entities with string values and no attributes', function() {
       const msg = bundle.getMessage('ref-foo');
       const val = bundle.format(msg, args, errs);
-      assert.equal(val, 'Foo');
+      assert.equal(val, '{foo.missing}');
       assert.equal(errs.length, 1);
       assert(errs[0] instanceof ReferenceError); // unknown attribute
     });
 
-    test('falls back gracefully for entities with string values and other attributes', function() {
+    test('entities with string values and other attributes', function() {
       const msg = bundle.getMessage('ref-bar');
       const val = bundle.format(msg, args, errs);
-      assert.equal(val, 'Bar');
+      assert.equal(val, '{bar.missing}');
       assert.equal(errs.length, 1);
       assert(errs[0] instanceof ReferenceError); // unknown attribute
     });
 
-    test('falls back gracefully for entities with pattern values and no attributes', function() {
+    test('entities with pattern values and no attributes', function() {
       const msg = bundle.getMessage('ref-baz');
       const val = bundle.format(msg, args, errs);
-      assert.equal(val, 'Foo Baz');
+      assert.equal(val, '{baz.missing}');
       assert.equal(errs.length, 1);
       assert(errs[0] instanceof ReferenceError); // unknown attribute
     });
 
-    test('falls back gracefully for entities with pattern values and other attributes', function() {
+    test('entities with pattern values and other attributes', function() {
       const msg = bundle.getMessage('ref-qux');
       const val = bundle.format(msg, args, errs);
-      assert.equal(val, 'Foo Qux');
+      assert.equal(val, '{qux.missing}');
       assert.equal(errs.length, 1);
       assert(errs[0] instanceof ReferenceError); // unknown attribute
     });

fluent/test/values_ref_test.js

@@ -39,6 +39,15 @@ suite('Referencing values', function(){
 
       ref10 = { key5.a }
       ref11 = { key5.b }
+      ref12 = { key5.c }
+
+      ref13 = { key6 }
+      ref14 = { key6.a }
+
+      ref15 = { -key6 }
+      ref16 = { -key6.a ->
+          *[a] A
+      }
     `);
   });
 
@@ -104,11 +113,34 @@ suite('Referencing values', function(){
   test('references the attributes', function(){
     const msg_a = bundle.getMessage('ref10');
     const msg_b = bundle.getMessage('ref11');
+    const msg_c = bundle.getMessage('ref12');
     const val_a = bundle.format(msg_a, args, errs)
     const val_b = bundle.format(msg_b, args, errs)
+    const val_c = bundle.format(msg_c, args, errs)
     assert.strictEqual(val_a, 'A5');
     assert.strictEqual(val_b, 'B5');
-    assert.equal(errs.length, 0);
+    assert.strictEqual(val_c, '{key5.c}');
+    assert.equal(errs.length, 1);
+  });
+
+  test('missing message reference', function(){
+    const msg_a = bundle.getMessage('ref13');
+    const msg_b = bundle.getMessage('ref14');
+    const val_a = bundle.format(msg_a, args, errs)
+    const val_b = bundle.format(msg_b, args, errs)
+    assert.strictEqual(val_a, '{key6}');
+    assert.strictEqual(val_b, '{key6}');
+    assert.equal(errs.length, 2);
+  });
+
+  test('missing term reference', function(){
+    const msg_a = bundle.getMessage('ref15');
+    const msg_b = bundle.getMessage('ref16');
+    const val_a = bundle.format(msg_a, args, errs)
+    const val_b = bundle.format(msg_b, args, errs)
+    assert.strictEqual(val_a, '{-key6}');
+    assert.strictEqual(val_b, 'A');
+    assert.equal(errs.length, 2);
   });
 
 });