RubyGems - raro_generator - Versions diffs - 0.0.1 - Mend

raro_generator 0.0.1

Files changed (555) hide show

data/lib/assets/javascripts/codemirror/mode/dylan/index.html ADDED Viewed

@@ -0,0 +1,407 @@
+<!doctype html>
+<title>CodeMirror: Dylan mode</title>
+<meta charset="utf-8"/>
+<link rel=stylesheet href="../../doc/docs.css">
+<link rel="stylesheet" href="../../lib/codemirror.css">
+<script src="../../lib/codemirror.js"></script>
+<script src="../../addon/edit/matchbrackets.js"></script>
+<script src="../../addon/comment/continuecomment.js"></script>
+<script src="../../addon/comment/comment.js"></script>
+<script src="dylan.js"></script>
+<style type="text/css">.CodeMirror {border-top: 1px solid black; border-bottom: 1px solid black;}</style>
+<div id=nav>
+  <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
+  <ul>
+    <li><a href="../../index.html">Home</a>
+    <li><a href="../../doc/manual.html">Manual</a>
+    <li><a href="https://github.com/codemirror/codemirror">Code</a>
+  </ul>
+  <ul>
+    <li><a href="../index.html">Language modes</a>
+    <li><a class=active href="#">Dylan</a>
+  </ul>
+</div>
+<article>
+<h2>Dylan mode</h2>
+<div><textarea id="code" name="code">
+Module:       locators-internals
+Synopsis:     Abstract modeling of locations
+Author:       Andy Armstrong
+Copyright:    Original Code is Copyright (c) 1995-2004 Functional Objects, Inc.
+              All rights reserved.
+License:      See License.txt in this distribution for details.
+Warranty:     Distributed WITHOUT WARRANTY OF ANY KIND
+define open generic locator-server
+    (locator :: <locator>) => (server :: false-or(<server-locator>));
+define open generic locator-host
+    (locator :: <locator>) => (host :: false-or(<string>));
+define open generic locator-volume
+    (locator :: <locator>) => (volume :: false-or(<string>));
+define open generic locator-directory
+    (locator :: <locator>) => (directory :: false-or(<directory-locator>));
+define open generic locator-relative?
+    (locator :: <locator>) => (relative? :: <boolean>);
+define open generic locator-path
+    (locator :: <locator>) => (path :: <sequence>);
+define open generic locator-base
+    (locator :: <locator>) => (base :: false-or(<string>));
+define open generic locator-extension
+    (locator :: <locator>) => (extension :: false-or(<string>));
+/// Locator classes
+define open abstract class <directory-locator> (<physical-locator>)
+end class <directory-locator>;
+define open abstract class <file-locator> (<physical-locator>)
+end class <file-locator>;
+define method as
+    (class == <directory-locator>, string :: <string>)
+ => (locator :: <directory-locator>)
+  as(<native-directory-locator>, string)
+end method as;
+define method make
+    (class == <directory-locator>,
+     #key server :: false-or(<server-locator>) = #f,
+          path :: <sequence> = #[],
+          relative? :: <boolean> = #f,
+          name :: false-or(<string>) = #f)
+ => (locator :: <directory-locator>)
+  make(<native-directory-locator>,
+       server:    server,
+       path:      path,
+       relative?: relative?,
+       name:      name)
+end method make;
+define method as
+    (class == <file-locator>, string :: <string>)
+ => (locator :: <file-locator>)
+  as(<native-file-locator>, string)
+end method as;
+define method make
+    (class == <file-locator>,
+     #key directory :: false-or(<directory-locator>) = #f,
+          base :: false-or(<string>) = #f,
+          extension :: false-or(<string>) = #f,
+          name :: false-or(<string>) = #f)
+ => (locator :: <file-locator>)
+  make(<native-file-locator>,
+       directory: directory,
+       base:      base,
+       extension: extension,
+       name:      name)
+end method make;
+/// Locator coercion
+//---*** andrewa: This caching scheme doesn't work yet, so disable it.
+define constant $cache-locators?        = #f;
+define constant $cache-locator-strings? = #f;
+define constant $locator-to-string-cache = make(<object-table>, weak: #"key");
+define constant $string-to-locator-cache = make(<string-table>, weak: #"value");
+define open generic locator-as-string
+    (class :: subclass(<string>), locator :: <locator>)
+ => (string :: <string>);
+define open generic string-as-locator
+    (class :: subclass(<locator>), string :: <string>)
+ => (locator :: <locator>);
+define sealed sideways method as
+    (class :: subclass(<string>), locator :: <locator>)
+ => (string :: <string>)
+  let string = element($locator-to-string-cache, locator, default: #f);
+  if (string)
+    as(class, string)
+  else
+    let string = locator-as-string(class, locator);
+    if ($cache-locator-strings?)
+      element($locator-to-string-cache, locator) := string;
+    else
+      string
+    end
+  end
+end method as;
+define sealed sideways method as
+    (class :: subclass(<locator>), string :: <string>)
+ => (locator :: <locator>)
+  let locator = element($string-to-locator-cache, string, default: #f);
+  if (instance?(locator, class))
+    locator
+  else
+    let locator = string-as-locator(class, string);
+    if ($cache-locators?)
+      element($string-to-locator-cache, string) := locator;
+    else
+      locator
+    end
+  end
+end method as;
+/// Locator conditions
+define class <locator-error> (<format-string-condition>, <error>)
+end class <locator-error>;
+define function locator-error
+    (format-string :: <string>, #rest format-arguments)
+  error(make(<locator-error>,
+             format-string:    format-string,
+             format-arguments: format-arguments))
+end function locator-error;
+/// Useful locator protocols
+define open generic locator-test
+    (locator :: <directory-locator>) => (test :: <function>);
+define method locator-test
+    (locator :: <directory-locator>) => (test :: <function>)
+  \=
+end method locator-test;
+define open generic locator-might-have-links?
+    (locator :: <directory-locator>) => (links? :: <boolean>);
+define method locator-might-have-links?
+    (locator :: <directory-locator>) => (links? :: singleton(#f))
+  #f
+end method locator-might-have-links?;
+define method locator-relative?
+    (locator :: <file-locator>) => (relative? :: <boolean>)
+  let directory = locator.locator-directory;
+  ~directory | directory.locator-relative?
+end method locator-relative?;
+define method current-directory-locator?
+    (locator :: <directory-locator>) => (current-directory? :: <boolean>)
+  locator.locator-relative?
+    & locator.locator-path = #[#"self"]
+end method current-directory-locator?;
+define method locator-directory
+    (locator :: <directory-locator>) => (parent :: false-or(<directory-locator>))
+  let path = locator.locator-path;
+  unless (empty?(path))
+    make(object-class(locator),
+         server:    locator.locator-server,
+         path:      copy-sequence(path, end: path.size - 1),
+         relative?: locator.locator-relative?)
+  end
+end method locator-directory;
+/// Simplify locator
+define open generic simplify-locator
+    (locator :: <physical-locator>)
+ => (simplified-locator :: <physical-locator>);
+define method simplify-locator
+    (locator :: <directory-locator>)
+ => (simplified-locator :: <directory-locator>)
+  let path = locator.locator-path;
+  let relative? = locator.locator-relative?;
+  let resolve-parent? = ~locator.locator-might-have-links?;
+  let simplified-path
+    = simplify-path(path,
+                    resolve-parent?: resolve-parent?,
+                    relative?: relative?);
+  if (path ~= simplified-path)
+    make(object-class(locator),
+         server:    locator.locator-server,
+         path:      simplified-path,
+         relative?: locator.locator-relative?)
+  else
+    locator
+  end
+end method simplify-locator;
+define method simplify-locator
+    (locator :: <file-locator>) => (simplified-locator :: <file-locator>)
+  let directory = locator.locator-directory;
+  let simplified-directory = directory & simplify-locator(directory);
+  if (directory ~= simplified-directory)
+    make(object-class(locator),
+         directory: simplified-directory,
+         base:      locator.locator-base,
+         extension: locator.locator-extension)
+  else
+    locator
+  end
+end method simplify-locator;
+/// Subdirectory locator
+define open generic subdirectory-locator
+    (locator :: <directory-locator>, #rest sub-path)
+ => (subdirectory :: <directory-locator>);
+define method subdirectory-locator
+    (locator :: <directory-locator>, #rest sub-path)
+ => (subdirectory :: <directory-locator>)
+  let old-path = locator.locator-path;
+  let new-path = concatenate-as(<simple-object-vector>, old-path, sub-path);
+  make(object-class(locator),
+       server:    locator.locator-server,
+       path:      new-path,
+       relative?: locator.locator-relative?)
+end method subdirectory-locator;
+/// Relative locator
+define open generic relative-locator
+    (locator :: <physical-locator>, from-locator :: <physical-locator>)
+ => (relative-locator :: <physical-locator>);
+define method relative-locator
+    (locator :: <directory-locator>, from-locator :: <directory-locator>)
+ => (relative-locator :: <directory-locator>)
+  let path = locator.locator-path;
+  let from-path = from-locator.locator-path;
+  case
+    ~locator.locator-relative? & from-locator.locator-relative? =>
+      locator-error
+        ("Cannot find relative path of absolute locator %= from relative locator %=",
+         locator, from-locator);
+    locator.locator-server ~= from-locator.locator-server =>
+      locator;
+    path = from-path =>
+      make(object-class(locator),
+           path: vector(#"self"),
+           relative?: #t);
+    otherwise =>
+      make(object-class(locator),
+           path: relative-path(path, from-path, test: locator.locator-test),
+           relative?: #t);
+  end
+end method relative-locator;
+define method relative-locator
+    (locator :: <file-locator>, from-directory :: <directory-locator>)
+ => (relative-locator :: <file-locator>)
+  let directory = locator.locator-directory;
+  let relative-directory = directory & relative-locator(directory, from-directory);
+  if (relative-directory ~= directory)
+    simplify-locator
+      (make(object-class(locator),
+            directory: relative-directory,
+            base:      locator.locator-base,
+            extension: locator.locator-extension))
+  else
+    locator
+  end
+end method relative-locator;
+define method relative-locator
+    (locator :: <physical-locator>, from-locator :: <file-locator>)
+ => (relative-locator :: <physical-locator>)
+  let from-directory = from-locator.locator-directory;
+  case
+    from-directory =>
+      relative-locator(locator, from-directory);
+    ~locator.locator-relative? =>
+      locator-error
+        ("Cannot find relative path of absolute locator %= from relative locator %=",
+         locator, from-locator);
+    otherwise =>
+      locator;
+  end
+end method relative-locator;
+/// Merge locators
+define open generic merge-locators
+    (locator :: <physical-locator>, from-locator :: <physical-locator>)
+ => (merged-locator :: <physical-locator>);
+/// Merge locators
+define method merge-locators
+    (locator :: <directory-locator>, from-locator :: <directory-locator>)
+ => (merged-locator :: <directory-locator>)
+  if (locator.locator-relative?)
+    let path = concatenate(from-locator.locator-path, locator.locator-path);
+    simplify-locator
+      (make(object-class(locator),
+            server:    from-locator.locator-server,
+            path:      path,
+            relative?: from-locator.locator-relative?))
+  else
+    locator
+  end
+end method merge-locators;
+define method merge-locators
+    (locator :: <file-locator>, from-locator :: <directory-locator>)
+ => (merged-locator :: <file-locator>)
+  let directory = locator.locator-directory;
+  let merged-directory
+    = if (directory)
+        merge-locators(directory, from-locator)
+      else
+        simplify-locator(from-locator)
+      end;
+  if (merged-directory ~= directory)
+    make(object-class(locator),
+         directory: merged-directory,
+         base:      locator.locator-base,
+         extension: locator.locator-extension)
+  else
+    locator
+  end
+end method merge-locators;
+define method merge-locators
+    (locator :: <physical-locator>, from-locator :: <file-locator>)
+ => (merged-locator :: <physical-locator>)
+  let from-directory = from-locator.locator-directory;
+  if (from-directory)
+    merge-locators(locator, from-directory)
+  else
+    locator
+  end
+end method merge-locators;
+/// Locator protocols
+define sideways method supports-open-locator?
+    (locator :: <file-locator>) => (openable? :: <boolean>)
+  ~locator.locator-relative?
+end method supports-open-locator?;
+define sideways method open-locator
+    (locator :: <file-locator>, #rest keywords, #key, #all-keys)
+ => (stream :: <stream>)
+  apply(open-file-stream, locator, keywords)
+end method open-locator;
+</textarea></div>
+    <script>
+      var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
+        mode: "text/x-dylan",
+        lineNumbers: true,
+        matchBrackets: true,
+        continueComments: "Enter",
+        extraKeys: {"Ctrl-Q": "toggleComment"},
+        tabMode: "indent",
+        indentUnit: 2
+      });
+    </script>
+    <p><strong>MIME types defined:</strong> <code>text/x-dylan</code>.</p>
+</article>

data/lib/assets/javascripts/codemirror/mode/ecl/ecl.js ADDED Viewed

@@ -0,0 +1,207 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: http://codemirror.net/LICENSE
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+"use strict";
+CodeMirror.defineMode("ecl", function(config) {
+  function words(str) {
+    var obj = {}, words = str.split(" ");
+    for (var i = 0; i < words.length; ++i) obj[words[i]] = true;
+    return obj;
+  }
+  function metaHook(stream, state) {
+    if (!state.startOfLine) return false;
+    stream.skipToEnd();
+    return "meta";
+  }
+  var indentUnit = config.indentUnit;
+  var keyword = words("abs acos allnodes ascii asin asstring atan atan2 ave case choose choosen choosesets clustersize combine correlation cos cosh count covariance cron dataset dedup define denormalize distribute distributed distribution ebcdic enth error evaluate event eventextra eventname exists exp failcode failmessage fetch fromunicode getisvalid global graph group hash hash32 hash64 hashcrc hashmd5 having if index intformat isvalid iterate join keyunicode length library limit ln local log loop map matched matchlength matchposition matchtext matchunicode max merge mergejoin min nolocal nonempty normalize parse pipe power preload process project pull random range rank ranked realformat recordof regexfind regexreplace regroup rejected rollup round roundup row rowdiff sample set sin sinh sizeof soapcall sort sorted sqrt stepped stored sum table tan tanh thisnode topn tounicode transfer trim truncate typeof ungroup unicodeorder variance which workunit xmldecode xmlencode xmltext xmlunicode");
+  var variable = words("apply assert build buildindex evaluate fail keydiff keypatch loadxml nothor notify output parallel sequential soapcall wait");
+  var variable_2 = words("__compressed__ all and any as atmost before beginc++ best between case const counter csv descend encrypt end endc++ endmacro except exclusive expire export extend false few first flat from full function group header heading hole ifblock import in interface joined keep keyed last left limit load local locale lookup macro many maxcount maxlength min skew module named nocase noroot noscan nosort not of only opt or outer overwrite packed partition penalty physicallength pipe quote record relationship repeat return right scan self separator service shared skew skip sql store terminator thor threshold token transform trim true type unicodeorder unsorted validate virtual whole wild within xml xpath");
+  var variable_3 = words("ascii big_endian boolean data decimal ebcdic integer pattern qstring real record rule set of string token udecimal unicode unsigned varstring varunicode");
+  var builtin = words("checkpoint deprecated failcode failmessage failure global independent onwarning persist priority recovery stored success wait when");
+  var blockKeywords = words("catch class do else finally for if switch try while");
+  var atoms = words("true false null");
+  var hooks = {"#": metaHook};
+  var multiLineStrings;
+  var isOperatorChar = /[+\-*&%=<>!?|\/]/;
+  var curPunc;
+  function tokenBase(stream, state) {
+    var ch = stream.next();
+    if (hooks[ch]) {
+      var result = hooks[ch](stream, state);
+      if (result !== false) return result;
+    }
+    if (ch == '"' || ch == "'") {
+      state.tokenize = tokenString(ch);
+      return state.tokenize(stream, state);
+    }
+    if (/[\[\]{}\(\),;\:\.]/.test(ch)) {
+      curPunc = ch;
+      return null;
+    }
+    if (/\d/.test(ch)) {
+      stream.eatWhile(/[\w\.]/);
+      return "number";
+    }
+    if (ch == "/") {
+      if (stream.eat("*")) {
+        state.tokenize = tokenComment;
+        return tokenComment(stream, state);
+      }
+      if (stream.eat("/")) {
+        stream.skipToEnd();
+        return "comment";
+      }
+    }
+    if (isOperatorChar.test(ch)) {
+      stream.eatWhile(isOperatorChar);
+      return "operator";
+    }
+    stream.eatWhile(/[\w\$_]/);
+    var cur = stream.current().toLowerCase();
+    if (keyword.propertyIsEnumerable(cur)) {
+      if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
+      return "keyword";
+    } else if (variable.propertyIsEnumerable(cur)) {
+      if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
+      return "variable";
+    } else if (variable_2.propertyIsEnumerable(cur)) {
+      if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
+      return "variable-2";
+    } else if (variable_3.propertyIsEnumerable(cur)) {
+      if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
+      return "variable-3";
+    } else if (builtin.propertyIsEnumerable(cur)) {
+      if (blockKeywords.propertyIsEnumerable(cur)) curPunc = "newstatement";
+      return "builtin";
+    } else { //Data types are of from KEYWORD##
+                var i = cur.length - 1;
+                while(i >= 0 && (!isNaN(cur[i]) || cur[i] == '_'))
+                        --i;
+                if (i > 0) {
+                        var cur2 = cur.substr(0, i + 1);
+                if (variable_3.propertyIsEnumerable(cur2)) {
+                        if (blockKeywords.propertyIsEnumerable(cur2)) curPunc = "newstatement";
+                        return "variable-3";
+                }
+            }
+    }
+    if (atoms.propertyIsEnumerable(cur)) return "atom";
+    return null;
+  }
+  function tokenString(quote) {
+    return function(stream, state) {
+      var escaped = false, next, end = false;
+      while ((next = stream.next()) != null) {
+        if (next == quote && !escaped) {end = true; break;}
+        escaped = !escaped && next == "\\";
+      }
+      if (end || !(escaped || multiLineStrings))
+        state.tokenize = tokenBase;
+      return "string";
+    };
+  }
+  function tokenComment(stream, state) {
+    var maybeEnd = false, ch;
+    while (ch = stream.next()) {
+      if (ch == "/" && maybeEnd) {
+        state.tokenize = tokenBase;
+        break;
+      }
+      maybeEnd = (ch == "*");
+    }
+    return "comment";
+  }
+  function Context(indented, column, type, align, prev) {
+    this.indented = indented;
+    this.column = column;
+    this.type = type;
+    this.align = align;
+    this.prev = prev;
+  }
+  function pushContext(state, col, type) {
+    return state.context = new Context(state.indented, col, type, null, state.context);
+  }
+  function popContext(state) {
+    var t = state.context.type;
+    if (t == ")" || t == "]" || t == "}")
+      state.indented = state.context.indented;
+    return state.context = state.context.prev;
+  }
+  // Interface
+  return {
+    startState: function(basecolumn) {
+      return {
+        tokenize: null,
+        context: new Context((basecolumn || 0) - indentUnit, 0, "top", false),
+        indented: 0,
+        startOfLine: true
+      };
+    },
+    token: function(stream, state) {
+      var ctx = state.context;
+      if (stream.sol()) {
+        if (ctx.align == null) ctx.align = false;
+        state.indented = stream.indentation();
+        state.startOfLine = true;
+      }
+      if (stream.eatSpace()) return null;
+      curPunc = null;
+      var style = (state.tokenize || tokenBase)(stream, state);
+      if (style == "comment" || style == "meta") return style;
+      if (ctx.align == null) ctx.align = true;
+      if ((curPunc == ";" || curPunc == ":") && ctx.type == "statement") popContext(state);
+      else if (curPunc == "{") pushContext(state, stream.column(), "}");
+      else if (curPunc == "[") pushContext(state, stream.column(), "]");
+      else if (curPunc == "(") pushContext(state, stream.column(), ")");
+      else if (curPunc == "}") {
+        while (ctx.type == "statement") ctx = popContext(state);
+        if (ctx.type == "}") ctx = popContext(state);
+        while (ctx.type == "statement") ctx = popContext(state);
+      }
+      else if (curPunc == ctx.type) popContext(state);
+      else if (ctx.type == "}" || ctx.type == "top" || (ctx.type == "statement" && curPunc == "newstatement"))
+        pushContext(state, stream.column(), "statement");
+      state.startOfLine = false;
+      return style;
+    },
+    indent: function(state, textAfter) {
+      if (state.tokenize != tokenBase && state.tokenize != null) return 0;
+      var ctx = state.context, firstChar = textAfter && textAfter.charAt(0);
+      if (ctx.type == "statement" && firstChar == "}") ctx = ctx.prev;
+      var closing = firstChar == ctx.type;
+      if (ctx.type == "statement") return ctx.indented + (firstChar == "{" ? 0 : indentUnit);
+      else if (ctx.align) return ctx.column + (closing ? 0 : 1);
+      else return ctx.indented + (closing ? 0 : indentUnit);
+    },
+    electricChars: "{}"
+  };
+});
+CodeMirror.defineMIME("text/x-ecl", "ecl");
+});