n.kolosnaj/SimfonyBasics
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Last commit july 5th

Browse Source
This commit is contained in:
nkolosnjaj
2024-07-05 13:46:23 +02:00
parent dad0d86e8c
commit b0e4dfbb76
24982 changed files with 2621219 additions and 413 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
spa/node_modules/dep-graph/.npmignore generated vendored Normal file
View File

@@ -0,0 +1 @@
node_modules

51
spa/node_modules/dep-graph/Cakefile generated vendored Normal file
View File

@@ -0,0 +1,51 @@
fs = require 'fs'
{print} = require 'util'
{spawn, exec} = require 'child_process'
watchit = require 'watchit'
build = (watch, callback) ->
if typeof watch is 'function'
callback = watch
watch = false
options = ['-c', '-o', 'lib', 'src']
options.unshift '-w' if watch
coffee = spawn 'coffee', options
coffee.stdout.on 'data', (data) -> print data.toString()
coffee.stderr.on 'data', (data) -> print data.toString()
coffee.on 'exit', (status) -> callback?() if status is 0
task 'docs', 'Generate annotated source code with Docco', ->
fs.readdir 'src', (err, contents) ->
files = ("src/#{file}" for file in contents when /\.coffee$/.test file)
docco = spawn 'docco', files
docco.stdout.on 'data', (data) -> print data.toString()
docco.stderr.on 'data', (data) -> print data.toString()
docco.on 'exit', (status) -> callback?() if status is 0
task 'build', 'Compile CoffeeScript source files', ->
build()
task 'watch', 'Recompile CoffeeScript source files when modified', ->
build true
task 'test', 'Run the test suite (and re-run if anything changes)', ->
suite = null
build ->
do runTests = ->
suite?.kill()
suiteNames = ['test']
suiteIndex = 0
do runNextTestSuite = ->
return unless suiteName = suiteNames[suiteIndex]
suite = spawn "coffee", ["-e", "{reporters} = require 'nodeunit'; reporters.default.run ['#{suiteName}.coffee']"], cwd: 'test'
suite.stdout.on 'data', (data) -> print data.toString()
suite.stderr.on 'data', (data) -> print data.toString()
suite.on 'exit', -> suiteIndex++; runNextTestSuite()
invoke 'docs' # lest I forget
watchTargets = (targets..., callback) ->
for target in targets
watchit target, include: true, (event) ->
callback() unless event is 'success'
watchTargets 'src', -> build runTests
watchTargets 'test', 'Cakefile', runTests

40
spa/node_modules/dep-graph/README.mdown generated vendored Normal file
View File

@@ -0,0 +1,40 @@
# dep-graph.js
This is a small project spun off from [connect-assets](http://github.com/TrevorBurnham/connect-assets). Written in [CoffeeScript](coffeescript.org) by the author of [CoffeeScript: Accelerated JavaScript Development](http://pragprog.com/book/tbcoffee/coffeescript).
## What's it for?
Say you have a set of resources that depend on each other in some way. These resources can be anything—files, chains of command, plot twists on *Lost*—whatever. All that matters is that each one has a unique string identifier, and a list of direct dependencies.
`dep-graph` makes it easy to compute "chains" of dependencies, with guaranteed logical ordering and no duplicates. That's trivial in most cases, but if `A` depends on `B` and `B` depends on `A`, a naïve dependency graph would get trapped in an infinite loop. `dep-graph` throws an error if any such "cycles" are detected.
## How to use it?
### In the browser
deps = new DepGraph
deps.add 'A', 'B' # A requires B
deps.add 'B', 'C' # B requires C
deps.getChain 'A' # ['C', 'B', 'A']
### In Node.js
Same as above, but first run
npm install dep-graph
from your project's directory, and put
DepGraph = require 'dep-graph'
at the top of your file.
## License
©2011 Trevor Burnham and available under the [MIT license](http://www.opensource.org/licenses/mit-license.php):
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

44
spa/node_modules/dep-graph/docs/dep-graph.html generated vendored Normal file
View File

@@ -0,0 +1,44 @@
<!DOCTYPE html> <html> <head> <title>dep-graph.coffee</title> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> <link rel="stylesheet" media="all" href="docco.css" /> </head> <body> <div id="container"> <div id="background"></div> <table cellpadding="0" cellspacing="0"> <thead> <tr> <th class="docs"> <h1> dep-graph.coffee </h1> </th> <th class="code"> </th> </tr> </thead> <tbody> <tr id="section-1"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-1">&#182;</a> </div> <p><a href="http://github.com/TrevorBurnham/dep-graph">dep-graph</a></p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">_ = </span><span class="nx">require</span> <span class="s1">&#39;underscore&#39;</span>
<span class="k">class</span> <span class="nx">DepGraph</span>
<span class="nv">constructor: </span><span class="o">-&gt;</span></pre></div> </td> </tr> <tr id="section-2"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-2">&#182;</a> </div> <p>The internal representation of the dependency graph in the format
<code>id: [ids]</code>, indicating only <em>direct</em> dependencies.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="vi">@map = </span><span class="p">{}</span></pre></div> </td> </tr> <tr id="section-3"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-3">&#182;</a> </div> <p>Add a direct dependency. Returns <code>false</code> if that dependency is a duplicate.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">add: </span><span class="nf">(id, depId) -&gt;</span>
<span class="nx">@map</span><span class="p">[</span><span class="nx">id</span><span class="p">]</span> <span class="o">?=</span> <span class="p">[]</span>
<span class="k">return</span> <span class="kc">false</span> <span class="k">if</span> <span class="nx">depId</span> <span class="k">in</span> <span class="nx">@map</span><span class="p">[</span><span class="nx">id</span><span class="p">]</span>
<span class="nx">@map</span><span class="p">[</span><span class="nx">id</span><span class="p">].</span><span class="nx">push</span> <span class="nx">depId</span>
<span class="nx">@map</span><span class="p">[</span><span class="nx">id</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-4"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-4">&#182;</a> </div> <p>Generate a list of all dependencies (direct and indirect) for the given id,
in logical order with no duplicates.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">getChain: </span><span class="nf">(id) -&gt;</span></pre></div> </td> </tr> <tr id="section-5"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-5">&#182;</a> </div> <p>First, get a list of all dependencies (unordered)</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">deps = </span><span class="nx">@descendantsOf</span> <span class="nx">id</span></pre></div> </td> </tr> <tr id="section-6"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-6">&#182;</a> </div> <p>Second, order them (using the Tarjan algorithm)</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">chain = </span><span class="p">[]</span>
<span class="nv">visited = </span><span class="p">{}</span>
<span class="nv">visit = </span><span class="p">(</span><span class="nx">node</span><span class="p">)</span> <span class="o">=&gt;</span>
<span class="k">return</span> <span class="k">if</span> <span class="nx">visited</span><span class="p">[</span><span class="nx">node</span><span class="p">]</span> <span class="o">or</span> <span class="nx">node</span> <span class="o">is</span> <span class="nx">id</span>
<span class="nx">visited</span><span class="p">[</span><span class="nx">node</span><span class="p">]</span> <span class="o">=</span> <span class="kc">true</span>
<span class="k">for</span> <span class="nx">parent</span> <span class="k">in</span> <span class="nx">@parentsOf</span><span class="p">(</span><span class="nx">node</span><span class="p">)</span>
<span class="nx">visit</span> <span class="nx">parent</span>
<span class="nx">chain</span><span class="p">.</span><span class="nx">unshift</span> <span class="nx">node</span>
<span class="k">for</span> <span class="nx">leafNode</span> <span class="k">in</span> <span class="nx">_</span><span class="p">.</span><span class="nx">intersection</span><span class="p">(</span><span class="nx">deps</span><span class="p">,</span> <span class="nx">@leafNodes</span><span class="p">()).</span><span class="nx">reverse</span><span class="p">()</span>
<span class="nx">visit</span> <span class="nx">leafNode</span>
<span class="nx">chain</span>
<span class="nv">leafNodes: </span><span class="o">-&gt;</span>
<span class="nv">allNodes = </span><span class="nx">_</span><span class="p">.</span><span class="nx">uniq</span> <span class="nx">_</span><span class="p">.</span><span class="nx">flatten</span> <span class="nx">_</span><span class="p">.</span><span class="nx">values</span> <span class="nx">@map</span>
<span class="nx">node</span> <span class="k">for</span> <span class="nx">node</span> <span class="k">in</span> <span class="nx">allNodes</span> <span class="k">when</span> <span class="o">!</span><span class="nx">@map</span><span class="p">[</span><span class="nx">node</span><span class="p">]</span><span class="o">?</span><span class="p">.</span><span class="nx">length</span>
<span class="nv">parentsOf: </span><span class="nf">(child) -&gt;</span>
<span class="nx">node</span> <span class="k">for</span> <span class="nx">node</span> <span class="k">in</span> <span class="nx">_</span><span class="p">.</span><span class="nx">keys</span><span class="p">(</span><span class="nx">@map</span><span class="p">)</span> <span class="k">when</span> <span class="nx">child</span> <span class="k">in</span> <span class="nx">@map</span><span class="p">[</span><span class="nx">node</span><span class="p">]</span>
<span class="nv">descendantsOf: </span><span class="nf">(parent, descendants = [], branch = []) -&gt;</span>
<span class="nx">descendants</span><span class="p">.</span><span class="nx">push</span> <span class="nx">parent</span>
<span class="nx">branch</span><span class="p">.</span><span class="nx">push</span> <span class="nx">parent</span>
<span class="k">for</span> <span class="nx">child</span> <span class="k">in</span> <span class="nx">@map</span><span class="p">[</span><span class="nx">parent</span><span class="p">]</span> <span class="o">?</span> <span class="p">[]</span>
<span class="k">if</span> <span class="nx">child</span> <span class="k">in</span> <span class="nx">branch</span> <span class="c1"># cycle</span>
<span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span><span class="p">(</span><span class="s2">&quot;Cyclic dependency from #{parent} to #{child}&quot;</span><span class="p">)</span>
<span class="k">continue</span> <span class="k">if</span> <span class="nx">child</span> <span class="k">in</span> <span class="nx">descendants</span> <span class="c1"># duplicate</span>
<span class="nx">@descendantsOf</span> <span class="nx">child</span><span class="p">,</span> <span class="nx">descendants</span><span class="p">,</span> <span class="nx">branch</span><span class="p">.</span><span class="nx">slice</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="nx">descendants</span><span class="p">[</span><span class="mi">1</span><span class="p">..]</span></pre></div> </td> </tr> <tr id="section-7"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-7">&#182;</a> </div> <p>Export the class in Node, make it global in the browser.</p> </td> <td class="code"> <div class="highlight"><pre><span class="k">if</span> <span class="nx">module</span><span class="o">?</span><span class="p">.</span><span class="nx">exports</span><span class="o">?</span>
<span class="nv">module.exports = </span><span class="nx">DepGraph</span>
<span class="k">else</span>
<span class="vi">@DepGraph = </span><span class="nx">DepGraph</span>
</pre></div> </td> </tr> </tbody> </table> </div> </body> </html>

186
spa/node_modules/dep-graph/docs/docco.css generated vendored Normal file
View File

@@ -0,0 +1,186 @@
/*--------------------- Layout and Typography ----------------------------*/
body {
font-family: 'Palatino Linotype', 'Book Antiqua', Palatino, FreeSerif, serif;
font-size: 15px;
line-height: 22px;
color: #252519;
margin: 0; padding: 0;
}
a {
color: #261a3b;
}
a:visited {
color: #261a3b;
}
p {
margin: 0 0 15px 0;
}
h1, h2, h3, h4, h5, h6 {
margin: 0px 0 15px 0;
}
h1 {
margin-top: 40px;
}
#container {
position: relative;
}
#background {
position: fixed;
top: 0; left: 525px; right: 0; bottom: 0;
background: #f5f5ff;
border-left: 1px solid #e5e5ee;
z-index: -1;
}
#jump_to, #jump_page {
background: white;
-webkit-box-shadow: 0 0 25px #777; -moz-box-shadow: 0 0 25px #777;
-webkit-border-bottom-left-radius: 5px; -moz-border-radius-bottomleft: 5px;
font: 10px Arial;
text-transform: uppercase;
cursor: pointer;
text-align: right;
}
#jump_to, #jump_wrapper {
position: fixed;
right: 0; top: 0;
padding: 5px 10px;
}
#jump_wrapper {
padding: 0;
display: none;
}
#jump_to:hover #jump_wrapper {
display: block;
}
#jump_page {
padding: 5px 0 3px;
margin: 0 0 25px 25px;
}
#jump_page .source {
display: block;
padding: 5px 10px;
text-decoration: none;
border-top: 1px solid #eee;
}
#jump_page .source:hover {
background: #f5f5ff;
}
#jump_page .source:first-child {
}
table td {
border: 0;
outline: 0;
}
td.docs, th.docs {
max-width: 450px;
min-width: 450px;
min-height: 5px;
padding: 10px 25px 1px 50px;
overflow-x: hidden;
vertical-align: top;
text-align: left;
}
.docs pre {
margin: 15px 0 15px;
padding-left: 15px;
}
.docs p tt, .docs p code {
background: #f8f8ff;
border: 1px solid #dedede;
font-size: 12px;
padding: 0 0.2em;
}
.pilwrap {
position: relative;
}
.pilcrow {
font: 12px Arial;
text-decoration: none;
color: #454545;
position: absolute;
top: 3px; left: -20px;
padding: 1px 2px;
opacity: 0;
-webkit-transition: opacity 0.2s linear;
}
td.docs:hover .pilcrow {
opacity: 1;
}
td.code, th.code {
padding: 14px 15px 16px 25px;
width: 100%;
vertical-align: top;
background: #f5f5ff;
border-left: 1px solid #e5e5ee;
}
pre, tt, code {
font-size: 12px; line-height: 18px;
font-family: Monaco, Consolas, "Lucida Console", monospace;
margin: 0; padding: 0;
}
/*---------------------- Syntax Highlighting -----------------------------*/
td.linenos { background-color: #f0f0f0; padding-right: 10px; }
span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }
body .hll { background-color: #ffffcc }
body .c { color: #408080; font-style: italic } /* Comment */
body .err { border: 1px solid #FF0000 } /* Error */
body .k { color: #954121 } /* Keyword */
body .o { color: #666666 } /* Operator */
body .cm { color: #408080; font-style: italic } /* Comment.Multiline */
body .cp { color: #BC7A00 } /* Comment.Preproc */
body .c1 { color: #408080; font-style: italic } /* Comment.Single */
body .cs { color: #408080; font-style: italic } /* Comment.Special */
body .gd { color: #A00000 } /* Generic.Deleted */
body .ge { font-style: italic } /* Generic.Emph */
body .gr { color: #FF0000 } /* Generic.Error */
body .gh { color: #000080; font-weight: bold } /* Generic.Heading */
body .gi { color: #00A000 } /* Generic.Inserted */
body .go { color: #808080 } /* Generic.Output */
body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
body .gs { font-weight: bold } /* Generic.Strong */
body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
body .gt { color: #0040D0 } /* Generic.Traceback */
body .kc { color: #954121 } /* Keyword.Constant */
body .kd { color: #954121; font-weight: bold } /* Keyword.Declaration */
body .kn { color: #954121; font-weight: bold } /* Keyword.Namespace */
body .kp { color: #954121 } /* Keyword.Pseudo */
body .kr { color: #954121; font-weight: bold } /* Keyword.Reserved */
body .kt { color: #B00040 } /* Keyword.Type */
body .m { color: #666666 } /* Literal.Number */
body .s { color: #219161 } /* Literal.String */
body .na { color: #7D9029 } /* Name.Attribute */
body .nb { color: #954121 } /* Name.Builtin */
body .nc { color: #0000FF; font-weight: bold } /* Name.Class */
body .no { color: #880000 } /* Name.Constant */
body .nd { color: #AA22FF } /* Name.Decorator */
body .ni { color: #999999; font-weight: bold } /* Name.Entity */
body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */
body .nf { color: #0000FF } /* Name.Function */
body .nl { color: #A0A000 } /* Name.Label */
body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
body .nt { color: #954121; font-weight: bold } /* Name.Tag */
body .nv { color: #19469D } /* Name.Variable */
body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
body .w { color: #bbbbbb } /* Text.Whitespace */
body .mf { color: #666666 } /* Literal.Number.Float */
body .mh { color: #666666 } /* Literal.Number.Hex */
body .mi { color: #666666 } /* Literal.Number.Integer */
body .mo { color: #666666 } /* Literal.Number.Oct */
body .sb { color: #219161 } /* Literal.String.Backtick */
body .sc { color: #219161 } /* Literal.String.Char */
body .sd { color: #219161; font-style: italic } /* Literal.String.Doc */
body .s2 { color: #219161 } /* Literal.String.Double */
body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
body .sh { color: #219161 } /* Literal.String.Heredoc */
body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
body .sx { color: #954121 } /* Literal.String.Other */
body .sr { color: #BB6688 } /* Literal.String.Regex */
body .s1 { color: #219161 } /* Literal.String.Single */
body .ss { color: #19469D } /* Literal.String.Symbol */
body .bp { color: #954121 } /* Name.Builtin.Pseudo */
body .vc { color: #19469D } /* Name.Variable.Class */
body .vg { color: #19469D } /* Name.Variable.Global */
body .vi { color: #19469D } /* Name.Variable.Instance */
body .il { color: #666666 } /* Literal.Number.Integer.Long */

115
spa/node_modules/dep-graph/lib/dep-graph.js generated vendored Normal file
View File

@@ -0,0 +1,115 @@
// Generated by CoffeeScript 1.3.3
(function() {
var DepGraph, _,
__indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
_ = require('underscore');
DepGraph = (function() {
function DepGraph() {
this.map = {};
}
DepGraph.prototype.add = function(id, depId) {
var _base, _ref;
if ((_ref = (_base = this.map)[id]) == null) {
_base[id] = [];
}
if (__indexOf.call(this.map[id], depId) >= 0) {
return false;
}
this.map[id].push(depId);
return this.map[id];
};
DepGraph.prototype.getChain = function(id) {
var chain, deps, leafNode, visit, visited, _i, _len, _ref,
_this = this;
deps = this.descendantsOf(id);
chain = [];
visited = {};
visit = function(node) {
var parent, _i, _len, _ref;
if (visited[node] || node === id) {
return;
}
visited[node] = true;
_ref = _this.parentsOf(node);
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
parent = _ref[_i];
if (__indexOf.call(deps, parent) >= 0) {
visit(parent);
}
}
return chain.unshift(node);
};
_ref = _.intersection(deps, this.leafNodes()).reverse();
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
leafNode = _ref[_i];
visit(leafNode);
}
return chain;
};
DepGraph.prototype.leafNodes = function() {
var allNodes, node, _i, _len, _ref, _results;
allNodes = _.uniq(_.flatten(_.values(this.map)));
_results = [];
for (_i = 0, _len = allNodes.length; _i < _len; _i++) {
node = allNodes[_i];
if (!((_ref = this.map[node]) != null ? _ref.length : void 0)) {
_results.push(node);
}
}
return _results;
};
DepGraph.prototype.parentsOf = function(child) {
var node, _i, _len, _ref, _results;
_ref = _.keys(this.map);
_results = [];
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
node = _ref[_i];
if (__indexOf.call(this.map[node], child) >= 0) {
_results.push(node);
}
}
return _results;
};
DepGraph.prototype.descendantsOf = function(parent, descendants, branch) {
var child, _i, _len, _ref, _ref1;
if (descendants == null) {
descendants = [];
}
if (branch == null) {
branch = [];
}
descendants.push(parent);
branch.push(parent);
_ref1 = (_ref = this.map[parent]) != null ? _ref : [];
for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
child = _ref1[_i];
if (__indexOf.call(branch, child) >= 0) {
throw new Error("Cyclic dependency from " + parent + " to " + child);
}
if (__indexOf.call(descendants, child) >= 0) {
continue;
}
this.descendantsOf(child, descendants, branch.slice(0));
}
return descendants.slice(1);
};
return DepGraph;
})();
if ((typeof module !== "undefined" && module !== null ? module.exports : void 0) != null) {
module.exports = DepGraph;
} else {
this.DepGraph = DepGraph;
}
}).call(this);

20
spa/node_modules/dep-graph/package.json generated vendored Normal file
View File

@@ -0,0 +1,20 @@
{
"author": "Trevor Burnham (http://trevorburnham.com)",
"name": "dep-graph",
"description": "Simple dependency graph management",
"version": "1.1.0",
"homepage": "http://github.com/TrevorBurnham/dep-graph",
"repository": {
"type": "git",
"url": "git://github.com/TrevorBurnham/dep-graph.git"
},
"main": "lib/dep-graph.js",
"dependencies": {
"underscore": "1.2.1"
},
"devDependencies": {
"coffee-script": "1.1.2",
"nodeunit": "0.5.4",
"watchit": ">=0.0.1"
}
}

59
spa/node_modules/dep-graph/src/dep-graph.coffee generated vendored Normal file
View File

@@ -0,0 +1,59 @@
# [dep-graph](http://github.com/TrevorBurnham/dep-graph)
_ = require 'underscore'
class DepGraph
constructor: ->
# The internal representation of the dependency graph in the format
# `id: [ids]`, indicating only *direct* dependencies.
@map = {}
# Add a direct dependency. Returns `false` if that dependency is a duplicate.
add: (id, depId) ->
@map[id] ?= []
return false if depId in @map[id]
@map[id].push depId
@map[id]
# Generate a list of all dependencies (direct and indirect) for the given id,
# in logical order with no duplicates.
getChain: (id) ->
# First, get a list of all dependencies (unordered)
deps = @descendantsOf id
# Second, order them (using the Tarjan algorithm)
chain = []
visited = {}
visit = (node) =>
return if visited[node] or node is id
visited[node] = true
visit parent for parent in @parentsOf(node) when parent in deps
chain.unshift node
for leafNode in _.intersection(deps, @leafNodes()).reverse()
visit leafNode
chain
leafNodes: ->
allNodes = _.uniq _.flatten _.values @map
node for node in allNodes when !@map[node]?.length
parentsOf: (child) ->
node for node in _.keys(@map) when child in @map[node]
descendantsOf: (parent, descendants = [], branch = []) ->
descendants.push parent
branch.push parent
for child in @map[parent] ? []
if child in branch # cycle
throw new Error("Cyclic dependency from #{parent} to #{child}")
continue if child in descendants # duplicate
@descendantsOf child, descendants, branch.slice(0)
descendants[1..]
# Export the class in Node, make it global in the browser.
if module?.exports?
module.exports = DepGraph
else
@DepGraph = DepGraph

50
spa/node_modules/dep-graph/test/test.coffee generated vendored Normal file
View File

@@ -0,0 +1,50 @@
DepGraph = require('../lib/dep-graph.js')
depGraph = new DepGraph
exports['Direct dependencies are chained in original order'] = (test) ->
depGraph.add '0', '1'
depGraph.add '0', '2'
depGraph.add '0', '3'
test.deepEqual depGraph.getChain('0'), ['1', '2', '3']
test.done()
exports['Indirect dependencies are chained before their dependents'] = (test) ->
depGraph.add '2', 'A'
depGraph.add '2', 'B'
test.deepEqual depGraph.getChain('0'), ['1', 'A', 'B', '2', '3']
test.done()
exports['getChain can safely be called for unknown resources'] = (test) ->
test.doesNotThrow -> depGraph.getChain('Z')
test.deepEqual depGraph.getChain('Z'), []
test.done()
exports['Cyclic dependencies are detected'] = (test) ->
depGraph.add 'yin', 'yang'
depGraph.add 'yang', 'yin'
test.throws -> depGraph.getChain 'yin'
test.throws -> depGraph.getChain 'yang'
test.done()
exports['Arc direction is taken into account (issue #1)'] = (test) ->
depGraph.add 'MAIN', 'One'
depGraph.add 'MAIN', 'Three'
depGraph.add 'One', 'Two'
depGraph.add 'Two', 'Three'
test.deepEqual depGraph.getChain('MAIN'), ['Three', 'Two', 'One']
test.done()
exports['Dependency ordering is consistent (issue #2)'] = (test) ->
depGraph.add 'Head', 'Neck'
depGraph.add 'Head', 'Heart'
depGraph.add 'Heart', 'Neck'
depGraph.add 'Neck', 'Shoulders'
test.deepEqual depGraph.getChain('Head'), ['Shoulders', 'Neck', 'Heart']
test.done()
exports['Nodes with same dependencies do not depend on each other (issue #6)'] = (test) ->
depGraph.add 'Java', 'JVM'
depGraph.add 'JRuby', 'JVM'
test.deepEqual depGraph.getChain('Java'), ['JVM']
test.deepEqual depGraph.getChain('JRuby'), ['JVM']
test.done()