to-tmlanguage

#!/usr/bin/env pike
//! This program converts a JSON file to a Sublime language definition file.
//!
//! run like:
//!
//! user@computer:~$ to-tmlanguage /path/to/json-file
//!
//! The resulting file will be placed in the same directory as the original
//! file. NOTE! The resulting file will be named like
//! [first-part-of-orgiginal-file.tmLanguage]. So if the input file is named
//! Lang.json the resulting file will be named Lang.tmLanguage.
//!
//! * To generate a UUID give the "key" uuid in the property list file the value
//!   #uuid. The #uuid part will be replaced with a real UUID.
//!
//! * $scopeName in the JSON file will be expanded to the value of the
//!   "scopeName" key.
//!
//! { "name" : "Lang",
//!   "scopeName" : "source.lang",
//!   "uuid" : "#uuid",
//!   "test" : "some.stuff.$scopeName"
//! }
//!
//! Will result in
//!
//! <dict>
//!   <key>name</key>
//!   <string>Lang</string>
//!   <key>scopeName</key>
//!   <string>source.lang</string>
//!   <key>uuid</key>
//!   <string>f0c5f4ad-3e8a-4add-9ebf-2ce1d5e5262f</string>
//!   <key>test</key>
//!   <string>some.stuff.source.lang</string>
//! </dict>

String.Buffer buffer;
function add;
int level = 1; // Indentation level of the XML file

// Replace < and > with XML entities
#define rep(X) replace((string)(X), ([ "&":"&amp;", "<":"&lt;", ">":"&gt;" ]))

// Create an opening tag
#define tag1(X) "\n" + ("\t" * level) + "<" + X + ">"

// Create a closing tag
#define tag2(X) "</" + X  + ">"

// Add tag to buffer
#define tag(TYPE,VAL) add(tag1(TYPE), rep((VAL)), tag2(TYPE))

// Append newline and indentation to buffer
#define end() ("\n" + ("  " * level))

// Regexp for removing our own comments in the JSON file
Regexp.PCRE comment_re = Regexp.PCRE("^[ \t]*//-.*$",
                                     Regexp.PCRE.OPTION.MULTILINE);

// Replace the most common control characters to make the JSON parser happy
#define newline_marker "__NEWLINE_MARKER__"
#define tab_marker "__TAB_MARKER__"

int main(int argc, array(string) argv)
{
  if (argc < 2) {
    werror("Missing Sublime Syntax file as argument\n");
    return 1;
  }

  string file = argv[1];

  if (!Stdio.exist(file) || !Stdio.is_file(file)) {
    werror("Argument is not a file!\n");
    return 1;
  }

  buffer = String.Buffer();
  add = buffer->add;

  add("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
      "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" "
      "\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
      "<plist version=\"1.0\">");

  string file_content = Stdio.read_file(file);

  // Remove our special comments
  file_content = comment_re->replace(file_content, "");
  file_content = fix_multiline(file_content);

#ifdef DEBUG
  werror("%s\n", file_content);
  Stdio.write_file(file+".debug", file_content);
  return 0;
#endif

  mixed json = Standards.JSON.decode(file_content);

  if (json->uuid && json->uuid == "#uuid") {
    json->uuid = (string) Standards.UUID.make_version4();
    file_content = replace(file_content, "#uuid", json->uuid);
    Stdio.write_file(file, file_content);
  }

  encode_xml(json);

  add("\n</plist>");

  string data = buffer->get();

  foreach (json; string key; mixed v) {
    if (stringp(v))
      data = replace(data, "$" + key, v);
  }

  string ofname, fname, path;
  path = dirname(file);
  ofname = fname = basename(file);

  if (search(fname, ".") > -1)
    fname = (fname/".")[0];

  fname += ".tmLanguage";

  if (fname == ofname) {
    werror("The input file has the same name as the output file! Please "
           "rename the input file!\n");
    return 1;
  }

  path = combine_path(path, fname);

  Stdio.write_file(path, data);

#ifdef DEVMODE
  string config_path = combine_path(getenv("HOME"),
                        ".config/sublime-text-2/Packages/User/Pike");
  write("Copying tmLanguage to %O\n", config_path);
  Stdio.write_file(combine_path(config_path, fname), data);
#endif

  return 0;
}

string fix_multiline(string s)
{
  int len = sizeof(s);
  int pos = 0;
  int(0..1) in_str = 0;
  string ns = "";

  // Pad so that we don't peek beyond the end
  s += "\0";

  do {
    // Remove multiline comments like /* ... */
    if (s[pos] == '/' && s[pos+1] == '*') {
      pos++;

      while (pos++ < len) {
        if (s[pos] == '*' && s[pos+1] == '/')
          break;
      }

      pos++;
      continue;
    }

    if (s[pos] == '\\' && s[pos+1] == '\n') {
      // Remove beginning whitespace on next line
      sscanf (reverse(ns), "%*[ \t]%s", ns);
      ns = reverse(ns[1..]);
      pos += 2;

      // Skip whitespaces
      while (s[pos++] == ' ' || s[pos] == '\t')
        ;

      ns += s[pos..pos];

      continue;
    }

    // Check for a multiline string: #"
    if (!in_str && s[pos] == '#' && s[pos+1] == '"') {
      in_str = 1;
      ns += "\"";
      pos++;
      continue;
    }
    // If in a string and a " if found with no \ before we're at the string end
    else if (in_str && s[pos] == '"' && s[pos-1] != '\\')
      in_str = 0;

    // If in a string and a newline, remove and replace it with mumbojumbo
    // that will make the JSON parser happy. Mumbojumbo will be replaced with
    // a real newline in the end result.
    if (in_str && s[pos] == '\n')
      ns += newline_marker;
    else if (in_str && s[pos] == '\t')
      ns += tab_marker;
    else
      ns += s[pos..pos];

  } while (pos++ < len);

  // Remove null padding
  ns = ns[..sizeof(ns)-2];

  return ns;
}

string type_to_string(mixed x)
{
  if (intp(x)) return "int";
  if (arrayp(x)) return "array";
  if (floatp(x)) return "float";
  if (stringp(x)) return "string";
  if (mappingp(x)) return "dict";

  error("Unhandled Pike type: %O\n", x);
}

mixed encode_xml(mixed in)
{
  string type = type_to_string(in);

  switch (type)
  {
    case "dict":

      add(tag1(type));

      foreach (sort(indices(in)), string key) {
        mixed value = in[key];
        level++;
        tag("key", key);
        encode_xml(value);
        level--;
      }

      add(end(), tag2(type));

      break;

    case "array":

      add(tag1(type));

      foreach (in, mixed v) {
        level++;
        encode_xml(v);
        level--;
      }

      add(end(), tag2(type));

      break;

    case "string":
      in = replace(in, ({ newline_marker, tab_marker }), ({ "\n", "\t" }));
    case "float":
    case "int":

      tag(type, in);

      break;
  }
}