Abstract into tryReadFileSync

etc/browser/lib/files.js

@@ -12,10 +12,13 @@ function createSyncImportHook() {
   return function () { throw createError(); };
 }
 
+function tryReadFileSync() { return null; }
+
 module.exports = {
   createImportHook,
   createSyncImportHook,
   existsSync: function () { return false; },
   readFileSync: function () { throw createError(); },
-  readSchemaFromPathOrString: function () { throw createError(); }
+  tryReadFileSync,
+  readSchemaFromPathOrString: function () { throw createError(); },
 };

lib/files.js

@@ -8,8 +8,7 @@
  */
 
 let fs = require('fs'),
-    path = require('path'),
-    specs = require('./specs');
+    path = require('path');
 
 /** Default (asynchronous) file loading function for assembling IDLs. */
 function createImportHook() {
@@ -54,68 +53,20 @@ function createSyncImportHook() {
 }
 
 /**
- * Convenience function to parse multiple inputs into protocols and schemas.
- *
- * It should cover most basic use-cases but has a few limitations:
- *
- * + It doesn't allow passing options to the parsing step.
- * + The protocol/type inference logic can be deceived.
- *
- * The parsing logic is as follows:
- *
- * + If `str` contains `path.sep` (on windows `\`, otherwise `/`) and is a path
- *   to an existing file, it will first be read as JSON, then as an IDL
- *   specification if JSON parsing failed. If either succeeds, the result is
- *   returned, otherwise the next steps are run using the file's content
- *   instead of the input path.
- * + If `str` is a valid JSON string, it is parsed then returned.
- * + If `str` is a valid IDL protocol specification, it is parsed and returned
- *   if no imports are present (and an error is thrown if there are any
- *   imports).
- * + If `str` is a valid IDL type specification, it is parsed and returned.
- * + If neither of the above cases apply, `str` is returned.
+ * Check if the given input string is "path-like" or a path to an existing file,
+ * and if so, read it. This requires it to contain a path separator
+ * (`path.sep`). If not, this will return `null`.
  */
-function readSchemaFromPathOrString(str) {
-  let schema;
+function tryReadFileSync(str) {
   if (
     typeof str == 'string' &&
-    str.indexOf('/') !== -1 &&
+    str.indexOf(path.sep) !== -1 &&
     fs.existsSync(str)
   ) {
-    // Try interpreting `str` as path to a file contain a JSON schema or an IDL
-    // protocol. Note that we add the second check to skip primitive references
-    // (e.g. `"int"`, the most common use-case for `avro.parse`).
-    let contents = fs.readFileSync(str, {encoding: 'utf8'});
-    try {
-      return JSON.parse(contents);
-    } catch (err) {
-      let opts = {importHook: createSyncImportHook()};
-      specs.assembleProtocol(str, opts, (err, protocolSchema) => {
-        schema = err ? contents : protocolSchema;
-      });
-    }
-  } else {
-    schema = str;
-  }
-  if (typeof schema != 'string' || schema === 'null') {
-    // This last predicate is to allow `read('null')` to work similarly to
-    // `read('int')` and other primitives (null needs to be handled separately
-    // since it is also a valid JSON identifier).
-    return schema;
-  }
-  try {
-    return JSON.parse(schema);
-  } catch (err) {
-    try {
-      return specs.readProtocol(schema);
-    } catch (err) {
-      try {
-        return specs.readSchema(schema);
-      } catch (err) {
-        return schema;
-      }
-    }
+    // Try interpreting `str` as path to a file.
+    return fs.readFileSync(str, {encoding: 'utf8'});
   }
+  return null;
 }
 
 module.exports = {
@@ -124,5 +75,5 @@ module.exports = {
   // Proxy a few methods to better shim them for browserify.
   existsSync: fs.existsSync,
   readFileSync: fs.readFileSync,
-  readSchemaFromPathOrString
+  tryReadFileSync
 };

lib/specs.js

@@ -210,15 +210,11 @@ function assembleProtocol(fpath, opts, cb) {
  */
 function read(str) {
   let schema;
-  if (
-    typeof str == 'string' &&
-    str.indexOf('/') !== -1 &&
-    files.existsSync(str)
-  ) {
-    // Try interpreting `str` as path to a file contain a JSON schema or an IDL
-    // protocol. Note that we add the second check to skip primitive references
-    // (e.g. `"int"`, the most common use-case for `avro.parse`).
-    let contents = files.readFileSync(str, {encoding: 'utf8'});
+  let contents = files.tryReadFileSync(str);
+
+  if (contents === null) {
+    schema = str;
+  } else {
     try {
       return JSON.parse(contents);
     } catch (err) {
@@ -227,8 +223,6 @@ function read(str) {
         schema = err ? contents : protocolSchema;
       });
     }
-  } else {
-    schema = str;
   }
   if (typeof schema != 'string' || schema === 'null') {
     // This last predicate is to allow `read('null')` to work similarly to