Not logged in.  Login/Logout/Register | List snippets | | Create snippet | Upload image | Upload data

297
LINES

< > BotCompany Repo | #1030131 - JavaXHyperlinker - annotates JavaX sources in HTML

JavaX fragment (include) [tags: use-pretranspiled]

Transpiled version (7573L) is out of date.

sclass JavaXHyperlinker {
  bool targetBlank;
  
  // only a single token allowed on LHS
  SS shortFor = litmap(
    "BigInt", "BIgInteger",
    "$1", "m.unq(0)",
    "$2", "m.unq(1)",
    "$3", "m.unq(2)",
    "LS", "List<String>",
    "sclass", "static class",
    "asclass", "abstract static class",
    "svoid", "static void",
    "SS", "Map<String, String>",
    "S", "String",
    "ret", "return",
    "L", "List",
    "Cl", "Collection",
    "O", "Object",
    "sO", "static Object",
    "sS", "static String",
    "fO", "final Object",
    "fS", "final String",
    "sS", "static String",
    "sbool", "static boolean",
    "fbool", "final boolean",
    "bool", "boolean",
    "Int", "Integer",
    "cast", "casting to the type required on the left-hand side",
    "°", "()",
    "ItIt", "IterableIterator",
    "ES", "Ext<S> (string plus extended information)",
    "CloseableItIt", "CloseableIterableIterator",
    "LPairS", "List<Pair<String>>",
    "ISegmenter", "IF1<BufferedImage, L<Rect>>",
  );
  
  S explFunc = "anonymous function declaration (similar to Java 8 lambdas)";
  S explPNoconsole = "Main program including Substance L&F, started in non-AWT thread, hiding the console";
  
  // any number of tokens allowed on LHS
  SS tokenExplanations = litmap(
    "== null ?:", "short for: == null ? null :",
    "p-exp {", "main program with automatic upgrade",
    "mapLike", "a function that takes a global function name as first argument and can be called like this: <mapLikeFunction> <otherFunction>(...)",
    "mapMethodLike", "a function that takes a method or field name as first argument and can be called like this: <mapMethodLikeFunction> <methodOrFieldName>(...)",
    "func(", explFunc, "func{", explFunc,
    //"f(", explFunc, "f{", explFunc,
    "voidfunc", "anonymous function declaration without return value (similar to Java 8 lambdas)",
    "ctex", "ctex rethrows exceptions as RuntimeExceptions so you don't have to declare them",
    "p {", "short for: public static void main(String[] args)",
    "p-experiment {", "Main program with a nice big console & auto-restart",
    "p-substance {", "Main program including Substance L&F, started in AWT thread",
    "p-subst {", "Main program including Substance L&F, started in non-AWT thread",
    "p-noconsole {", explPNoconsole,
    "pn {", explPNoconsole,
    "answer {", "Answer function - static S answer(S s) { new Matches m; ...; null; }",
    "time {", "Run the code block and print how long it took",
    "cprint {", "A module with default class name derived from DynPrintLog",
    "semiauto {", "In a semiauto block, JavaX automatically adds a ; to (almost) every line",
    "autosemi {", "In an autosemi block, JavaX automatically adds a ; to (almost) every line",
    "Clusters", "Clusters<A> is short for Map<A, Collection<A>>",
    "temp", "temp is like try (...) extending to the end of the current block",
    "pcall {", "protected call - try { ... } catch { print exception }",
    "r {", "r { ... } is short for: new Runnable() { public void run() { ... } }",
    "runnable {", "runnable { ... } is short for: new Runnable() { public void run() { ... } }",
    "pcall-short {", "protected call, shorter output - try { ... } catch { printShortException }",
    "LPair<", "LPair<...> is short for: L<Pair<...>>",
    "visualize {", "Visualisation method for an OS module; returns a Swing component",
    "visualize as", "define a visualization for the module",
    "enhanceFrame {", "Method that changes properties of an OS module's frame",
    "run {", "short for: public void run()",
    "start {", "Method that is run when an OS module is loaded",
    "enter {", "Methods in a module should be marked 'enter' for bookkeeping",
    "vf<", "reference to function as voidfunc",
    "compact module", "try to save memory by reusing code between modules",
    "cmodule", "cmodule = compact module for Stefan's OS. compact = try to save memory by reusing code between modules",
    "cmodule2", "cmodule2 = compact module for Stefan's OS (newer version). compact = try to save memory by reusing code between modules",
    "rThread {", "Runnable in a new thread",
    "shit(", "short for: return with print",
    "shit:", "short for: return with print",
    ":=", [[the := operator translates to a simple comma, but converts an identifier on its left-hand side into a string]],
    "noeq", "don't auto-generate equals+hashCode methods",
    "for single (", "for single is for ping + singletonUnlessNull",
    "selfType", "selfType is replaced with the enclosing class's name",
    "runnable class", "short for: class X implementing Runnable { run { ... }}",
  );
  
  SS sc, sf;
  StringTree2<S> tokenExplanationsTree;

  *() {
    clearCaches();
    tokenExplanationsTree = stringTree2_javaTok(tokenExplanations);
  }

  S codeToHTML(S code, bool real default true) {
    L<S> tok = javaTok(code);
  
    new Map<Int, S> links; // token index -> sf snippet ID
    new Map<Int, S> explanations; // token index -> explanation text
    
    putMultipleKeys(explanations, allPlus(4, jfindAll(tok, "void <id> q {")),
      "Function will execute in module's queue");
    
    new Matches m;
    for (int i = 1; i < l(tok); i += 2) {
      S t = tok.get(i);
      S prev = get(tok, i-2), prevPrev = get(tok, i-4);
      S next = get(tok, i+2);
      S sfID = sf.get(t);
      
      if (startsWith(t, "lambda", m) && isInteger(m.rest()) && isIdentifier(next))
        explanations.put(i, "lambda reference to a \*m.rest()*/-argument function");
        
      if (eq(t, "methodLambda0") && isIdentifier(next))
        explanations.put(i, "short for: x -> x.\*next*/() (with a fresh variable instead of x)");
        
      if (eq(t, "swappable") && isIdentifier(next))
        explanations.put(i, "swappable functions can be exchanged per object instance");
        
      if (eq(t, "autoDispose") && isIdentifier(next))
        explanations.put(i, [[autoDispose adds a cleanMeUp method that properly disposes of this variable]]);
        
      if (eq(t, "virtual") && isIdentifier(next))
        explanations.put(i, [["virtual" represents a type that is not visible in this realm, so it is transpiled to just Object]]);
        
      if (eq(t, "concept") && isIdentifier(next))
        explanations.put(i, "A concept is like a Java class, but persistable");
        
      if (eq(t, "flexeq") && isIdentifier(next))
        explanations.put(i, "flexeq is a fix for records inside parameterized classes");
        
      if (eq(t, "switchable") && isIdentifier(next))
        explanations.put(i, "A field that can be changed through the module's popup menu");
        
      if (eq(t, "embedded") && isIdentifier(next))
        explanations.put(i, [["embedded" allows you to put a function where they would not normally be allowed]]);
        
      if (eq(t, "visual") && isIdentifier(next))
        explanations.put(i, "short definition of the visualize() function");
        
      if (eq(t, "dm_q") && isIdentifier(next))
        explanations.put(i, "Function reference delegating to module queue");
        
      if (eq(t, "!") && isIdentifier(prev) && neq(next, "="))
        explanations.put(i, "! is short for .get()");
        
      /*if (eq(t, "!") && containsNewLine(get(tok, i-1)) && isInteger(next))
        explanations.put(i, "Translator invocation");*/
        
      if (eq(t, "#") && isIdentifier(next))
        explanations.put(i, "#<name> makes an identifier local to the scope");
      
      if (eq(t, "f") && isIdentifier(next))
        explanations.put(i, "f <name> references a static function in the main class");
      
      if (eq(t, "r") && isIdentifier(next))
        explanations.put(i, "short for: r { " + next + "() }");
      
      if (eqOneOf(t, "rThread", "rThreadEnter") && isIdentifier(next))
        explanations.put(i, "short for: " + t + " { " + next + "() }");
      
      if (eq(t, "dispose") && isIdentifier(next))
        explanations.put(i, "short for: cleanUp(" + next + "); " + next + " = null;");
      
      if (eq(t, "*") && eq(next, "("))
        explanations.put(i, "Short syntax for a constructor declaration");
    
      if (eq(t, "thread") && eq(next, "{"))
        explanations.put(i, "Start a new thread with the following code");
        
      if (eq(t, "module") && isIdentifier(next))
        explanations.put(i, "A module is a class that can be loaded in Stefan's OS");
        
      if (eq(t, "record") && isIdentifier(next))
        explanations.put(i, "A record is a value-based class");
        
      if (eq(t, "srecord") && isIdentifier(next))
        explanations.put(i, "An srecord is a static value-based class");
        
      if (eqOneOf(t, "cached", "simplyCached") && isIdentifier(next))
        explanations.put(i, "A function that caches its return value");
        
      if (eq(t, "thread") && isQuoted(next))
        explanations.put(i, "Start a new thread with the following name & code");
        
      if (eq(t, "if") && isQuoted(next)) pcall {
        LS tok2 = tok_subListWithoutBorderNTokens(tok, i, i+3);
        tok_expandIfQuoted(tok2);
        explanations.put(i, "short for: " + join(tok2));
      }
        
      if (eq(t, "html") && eq(next, "{"))
        explanations.put(i, "short for: static Object html(String uri, final Map<String, String> params) ctex {");
        
      if (eq(t, 'try) && eq(next, 'answer))
        doublePut(explanations, i, i+2, "\"try answer\" returns the expression if it isn't null or empty");
        
      if (isSingleQuoteIdentifier(t))
        explanations.put(i, "string constant, " + quote(fromSingleQuoteIdentifier(t)));
        
      if (eq(t, "event") && isIdentifier(next))
        explanations.put(i, "declare a function called " + next + "() plus helpers for adding listeners");
        
      if (eqOneOf(t, 'null, 'false, 'true, 'this)
        && eq(next, ";")
        && tok_tokenBeforeLonelyReturnValue(tok, i-2))
        doublePut(explanations, i, i+2, "short for: return " + t + ";");
        
      S e = shortFor.get(t);
      if (e != null)
        mapPut(explanations, i, "short for: " + e);
        
      // link to standard function
      if (!explanations.containsKey(i) && sfID != null) {
        if (eqOneOf(prev, "f", "r", "rThread")
          || startsWith(prev, "lambda")
          || isIdentifier(next) && eqGet(tok, i+4, "(")
          || eqOneOf(next, "(", "°")
            && (neq(prev, ".") || eq(prevPrev, "main") && neq(get(tok, i-6), "."))
          || eq(prev, "{") && eq(next, "}") && eq(prevPrev, "postProcess")
          || eq(prev, ":") && eq(prevPrev, ":"))
          links.put(i, sfID);
      }
      
      L<S> fewTokens = codeTokens(subList(tok, i-1, i+2*5));
      Pair<S, Int> p = stringTreeLeafValue2(tokenExplanationsTree, fewTokens);
      if (p != null) {
        //print(struct(p));
        int lastCodeToken = i+p.b*2-2;
        if (eq(get(tok, lastCodeToken), "{")) lastCodeToken -= 2;
        mapPutInRange(explanations, i, lastCodeToken+1, p.a);
      }
  
      if (isQuoted(t) && eq(prev, "(") && isIdentifier(prevPrev)
        && isMechFunction(prevPrev))
        mapPut(links, i, neatMechListURL(unquote(t)));
      
      //mapPut(explanations, i, tokenExplanations.get(t));
        
      S id = sc.get(t);
      if (id != null)
        links.put(i, id);
    }
    new StringBuilder out;
    SS titles = getSnippetTitles(filter isSnippetID(values(links)));
    for i over tok: {
      S t = tok.get(i), id = links.get(i), ex = explanations.get(i);
      if (empty(t)) continue;
      if (t.startsWith("[[") && t.endsWith("]]")) {
        S explanation = "[[...]] denotes a multi-line string constant (as in Lua)";
        out.append(dottedSpan("[[", explanation);
        S inner = htmlencode(dropPrefix("[[", dropSuffix("]]", t)));
        out.append(span(inner, style := "background-color: #77FF77"));
        out.append(dottedSpan("]]", explanation);
        continue;
      }
      if (t.startsWith("[=[") && t.endsWith("]=]")) {
        S explanation = "[=[...]=] denotes a multi-line string constant (as in Lua)";
        out.append(dottedSpan("[=[", explanation);
        S inner = htmlencode(dropPrefix("[=[", dropSuffix("]=]", t)));
        out.append(span(inner, style := "background-color: #77FF77"));
        out.append(dottedSpan("]=]", explanation);
        continue;
      }
      S enc = htmlencode(t);
      out.append(id != null
        ? ahref(makeLink(real, id), enc,
          title := isSnippetID(id) ? titles.get(fsI(id)) : ex, style := "text-decoration: none; color: black; border-bottom: dotted 1px", target := targetBlank ? "_blank" : null)
        : ex != null ? dottedSpan(enc, ex)
        : enc);
    }
    S html = str(out);
    html = dynamize_noEncode(html);
    ret html;
  }

  // id can be a URL
  S makeLink(bool real, S id) {
    if (isURL(id)) ret id;
    if (real)
      ret longSnippetLink(id);
    ret "/" + psI(id);
  }
  
  void clearCaches {
    stdFunctions_clearCache();
    sc = standardClassesMap();
    sf = stdFunctions_cached();
    sf.putAll(tok_findStandardFunctionDefinitions(javaTokSnippet(#1022367)));
  }
  
  bool isMechFunction(S s) {
    ret startsWithOneOf(s, "mech", "mL");
  }
}

Author comment

Began life as a copy of #1008705

download  show line numbers  debug dex   

Travelled to 3 computer(s): bhatertpkbcr, mqqgnosmbjvj, pyentgdyhuwx

No comments. add comment

Snippet ID: #1030131
Snippet name: JavaXHyperlinker - annotates JavaX sources in HTML
Eternal ID of this version: #1030131/14
Text MD5: 9bc93d5ac05ca0a94bc05e3cf42a4bd3
Author: stefan
Category: javax
Type: JavaX fragment (include)
Public (visible to everyone): Yes
Archived (hidden from active list): No
Created/modified: 2020-12-09 17:32:11
Source code size: 13532 bytes / 297 lines
Pitched / IR pitched: No / No
Views / Downloads: 46 / 123
Version history: 13 change(s)
Referenced in: [show references]

Formerly at http://tinybrain.de/1030131 & http://1030131.tinybrain.de