mirror of
https://github.com/zulip/zulip.git
synced 2025-11-16 20:02:15 +00:00
ac7b09d57e
And convert the corresponding function expressions to arrow style
while we’re here.
import * as babelParser from "recast/parsers/babel";
import * as recast from "recast";
import * as tsParser from "recast/parsers/typescript";
import { builders as b, namedTypes as n } from "ast-types";
import K from "ast-types/gen/kinds";
import fs from "fs";
import path from "path";
import process from "process";
const checkExpression = (node: n.Node): node is K.ExpressionKind =>
n.Expression.check(node);
for (const file of process.argv.slice(2)) {
console.log("Parsing", file);
const ast = recast.parse(fs.readFileSync(file, { encoding: "utf8" }), {
parser: path.extname(file) === ".ts" ? tsParser : babelParser,
});
let changed = false;
recast.visit(ast, {
visitCallExpression(path) {
const { callee, arguments: args } = path.node;
if (
n.MemberExpression.check(callee) &&
!callee.computed &&
n.Identifier.check(callee.object) &&
callee.object.name === "_" &&
n.Identifier.check(callee.property) &&
callee.property.name === "map" &&
args.length === 2 &&
checkExpression(args[0]) &&
checkExpression(args[1])
) {
const [arr, fn] = args;
path.replace(
b.callExpression(b.memberExpression(arr, b.identifier("map")), [
n.FunctionExpression.check(fn) ||
n.ArrowFunctionExpression.check(fn)
? b.arrowFunctionExpression(
fn.params,
n.BlockStatement.check(fn.body) &&
fn.body.body.length === 1 &&
n.ReturnStatement.check(fn.body.body[0])
? fn.body.body[0].argument || b.identifier("undefined")
: fn.body
)
: fn,
])
);
changed = true;
}
this.traverse(path);
},
});
if (changed) {
console.log("Writing", file);
fs.writeFileSync(file, recast.print(ast).code, { encoding: "utf8" });
}
}
Signed-off-by: Anders Kaseorg <anders@zulipchat.com>
265 lines
8.4 KiB
JavaScript
265 lines
8.4 KiB
JavaScript
set_global('i18n', global.stub_i18n);
|
|
|
|
zrequire('people');
|
|
zrequire('Filter', 'js/filter');
|
|
zrequire('stream_data');
|
|
zrequire('narrow_state');
|
|
zrequire('util');
|
|
|
|
set_global('blueslip', global.make_zblueslip());
|
|
set_global('page_params', {});
|
|
|
|
function set_filter(operators) {
|
|
operators = operators.map(op => ({
|
|
operator: op[0],
|
|
operand: op[1],
|
|
}));
|
|
narrow_state.set_current_filter(new Filter(operators));
|
|
}
|
|
|
|
|
|
run_test('stream', () => {
|
|
assert.equal(narrow_state.public_operators(), undefined);
|
|
assert(!narrow_state.active());
|
|
|
|
const test_stream = {name: 'Test', stream_id: 15};
|
|
stream_data.add_sub(test_stream);
|
|
|
|
assert(!narrow_state.is_for_stream_id(test_stream.stream_id));
|
|
|
|
set_filter([
|
|
['stream', 'Test'],
|
|
['topic', 'Bar'],
|
|
['search', 'yo'],
|
|
]);
|
|
assert(narrow_state.active());
|
|
|
|
assert.equal(narrow_state.stream(), 'Test');
|
|
assert.equal(narrow_state.stream_id(), test_stream.stream_id);
|
|
assert.equal(narrow_state.topic(), 'Bar');
|
|
assert(narrow_state.is_for_stream_id(test_stream.stream_id));
|
|
|
|
const expected_operators = [
|
|
{ negated: false, operator: 'stream', operand: 'Test' },
|
|
{ negated: false, operator: 'topic', operand: 'Bar' },
|
|
{ negated: false, operator: 'search', operand: 'yo' },
|
|
];
|
|
|
|
const public_operators = narrow_state.public_operators();
|
|
assert.deepEqual(public_operators, expected_operators);
|
|
assert.equal(narrow_state.search_string(), 'stream:Test topic:Bar yo');
|
|
});
|
|
|
|
|
|
run_test('narrowed', () => {
|
|
narrow_state.reset_current_filter(); // not narrowed, basically
|
|
assert(!narrow_state.narrowed_to_pms());
|
|
assert(!narrow_state.narrowed_by_reply());
|
|
assert(!narrow_state.narrowed_by_pm_reply());
|
|
assert(!narrow_state.narrowed_by_topic_reply());
|
|
assert(!narrow_state.narrowed_to_search());
|
|
assert(!narrow_state.narrowed_to_topic());
|
|
assert(!narrow_state.narrowed_by_stream_reply());
|
|
assert.equal(narrow_state.stream_id(), undefined);
|
|
|
|
set_filter([['stream', 'Foo']]);
|
|
assert(!narrow_state.narrowed_to_pms());
|
|
assert(!narrow_state.narrowed_by_reply());
|
|
assert(!narrow_state.narrowed_by_pm_reply());
|
|
assert(!narrow_state.narrowed_by_topic_reply());
|
|
assert(!narrow_state.narrowed_to_search());
|
|
assert(!narrow_state.narrowed_to_topic());
|
|
assert(narrow_state.narrowed_by_stream_reply());
|
|
|
|
set_filter([['pm-with', 'steve@zulip.com']]);
|
|
assert(narrow_state.narrowed_to_pms());
|
|
assert(narrow_state.narrowed_by_reply());
|
|
assert(narrow_state.narrowed_by_pm_reply());
|
|
assert(!narrow_state.narrowed_by_topic_reply());
|
|
assert(!narrow_state.narrowed_to_search());
|
|
assert(!narrow_state.narrowed_to_topic());
|
|
assert(!narrow_state.narrowed_by_stream_reply());
|
|
|
|
set_filter([['stream', 'Foo'], ['topic', 'bar']]);
|
|
assert(!narrow_state.narrowed_to_pms());
|
|
assert(narrow_state.narrowed_by_reply());
|
|
assert(!narrow_state.narrowed_by_pm_reply());
|
|
assert(narrow_state.narrowed_by_topic_reply());
|
|
assert(!narrow_state.narrowed_to_search());
|
|
assert(narrow_state.narrowed_to_topic());
|
|
assert(!narrow_state.narrowed_by_stream_reply());
|
|
|
|
set_filter([['search', 'grail']]);
|
|
assert(!narrow_state.narrowed_to_pms());
|
|
assert(!narrow_state.narrowed_by_reply());
|
|
assert(!narrow_state.narrowed_by_pm_reply());
|
|
assert(!narrow_state.narrowed_by_topic_reply());
|
|
assert(narrow_state.narrowed_to_search());
|
|
assert(!narrow_state.narrowed_to_topic());
|
|
assert(!narrow_state.narrowed_by_stream_reply());
|
|
});
|
|
|
|
run_test('operators', () => {
|
|
set_filter([['stream', 'Foo'], ['topic', 'Bar'], ['search', 'Yo']]);
|
|
let result = narrow_state.operators();
|
|
assert.equal(result.length, 3);
|
|
assert.equal(result[0].operator, 'stream');
|
|
assert.equal(result[0].operand, 'Foo');
|
|
|
|
assert.equal(result[1].operator, 'topic');
|
|
assert.equal(result[1].operand, 'Bar');
|
|
|
|
assert.equal(result[2].operator, 'search');
|
|
assert.equal(result[2].operand, 'yo');
|
|
|
|
narrow_state.reset_current_filter();
|
|
result = narrow_state.operators();
|
|
assert.equal(result.length, 0);
|
|
});
|
|
|
|
run_test('muting_enabled', () => {
|
|
set_filter([['stream', 'devel']]);
|
|
assert(narrow_state.muting_enabled());
|
|
|
|
narrow_state.reset_current_filter(); // not narrowed, basically
|
|
assert(narrow_state.muting_enabled());
|
|
|
|
set_filter([['stream', 'devel'], ['topic', 'mac']]);
|
|
assert(!narrow_state.muting_enabled());
|
|
|
|
set_filter([['search', 'whatever']]);
|
|
assert(!narrow_state.muting_enabled());
|
|
|
|
set_filter([['is', 'private']]);
|
|
assert(!narrow_state.muting_enabled());
|
|
|
|
});
|
|
|
|
run_test('set_compose_defaults', () => {
|
|
set_filter([['stream', 'Foo'], ['topic', 'Bar']]);
|
|
|
|
const stream_and_subject = narrow_state.set_compose_defaults();
|
|
assert.equal(stream_and_subject.stream, 'Foo');
|
|
assert.equal(stream_and_subject.topic, 'Bar');
|
|
|
|
set_filter([['pm-with', 'foo@bar.com']]);
|
|
let pm_test = narrow_state.set_compose_defaults();
|
|
assert.equal(pm_test.private_message_recipient, undefined);
|
|
|
|
const john = {
|
|
email: 'john@doe.com',
|
|
user_id: 57,
|
|
full_name: 'John Doe',
|
|
};
|
|
people.add(john);
|
|
people.add_in_realm(john);
|
|
|
|
set_filter([['pm-with', 'john@doe.com']]);
|
|
pm_test = narrow_state.set_compose_defaults();
|
|
assert.equal(pm_test.private_message_recipient, 'john@doe.com');
|
|
|
|
set_filter([['topic', 'duplicate'], ['topic', 'duplicate']]);
|
|
assert.deepEqual(narrow_state.set_compose_defaults(), {});
|
|
|
|
stream_data.add_sub({name: 'ROME', stream_id: 99});
|
|
set_filter([['stream', 'rome']]);
|
|
|
|
const stream_test = narrow_state.set_compose_defaults();
|
|
assert.equal(stream_test.stream, 'ROME');
|
|
});
|
|
|
|
run_test('update_email', () => {
|
|
const steve = {
|
|
email: 'steve@foo.com',
|
|
user_id: 43,
|
|
full_name: 'Steve',
|
|
};
|
|
|
|
people.add(steve);
|
|
set_filter([
|
|
['pm-with', 'steve@foo.com'],
|
|
['sender', 'steve@foo.com'],
|
|
['stream', 'steve@foo.com'], // try to be tricky
|
|
]);
|
|
narrow_state.update_email(steve.user_id, 'showell@foo.com');
|
|
const filter = narrow_state.filter();
|
|
assert.deepEqual(filter.operands('pm-with'), ['showell@foo.com']);
|
|
assert.deepEqual(filter.operands('sender'), ['showell@foo.com']);
|
|
assert.deepEqual(filter.operands('stream'), ['steve@foo.com']);
|
|
});
|
|
|
|
run_test('topic', () => {
|
|
set_filter([['stream', 'Foo'], ['topic', 'Bar']]);
|
|
assert.equal(narrow_state.topic(), 'Bar');
|
|
|
|
set_filter([['stream', 'release'], ['topic', '@#$$^test']]);
|
|
assert.equal(narrow_state.topic(), '@#$$^test');
|
|
|
|
set_filter([]);
|
|
assert.equal(narrow_state.topic(), undefined);
|
|
|
|
set_filter([
|
|
['sender', 'test@foo.com'],
|
|
['pm-with', 'test@foo.com'],
|
|
]);
|
|
assert.equal(narrow_state.topic(), undefined);
|
|
|
|
narrow_state.set_current_filter(undefined);
|
|
assert.equal(narrow_state.topic(), undefined);
|
|
});
|
|
|
|
|
|
run_test('stream', () => {
|
|
set_filter([]);
|
|
assert.equal(narrow_state.stream(), undefined);
|
|
assert.equal(narrow_state.stream_id(), undefined);
|
|
|
|
set_filter([['stream', 'Foo'], ['topic', 'Bar']]);
|
|
assert.equal(narrow_state.stream(), 'Foo');
|
|
assert.equal(narrow_state.stream_sub(), undefined);
|
|
assert.equal(narrow_state.stream_id(), undefined);
|
|
|
|
const sub = {name: 'Foo', stream_id: 55};
|
|
stream_data.add_sub(sub);
|
|
assert.equal(narrow_state.stream_id(), 55);
|
|
assert.deepEqual(narrow_state.stream_sub(), sub);
|
|
|
|
set_filter([['sender', 'someone'], ['topic', 'random']]);
|
|
assert.equal(narrow_state.stream(), undefined);
|
|
});
|
|
|
|
run_test('pm_string', () => {
|
|
// This function will return undefined unless we're clearly
|
|
// narrowed to a specific PM (including huddles) with real
|
|
// users.
|
|
narrow_state.set_current_filter(undefined);
|
|
assert.equal(narrow_state.pm_string(), undefined);
|
|
|
|
set_filter([['stream', 'Foo'], ['topic', 'Bar']]);
|
|
assert.equal(narrow_state.pm_string(), undefined);
|
|
|
|
set_filter([['pm-with', '']]);
|
|
assert.equal(narrow_state.pm_string(), undefined);
|
|
|
|
set_filter([['pm-with', 'bogus@foo.com']]);
|
|
assert.equal(narrow_state.pm_string(), undefined);
|
|
|
|
const alice = {
|
|
email: 'alice@foo.com',
|
|
user_id: 444,
|
|
full_name: 'Alice',
|
|
};
|
|
|
|
const bob = {
|
|
email: 'bob@foo.com',
|
|
user_id: 555,
|
|
full_name: 'Bob',
|
|
};
|
|
|
|
people.add(alice);
|
|
people.add(bob);
|
|
|
|
set_filter([['pm-with', 'bob@foo.com,alice@foo.com']]);
|
|
assert.equal(narrow_state.pm_string(), '444,555');
|
|
});
|