Wren Support

Wren Language

Wren is a small, fast, class-based concurrent scripting language

Think Smalltalk in a Lua-sized package with a dash of Erlang and wrapped up in a familiar, modern syntax.

System.print("Hello, world!")

class Wren {
  flyTo(city) {
    System.print("Flying to %(city)")
  }
}

var adjectives = Fiber.new {
  ["small", "clean", "fast"].each {|word| Fiber.yield(word) }
}

while (!adjectives.isDone) System.print(adjectives.call())

Additional resources

• https://wren.io/
• https://github.com/wren-lang/wren

Possible Implementation

Butchered some available languages and came with something. But stills needs some testing 👍

// Prism.languages.wren
export default (function (Prism) {
  var multilineComment = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source;
  for (var i = 0; i < 2; i++) {
    // support 4 levels of nested comments
    multilineComment = multilineComment.replace(/<self>/g, function () { return multilineComment; });
  }
  multilineComment = multilineComment.replace(/<self>/g, function () { return /[^\s\S]/.source; });

  Prism.languages.wren = {
    'hashbang': {
      pattern: /^#!.*/,
      greedy: true,
      alias: 'comment'
    },
    'comment': [
      {
        pattern: RegExp(/(^|[^\\])/.source + multilineComment),
        lookbehind: true,
        greedy: true
      },
      {
        pattern: /(^|[^\\:])\/\/.*/,
        lookbehind: true,
        greedy: true
      }
    ],
    'triple-quoted-string': {
      pattern: /(?:[])?(""")[\s\S]*?\1/i,
      greedy: true,
      alias: 'string'
    },
    'string': {
      pattern: /(?:[])?(")[\s\S]*?\1/i,
      greedy: true
    },
    'class-name': {
      pattern: /(\b(?:class|is|Num|System|Object|Sequence|List|Map|Bool|String|Range|Fn|Fiber)\s+|\bcatch\s+\()[\w.\\]+/i,
      lookbehind: true,
      inside: {
        'punctuation': /[.\\]/
      }
    },
    'keyword': /\b(?:if|else|while|for|return|in|is|as|null|break|continue|foreign|construct|static|var|class|this|super|#!|#)\b/,
    'boolean': /\b(?:true|false)\b/,
    'number': /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
    'null': {
      pattern: /\bnull\b/,
      alias: 'keyword'
    },
    'function': /(?!\d)\w+(?=\s*(?:[({]))/,
    'operator': [
        /[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/,
        {
          // Match ".." but don't break "..."
          pattern: /(^|[^.])\.\.(?!\.)/,
          lookbehind: true
        }
      ],
    'punctuation': /[\[\](){},;]|\.+|:+/
  };
});

[RunDevelopment]

@clsource Would you like to do a PR?

@joshgoebel I think it’s ok. It’s a little off-topic but you also contribute by responding to comments and sharing your experience, so I don’t mind.

[clsource]

Ok implemented your suggestions and added hashbangs 👍

// https://wren.io/
// Prism.languages.wren
export default (function (Prism) {

  // Multiline based on prism-rust.js
  var multilineComment = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source;
  for (var i = 0; i < 2; i++) {
      // Supports up to 4 levels of nested comments
      multilineComment = multilineComment.replace(/<self>/g, function () { return multilineComment; });
  }
  multilineComment = multilineComment.replace(/<self>/g, function () { return /[^\s\S]/.source; });

  var wren = {
      // Multiline comments in Wren can have nested multiline comments
      // Comments: // and /* */
      'comment': [
          {
              pattern: RegExp(/(^|[^\\])/.source + multilineComment),
              lookbehind: true,
              greedy: true
          },
          {
              pattern: /(^|[^\\:])\/\/.*/,
              lookbehind: true,
              greedy: true
          }
      ],

      // Triple quoted strings are multiline but cannot have interpolation (raw strings)
      // Based on prism-python.js
      'triple-quoted-string': {
          pattern: /(""")[\s\S]*?\1/iu,
          greedy: true,
          alias: 'string'
      },

      // A single quote string is multiline and can have interpolation (similar to JS backticks ``)
      'string': {
          pattern: /"(?:\\[\s\S]|%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))+\)|(?!%\()[^\\"])*"/u,
          greedy: true,
          inside: {}
          // Interpolation defined at the end of this function
      },

      'boolean': /\b(?:true|false)\b/,
      'number': /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
      'null': {
          pattern: /\bnull\b/,
          alias: 'keyword'
      },

      // Highlight predefined classes and wren_cli classes as builtin
      'builtin': /\b(?:Num|System|Object|Sequence|List|Map|Bool|String|Range|Fn|Fiber|Meta|Random|File|Directory|Stat|Stdin|Stdout|Platform|Process|Scheduler|Timer)\b/,

      // Attributes are special keywords to add meta data to classes
      'attribute': [
          // #! attributes are stored in class properties
          // #!myvar = true
          // #attributes are not stored and dismissed at compilation
          {
              pattern: /#!?[ \t\u3000]*[A-Za-z_\d]+\b/u,
              alias: 'keyword'
          },
      ],
      // #!/usr/bin/env wren on the first line
      'hashbang': [
        {
          pattern: /#!\/[\S \t\u3000]+/u,
          greedy:true,
          alias:'constant'
        }
      ],
      'class-name': [
          {
              // class definition
              // class Meta {}
              pattern: /(\b(?:class)\s+)[\w.\\]+/i,
              lookbehind: true,
              inside: {
                  'punctuation': /[.\\]/
              }
          },
          {
            // A class must always start with an uppercase.
            // File.read
            pattern: /\b[A-Z][a-z\d_]*\b/,
            lookbehind:true,
            inside: {
              'punctuation': /[.\\]/
            }
          }
      ],

      // A constant can be a variable, class, property or method. Just named in all uppercase letters
      'constant': /\b[A-Z][A-Z\d_]*\b/,

      'keyword': /\b(?:if|else|while|for|return|in|is|as|null|break|continue|foreign|construct|static|var|class|this|super|#!|#|import)\b/,

      // Functions can be Class.method()
      'function': /(?!\d)\w+(?=\s*(?:[({]))/,

      // Traditional operators but adding .. and ... for Ranges e.g.: 1..2
      // Based on prism-lua.js
      'operator': [
          /[-+*%^&|]|\/\/?|<[<=]?|>[>=]?|[=~]=?/,
          {
              // Match ".." but don't break "..."
              pattern: /(^|[^.])\.\.(?!\.)/,
              lookbehind: true
          }
      ],
      // Traditional punctuation although ; is not used in Wren
      'punctuation': /[\[\](){},;]|\.+|:+/,
      'variable': /[a-zA-Z_\d]\w*\b/,
  };

  // Based on prism-javascript.js interpolation
  // "%(interpolation)"
  var stringInside = {
    'template-punctuation': {
      pattern: /^"|"$/,
      alias: 'string'
    },
    'interpolation': {
      pattern: /((?:^|[^\\])(?:\\{2})*)%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))+\)/,
      lookbehind: true,
      inside: {
        'interpolation-punctuation': {
          pattern: /^%(|)$/,
          alias: 'punctuation'
        },
        rest: wren
      }
    },
    'string': /[\s\S]+/iu
  };

  // Only single quote strings can have interpolation
  wren['string'].inside = stringInside;

  Prism.languages.wren = wren;
});