rafaelcaricio/actual
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

style: apply prettier fixes

Browse source
This commit is contained in:
Tom French 2022-07-17 11:28:05 +01:00
parent 5977e020f0
commit d30067b5b9
47 changed files with 474 additions and 418 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
packages/desktop-client/src/components/Box.js
View file

@ -9,14 +9,18 @@ function getFlex(flex) {
}
function Box({ flex, children, direction, style }) {
return <div
return (
<div
style={{
...style,
flex: getFlex(flex),
display: 'flex',
flexDirection: direction || 'column'
}}
>{children}</div>;
>
{children}
</div>
);
}
export default Box;

2
packages/desktop-client/src/components/Debugger.js
View file

@ -206,7 +206,7 @@ class Debugger extends React.Component {
height: 10,
backgroundColor: '#303030',
marginRight: 10,
borderRadius: 10,
borderRadius: 10
}}
/>
<Button onClick={this.toggleRecord} style={{ marginRight: 10 }}>

4
packages/desktop-client/src/components/FatalError.js
View file

@ -99,7 +99,9 @@ class FatalError extends React.Component {
.
</P>
<P>
<Button onClick={() => window.Actual.relaunch()}>{buttonText}</Button>
<Button onClick={() => window.Actual.relaunch()}>
{buttonText}
</Button>
</P>
<P isLast={true} style={{ fontSize: 11 }}>
<Link

5
packages/desktop-client/src/components/FinancesApp.js
View file

@ -277,7 +277,4 @@ function FinancesAppWithContext(props) {
);
}
export default connect(
null,
actions
)(FinancesAppWithContext);
export default connect(null, actions)(FinancesAppWithContext);

6
packages/desktop-client/src/components/accounts/Account.js
View file

@ -642,7 +642,7 @@ const AccountHeader = React.memo(
let searchInput = useRef(null);
let splitsExpanded = useSplitsExpanded();
let canSync = syncEnabled && (account && account.account_id);
let canSync = syncEnabled && account && account.account_id;
if (!account) {
// All accounts - check for any syncable account
canSync = !!accounts.find(account => !!account.account_id);
@ -1701,9 +1701,9 @@ class AccountInternal extends React.PureComponent {
}
showAccount={
!accountId ||
(accountId === 'offbudget' ||
accountId === 'offbudget' ||
accountId === 'budgeted' ||
accountId === 'uncategorized')
accountId === 'uncategorized'
}
isAdding={this.state.isAdding}
isNew={this.isNew}

6
packages/desktop-client/src/components/accounts/Filters.js
View file

@ -149,7 +149,11 @@ function ConfigureField({ field, op, value, dispatch, onApply }) {
['amount-outflow', 'Amount (outflow)']
]
: field === 'date'
? [['date', 'Date'], ['month', 'Month'], ['year', 'Year']]
? [
['date', 'Date'],
['month', 'Month'],
['year', 'Year']
]
: null
}
value={subfield}

7
packages/desktop-client/src/components/manager/ManagementApp.js
View file

@ -230,8 +230,7 @@ class ManagementApp extends React.Component {
}
}
export default connect(
state => {
export default connect(state => {
let { modalStack } = state.modals;
return {
@ -241,6 +240,4 @@ export default connect(
loadingText: state.app.loadingText,
currentModals: modalStack.map(modal => modal.name)
};
},
actions
)(ManagementApp);
}, actions)(ManagementApp);

5
packages/desktop-client/src/components/manager/subscribe/ConfirmPasswordForm.js
View file

@ -69,10 +69,7 @@ export function ConfirmPasswordForm({ buttons, onSetPassword, onError }) {
</label>
<View style={{ flex: 1 }} />
{buttons}
<ButtonWithLoading
primary
loading={loading}
>
<ButtonWithLoading primary loading={loading}>
OK
</ButtonWithLoading>
</View>

5
packages/desktop-client/src/components/modals/WelcomeScreen.js
View file

@ -70,7 +70,4 @@ function WelcomeScreen({ modalProps, actions }) {
);
}
export default connect(
null,
actions
)(WelcomeScreen);
export default connect(null, actions)(WelcomeScreen);

2
packages/desktop-client/src/components/reports/Change.js
View file

@ -2,7 +2,7 @@ import React from 'react';
import { styles } from 'loot-design/src/style';
import { integerToCurrency } from 'loot-core/src/shared/util';
import { Block } from 'loot-design/src/components/common';
import { colors } from 'loot-design/src/style'
import { colors } from 'loot-design/src/style';
function Change({ amount, style }) {
return (

5
packages/desktop-client/src/components/reports/Overview.js
View file

@ -110,7 +110,10 @@ function CashFlowCard() {
const end = monthUtils.currentDay();
const start = monthUtils.currentMonth() + '-01';
const data = useReport('cash_flow_simple', useArgsMemo(simpleCashFlow)(start, end));
const data = useReport(
'cash_flow_simple',
useArgsMemo(simpleCashFlow)(start, end)
);
if (!data) {
return null;
}

6
packages/desktop-client/src/components/tutorial/BudgetInitial.js
View file

@ -15,9 +15,9 @@ function BudgetInitial({ accounts, navigationProps }) {
{!minimized && (
<React.Fragment>
<P>
You should see all of your current accounts' balance available
to budget. Click on the budgeted column for a category create a
budget. Keep doing this until your "To Budget" amount is zero.
You should see all of your current accounts' balance available to
budget. Click on the budgeted column for a category create a budget.
Keep doing this until your "To Budget" amount is zero.
</P>
<P>
Don't worry too much about your initial budget. Just guess. You'll

7
packages/desktop-client/src/components/tutorial/BudgetNextMonth.js
View file

@ -61,7 +61,6 @@ function BudgetNextMonth({ stepTwo, navigationProps }) {
);
}
export default connect(
null,
dispatch => bindActionCreators(actions, dispatch)
)(BudgetNextMonth);
export default connect(null, dispatch => bindActionCreators(actions, dispatch))(
BudgetNextMonth
);

2
packages/desktop-client/src/components/tutorial/CategoryBalance.js
View file

@ -5,7 +5,7 @@ import { styles, colors } from 'loot-design/src/style';
import { Standalone, Title, useMinimized } from './common';
function CategoryBalance({ targetRect, navigationProps }) {
let [minimized, toggle] = useMinimized()
let [minimized, toggle] = useMinimized();
return (
<Standalone>

7
packages/desktop-client/src/components/tutorial/Overspending.js
View file

@ -96,7 +96,6 @@ function Overspending({ navigationProps, stepTwo }) {
);
}
export default connect(
null,
dispatch => bindActionCreators(actions, dispatch)
)(Overspending);
export default connect(null, dispatch => bindActionCreators(actions, dispatch))(
Overspending
);

4
packages/desktop-client/src/components/tutorial/TransactionAdd.js
View file

@ -33,8 +33,8 @@ function TransactionAdd({ targetRect, navigationProps }) {
</P>
<P isLast={true}>
Try <strong>clicking "Add New"</strong> to see how adding
transactions affects your budget.
Try <strong>clicking "Add New"</strong> to see how adding transactions
affects your budget.
</P>
<Navigation {...navigationProps} showBack={false} />

2
packages/desktop-client/src/components/tutorial/TransactionFinalize.js
View file

@ -3,7 +3,7 @@ import { P } from 'loot-design/src/components/common';
import { css } from 'glamor';
import Navigation from './Navigation';
import * as monthUtils from 'loot-core/src/shared/months';
import {Standalone} from './common';
import { Standalone } from './common';
function TransactionFinalize({ navigationProps }) {
return (

2
packages/loot-core/src/client/actions/debug.js
View file

@ -5,5 +5,5 @@ export function debugCell(sheet, name) {
type: constants.DEBUG_CELL,
sheet,
name
}
};
}

12
packages/loot-core/src/mocks/budget.js
View file

@ -439,15 +439,19 @@ async function fillOther(handlers, account, payees, groups) {
async function createBudget(accounts, payees, groups) {
let primaryAccount = accounts.find(a => (a.name = 'Bank of America'));
let earliestDate = (await db.first(
let earliestDate = (
await db.first(
`SELECT * FROM v_transactions t LEFT JOIN accounts a ON t.account = a.id
WHERE a.offbudget = 0 AND t.is_child = 0 ORDER BY date ASC LIMIT 1`
)).date;
let earliestPrimaryDate = (await db.first(
)
).date;
let earliestPrimaryDate = (
await db.first(
`SELECT * FROM v_transactions t LEFT JOIN accounts a ON t.account = a.id
WHERE a.id = ? AND a.offbudget = 0 AND t.is_child = 0 ORDER BY date ASC LIMIT 1`,
[primaryAccount.id]
)).date;
)
).date;
let start = monthUtils.monthFromDate(db.fromDateRepr(earliestDate));
let end = monthUtils.currentMonth();

5
packages/loot-core/src/platform/client/fetch/index.browser.js
View file

@ -172,7 +172,10 @@ module.exports.listen = function listen(name, cb) {
return () => {
let arr = listeners.get(name);
listeners.set(name, arr.filter(cb_ => cb_ !== cb));
listeners.set(
name,
arr.filter(cb_ => cb_ !== cb)
);
};
};

5
packages/loot-core/src/platform/client/fetch/index.mobile.js
View file

@ -82,7 +82,10 @@ function listen(name, cb) {
return () => {
let arr = listeners.get(name);
listeners.set(name, arr.filter(cb_ => cb_ !== cb));
listeners.set(
name,
arr.filter(cb_ => cb_ !== cb)
);
};
}

5
packages/loot-core/src/platform/client/fetch/index.testing.js
View file

@ -56,6 +56,9 @@ module.exports.listen = function listen(name, cb) {
return () => {
let arr = listeners.get(name);
listeners.set(name, arr.filter(cb_ => cb_ !== cb));
listeners.set(
name,
arr.filter(cb_ => cb_ !== cb)
);
};
};

5
packages/loot-core/src/platform/client/fetch/index.web.js
View file

@ -117,7 +117,10 @@ module.exports.listen = function listen(name, cb) {
return () => {
let arr = listeners.get(name);
if (arr) {
listeners.set(name, arr.filter(cb_ => cb_ !== cb));
listeners.set(
name,
arr.filter(cb_ => cb_ !== cb)
);
}
};
};

6
packages/loot-core/src/platform/exceptions/index.testing.js
View file

@ -1,5 +1,3 @@
export function captureException(exc) {
}
export function captureException(exc) {}
export function captureBreadcrumb(info) {
}
export function captureBreadcrumb(info) {}

6
packages/loot-core/src/platform/server/fs/index.web.js
View file

@ -167,9 +167,9 @@ async function _removeFile(filepath) {
// Load files from the server that should exist by default
async function populateDefaultFilesystem() {
let index = await (await fetch(
process.env.PUBLIC_URL + 'data-file-index.txt'
)).text();
let index = await (
await fetch(process.env.PUBLIC_URL + 'data-file-index.txt')
).text();
let files = index
.split('\n')
.map(name => name.trim())

16
packages/loot-core/src/server/accounts/title/lower-case.js
View file

@ -1,18 +1,18 @@
const conjunctions = [
'for',
'for', //
'and',
'nor',
'but',
'or',
'yet',
'so'
]
];
const articles = [
'a',
'a', //
'an',
'the'
]
];
const prepositions = [
'aboard',
@ -84,10 +84,6 @@ const prepositions = [
'with',
'within',
'without'
]
];
module.exports = new Set([
...conjunctions,
...articles,
...prepositions
])
module.exports = new Set([...conjunctions, ...articles, ...prepositions]);

6
packages/loot-core/src/server/accounts/transactions.js
View file

@ -117,9 +117,9 @@ export async function batchUpdateTransactions({
await Promise.all(allAdded.map(t => transfer.onInsert(t)));
// Return any updates from here
resultUpdated = (await Promise.all(
allUpdated.map(t => transfer.onUpdate(t))
)).filter(Boolean);
resultUpdated = (
await Promise.all(allUpdated.map(t => transfer.onUpdate(t)))
).filter(Boolean);
await Promise.all(allDeleted.map(t => transfer.onDelete(t)));
});

37
packages/loot-core/src/server/accounts/transfer.js
View file

@ -6,24 +6,28 @@ async function getPayee(acct) {
async function getTransferredAccount(transaction) {
if (transaction.payee) {
let { transfer_acct, id } = await db.first(
'SELECT id, transfer_acct FROM v_payees WHERE id = ?',
[transaction.payee]
);
let {
transfer_acct,
id
} = await db.first('SELECT id, transfer_acct FROM v_payees WHERE id = ?', [
transaction.payee
]);
return transfer_acct;
}
return null;
}
async function clearCategory(transaction, transferAcct) {
const { offbudget: fromOffBudget } = await db.first(
'SELECT offbudget FROM accounts WHERE id = ?',
[transaction.account]
);
const { offbudget: toOffBudget } = await db.first(
'SELECT offbudget FROM accounts WHERE id = ?',
[transferAcct]
);
const {
offbudget: fromOffBudget
} = await db.first('SELECT offbudget FROM accounts WHERE id = ?', [
transaction.account
]);
const {
offbudget: toOffBudget
} = await db.first('SELECT offbudget FROM accounts WHERE id = ?', [
transferAcct
]);
// We should clear the category to make sure it's not being
// accounted for in the budget, unless it should be in the case of
@ -36,10 +40,11 @@ async function clearCategory(transaction, transferAcct) {
}
export async function addTransfer(transaction, transferredAccount) {
let { id: fromPayee } = await db.first(
'SELECT id FROM payees WHERE transfer_acct = ?',
[transaction.account]
);
let {
id: fromPayee
} = await db.first('SELECT id FROM payees WHERE transfer_acct = ?', [
transaction.account
]);
// We need to enforce certain constraints with child transaction transfers
if (transaction.parent_id) {

36
packages/loot-core/src/server/aql/exec.test.js
View file

@ -81,28 +81,34 @@ describe('runQuery', () => {
expect(data[0].date).toBe('2020-01-04');
// date-month
data = (await runQuery(
data = (
await runQuery(
query('transactions')
.select({ month: { $month: '$date' } })
.serialize()
)).data;
)
).data;
expect(data[0].month).toBe('2020-01');
// date-year
data = (await runQuery(
data = (
await runQuery(
query('transactions')
.select({ year: { $year: '$date' } })
.serialize()
)).data;
)
).data;
expect(data[0].year).toBe('2020');
// boolean
data = (await runQuery(
data = (
await runQuery(
query('transactions')
.select(['is_child', 'is_parent'])
.raw()
.serialize()
)).data;
)
).data;
expect(data[0].is_child).toBe(false);
expect(data[0].is_parent).toBe(true);
expect(data[1].is_child).toBe(true);
@ -128,31 +134,37 @@ describe('runQuery', () => {
);
expect(data[0].id).toBe(transId);
data = (await runQuery(
data = (
await runQuery(
query('transactions')
.filter({ date: { $transform: '$month', $eq: { $month: ':month' } } })
.select('date')
.serialize(),
{ params: { month: '2020-01-02' } }
)).data;
)
).data;
expect(data[0].id).toBe(transId);
data = (await runQuery(
data = (
await runQuery(
query('transactions')
.filter({ date: { $transform: '$year', $eq: { $year: ':month' } } })
.select('date')
.serialize(),
{ params: { month: '2020-01-02' } }
)).data;
)
).data;
expect(data[0].id).toBe(transId);
data = (await runQuery(
data = (
await runQuery(
query('transactions')
.filter({ cleared: ':cleared' })
.select('date')
.serialize(),
{ params: { cleared: true } }
)).data;
)
).data;
expect(data[0].id).toBe(transId);
});

5
packages/loot-core/src/server/aql/schema/executors.js
View file

@ -143,7 +143,10 @@ async function execTransactionsGrouped(
rows = await db.all(rowSql, params);
matched = new Set(
[].concat.apply([], rows.map(row => row.matched.split(',')))
[].concat.apply(
[],
rows.map(row => row.matched.split(','))
)
);
}

4
packages/loot-core/src/server/aql/schema/index.test.js
View file

@ -10,7 +10,7 @@ describe('schema', () => {
test('never returns transactions without a date', async () => {
expect((await db.all('SELECT * FROM transactions')).length).toBe(0);
expect((await db.all('SELECT * FROM v_transactions')).length).toBe(0);
await db.runQuery('INSERT INTO transactions (acct) VALUES (?)', ["foo"]);
await db.runQuery('INSERT INTO transactions (acct) VALUES (?)', ['foo']);
expect((await db.all('SELECT * FROM transactions')).length).toBe(1);
expect((await db.all('SELECT * FROM v_transactions')).length).toBe(0);
});
@ -28,7 +28,7 @@ describe('schema', () => {
expect((await db.all('SELECT * FROM v_transactions')).length).toBe(0);
await db.runQuery(
'INSERT INTO transactions (date, acct, isChild) VALUES (?, ?, ?)',
[20200101, "foo", 1]
[20200101, 'foo', 1]
);
expect((await db.all('SELECT * FROM transactions')).length).toBe(1);
expect((await db.all('SELECT * FROM v_transactions')).length).toBe(0);

1
packages/loot-core/src/server/budget/app.js
View file

@ -3,7 +3,6 @@ import { mutator } from '../mutators';
import { undoable } from '../undo';
import * as actions from './actions';
let app = createApp();
app.method('budget/budget-amount', mutator(undoable(actions.setBudget)));

1
packages/loot-core/src/server/budget/util.js
View file

@ -19,4 +19,3 @@ export function unflatten2(arr) {
}
return res;
}

55
packages/loot-core/src/server/main.js
View file

@ -416,7 +416,10 @@ handlers['category-group-delete'] = mutator(async function({ id, transferId }) {
return batchMessages(async () => {
if (transferId) {
await budget.doTransfer(groupCategories.map(c => c.id), transferId);
await budget.doTransfer(
groupCategories.map(c => c.id),
transferId
);
}
await db.deleteCategoryGroup({ id }, transferId);
});
@ -761,11 +764,15 @@ handlers['accounts-get'] = async function() {
};
handlers['account-properties'] = async function({ id }) {
const { balance } = await db.first(
const {
balance
} = await db.first(
'SELECT sum(amount) as balance FROM transactions WHERE acct = ? AND isParent = 0 AND tombstone = 0',
[id]
);
const { count } = await db.first(
const {
count
} = await db.first(
'SELECT count(id) as count FROM transactions WHERE acct = ? AND tombstone = 0',
[id]
);
@ -904,10 +911,9 @@ handlers['account-close'] = mutator(async function({
true
);
let { id: payeeId } = await db.first(
'SELECT id FROM payees WHERE transfer_acct = ?',
[id]
);
let {
id: payeeId
} = await db.first('SELECT id FROM payees WHERE transfer_acct = ?', [id]);
await batchMessages(() => {
// TODO: what this should really do is send a special message that
@ -941,10 +947,11 @@ handlers['account-close'] = mutator(async function({
// If there is a balance we need to transfer it to the specified
// account (and possibly categorize it)
if (balance !== 0) {
let { id: payeeId } = await db.first(
'SELECT id FROM payees WHERE transfer_acct = ?',
[transferAccountId]
);
let {
id: payeeId
} = await db.first('SELECT id FROM payees WHERE transfer_acct = ?', [
transferAccountId
]);
await handlers['transaction-add']({
id: uuid.v4Sync(),
@ -1084,9 +1091,7 @@ handlers['accounts-sync'] = async function({ id }) {
} else if (err instanceof PostError && err.reason !== 'internal') {
errors.push({
accountId: acct.id,
message: `Account "${
acct.name
}" is not linked properly. Please link it again`
message: `Account "${acct.name}" is not linked properly. Please link it again`
});
} else {
errors.push({
@ -1136,10 +1141,9 @@ handlers['transactions-import'] = mutator(function({
});
handlers['account-unlink'] = mutator(async function({ id }) {
let { bank: bankId } = await db.first(
'SELECT bank FROM accounts WHERE id = ?',
[id]
);
let {
bank: bankId
} = await db.first('SELECT bank FROM accounts WHERE id = ?', [id]);
if (!bankId) {
return 'ok';
@ -1154,10 +1158,11 @@ handlers['account-unlink'] = mutator(async function({ id }) {
balance_limit: null
});
let { count } = await db.first(
'SELECT COUNT(*) as count FROM accounts WHERE bank = ?',
[bankId]
);
let {
count
} = await db.first('SELECT COUNT(*) as count FROM accounts WHERE bank = ?', [
bankId
]);
if (count === 0) {
// No more accounts are associated with this bank. We can remove
@ -1547,7 +1552,8 @@ handlers['get-version'] = async function() {
handlers['get-budgets'] = async function() {
const paths = await fs.listDir(fs.getDocumentDir());
const budgets = (await Promise.all(
const budgets = (
await Promise.all(
paths.map(async name => {
const prefsPath = fs.join(fs.getDocumentDir(), name, 'metadata.json');
if (await fs.exists(prefsPath)) {
@ -1575,7 +1581,8 @@ handlers['get-budgets'] = async function() {
return null;
})
)).filter(x => x);
)
).filter(x => x);
return budgets;
};

2
packages/loot-core/src/server/polyfills.mobile.js
View file

@ -1,2 +1,2 @@
// Mobile needs this
import 'core-js/modules/es.object.from-entries'
import 'core-js/modules/es.object.from-entries';

35
packages/loot-core/src/server/schedules/app.test.js
View file

@ -73,7 +73,10 @@ describe('schedule app', () => {
value: {
start: '2020-12-20',
frequency: 'monthly',
patterns: [{ type: 'day', value: 15 }, { type: 'day', value: 30 }]
patterns: [
{ type: 'day', value: 15 },
{ type: 'day', value: 30 }
]
}
})
).toBe('2021-05-30');
@ -90,7 +93,10 @@ describe('schedule app', () => {
value: {
start: '2020-12-20',
frequency: 'monthly',
patterns: [{ type: 'day', value: 15 }, { type: 'day', value: 30 }]
patterns: [
{ type: 'day', value: 15 },
{ type: 'day', value: 30 }
]
}
}
]
@ -125,7 +131,10 @@ describe('schedule app', () => {
value: {
start: '2020-12-20',
frequency: 'monthly',
patterns: [{ type: 'day', value: 15 }, { type: 'day', value: 30 }]
patterns: [
{ type: 'day', value: 15 },
{ type: 'day', value: 30 }
]
}
}
]
@ -152,7 +161,10 @@ describe('schedule app', () => {
value: {
start: '2020-12-20',
frequency: 'monthly',
patterns: [{ type: 'day', value: 18 }, { type: 'day', value: 29 }]
patterns: [
{ type: 'day', value: 18 },
{ type: 'day', value: 29 }
]
}
}
]
@ -179,7 +191,10 @@ describe('schedule app', () => {
value: {
start: '2020-12-20',
frequency: 'monthly',
patterns: [{ type: 'day', value: 15 }, { type: 'day', value: 30 }]
patterns: [
{ type: 'day', value: 15 },
{ type: 'day', value: 30 }
]
}
}
]
@ -202,7 +217,10 @@ describe('schedule app', () => {
value: {
start: '2020-12-20',
frequency: 'monthly',
patterns: [{ type: 'day', value: 15 }, { type: 'day', value: 30 }]
patterns: [
{ type: 'day', value: 15 },
{ type: 'day', value: 30 }
]
}
}
]
@ -224,7 +242,10 @@ describe('schedule app', () => {
value: {
start: '2020-12-20',
frequency: 'monthly',
patterns: [{ type: 'day', value: 18 }, { type: 'day', value: 28 }]
patterns: [
{ type: 'day', value: 18 },
{ type: 'day', value: 28 }
]
}
}
]

10
packages/loot-core/src/server/schedules/find-schedules.js
View file

@ -219,7 +219,10 @@ async function monthly1stor3rd(startDate, accountId) {
return {
start,
frequency: 'monthly',
patterns: [{ type: dayValue, value: 1 }, { type: dayValue, value: 3 }]
patterns: [
{ type: dayValue, value: 1 },
{ type: dayValue, value: 3 }
]
};
},
accountId
@ -237,7 +240,10 @@ async function monthly2ndor4th(startDate, accountId) {
return {
start,
frequency: 'monthly',
patterns: [{ type: dayValue, value: 2 }, { type: dayValue, value: 4 }]
patterns: [
{ type: dayValue, value: 2 },
{ type: dayValue, value: 4 }
]
};
},
accountId

2
packages/loot-core/src/server/spreadsheet/new/parser.js
View file

@ -363,7 +363,7 @@ function parsePostfix(state, node) {
while ((tok = nextToken(state))) {
if (tok.type === types.TOKEN_LEFT_PAREN) {
pushToken(state, tok);
let args = parseArgs(state)
let args = parseArgs(state);
node = new nodes.FunCall(tok.lineno, tok.colno, node, args);
} else if (tok.type === types.TOKEN_DOT) {
const val = nextToken(state);

4
packages/loot-core/src/server/spreadsheet/new/sqlgen.js
View file

@ -239,9 +239,7 @@ export default function generate(table, where, groupby, select, deps) {
joins.push(meta.sql(lookup.tableId));
} else {
joins.push(
`LEFT JOIN ${meta.table} ${lookup.tableId} ON ${
lookup.tableId
}.id = ${currentTable.id}.${lookup.field}`
`LEFT JOIN ${meta.table} ${lookup.tableId} ON ${lookup.tableId}.id = ${currentTable.id}.${lookup.field}`
);
}

5
packages/loot-core/src/server/spreadsheet/new/vm.js
View file

@ -74,7 +74,10 @@ export default class VM {
call(callee, args) {
const func = this.get(callee);
this.reg1 = func.apply(null, args.map(arg => this.get(arg)));
this.reg1 = func.apply(
null,
args.map(arg => this.get(arg))
);
}
query(sql, calculated) {

10
packages/loot-core/src/server/spreadsheet/tests/data-propagation.js
View file

@ -1,10 +1,8 @@
const expect = require('expect');
const propagate = require('../data-compute/propagate.js');
const expect = require("expect");
const propagate = require("../data-compute/propagate.js");
describe("data propagation", () => {
it("should work", () => {
describe('data propagation', () => {
it('should work', () => {
expect(true).toExist();
});
});

338
packages/loot-core/src/server/spreadsheet/tests/graph.js
View file

@ -1,308 +1,304 @@
// Unit tests for reactive-property.
var assert = require("assert");
var assert = require('assert');
// If using from the NPM package, this line would be
// var Graph = require("graph-data-structure");
var Graph = require("../data-compute/graph-data-structure");
var Graph = require('../data-compute/graph-data-structure');
describe("Graph", function() {
describe("Data structure", function() {
it("Should add nodes and list them.", function (){
describe('Graph', function() {
describe('Data structure', function() {
it('Should add nodes and list them.', function() {
var graph = Graph();
graph.addNode("a");
graph.addNode("b");
graph.addNode('a');
graph.addNode('b');
assert.equal(graph.nodes().length, 2);
assert(contains(graph.nodes(), "a"));
assert(contains(graph.nodes(), "b"));
assert(contains(graph.nodes(), 'a'));
assert(contains(graph.nodes(), 'b'));
});
it("Should chain addNode.", function (){
var graph = Graph().addNode("a").addNode("b");
it('Should chain addNode.', function() {
var graph = Graph()
.addNode('a')
.addNode('b');
assert.equal(graph.nodes().length, 2);
assert(contains(graph.nodes(), "a"));
assert(contains(graph.nodes(), "b"));
assert(contains(graph.nodes(), 'a'));
assert(contains(graph.nodes(), 'b'));
});
it("Should remove nodes.", function (){
it('Should remove nodes.', function() {
var graph = Graph();
graph.addNode("a");
graph.addNode("b");
graph.removeNode("a");
graph.removeNode("b");
graph.addNode('a');
graph.addNode('b');
graph.removeNode('a');
graph.removeNode('b');
assert.equal(graph.nodes().length, 0);
});
it("Should chain removeNode.", function (){
it('Should chain removeNode.', function() {
var graph = Graph()
.addNode("a")
.addNode("b")
.removeNode("a")
.removeNode("b");
.addNode('a')
.addNode('b')
.removeNode('a')
.removeNode('b');
assert.equal(graph.nodes().length, 0);
});
it("Should add edges and query for adjacent nodes.", function (){
it('Should add edges and query for adjacent nodes.', function() {
var graph = Graph();
graph.addNode("a");
graph.addNode("b");
graph.addEdge("a", "b");
assert.equal(graph.adjacent("a").length, 1);
assert.equal(graph.adjacent("a")[0], "b");
graph.addNode('a');
graph.addNode('b');
graph.addEdge('a', 'b');
assert.equal(graph.adjacent('a').length, 1);
assert.equal(graph.adjacent('a')[0], 'b');
});
it("Should implicitly add nodes when edges are added.", function (){
it('Should implicitly add nodes when edges are added.', function() {
var graph = Graph();
graph.addEdge("a", "b");
assert.equal(graph.adjacent("a").length, 1);
assert.equal(graph.adjacent("a")[0], "b");
graph.addEdge('a', 'b');
assert.equal(graph.adjacent('a').length, 1);
assert.equal(graph.adjacent('a')[0], 'b');
assert.equal(graph.nodes().length, 2);
assert(contains(graph.nodes(), "a"));
assert(contains(graph.nodes(), "b"));
assert(contains(graph.nodes(), 'a'));
assert(contains(graph.nodes(), 'b'));
});
it("Should chain addEdge.", function (){
var graph = Graph().addEdge("a", "b");
assert.equal(graph.adjacent("a").length, 1);
assert.equal(graph.adjacent("a")[0], "b");
it('Should chain addEdge.', function() {
var graph = Graph().addEdge('a', 'b');
assert.equal(graph.adjacent('a').length, 1);
assert.equal(graph.adjacent('a')[0], 'b');
});
it("Should remove edges.", function (){
it('Should remove edges.', function() {
var graph = Graph();
graph.addEdge("a", "b");
graph.removeEdge("a", "b");
assert.equal(graph.adjacent("a").length, 0);
graph.addEdge('a', 'b');
graph.removeEdge('a', 'b');
assert.equal(graph.adjacent('a').length, 0);
});
it("Should chain removeEdge.", function (){
it('Should chain removeEdge.', function() {
var graph = Graph()
.addEdge("a", "b")
.removeEdge("a", "b");
assert.equal(graph.adjacent("a").length, 0);
.addEdge('a', 'b')
.removeEdge('a', 'b');
assert.equal(graph.adjacent('a').length, 0);
});
it("Should not remove nodes when edges are removed.", function (){
it('Should not remove nodes when edges are removed.', function() {
var graph = Graph();
graph.addEdge("a", "b");
graph.removeEdge("a", "b");
graph.addEdge('a', 'b');
graph.removeEdge('a', 'b');
assert.equal(graph.nodes().length, 2);
assert(contains(graph.nodes(), "a"));
assert(contains(graph.nodes(), "b"));
assert(contains(graph.nodes(), 'a'));
assert(contains(graph.nodes(), 'b'));
});
it("Should remove outgoing edges when a node is removed.", function (){
it('Should remove outgoing edges when a node is removed.', function() {
var graph = Graph();
graph.addEdge("a", "b");
graph.removeNode("a");
assert.equal(graph.adjacent("a").length, 0);
graph.addEdge('a', 'b');
graph.removeNode('a');
assert.equal(graph.adjacent('a').length, 0);
});
it("Should remove incoming edges when a node is removed.", function (){
it('Should remove incoming edges when a node is removed.', function() {
var graph = Graph();
graph.addEdge("a", "b");
graph.removeNode("b");
assert.equal(graph.adjacent("a").length, 0);
graph.addEdge('a', 'b');
graph.removeNode('b');
assert.equal(graph.adjacent('a').length, 0);
});
it("Should compute indegree.", function (){
it('Should compute indegree.', function() {
var graph = Graph();
graph.addEdge("a", "b");
assert.equal(graph.indegree("a"), 0);
assert.equal(graph.indegree("b"), 1);
graph.addEdge('a', 'b');
assert.equal(graph.indegree('a'), 0);
assert.equal(graph.indegree('b'), 1);
graph.addEdge("c", "b");
assert.equal(graph.indegree("b"), 2);
graph.addEdge('c', 'b');
assert.equal(graph.indegree('b'), 2);
});
it("Should compute outdegree.", function (){
it('Should compute outdegree.', function() {
var graph = Graph();
graph.addEdge("a", "b");
assert.equal(graph.outdegree("a"), 1);
assert.equal(graph.outdegree("b"), 0);
graph.addEdge('a', 'b');
assert.equal(graph.outdegree('a'), 1);
assert.equal(graph.outdegree('b'), 0);
graph.addEdge("a", "c");
assert.equal(graph.outdegree("a"), 2);
graph.addEdge('a', 'c');
assert.equal(graph.outdegree('a'), 2);
});
});
});
describe("Algorithms", function() {
describe('Algorithms', function() {
// This example is from Cormen et al. "Introduction to Algorithms" page 550
it("Should compute topological sort.", function (){
it('Should compute topological sort.', function() {
var graph = Graph();
// Shoes depend on socks.
// Socks need to be put on before shoes.
graph.addEdge("socks", "shoes");
graph.addEdge('socks', 'shoes');
graph.addEdge("shirt", "belt");
graph.addEdge("shirt", "tie");
graph.addEdge("tie", "jacket");
graph.addEdge("belt", "jacket");
graph.addEdge("pants", "shoes");
graph.addEdge("underpants", "pants");
graph.addEdge("pants", "belt");
graph.addEdge('shirt', 'belt');
graph.addEdge('shirt', 'tie');
graph.addEdge('tie', 'jacket');
graph.addEdge('belt', 'jacket');
graph.addEdge('pants', 'shoes');
graph.addEdge('underpants', 'pants');
graph.addEdge('pants', 'belt');
var sorted = graph.topologicalSort();
assert(comesBefore(sorted, "pants", "shoes"));
assert(comesBefore(sorted, "underpants", "pants"));
assert(comesBefore(sorted, "underpants", "shoes"));
assert(comesBefore(sorted, "shirt", "jacket"));
assert(comesBefore(sorted, "shirt", "belt"));
assert(comesBefore(sorted, "belt", "jacket"));
assert(comesBefore(sorted, 'pants', 'shoes'));
assert(comesBefore(sorted, 'underpants', 'pants'));
assert(comesBefore(sorted, 'underpants', 'shoes'));
assert(comesBefore(sorted, 'shirt', 'jacket'));
assert(comesBefore(sorted, 'shirt', 'belt'));
assert(comesBefore(sorted, 'belt', 'jacket'));
assert.equal(sorted.length, 8);
});
it("Should compute topological sort, excluding source nodes.", function (){
it('Should compute topological sort, excluding source nodes.', function() {
var graph = Graph();
graph.addEdge("a", "b");
graph.addEdge("b", "c");
var sorted = graph.topologicalSort(["a"], false);
graph.addEdge('a', 'b');
graph.addEdge('b', 'c');
var sorted = graph.topologicalSort(['a'], false);
assert.equal(sorted.length, 2);
assert.equal(sorted[0], "b");
assert.equal(sorted[1], "c");
assert.equal(sorted[0], 'b');
assert.equal(sorted[1], 'c');
});
it("Should compute topological sort tricky case.", function (){
it('Should compute topological sort tricky case.', function() {
var graph = Graph(); // a
// / \
graph.addEdge("a", "b"); // b |
graph.addEdge("a", "d"); // | d
graph.addEdge("b", "c"); // c |
graph.addEdge("d", "e"); // \ /
graph.addEdge("c", "e"); // e
graph.addEdge('a', 'b'); // b |
graph.addEdge('a', 'd'); // | d
graph.addEdge('b', 'c'); // c |
graph.addEdge('d', 'e'); // \ /
graph.addEdge('c', 'e'); // e
var sorted = graph.topologicalSort(["a"], false);
var sorted = graph.topologicalSort(['a'], false);
assert.equal(sorted.length, 4);
assert(contains(sorted, "b"));
assert(contains(sorted, "c"));
assert(contains(sorted, "d"));
assert.equal(sorted[sorted.length - 1], "e");
assert(comesBefore(sorted, "b", "c"));
assert(comesBefore(sorted, "b", "e"));
assert(comesBefore(sorted, "c", "e"));
assert(comesBefore(sorted, "d", "e"));
assert(contains(sorted, 'b'));
assert(contains(sorted, 'c'));
assert(contains(sorted, 'd'));
assert.equal(sorted[sorted.length - 1], 'e');
assert(comesBefore(sorted, 'b', 'c'));
assert(comesBefore(sorted, 'b', 'e'));
assert(comesBefore(sorted, 'c', 'e'));
assert(comesBefore(sorted, 'd', 'e'));
});
it("Should exclude source nodes with a cycle.", function (){
it('Should exclude source nodes with a cycle.', function() {
var graph = Graph()
.addEdge("a", "b")
.addEdge("b", "c")
.addEdge("c", "a");
var sorted = graph.topologicalSort(["a"], false);
.addEdge('a', 'b')
.addEdge('b', 'c')
.addEdge('c', 'a');
var sorted = graph.topologicalSort(['a'], false);
assert.equal(sorted.length, 2);
assert.equal(sorted[0], "b");
assert.equal(sorted[1], "c");
assert.equal(sorted[0], 'b');
assert.equal(sorted[1], 'c');
});
it("Should exclude source nodes with multiple cycles.", function (){
it('Should exclude source nodes with multiple cycles.', function() {
var graph = Graph()
.addEdge('a', 'b')
.addEdge('b', 'a')
.addEdge("a", "b")
.addEdge("b", "a")
.addEdge('b', 'c')
.addEdge('c', 'b')
.addEdge("b", "c")
.addEdge("c", "b")
.addEdge('a', 'c')
.addEdge('c', 'a');
.addEdge("a", "c")
.addEdge("c", "a");
var sorted = graph.topologicalSort(["a", "b"], false);
assert(!contains(sorted, "b"));
var sorted = graph.topologicalSort(['a', 'b'], false);
assert(!contains(sorted, 'b'));
});
});
describe("Edge cases and error handling", function() {
it("Should return empty array of adjacent nodes for unknown nodes.", function (){
describe('Edge cases and error handling', function() {
it('Should return empty array of adjacent nodes for unknown nodes.', function() {
var graph = Graph();
assert.equal(graph.adjacent("a").length, 0);
assert.equal(graph.adjacent('a').length, 0);
assert.equal(graph.nodes(), 0);
});
it("Should do nothing if removing an edge that does not exist.", function (){
assert.doesNotThrow(function (){
it('Should do nothing if removing an edge that does not exist.', function() {
assert.doesNotThrow(function() {
var graph = Graph();
graph.removeEdge("a", "b");
graph.removeEdge('a', 'b');
});
});
it("Should return indegree of 0 for unknown nodes.", function (){
it('Should return indegree of 0 for unknown nodes.', function() {
var graph = Graph();
assert.equal(graph.indegree("z"), 0);
assert.equal(graph.indegree('z'), 0);
});
it("Should return outdegree of 0 for unknown nodes.", function (){
it('Should return outdegree of 0 for unknown nodes.', function() {
var graph = Graph();
assert.equal(graph.outdegree("z"), 0);
assert.equal(graph.outdegree('z'), 0);
});
});
});
describe("Serialization", function() {
describe('Serialization', function() {
var serialized;
function checkSerialized(graph){
function checkSerialized(graph) {
assert.equal(graph.nodes.length, 3);
assert.equal(graph.links.length, 2);
assert.equal(graph.nodes[0].id, "a");
assert.equal(graph.nodes[1].id, "b");
assert.equal(graph.nodes[2].id, "c");
assert.equal(graph.nodes[0].id, 'a');
assert.equal(graph.nodes[1].id, 'b');
assert.equal(graph.nodes[2].id, 'c');
assert.equal(graph.links[0].source, "a");
assert.equal(graph.links[0].target, "b");
assert.equal(graph.links[1].source, "b");
assert.equal(graph.links[1].target, "c");
assert.equal(graph.links[0].source, 'a');
assert.equal(graph.links[0].target, 'b');
assert.equal(graph.links[1].source, 'b');
assert.equal(graph.links[1].target, 'c');
}
it("Should serialize a graph.", function (){
it('Should serialize a graph.', function() {
var graph = Graph()
.addEdge("a", "b")
.addEdge("b", "c");
.addEdge('a', 'b')
.addEdge('b', 'c');
serialized = graph.serialize();
checkSerialized(serialized);
});
it("Should deserialize a graph.", function (){
it('Should deserialize a graph.', function() {
var graph = Graph();
graph.deserialize(serialized);
checkSerialized(graph.serialize());
});
it("Should chain deserialize a graph.", function (){
it('Should chain deserialize a graph.', function() {
var graph = Graph().deserialize(serialized);
checkSerialized(graph.serialize());
});
it("Should deserialize a graph passed to constructor.", function (){
it('Should deserialize a graph passed to constructor.', function() {
var graph = Graph(serialized);
checkSerialized(graph.serialize());
});
});
});
function contains(arr, item){
return arr.filter(function (d){
function contains(arr, item) {
return (
arr.filter(function(d) {
return d === item;
}).length > 0;
}).length > 0
);
}
function comesBefore(arr, a, b){
function comesBefore(arr, a, b) {
var aIndex, bIndex;
arr.forEach(function (d, i){
if(d === a){ aIndex = i; }
if(d === b){ bIndex = i; }
arr.forEach(function(d, i) {
if (d === a) {
aIndex = i;
}
if (d === b) {
bIndex = i;
}
});
return aIndex < bIndex;
}

33
packages/loot-core/src/server/spreadsheet/usage.js
View file

@ -1,12 +1,12 @@
const sqlite = require("sqlite3");
const escodegen = require("escodegen");
const sqlgen = require("./sqlgen");
const sqlite = require('sqlite3');
const escodegen = require('escodegen');
const sqlgen = require('./sqlgen');
// Example usage:
const Spreadsheet = require("./spreadsheet");
const Spreadsheet = require('./spreadsheet');
const db = new sqlite.Database(__dirname + "/../../db.sqlite");
const db = new sqlite.Database(__dirname + '/../../db.sqlite');
const sheet = new Spreadsheet({
plugins: {
runQuery: {
@ -20,22 +20,24 @@ const sheet = new Spreadsheet({
return {
data: {
type: "query",
type: 'query',
query: query,
sql: sql
},
ast: {
type: "CallExpression",
type: 'CallExpression',
callee: {
type: "Identifier",
name: "runQuery"
type: 'Identifier',
name: 'runQuery'
},
arguments: [{
type: "Literal",
arguments: [
{
type: 'Literal',
raw: sql,
value: sql
}]
}
]
}
};
},
@ -43,7 +45,7 @@ const sheet = new Spreadsheet({
return new Promise(resolve => {
const start = Date.now();
db.all(sql, function(err, rows) {
if(err) {
if (err) {
throw new Error(err);
}
resolve(rows);
@ -54,11 +56,12 @@ const sheet = new Spreadsheet({
}
});
db.on("preupdate", function(type, dbname, table, old, _new, oldId, newId) {
db.on('preupdate', function(type, dbname, table, old, _new, oldId, newId) {
sheet.resolve().then(() => {
const start = Date.now();
sheet.startTransaction();
sheet.getNodesOfType("query")
sheet
.getNodesOfType('query')
.filter(node => node.data.query.table === table)
.forEach(q => {
sheet.signal(q.name);

12
packages/loot-core/src/server/sync/sync.property.test.js
View file

@ -9,9 +9,10 @@ const Database = require('better-sqlite3');
const fs = require('fs');
const jsc = require('jsverify');
const uuid = require('uuid');
const uuidGenerator = jsc
.integer(97, 122)
.smap(x => String.fromCharCode(x), x => x.charCodeAt(x));
const uuidGenerator = jsc.integer(97, 122).smap(
x => String.fromCharCode(x),
x => x.charCodeAt(x)
);
const mockSyncServer = require('../tests/mockSyncServer');
@ -129,7 +130,10 @@ Object.keys(schema).forEach(table => {
generators.push(
makeGen({
table,
row: jsc.asciinestring.smap(x => 'sheet!' + x, x => x),
row: jsc.asciinestring.smap(
x => 'sheet!' + x,
x => x
),
field: 'expr',
value: jsc.constant(JSON.stringify('fooooo'))
})

7
packages/loot-core/src/server/sync/sync.test.js
View file

@ -3,12 +3,7 @@ import * as db from '../db';
import * as sheet from '../sheet';
import Timestamp, { getClock } from '../timestamp';
import { resolveName } from '../spreadsheet/util';
import {
setSyncingMode,
sendMessages,
applyMessages,
fullSync
} from './index';
import { setSyncingMode, sendMessages, applyMessages, fullSync } from './index';
import * as encoder from './encoder';
const mockSyncServer = require('../tests/mockSyncServer');

6
packages/loot-core/src/server/tracking/events.js
View file

@ -26,11 +26,9 @@ function isAnonymous(id) {
return !id.startsWith('user-');
}
export async function init() {
}
export async function init() {}
export async function login(userId) {
}
export async function login(userId) {}
let BUFFERING = false;
let BUFFER = [];