github/meteor
1
1
Fork 0
mirror of https://github.com/meteor/meteor.git synced 2026-05-02 03:01:46 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'release-0.9.4' of github.com:meteor/meteor into release-0.9.4

Browse Source
This commit is contained in:
Sashko Stubailo
2014-09-29 23:01:49 -07:00
parent 283b57894d 43c996cd13
commit 5ca48d48de
7 changed files with 163 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@@ -61,7 +61,7 @@ the app:
../meteor
You'll then be able to read the docs locally in your browser at
`http://localhost:3000/`
`http://localhost:3000/`.
Note that if you run Meteor from a git checkout, you cannot pin apps to specific
Meteor releases or run using different Meteor releases using `--release`.

8
docs/client/api.html
View File

@@ -2263,12 +2263,8 @@ This callback fires once and is the first callback to fire. Every
`created` callback with a certain template instance object in `this`,
you will eventually get a `destroyed` callback for the same object.
{{#note}}
The `created` callback is not currently very useful. In a later release, the
template instance object (or something like it) will be visible from helper
functions, and `created` will be a useful way to set up values that are read
from helpers. For now, you probably just want to use `rendered`.
{{/note}}
`created` is a useful way to set up values on template instance that are
read from template helpers using `Template.instance()`.
{{> autoApiBox "Template#destroyed"}}

11
docs/client/packages/showdown.html
View File

@@ -5,13 +5,18 @@
<!-- XXX rename to markdown when we rename the package -->
This package lets you use Markdown in your templates. It's easy: just
put your markdown inside
<code>{&#123;#markdown}}</code> ... <code>{&#123;/markdown}}</code>
put your markdown inside `{{dstache}}#markdown}} ... {{dstache}}/markdown}}`
tags. You can still use all of the usual Meteor template features
inside a Markdown block, such as `{{dstache}}#each}}`, and you still get
reactivity.
<!-- XXX include an example -->
Example:
`{{dstache}}#markdown}}I am using __markdown__.{{dstache}}/markdown}}`
outputs
<p>I am using <strong>markdown</strong>.</p>
{{/markdown}}
</template>

2
packages/tinytest/tinytest.js
View File

@@ -522,7 +522,7 @@ _.extend(TestRun.prototype, {
}, stop_at_offset);
// Wait for the test to complete or time out.
future.wait();
onComplete & onComplete();
onComplete && onComplete();
});
} else {
// client

13
tools/commands.js
View File

@@ -152,6 +152,7 @@ var runCommandOptions = {
'raw-logs': { type: Boolean },
settings: { type: String },
program: { type: String },
test: {type: Boolean, default: false},
verbose: { type: Boolean, short: "v" },
// With --once, meteor does not re-run the project if it crashes
// and does not monitor for file changes. Intentionally
@@ -312,6 +313,18 @@ function doRunCommand (options) {
if (options['raw-logs'])
runLog.setRawLogs(true);
// Velocity testing. Sets up a DDP connection to the app process and
// runs phantomjs.
//
// NOTE: this calls process.exit() when testing is done.
if (options['test']){
var serverUrl = "http://" + (parsedHostPort.host || "localhost") +
":" + parsedHostPort.port;
var velocity = require('./run-velocity.js');
velocity.runVelocity(serverUrl);
}
var runAll = require('./run-all.js');
return runAll.run(options.appDir, {
proxyPort: parsedUrl.port,

7
tools/help.txt
View File

@@ -51,10 +51,11 @@ Options:
--mobile-server=https://example.com:443).
--production Simulate production mode. Minify and bundle CSS and JS files.
--raw-logs Run without parsing logs from stdout and stderr.
--settings Set optional data for Meteor.settings on the server
--release Specify the release of Meteor to use
--program The program in the app to run (Advanced)
--settings Set optional data for Meteor.settings on the server.
--release Specify the release of Meteor to use.
--program The program in the app to run (Advanced).
--verbose Print all output from builds logs.
--test [Experimental] Run Velocity tests using phantomjs and exit.
>>> debug
Run the project, but suspend the server process for debugging.

134
tools/run-velocity.js Normal file
View File

@@ -0,0 +1,134 @@
var Console = require('./console.js').Console;
var uniload = require('./uniload.js');
var phantomjs = require('phantomjs');
var child_process = require('child_process');
var _ = require('underscore');
// XXX this could really use a self-test!
// XXX would be nice be nice if this didn't have to be in core. Perhaps
// at some point we'll have an API for packages to register commands in
// the tool.
// 1. Establish a DDP connection to Meteor
// 2. Subscribe to the Velocity subscriptions that tell us
// which tests pass/fail and when all tests have completed.
// 3. Open the app server with PhantomJS to run client side tests.
// 4. Print the results and exit with the appropriate exit code.
var runVelocity = function (url) {
var unipackages = uniload.load({
packages: [ 'ddp']
});
var DDP = unipackages.ddp.DDP;
// XXX maybe a startup message so users know the tests are running.
var ddpConnection = DDP.connect(url);
var interval = setInterval(function () {
if (ddpConnection.status().status === "connected") {
clearInterval(interval);
ddpConnection.subscribe("VelocityTestReports", {
onError: function () {
Console.stderr.write("failed to subscribe to VelocityTestReports "
+ "subscription");
// XXX tell user to add velocity:core
// XXX these also fire if the user turns on autopublish
}, onReady: function () {
this.connection.registerStore("velocityTestReports", {
update: function (msg) {
if (msg.msg === "added") {
var testDesc = msg.fields.framework + " : " +
msg.fields.ancestors.join(":") + " => " + msg.fields.name;
if (msg.fields.result === "passed") {
console.log("PASSED", testDesc);
} else if (msg.fields.result === "failed") {
console.error("FAILED", testDesc);
console.log(msg.fields.failureStackTrace);
}
}
}
});
}
});
var reports = {};
function updateReport(msg) {
var report = reports[msg.id];
if (! report) {
reports[msg.id] = msg.fields;
} else {
_.extend(report, msg.fields);
}
}
var aggregateResult = null;
var isFinished = false;
ddpConnection.subscribe("VelocityAggregateReports", {
onError: function () {
Console.stderr.write("failed to subscribe to " +
"VelocityAggregateReports subscription");
}, onReady: function () {
this.connection.registerStore("velocityAggregateReports", {
update: function (msg) {
if (msg.msg === "added" || msg.msg === "changed") {
updateReport(msg);
var report = reports[msg.id];
if (report.name === "aggregateResult") {
aggregateResult = report.result;
}
if (report.name === "aggregateComplete" &&
report.result === "completed") {
setTimeout(function () {
if (aggregateResult === "passed") {
console.log("TESTS RAN SUCCESSFULLY");
// XXX XXX this is not great. We shouldn't be
// exiting from deep within code like this. Better
// would be to integrate with run --once, and
// signal the inner process to exit cleanly on
// test completion.
process.exit(0);
}
if (aggregateResult === "failed") {
console.log("FAILURE");
process.exit(1);
}
}, 2000);
}
}
}
});
}
});
function visitWithPhantom (url) {
var phantomScript = "require('webpage').create().open('" + url + "');";
child_process.execFile(
'/bin/bash',
['-c',
("exec " + phantomjs.path + " /dev/stdin <<'END'\n" +
phantomScript + "END\n")]);
}
ddpConnection.subscribe("VelocityMirrors", {
onError: function (err) {
Console.stderr.write("failed to subscribe to VelocityMirrors " +
"subscription", err);
}, onReady: function () {
this.connection.registerStore("velocityMirrors", {
update: function (msg) {
if (msg.msg === "added") {
visitWithPhantom(msg.fields.rootUrl);
}
}
});
}
});
}
}, 2000);
};
exports.runVelocity = runVelocity;