StardewValley
/
jsoneditor
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactored ESON to use Symbols, refactored patchEson

This commit is contained in:
jos 2017-12-15 19:57:21 +01:00
parent 53b20e2f59
commit 156f330e4e
8 changed files with 347 additions and 351 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
src/components/JSONNode.js
View File

@ -8,7 +8,7 @@ import FloatingMenu from './menu/FloatingMenu'
import { escapeHTML, unescapeHTML } from '../utils/stringUtils' import { escapeHTML, unescapeHTML } from '../utils/stringUtils'
import { getInnerText, insideRect, findParentWithAttribute } from '../utils/domUtils' import { getInnerText, insideRect, findParentWithAttribute } from '../utils/domUtils'
import { stringConvert, valueType, isUrl } from '../utils/typeUtils' import { stringConvert, valueType, isUrl } from '../utils/typeUtils'
import { compileJSONPointer, mapEsonArray, SELECTED, SELECTED_END, SELECTED_AFTER, SELECTED_BEFORE } from '../eson' import { compileJSONPointer, META, SELECTED, SELECTED_END, SELECTED_AFTER, SELECTED_BEFORE } from '../eson'
import type { ESONObjectProperty, ESON, SearchResultStatus, Path } from '../types' import type { ESONObjectProperty, ESON, SearchResultStatus, Path } from '../types'
@ -46,10 +46,10 @@ export default class JSONNode extends PureComponent {
} }
render () { render () {
if (this.props.eson._meta.type === 'Object') { if (this.props.eson[META].type === 'Object') {
return this.renderJSONObject(this.props) return this.renderJSONObject(this.props)
} }
else if (this.props.eson._meta.type === 'Array') { else if (this.props.eson[META].type === 'Array') {
return this.renderJSONArray(this.props) return this.renderJSONArray(this.props)
} }
else { // no Object or Array else { // no Object or Array
@ -58,7 +58,7 @@ export default class JSONNode extends PureComponent {
} }
renderJSONObject ({prop, index, eson, options, events}) { renderJSONObject ({prop, index, eson, options, events}) {
const keys = eson._meta.keys const keys = eson[META].keys
const node = h('div', { const node = h('div', {
key: 'node', key: 'node',
onKeyDown: this.handleKeyDown, onKeyDown: this.handleKeyDown,
@ -70,14 +70,14 @@ export default class JSONNode extends PureComponent {
this.renderProperty(prop, index, eson, options), this.renderProperty(prop, index, eson, options),
this.renderReadonly(`{${keys.length}}`, `Array containing ${keys.length} items`), this.renderReadonly(`{${keys.length}}`, `Array containing ${keys.length} items`),
// this.renderFloatingMenuButton(), // this.renderFloatingMenuButton(),
this.renderError(eson._meta.error) this.renderError(eson[META].error)
]) ])
let childs let childs
if (eson._meta.expanded) { if (eson[META].expanded) {
if (keys.length > 0) { if (keys.length > 0) {
const props = keys.map(key => h(this.constructor, { const props = keys.map(key => h(this.constructor, {
key: eson[key]._meta.id, key: eson[key][META].id,
// parent: this, // parent: this,
prop: key, prop: key,
eson: eson[key], eson: eson[key],
@ -94,7 +94,7 @@ export default class JSONNode extends PureComponent {
} }
} }
const floatingMenu = (eson._meta.selected === SELECTED_END) const floatingMenu = (eson[META].selected === SELECTED_END)
? this.renderFloatingMenu([ ? this.renderFloatingMenu([
{type: 'sort'}, {type: 'sort'},
{type: 'duplicate'}, {type: 'duplicate'},
@ -108,8 +108,8 @@ export default class JSONNode extends PureComponent {
const insertArea = this.renderInsertBeforeArea() const insertArea = this.renderInsertBeforeArea()
return h('div', { return h('div', {
'data-path': compileJSONPointer(this.props.eson._meta.path), 'data-path': compileJSONPointer(this.props.eson[META].path),
className: this.getContainerClassName(eson._meta.selected, this.state.hover), className: this.getContainerClassName(eson[META].selected, this.state.hover),
onMouseOver: this.handleMouseOver, onMouseOver: this.handleMouseOver,
onMouseLeave: this.handleMouseLeave onMouseLeave: this.handleMouseLeave
}, [node, floatingMenu, insertArea, childs]) }, [node, floatingMenu, insertArea, childs])
@ -125,16 +125,16 @@ export default class JSONNode extends PureComponent {
// this.renderActionMenu('update', this.state.menu, this.handleCloseActionMenu), // this.renderActionMenu('update', this.state.menu, this.handleCloseActionMenu),
// this.renderActionMenuButton(), // this.renderActionMenuButton(),
this.renderProperty(prop, index, eson, options), this.renderProperty(prop, index, eson, options),
this.renderReadonly(`[${eson._meta.length}]`, `Array containing ${eson._meta.length} items`), this.renderReadonly(`[${eson.length}]`, `Array containing ${eson.length} items`),
// this.renderFloatingMenuButton(), // this.renderFloatingMenuButton(),
this.renderError(eson._meta.error) this.renderError(eson[META].error)
]) ])
let childs let childs
if (eson._meta.expanded) { if (eson[META].expanded) {
if (eson._meta.length > 0) { if (eson.length > 0) {
const items = mapEsonArray(eson, (item, index) => h(this.constructor, { const items = eson.map((item, index) => h(this.constructor, {
key : item._meta.id, key : item[META].id,
// parent: this, // parent: this,
index, index,
eson: item, eson: item,
@ -151,7 +151,7 @@ export default class JSONNode extends PureComponent {
} }
} }
const floatingMenu = (eson._meta.selected === SELECTED_END) const floatingMenu = (eson[META].selected === SELECTED_END)
? this.renderFloatingMenu([ ? this.renderFloatingMenu([
{type: 'sort'}, {type: 'sort'},
{type: 'duplicate'}, {type: 'duplicate'},
@ -165,8 +165,8 @@ export default class JSONNode extends PureComponent {
const insertArea = this.renderInsertBeforeArea() const insertArea = this.renderInsertBeforeArea()
return h('div', { return h('div', {
'data-path': compileJSONPointer(this.props.eson._meta.path), 'data-path': compileJSONPointer(this.props.eson[META].path),
className: this.getContainerClassName(eson._meta.selected, this.state.hover), className: this.getContainerClassName(eson[META].selected, this.state.hover),
onMouseOver: this.handleMouseOver, onMouseOver: this.handleMouseOver,
onMouseLeave: this.handleMouseLeave onMouseLeave: this.handleMouseLeave
}, [node, floatingMenu, insertArea, childs]) }, [node, floatingMenu, insertArea, childs])
@ -183,12 +183,12 @@ export default class JSONNode extends PureComponent {
// this.renderActionMenuButton(), // this.renderActionMenuButton(),
this.renderProperty(prop, index, eson, options), this.renderProperty(prop, index, eson, options),
this.renderSeparator(), this.renderSeparator(),
this.renderValue(eson._meta.value, eson._meta.searchValue, options), this.renderValue(eson[META].value, eson[META].searchValue, options),
// this.renderFloatingMenuButton(), // this.renderFloatingMenuButton(),
this.renderError(eson._meta.error) this.renderError(eson[META].error)
]) ])
const floatingMenu = (eson._meta.selected === SELECTED_END) const floatingMenu = (eson[META].selected === SELECTED_END)
? this.renderFloatingMenu([ ? this.renderFloatingMenu([
// {text: 'String', onClick: this.props.events.onChangeType, type: 'checkbox', checked: false}, // {text: 'String', onClick: this.props.events.onChangeType, type: 'checkbox', checked: false},
{type: 'duplicate'}, {type: 'duplicate'},
@ -202,15 +202,15 @@ export default class JSONNode extends PureComponent {
const insertArea = this.renderInsertBeforeArea() const insertArea = this.renderInsertBeforeArea()
return h('div', { return h('div', {
'data-path': compileJSONPointer(this.props.eson._meta.path), 'data-path': compileJSONPointer(this.props.eson[META].path),
className: this.getContainerClassName(eson._meta.selected, this.state.hover), className: this.getContainerClassName(eson[META].selected, this.state.hover),
onMouseOver: this.handleMouseOver, onMouseOver: this.handleMouseOver,
onMouseLeave: this.handleMouseLeave onMouseLeave: this.handleMouseLeave
}, [node, floatingMenu, insertArea]) }, [node, floatingMenu, insertArea])
} }
renderInsertBeforeArea () { renderInsertBeforeArea () {
const floatingMenu = (this.props.eson._meta.selected === SELECTED_BEFORE) const floatingMenu = (this.props.eson[META].selected === SELECTED_BEFORE)
? this.renderFloatingMenu([ ? this.renderFloatingMenu([
{type: 'insertStructure'}, {type: 'insertStructure'},
{type: 'insertValue'}, {type: 'insertValue'},
@ -234,7 +234,7 @@ export default class JSONNode extends PureComponent {
*/ */
renderAppend (text) { renderAppend (text) {
return h('div', { return h('div', {
'data-path': compileJSONPointer(this.props.eson._meta.path) + '/-', 'data-path': compileJSONPointer(this.props.eson[META].path) + '/-',
className: 'jsoneditor-node', className: 'jsoneditor-node',
onKeyDown: this.handleKeyDownAppend onKeyDown: this.handleKeyDownAppend
}, [ }, [
@ -269,10 +269,10 @@ export default class JSONNode extends PureComponent {
}, rootName) }, rootName)
} }
const editable = !isIndex && (!options.isPropertyEditable || options.isPropertyEditable(this.props.eson._meta.path)) const editable = !isIndex && (!options.isPropertyEditable || options.isPropertyEditable(this.props.eson[META].path))
const emptyClassName = (prop != null && prop.length === 0) ? ' jsoneditor-empty' : '' const emptyClassName = (prop != null && prop.length === 0) ? ' jsoneditor-empty' : ''
const searchClassName = prop != null ? JSONNode.getSearchResultClass(eson._meta.searchProperty) : '' const searchClassName = prop != null ? JSONNode.getSearchResultClass(eson[META].searchProperty) : ''
const escapedPropName = prop != null ? escapeHTML(prop, options.escapeUnicode) : null const escapedPropName = prop != null ? escapeHTML(prop, options.escapeUnicode) : null
if (editable) { if (editable) {
@ -303,7 +303,7 @@ export default class JSONNode extends PureComponent {
const itsAnUrl = isUrl(value) const itsAnUrl = isUrl(value)
const isEmpty = escapedValue.length === 0 const isEmpty = escapedValue.length === 0
const editable = !options.isValueEditable || options.isValueEditable(this.props.eson._meta.path) const editable = !options.isValueEditable || options.isValueEditable(this.props.eson[META].path)
if (editable) { if (editable) {
return h('div', { return h('div', {
key: 'value', key: 'value',
@ -395,7 +395,7 @@ export default class JSONNode extends PureComponent {
} }
target.className = JSONNode.getValueClass(type, itsAnUrl, isEmpty) + target.className = JSONNode.getValueClass(type, itsAnUrl, isEmpty) +
JSONNode.getSearchResultClass(this.props.eson._meta.searchValue) JSONNode.getSearchResultClass(this.props.eson[META].searchValue)
target.title = itsAnUrl ? JSONNode.URL_TITLE : '' target.title = itsAnUrl ? JSONNode.URL_TITLE : ''
// remove all classNames from childs (needed for IE and Edge) // remove all classNames from childs (needed for IE and Edge)
@ -448,7 +448,7 @@ export default class JSONNode extends PureComponent {
} }
renderExpandButton () { renderExpandButton () {
const className = `jsoneditor-button jsoneditor-${this.props.eson._meta.expanded ? 'expanded' : 'collapsed'}` const className = `jsoneditor-button jsoneditor-${this.props.eson[META].expanded ? 'expanded' : 'collapsed'}`
return h('div', {key: 'expand', className: 'jsoneditor-button-container'}, return h('div', {key: 'expand', className: 'jsoneditor-button-container'},
h('button', { h('button', {
@ -469,9 +469,9 @@ export default class JSONNode extends PureComponent {
return h(ActionMenu, { return h(ActionMenu, {
key: 'menu', key: 'menu',
path: this.props.eson._meta.path, path: this.props.eson[META].path,
events: this.props.events, events: this.props.events,
type: this.props.eson._meta.type, // TODO: fix type type: this.props.eson[META].type, // TODO: fix type
menuType, menuType,
open: true, open: true,
@ -513,7 +513,7 @@ export default class JSONNode extends PureComponent {
renderFloatingMenu (items) { renderFloatingMenu (items) {
return h(FloatingMenu, { return h(FloatingMenu, {
key: 'floating-menu', key: 'floating-menu',
path: this.props.eson._meta.path, path: this.props.eson[META].path,
events: this.props.events, events: this.props.events,
items items
}) })
@ -603,7 +603,7 @@ export default class JSONNode extends PureComponent {
/** @private */ /** @private */
handleChangeProperty = (event) => { handleChangeProperty = (event) => {
const parentPath = initial(this.props.eson._meta.path) const parentPath = initial(this.props.eson[META].path)
const oldProp = this.props.prop.name const oldProp = this.props.prop.name
const newProp = unescapeHTML(getInnerText(event.target)) const newProp = unescapeHTML(getInnerText(event.target))
@ -616,8 +616,8 @@ export default class JSONNode extends PureComponent {
handleChangeValue = (event) => { handleChangeValue = (event) => {
const value = this.getValueFromEvent(event) const value = this.getValueFromEvent(event)
if (value !== this.props.eson._meta.value) { if (value !== this.props.eson[META].value) {
this.props.events.onChangeValue(this.props.eson._meta.path, value) this.props.events.onChangeValue(this.props.eson[META].path, value)
} }
} }
@ -634,24 +634,24 @@ export default class JSONNode extends PureComponent {
if (keyBinding === 'duplicate') { if (keyBinding === 'duplicate') {
event.preventDefault() event.preventDefault()
this.props.events.onDuplicate(this.props.eson._meta.path) this.props.events.onDuplicate(this.props.eson[META].path)
} }
if (keyBinding === 'insert') { if (keyBinding === 'insert') {
event.preventDefault() event.preventDefault()
this.props.events.onInsert(this.props.eson._meta.path, 'value') this.props.events.onInsert(this.props.eson[META].path, 'value')
} }
if (keyBinding === 'remove') { if (keyBinding === 'remove') {
event.preventDefault() event.preventDefault()
this.props.events.onRemove(this.props.eson._meta.path) this.props.events.onRemove(this.props.eson[META].path)
} }
if (keyBinding === 'expand') { if (keyBinding === 'expand') {
event.preventDefault() event.preventDefault()
const recurse = false const recurse = false
const expanded = !this.props.eson._meta.expanded const expanded = !this.props.eson[META].expanded
this.props.events.onExpand(this.props.eson._meta.path, expanded, recurse) this.props.events.onExpand(this.props.eson[META].path, expanded, recurse)
} }
if (keyBinding === 'actionMenu') { if (keyBinding === 'actionMenu') {
@ -666,7 +666,7 @@ export default class JSONNode extends PureComponent {
if (keyBinding === 'insert') { if (keyBinding === 'insert') {
event.preventDefault() event.preventDefault()
this.props.events.onAppend(this.props.eson._meta.path, 'value') this.props.events.onAppend(this.props.eson[META].path, 'value')
} }
if (keyBinding === 'actionMenu') { if (keyBinding === 'actionMenu') {
@ -687,8 +687,8 @@ export default class JSONNode extends PureComponent {
/** @private */ /** @private */
handleExpand = (event) => { handleExpand = (event) => {
const recurse = event.ctrlKey const recurse = event.ctrlKey
const path = this.props.eson._meta.path const path = this.props.eson[META].path
const expanded = !this.props.eson._meta.expanded const expanded = !this.props.eson[META].expanded
this.props.events.onExpand(path, expanded, recurse) this.props.events.onExpand(path, expanded, recurse)
} }
@ -717,7 +717,7 @@ export default class JSONNode extends PureComponent {
*/ */
getValueFromEvent (event) { getValueFromEvent (event) {
const stringValue = unescapeHTML(getInnerText(event.target)) const stringValue = unescapeHTML(getInnerText(event.target))
return this.props.eson._meta.type === 'string' return this.props.eson[META].type === 'string'
? stringValue ? stringValue
: stringConvert(stringValue) : stringConvert(stringValue)
} }

7
src/components/TreeMode.js
View File

@ -12,6 +12,7 @@ import { getIn, setIn, updateIn } from '../utils/immutabilityHelpers'
import { parseJSON } from '../utils/jsonUtils' import { parseJSON } from '../utils/jsonUtils'
import { enrichSchemaError } from '../utils/schemaUtils' import { enrichSchemaError } from '../utils/schemaUtils'
import { import {
META,
jsonToEson, esonToJson, pathExists, jsonToEson, esonToJson, pathExists,
expand, expandOne, expandPath, applyErrors, expand, expandOne, expandPath, applyErrors,
search, nextSearchResult, previousSearchResult, search, nextSearchResult, previousSearchResult,
@ -154,7 +155,7 @@ export default class TreeMode extends Component {
// Apply json // Apply json
if (nextProps.json !== currentProps.json) { if (nextProps.json !== currentProps.json) {
// FIXME: merge _meta from existing eson // FIXME: merge meta data from existing eson
this.setState({ this.setState({
json: nextProps.json, json: nextProps.json,
eson: jsonToEson(nextProps.json) // FIXME: how to handle expand? eson: jsonToEson(nextProps.json) // FIXME: how to handle expand?
@ -222,7 +223,7 @@ export default class TreeMode extends Component {
onMouseDown: this.handleTouchStart, onMouseDown: this.handleTouchStart,
onTouchStart: this.handleTouchStart, onTouchStart: this.handleTouchStart,
className: 'jsoneditor-list jsoneditor-root' + className: 'jsoneditor-list jsoneditor-root' +
(eson._meta.selected ? ' jsoneditor-selected' : '')}, (eson[META].selected ? ' jsoneditor-selected' : '')},
h(Node, { h(Node, {
eson, eson,
events: state.events, events: state.events,
@ -982,7 +983,7 @@ export default class TreeMode extends Component {
* @return {boolean} Returns true when expanded, false otherwise * @return {boolean} Returns true when expanded, false otherwise
*/ */
isExpanded (path) { isExpanded (path) {
return getIn(this.state.eson, path)._meta.expanded return getIn(this.state.eson, path)[META].expanded
} }
/** /**

98
src/eson.js
View File

@ -47,7 +47,7 @@ export function jsonToEson (json, path = []) {
return eson return eson
} }
else if (Array.isArray(json)) { else if (Array.isArray(json)) {
let eson = json.map((value, index) => jsonToEson(value, path.concat(index))) let eson = json.map((value, index) => jsonToEson(value, path.concat(String(index))))
eson[META] = { id, path, type: 'Array' } eson[META] = { id, path, type: 'Array' }
return eson return eson
} }
@ -58,21 +58,6 @@ export function jsonToEson (json, path = []) {
} }
} }
/**
* Map over an eson array
* @param {ESONArray} esonArray
* @param {function (value, index, array)} callback
* @return {Array}
*/
export function mapEsonArray (esonArray, callback) {
const length = esonArray[META].length
let result = []
for (let i = 0; i < length; i++) {
result[i] = callback(esonArray[i], i, esonArray)
}
return result
}
/** /**
* Expand function which will expand all nodes * Expand function which will expand all nodes
* @param {Path} path * @param {Path} path
@ -130,21 +115,21 @@ export function jsonToEsonOld (json, expand = expandAll, path: JSONPath = [], ty
* @return {Object | Array | string | number | boolean | null} json * @return {Object | Array | string | number | boolean | null} json
*/ */
export function esonToJson (eson: ESON) { export function esonToJson (eson: ESON) {
switch (eson.type) { switch (eson[META].type) {
case 'Array': case 'Array':
return eson.items.map(item => esonToJson(item.value)) return eson.map(item => esonToJson(item))
case 'Object': case 'Object':
const object = {} const object = {}
eson.props.forEach(prop => { eson[META].keys.forEach(prop => {
object[prop.name] = esonToJson(prop.value) object[prop] = esonToJson(eson[prop])
}) })
return object return object
default: // type 'string' or 'value' default: // type 'string' or 'value'
return eson.value return eson[META].value
} }
} }
@ -236,13 +221,6 @@ export function setInEson (eson: ESON, jsonPath: JSONPath, value: JSONType) {
return setIn(eson, toEsonPath(eson, jsonPath), value) return setIn(eson, toEsonPath(eson, jsonPath), value)
} }
/**
* Set the value of a nested property in an ESON object using a JSON path
*/
export function updateInEson (eson: ESON, jsonPath: JSONPath, callback) {
return updateIn(eson, toEsonPath(eson, jsonPath), callback)
}
/** /**
* Set the value of a nested property in an ESON object using a JSON path * Set the value of a nested property in an ESON object using a JSON path
*/ */
@ -279,7 +257,7 @@ export function transform (eson, callback, path = []) {
let changed = false let changed = false
let updatedArr = [] let updatedArr = []
for (let i = 0; i < updated.length; i++) { for (let i = 0; i < updated.length; i++) {
updatedArr[i] = transform(updated[i], callback, path.concat(i)) updatedArr[i] = transform(updated[i], callback, path.concat(String(i)))
changed = changed || (updatedArr[i] !== updated[i]) changed = changed || (updatedArr[i] !== updated[i])
} }
updatedArr[META] = updated[META] updatedArr[META] = updated[META]
@ -290,6 +268,26 @@ export function transform (eson, callback, path = []) {
} }
} }
/**
* Recursively update all paths in an eson object, array or value
* @param {ESON} eson
* @param {Path} [path]
* @return {ESON}
*/
export function updatePaths(eson, path = []) {
return transform(eson, function (value, path) {
if (!isEqual(value[META].path, path)) {
// TODO: extend setIn to support symbols
let updatedValue = cloneWithSymbols(value)
updatedValue[META] = setIn(value[META], ['path'], path)
return updatedValue
}
else {
return value
}
}, path)
}
/** /**
* Expand or collapse all items matching a filter callback * Expand or collapse all items matching a filter callback
* @param {ESON} eson * @param {ESON} eson
@ -550,7 +548,7 @@ export function applySelection (eson, selection) {
const maxIndex = Math.max(startIndex, endIndex) + 1 // include max index itself const maxIndex = Math.max(startIndex, endIndex) + 1 // include max index itself
const selectedIndices = range(minIndex, maxIndex) const selectedIndices = range(minIndex, maxIndex)
selectedPaths = selectedIndices.map(index => rootPath.concat(index)) selectedPaths = selectedIndices.map(index => rootPath.concat(String(index)))
let updatedArr = root.slice() let updatedArr = root.slice()
updatedArr = cloneWithSymbols(root) updatedArr = cloneWithSymbols(root)
@ -752,11 +750,11 @@ function recurseTraverse (value: ESON, path: JSONPath, root: ESON, callback: Rec
/** /**
* Test whether a path exists in the eson object * Test whether a path exists in the eson object
* @param {ESON} eson * @param {ESON} eson
* @param {JSONPath} path * @param {Path} path
* @return {boolean} Returns true if the path exists, else returns false * @return {boolean} Returns true if the path exists, else returns false
* @private * @private
*/ */
export function pathExists (eson: ESON, path: JSONPath) { export function pathExists (eson, path) {
if (eson === undefined) { if (eson === undefined) {
return false return false
} }
@ -765,19 +763,13 @@ export function pathExists (eson: ESON, path: JSONPath) {
return true return true
} }
if (eson.type === 'Array') { if (Array.isArray(eson)) {
// index of an array // index of an array
const index = path[0] return pathExists(eson[parseInt(path[0])], path.slice(1))
const item = eson.items[parseInt(index)]
return pathExists(item && item.value, path.slice(1))
} }
else { // eson.type === 'Object' else { // eson.type === 'Object'
// object property. find the index of this property // object property. find the index of this property
const index = findPropertyIndex(eson, path[0]) return pathExists(eson[path[0]], path.slice(1))
const prop = eson.props[index]
return pathExists(prop && prop.value, path.slice(1))
} }
} }
@ -790,15 +782,12 @@ export function pathExists (eson: ESON, path: JSONPath) {
*/ */
export function resolvePathIndex (eson, path) { export function resolvePathIndex (eson, path) {
if (path[path.length - 1] === '-') { if (path[path.length - 1] === '-') {
const parentPath = path.slice(0, path.length - 1) const parentPath = initial(path)
const parent = getInEson(eson, parentPath) const parent = getIn(eson, parentPath)
if (parent.type === 'Array') { if (Array.isArray(parent)) {
const index = parent.items.length const index = parent.length
const resolvedPath = path.slice(0) return parentPath.concat(String(index))
resolvedPath[resolvedPath.length - 1] = index
return resolvedPath
} }
} }
@ -812,14 +801,9 @@ export function resolvePathIndex (eson, path) {
* @return {string | null} Returns the name of the next property, * @return {string | null} Returns the name of the next property,
* or null if there is none * or null if there is none
*/ */
export function findNextProp (parent: ESONObject, prop: string) : string | null { export function findNextProp (parent, prop) {
const index = findPropertyIndex(parent, prop) const index = parent[META].keys.indexOf(prop)
if (index === -1) { return parent[META].keys[index + 1] || null
return null
}
const next = parent.props[index + 1]
return next && next.name || null
} }
/** /**

133
src/patchEson.js
View File

@ -3,12 +3,15 @@ import initial from 'lodash/initial'
import last from 'lodash/last' import last from 'lodash/last'
import type { ESON, Path, ESONPatch } from './types' import type { ESON, Path, ESONPatch } from './types'
import { setIn, updateIn, getIn, insertAt } from './utils/immutabilityHelpers'
import { import {
jsonToEson, jsonToEsonOld, esonToJson, toEsonPath, setIn, updateIn, getIn, deleteIn, insertAt,
getInEson, setInEson, deleteInEson, cloneWithSymbols
} from './utils/immutabilityHelpers'
import {
META,
jsonToEson, esonToJson, updatePaths,
parseJSONPointer, compileJSONPointer, parseJSONPointer, compileJSONPointer,
expandAll, pathExists, resolvePathIndex, findPropertyIndex, findNextProp, createId expandAll, pathExists, resolvePathIndex, createId
} from './eson' } from './eson'
/** /**
@ -19,7 +22,7 @@ import {
* what nodes must be expanded * what nodes must be expanded
* @return {{data: ESON, revert: Object[], error: Error | null}} * @return {{data: ESON, revert: Object[], error: Error | null}}
*/ */
export function patchEson (eson: ESON, patch: ESONPatch, expand = expandAll) { export function patchEson (eson, patch, expand = expandAll) {
let updatedEson = eson let updatedEson = eson
let revert = [] let revert = []
@ -32,7 +35,9 @@ export function patchEson (eson: ESON, patch: ESONPatch, expand = expandAll) {
switch (action.op) { switch (action.op) {
case 'add': { case 'add': {
const path = parseJSONPointer(action.path) const path = parseJSONPointer(action.path)
const newValue = jsonToEsonOld(action.value, expand, path, options && options.type) const newValue = jsonToEson(action.value, path)
// FIXME: apply expanded state
// FIXME: apply options.type
const result = add(updatedEson, action.path, newValue, options) const result = add(updatedEson, action.path, newValue, options)
updatedEson = result.data updatedEson = result.data
revert = result.revert.concat(revert) revert = result.revert.concat(revert)
@ -50,7 +55,9 @@ export function patchEson (eson: ESON, patch: ESONPatch, expand = expandAll) {
case 'replace': { case 'replace': {
const path = parseJSONPointer(action.path) const path = parseJSONPointer(action.path)
const newValue = jsonToEsonOld(action.value, expand, path, options && options.type) const newValue = jsonToEson(action.value, path)
// FIXME: apply expanded state
// FIXME: apply options.type
const result = replace(updatedEson, path, newValue) const result = replace(updatedEson, path, newValue)
updatedEson = result.data updatedEson = result.data
revert = result.revert.concat(revert) revert = result.revert.concat(revert)
@ -125,17 +132,17 @@ export function patchEson (eson: ESON, patch: ESONPatch, expand = expandAll) {
* @param {ESON} value * @param {ESON} value
* @return {{data: ESON, revert: ESONPatch}} * @return {{data: ESON, revert: ESONPatch}}
*/ */
export function replace (data: ESON, path: Path, value: ESON) { export function replace (data, path, value) {
const oldValue = getInEson(data, path) const oldValue = getIn(data, path)
return { return {
data: setInEson(data, path, value), data: setIn(data, path, value),
revert: [{ revert: [{
op: 'replace', op: 'replace',
path: compileJSONPointer(path), path: compileJSONPointer(path),
value: esonToJson(oldValue), value: esonToJson(oldValue),
jsoneditor: { jsoneditor: {
type: oldValue.type type: oldValue[META].type
} }
}] }]
} }
@ -148,40 +155,45 @@ export function replace (data: ESON, path: Path, value: ESON) {
* @return {{data: ESON, revert: ESONPatch}} * @return {{data: ESON, revert: ESONPatch}}
*/ */
// FIXME: path should be a path instead of a string? (all functions in patchEson) // FIXME: path should be a path instead of a string? (all functions in patchEson)
export function remove (data: ESON, path: string) { export function remove (data, path) {
// console.log('remove', path) // console.log('remove', path)
const pathArray = parseJSONPointer(path) const pathArray = parseJSONPointer(path)
const parentPath = initial(pathArray) const parentPath = initial(pathArray)
const parent = getInEson(data, parentPath) const parent = getIn(data, parentPath)
const dataValue = getInEson(data, pathArray) const dataValue = getIn(data, pathArray)
const value = esonToJson(dataValue) const value = esonToJson(dataValue)
if (parent.type === 'Array') { if (parent[META].type === 'Array') {
return { return {
data: deleteInEson(data, pathArray), data: updatePaths(deleteIn(data, pathArray)),
revert: [{ revert: [{
op: 'add', op: 'add',
path, path,
value, value,
jsoneditor: { jsoneditor: {
type: dataValue.type type: dataValue[META].type
} }
}] }]
} }
} }
else { // object.type === 'Object' else { // object.type === 'Object'
const prop = last(pathArray) const prop = last(pathArray)
const index = parent[META].keys.indexOf(prop)
const nextProp = parent[META].keys[index + 1] || null
let updatedParent = deleteIn(parent, [prop])
updatedParent[META] = deleteIn(parent[META], ['keys', index], parent[META].keys)
return { return {
data: deleteInEson(data, pathArray), data: setIn(data, parentPath, updatePaths(updatedParent, parentPath)),
revert: [{ revert: [{
op: 'add', op: 'add',
path, path,
value, value,
jsoneditor: { jsoneditor: {
type: dataValue.type, type: dataValue[META].type,
before: findNextProp(parent, prop) before: nextProp
} }
}] }]
} }
@ -193,47 +205,55 @@ export function remove (data: ESON, path: string) {
* @param {string} path * @param {string} path
* @param {ESON} value * @param {ESON} value
* @param {{before?: string}} [options] * @param {{before?: string}} [options]
* @param {number} [id] Optional id for the new item
* @return {{data: ESON, revert: ESONPatch}} * @return {{data: ESON, revert: ESONPatch}}
* @private * @private
*/ */
export function add (data: ESON, path: string, value: ESON, options, id = createId()) { // TODO: refactor path to an array with strings
export function add (data, path, value, options) {
// FIXME: apply id to new created values
const pathArray = parseJSONPointer(path) const pathArray = parseJSONPointer(path)
const parentPath = pathArray.slice(0, pathArray.length - 1) const parentPath = initial(pathArray)
const esonPath = toEsonPath(data, parentPath) const parent = getIn(data, parentPath)
const parent = getIn(data, esonPath)
const resolvedPath = resolvePathIndex(data, pathArray) const resolvedPath = resolvePathIndex(data, pathArray)
const prop = resolvedPath[resolvedPath.length - 1] const prop = last(resolvedPath)
let updatedEson let updatedEson
if (parent.type === 'Array') { if (parent[META].type === 'Array') {
const newItem = { updatedEson = updatePaths(insertAt(data, resolvedPath, value))
id, // TODO: create a unique id within current id's instead of using a global, ever incrementing id
value
}
updatedEson = insertAt(data, esonPath.concat('items', prop), newItem)
} }
else { // parent.type === 'Object' else { // parent.type === 'Object'
updatedEson = updateIn(data, esonPath, (object) => { updatedEson = updateIn(data, parentPath, (parent) => {
const existingIndex = findPropertyIndex(object, prop) const oldValue = getIn(data, pathArray)
const props = parent[META].keys
const existingIndex = props.indexOf(prop)
if (existingIndex !== -1) { if (existingIndex !== -1) {
// replace existing item // replace existing item
return setIn(object, ['props', existingIndex, 'value'], value) // update path
// FIXME: also update value's id
let newValue = updatePaths(cloneWithSymbols(value), pathArray)
newValue[META] = setIn(newValue[META], ['id'], oldValue[META].id)
// console.log('copied id from existing value' + oldValue[META].id)
// TODO: update paths of existing value
return setIn(parent, [prop], newValue)
} }
else { else {
// insert new item // insert new item
const newProp = { id, name: prop, value }
const index = (options && typeof options.before === 'string') const index = (options && typeof options.before === 'string')
? findPropertyIndex(object, options.before) // insert before ? props.indexOf(options.before) // insert before
: object.props.length // append : props.length // append
return insertAt(object, ['props', index], newProp) let updatedKeys = props.slice()
updatedKeys.splice(index, 0, prop)
const updatedParent = setIn(parent, [prop], updatePaths(value, parentPath.concat(prop)))
return setIn(updatedParent, [META, 'keys'], updatedKeys)
} }
}) })
} }
if (parent.type === 'Object' && pathExists(data, resolvedPath)) { if (parent[META].type === 'Object' && pathExists(data, resolvedPath)) {
const oldValue = getInEson(data, resolvedPath) const oldValue = getIn(data, resolvedPath)
return { return {
data: updatedEson, data: updatedEson,
@ -241,7 +261,7 @@ export function add (data: ESON, path: string, value: ESON, options, id = create
op: 'replace', op: 'replace',
path: compileJSONPointer(resolvedPath), path: compileJSONPointer(resolvedPath),
value: esonToJson(oldValue), value: esonToJson(oldValue),
jsoneditor: { type: oldValue.type } jsoneditor: { type: oldValue[META].type }
}] }]
} }
} }
@ -265,10 +285,14 @@ export function add (data: ESON, path: string, value: ESON, options, id = create
* @return {{data: ESON, revert: ESONPatch}} * @return {{data: ESON, revert: ESONPatch}}
* @private * @private
*/ */
export function copy (data: ESON, path: string, from: string, options) { export function copy (data, path, from, options) {
const value = getInEson(data, parseJSONPointer(from)) const value = getIn(data, parseJSONPointer(from))
return add(data, path, value, options) // create new id for the copied item
let updatedValue = cloneWithSymbols(value)
updatedValue[META] = setIn(updatedValue[META], ['id'], createId())
return add(data, path, updatedValue, options)
} }
/** /**
@ -280,22 +304,19 @@ export function copy (data: ESON, path: string, from: string, options) {
* @return {{data: ESON, revert: ESONPatch}} * @return {{data: ESON, revert: ESONPatch}}
* @private * @private
*/ */
export function move (data: ESON, path: string, from: string, options) { export function move (data, path, from, options) {
const fromArray = parseJSONPointer(from) const fromArray = parseJSONPointer(from)
const prop = getIn(data, initial(toEsonPath(data, fromArray))) const dataValue = getIn(data, fromArray)
const dataValue = prop.value
const id = prop.id // we want to use the existing id in case the move is a renaming a property
// FIXME: only reuse the existing id when move is renaming a property in the same object
const parentPathFrom = initial(fromArray) const parentPathFrom = initial(fromArray)
const parent = getInEson(data, parentPathFrom) const parent = getIn(data, parentPathFrom)
const result1 = remove(data, from) const result1 = remove(data, from)
const result2 = add(result1.data, path, dataValue, options, id) const result2 = add(result1.data, path, dataValue, options)
// FIXME: passing id as parameter is ugly, make that redundant (use replace instead of remove/add? (that would give less predictive output :( )) // FIXME: passing id as parameter is ugly, make that redundant (use replace instead of remove/add? (that would give less predictive output :( ))
const before = result1.revert[0].jsoneditor.before const before = result1.revert[0].jsoneditor.before
const beforeNeeded = (parent.type === 'Object' && before) const beforeNeeded = (parent[META].type === 'Object' && before)
if (result2.revert[0].op === 'replace') { if (result2.revert[0].op === 'replace') {
const value = result2.revert[0].value const value = result2.revert[0].value
@ -314,7 +335,7 @@ export function move (data: ESON, path: string, from: string, options) {
return { return {
data: result2.data, data: result2.data,
revert: beforeNeeded revert: beforeNeeded
? [{ op: 'move', from: path, path: from, jsoneditor: {before} }] ? [{ op: 'move', from: path, path: from, jsoneditor: { before } }]
: [{ op: 'move', from: path, path: from }] : [{ op: 'move', from: path, path: from }]
} }
} }
@ -328,7 +349,7 @@ export function move (data: ESON, path: string, from: string, options) {
* @param {*} value * @param {*} value
* @return {null | Error} Returns an error when the tests, returns null otherwise * @return {null | Error} Returns an error when the tests, returns null otherwise
*/ */
export function test (data: ESON, path: string, value: any) { export function test (data, path, value) {
if (value === undefined) { if (value === undefined) {
return new Error('Test failed, no value provided') return new Error('Test failed, no value provided')
} }
@ -338,7 +359,7 @@ export function test (data: ESON, path: string, value: any) {
return new Error('Test failed, path not found') return new Error('Test failed, path not found')
} }
const actualValue = getInEson(data, pathArray) const actualValue = getIn(data, pathArray)
if (!isEqual(esonToJson(actualValue), value)) { if (!isEqual(esonToJson(actualValue), value)) {
return new Error('Test failed, value differs') return new Error('Test failed, value differs')
} }

4
src/utils/immutabilityHelpers.js
View File

@ -125,6 +125,7 @@ export function updateIn (object, path, callback) {
const key = path[0] const key = path[0]
const updatedValue = updateIn(object[key], path.slice(1), callback) const updatedValue = updateIn(object[key], path.slice(1), callback)
// TODO: create a function applyProp(...) which does the following if/else construct
if (object[key] === updatedValue) { if (object[key] === updatedValue) {
// return original object unchanged when the new value is identical to the old one // return original object unchanged when the new value is identical to the old one
return object return object
@ -206,8 +207,7 @@ export function insertAt (object, path, value) {
throw new TypeError('Array expected at path ' + JSON.stringify(parentPath)) throw new TypeError('Array expected at path ' + JSON.stringify(parentPath))
} }
const updatedItems = items.slice(0) const updatedItems = cloneWithSymbols(items)
updatedItems.splice(index, 0, value) updatedItems.splice(index, 0, value)
return updatedItems return updatedItems

114
test/eson.test.js
View File

@ -12,35 +12,13 @@ import {
SELECTED, SELECTED_END SELECTED, SELECTED_END
} from '../src/eson' } from '../src/eson'
import 'console.table' import 'console.table'
import lodashTransform from 'lodash/transform'
import repeat from 'lodash/repeat' import repeat from 'lodash/repeat'
import { assertDeepEqualEson } from './utils/assertDeepEqualEson'
const JSON1 = loadJSON('./resources/json1.json') const JSON1 = loadJSON('./resources/json1.json')
const ESON1 = loadJSON('./resources/eson1.json') const ESON1 = loadJSON('./resources/eson1.json')
const ESON2 = loadJSON('./resources/eson2.json') const ESON2 = loadJSON('./resources/eson2.json')
test('toEsonPath', t => {
const jsonPath = ['obj', 'arr', '2', 'last']
const esonPath = [
'props', '0', 'value',
'props', '0', 'value',
'items', '2', 'value',
'props', '1', 'value'
]
t.deepEqual(toEsonPath(ESON1, jsonPath), esonPath)
})
test('toJsonPath', t => {
const jsonPath = ['obj', 'arr', '2', 'last']
const esonPath = [
'props', '0', 'value',
'props', '0', 'value',
'items', '2', 'value',
'props', '1', 'value'
]
t.deepEqual(toJsonPath(ESON1, esonPath), jsonPath)
})
test('jsonToEson', t => { test('jsonToEson', t => {
assertDeepEqualEson(t, jsonToEson(1), {[META]: {id: '[ID]', path: [], type: 'value', value: 1}}) assertDeepEqualEson(t, jsonToEson(1), {[META]: {id: '[ID]', path: [], type: 'value', value: 1}})
assertDeepEqualEson(t, jsonToEson("foo"), {[META]: {id: '[ID]', path: [], type: 'value', value: "foo"}}) assertDeepEqualEson(t, jsonToEson("foo"), {[META]: {id: '[ID]', path: [], type: 'value', value: "foo"}})
@ -54,15 +32,24 @@ test('jsonToEson', t => {
const actual = jsonToEson([1,2]) const actual = jsonToEson([1,2])
const expected = [ const expected = [
{[META]: {id: '[ID]', path: [0], type: 'value', value: 1}}, {[META]: {id: '[ID]', path: ['0'], type: 'value', value: 1}},
{[META]: {id: '[ID]', path: [1], type: 'value', value: 2}} {[META]: {id: '[ID]', path: ['1'], type: 'value', value: 2}}
] ]
expected[META] = {id: '[ID]', path: [], type: 'Array'} expected[META] = {id: '[ID]', path: [], type: 'Array'}
assertDeepEqualEson(t, actual, expected) assertDeepEqualEson(t, actual, expected)
}) })
test('esonToJson', t => { test('esonToJson', t => {
t.deepEqual(esonToJson(ESON1), JSON1) const json = {
"obj": {
"arr": [1,2, {"first":3,"last":4}]
},
"str": "hello world",
"nill": null,
"bool": false
}
const eson = jsonToEson(json)
t.deepEqual(esonToJson(eson), json)
}) })
test('expand a single path', t => { test('expand a single path', t => {
@ -186,10 +173,19 @@ test('transform (change based on path)', t => {
}) })
test('pathExists', t => { test('pathExists', t => {
t.is(pathExists(ESON1, ['obj', 'arr', 2, 'first']), true) const eson = jsonToEson({
t.is(pathExists(ESON1, ['obj', 'foo']), false) "obj": {
t.is(pathExists(ESON1, ['obj', 'foo', 'bar']), false) "arr": [1,2, {"first":3,"last":4}]
t.is(pathExists(ESON1, []), true) },
"str": "hello world",
"nill": null,
"bool": false
})
t.is(pathExists(eson, ['obj', 'arr', 2, 'first']), true)
t.is(pathExists(eson, ['obj', 'foo']), false)
t.is(pathExists(eson, ['obj', 'foo', 'bar']), false)
t.is(pathExists(eson, []), true)
}) })
test('parseJSONPointer', t => { test('parseJSONPointer', t => {
@ -282,14 +278,14 @@ test('search', t => {
const active = searchResult.active const active = searchResult.active
t.deepEqual(matches, [ t.deepEqual(matches, [
{path: ['obj', 'arr', 2, 'last'], area: 'property'}, {path: ['obj', 'arr', '2', 'last'], area: 'property'},
{path: ['str'], area: 'value'}, {path: ['str'], area: 'value'},
{path: ['nill'], area: 'property'}, {path: ['nill'], area: 'property'},
{path: ['nill'], area: 'value'}, {path: ['nill'], area: 'value'},
{path: ['bool'], area: 'property'}, {path: ['bool'], area: 'property'},
{path: ['bool'], area: 'value'} {path: ['bool'], area: 'value'}
]) ])
t.deepEqual(active, {path: ['obj', 'arr', 2, 'last'], area: 'property'}) t.deepEqual(active, {path: ['obj', 'arr', '2', 'last'], area: 'property'})
let expected = esonWithSearch let expected = esonWithSearch
expected = setIn(expected, ['obj', 'arr', '2', 'last', META, 'searchProperty'], 'active') expected = setIn(expected, ['obj', 'arr', '2', 'last', META, 'searchProperty'], 'active')
@ -315,31 +311,31 @@ test('nextSearchResult', t => {
t.deepEqual(searchResult.matches, [ t.deepEqual(searchResult.matches, [
{path: ['obj', 'arr'], area: 'property'}, {path: ['obj', 'arr'], area: 'property'},
{path: ['obj', 'arr', 2, 'last'], area: 'property'}, {path: ['obj', 'arr', '2', 'last'], area: 'property'},
{path: ['bool'], area: 'value'} {path: ['bool'], area: 'value'}
]) ])
t.deepEqual(searchResult.active, {path: ['obj', 'arr'], area: 'property'}) t.deepEqual(searchResult.active, {path: ['obj', 'arr'], area: 'property'})
t.is(getIn(searchResult.eson, ['obj', 'arr', META, 'searchProperty']), 'active') t.is(getIn(searchResult.eson, ['obj', 'arr', META, 'searchProperty']), 'active')
t.is(getIn(searchResult.eson, ['obj', 'arr', 2, 'last', META, 'searchProperty']), 'normal') t.is(getIn(searchResult.eson, ['obj', 'arr', '2', 'last', META, 'searchProperty']), 'normal')
t.is(getIn(searchResult.eson, ['bool', META, 'searchValue']), 'normal') t.is(getIn(searchResult.eson, ['bool', META, 'searchValue']), 'normal')
const second = nextSearchResult(searchResult.eson, searchResult.matches, searchResult.active) const second = nextSearchResult(searchResult.eson, searchResult.matches, searchResult.active)
t.deepEqual(second.active, {path: ['obj', 'arr', 2, 'last'], area: 'property'}) t.deepEqual(second.active, {path: ['obj', 'arr', '2', 'last'], area: 'property'})
t.is(getIn(second.eson, ['obj', 'arr', META, 'searchProperty']), 'normal') t.is(getIn(second.eson, ['obj', 'arr', META, 'searchProperty']), 'normal')
t.is(getIn(second.eson, ['obj', 'arr', 2, 'last', META, 'searchProperty']), 'active') t.is(getIn(second.eson, ['obj', 'arr', '2', 'last', META, 'searchProperty']), 'active')
t.is(getIn(second.eson, ['bool', META, 'searchValue']), 'normal') t.is(getIn(second.eson, ['bool', META, 'searchValue']), 'normal')
const third = nextSearchResult(second.eson, second.matches, second.active) const third = nextSearchResult(second.eson, second.matches, second.active)
t.deepEqual(third.active, {path: ['bool'], area: 'value'}) t.deepEqual(third.active, {path: ['bool'], area: 'value'})
t.is(getIn(third.eson, ['obj', 'arr', META, 'searchProperty']), 'normal') t.is(getIn(third.eson, ['obj', 'arr', META, 'searchProperty']), 'normal')
t.is(getIn(third.eson, ['obj', 'arr', 2, 'last', META, 'searchProperty']), 'normal') t.is(getIn(third.eson, ['obj', 'arr', '2', 'last', META, 'searchProperty']), 'normal')
t.is(getIn(third.eson, ['bool', META, 'searchValue']), 'active') t.is(getIn(third.eson, ['bool', META, 'searchValue']), 'active')
const wrappedAround = nextSearchResult(third.eson, third.matches, third.active) const wrappedAround = nextSearchResult(third.eson, third.matches, third.active)
t.deepEqual(wrappedAround.active, {path: ['obj', 'arr'], area: 'property'}) t.deepEqual(wrappedAround.active, {path: ['obj', 'arr'], area: 'property'})
t.is(getIn(wrappedAround.eson, ['obj', 'arr', META, 'searchProperty']), 'active') t.is(getIn(wrappedAround.eson, ['obj', 'arr', META, 'searchProperty']), 'active')
t.is(getIn(wrappedAround.eson, ['obj', 'arr', 2, 'last', META, 'searchProperty']), 'normal') t.is(getIn(wrappedAround.eson, ['obj', 'arr', '2', 'last', META, 'searchProperty']), 'normal')
t.is(getIn(wrappedAround.eson, ['bool', META, 'searchValue']), 'normal') t.is(getIn(wrappedAround.eson, ['bool', META, 'searchValue']), 'normal')
}) })
@ -356,31 +352,31 @@ test('previousSearchResult', t => {
t.deepEqual(searchResult.matches, [ t.deepEqual(searchResult.matches, [
{path: ['obj', 'arr'], area: 'property'}, {path: ['obj', 'arr'], area: 'property'},
{path: ['obj', 'arr', 2, 'last'], area: 'property'}, {path: ['obj', 'arr', '2', 'last'], area: 'property'},
{path: ['bool'], area: 'value'} {path: ['bool'], area: 'value'}
]) ])
t.deepEqual(searchResult.active, {path: ['obj', 'arr'], area: 'property'}) t.deepEqual(searchResult.active, {path: ['obj', 'arr'], area: 'property'})
t.is(getIn(searchResult.eson, ['obj', 'arr', META, 'searchProperty']), 'active') t.is(getIn(searchResult.eson, ['obj', 'arr', META, 'searchProperty']), 'active')
t.is(getIn(searchResult.eson, ['obj', 'arr', 2, 'last', META, 'searchProperty']), 'normal') t.is(getIn(searchResult.eson, ['obj', 'arr', '2', 'last', META, 'searchProperty']), 'normal')
t.is(getIn(searchResult.eson, ['bool', META, 'searchValue']), 'normal') t.is(getIn(searchResult.eson, ['bool', META, 'searchValue']), 'normal')
const third = previousSearchResult(searchResult.eson, searchResult.matches, searchResult.active) const third = previousSearchResult(searchResult.eson, searchResult.matches, searchResult.active)
t.deepEqual(third.active, {path: ['bool'], area: 'value'}) t.deepEqual(third.active, {path: ['bool'], area: 'value'})
t.is(getIn(third.eson, ['obj', 'arr', META, 'searchProperty']), 'normal') t.is(getIn(third.eson, ['obj', 'arr', META, 'searchProperty']), 'normal')
t.is(getIn(third.eson, ['obj', 'arr', 2, 'last', META, 'searchProperty']), 'normal') t.is(getIn(third.eson, ['obj', 'arr', '2', 'last', META, 'searchProperty']), 'normal')
t.is(getIn(third.eson, ['bool', META, 'searchValue']), 'active') t.is(getIn(third.eson, ['bool', META, 'searchValue']), 'active')
const second = previousSearchResult(third.eson, third.matches, third.active) const second = previousSearchResult(third.eson, third.matches, third.active)
t.deepEqual(second.active, {path: ['obj', 'arr', 2, 'last'], area: 'property'}) t.deepEqual(second.active, {path: ['obj', 'arr', '2', 'last'], area: 'property'})
t.is(getIn(second.eson, ['obj', 'arr', META, 'searchProperty']), 'normal') t.is(getIn(second.eson, ['obj', 'arr', META, 'searchProperty']), 'normal')
t.is(getIn(second.eson, ['obj', 'arr', 2, 'last', META, 'searchProperty']), 'active') t.is(getIn(second.eson, ['obj', 'arr', '2', 'last', META, 'searchProperty']), 'active')
t.is(getIn(second.eson, ['bool', META, 'searchValue']), 'normal') t.is(getIn(second.eson, ['bool', META, 'searchValue']), 'normal')
const first = previousSearchResult(second.eson, second.matches, second.active) const first = previousSearchResult(second.eson, second.matches, second.active)
t.deepEqual(first.active, {path: ['obj', 'arr'], area: 'property'}) t.deepEqual(first.active, {path: ['obj', 'arr'], area: 'property'})
t.is(getIn(first.eson, ['obj', 'arr', META, 'searchProperty']), 'active') t.is(getIn(first.eson, ['obj', 'arr', META, 'searchProperty']), 'active')
t.is(getIn(first.eson, ['obj', 'arr', 2, 'last', META, 'searchProperty']), 'normal') t.is(getIn(first.eson, ['obj', 'arr', '2', 'last', META, 'searchProperty']), 'normal')
t.is(getIn(first.eson, ['bool', META, 'searchValue']), 'normal') t.is(getIn(first.eson, ['bool', META, 'searchValue']), 'normal')
}) })
@ -531,36 +527,6 @@ test('pathsFromSelection (after)', t => {
t.deepEqual(pathsFromSelection(ESON1, selection), []) t.deepEqual(pathsFromSelection(ESON1, selection), [])
}) })
function assertDeepEqualEson (t, actual, expected, path = [], ignoreIds = true) {
const actualMeta = ignoreIds ? normalizeMetaIds(actual[META]) : actual[META]
const expectedMeta = ignoreIds ? normalizeMetaIds(expected[META]) : expected[META]
t.deepEqual(actualMeta, expectedMeta, `Meta data not equal, path=[${path.join(', ')}]`)
if (actualMeta.type === 'Array') {
t.deepEqual(actual.length, expected.length, 'Actual lengths of arrays should be equal, path=[${path.join(\', \')}]')
actual.forEach((item, index) => assertDeepEqualEson(t, actual[index], expected[index], path.concat(index)), ignoreIds)
}
else if (actualMeta.type === 'Object') {
t.deepEqual(Object.keys(actual).sort(), Object.keys(expected).sort(), 'Actual properties should be equal, path=[${path.join(\', \')}]')
actualMeta.keys.forEach(key => assertDeepEqualEson(t, actual[key], expected[key], path.concat(key)), ignoreIds)
}
else { // actual[META].type === 'value'
t.deepEqual(Object.keys(actual), [], 'Value should not contain additional properties, path=[${path.join(\', \')}]')
}
}
function normalizeMetaIds (meta) {
return lodashTransform(meta, (result, value, key) => {
if (key === 'id') {
result[key] = '[ID]'
}
else {
result[key] = value
}
}, {})
}
// helper function to print JSON in the console // helper function to print JSON in the console
function printJSON (json, message = null) { function printJSON (json, message = null) {
if (message) { if (message) {

210
test/patchEson.test.js
View File

@ -1,9 +1,8 @@
import { readFileSync } from 'fs' import { readFileSync } from 'fs'
import test from 'ava' import test from 'ava'
import { jsonToEsonOld, esonToJson, toEsonPath } from '../src/eson' import { META, jsonToEson, esonToJson } from '../src/eson'
import { patchEson, cut } from '../src/patchEson' import { patchEson } from '../src/patchEson'
import { assertDeepEqualEson } from './utils/assertDeepEqualEson'
const ESON1 = loadJSON('./resources/eson1.json')
test('jsonpatch add', t => { test('jsonpatch add', t => {
const json = { const json = {
@ -15,21 +14,44 @@ test('jsonpatch add', t => {
{op: 'add', path: '/obj/b', value: {foo: 'bar'}} {op: 'add', path: '/obj/b', value: {foo: 'bar'}}
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const result = patchEson(data, patch) const result = patchEson(data, patch)
const patchedData = result.data const patchedData = result.data
const revert = result.revert const revert = result.revert
const patchedJson = esonToJson(patchedData)
t.deepEqual(patchedJson, { assertDeepEqualEson(t, patchedData, jsonToEson({
arr: [1,2,3], arr: [1,2,3],
obj: {a : 2, b: {foo: 'bar'}} obj: {a : 2, b: {foo: 'bar'}}
}) }))
t.deepEqual(revert, [ t.deepEqual(revert, [
{op: 'remove', path: '/obj/b'} {op: 'remove', path: '/obj/b'}
]) ])
}) })
test('jsonpatch add: insert in matrix', t => {
const json = {
arr: [1,2,3],
obj: {a : 2}
}
const patch = [
{op: 'add', path: '/arr/1', value: 4}
]
const data = jsonToEson(json)
const result = patchEson(data, patch)
const patchedData = result.data
const revert = result.revert
assertDeepEqualEson(t, patchedData, jsonToEson({
arr: [1,4,2,3],
obj: {a : 2}
}))
t.deepEqual(revert, [
{op: 'remove', path: '/arr/1'}
])
})
test('jsonpatch add: append to matrix', t => { test('jsonpatch add: append to matrix', t => {
const json = { const json = {
arr: [1,2,3], arr: [1,2,3],
@ -40,22 +62,20 @@ test('jsonpatch add: append to matrix', t => {
{op: 'add', path: '/arr/-', value: 4} {op: 'add', path: '/arr/-', value: 4}
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const result = patchEson(data, patch) const result = patchEson(data, patch)
const patchedData = result.data const patchedData = result.data
const revert = result.revert const revert = result.revert
const patchedJson = esonToJson(patchedData)
t.deepEqual(patchedJson, { assertDeepEqualEson(t, patchedData, jsonToEson({
arr: [1,2,3,4], arr: [1,2,3,4],
obj: {a : 2} obj: {a : 2}
}) }))
t.deepEqual(revert, [ t.deepEqual(revert, [
{op: 'remove', path: '/arr/3'} {op: 'remove', path: '/arr/3'}
]) ])
}) })
test('jsonpatch remove', t => { test('jsonpatch remove', t => {
const json = { const json = {
arr: [1,2,3], arr: [1,2,3],
@ -67,23 +87,23 @@ test('jsonpatch remove', t => {
{op: 'remove', path: '/arr/1'}, {op: 'remove', path: '/arr/1'},
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const result = patchEson(data, patch) const result = patchEson(data, patch)
const patchedData = result.data const patchedData = result.data
const revert = result.revert const revert = result.revert
const patchedJson = esonToJson(patchedData) const patchedJson = esonToJson(patchedData)
t.deepEqual(patchedJson, { assertDeepEqualEson(t, patchedData, jsonToEson({
arr: [1,3], arr: [1,3],
obj: {} obj: {}
}) }))
t.deepEqual(revert, [ t.deepEqual(revert, [
{op: 'add', path: '/arr/1', value: 2, jsoneditor: {type: 'value'}}, {op: 'add', path: '/arr/1', value: 2, jsoneditor: {type: 'value'}},
{op: 'add', path: '/obj/a', value: 4, jsoneditor: {type: 'value', before: null}} {op: 'add', path: '/obj/a', value: 4, jsoneditor: {type: 'value', before: null}}
]) ])
// test revert // test revert
const data2 = jsonToEsonOld(patchedJson) const data2 = jsonToEson(patchedJson)
const result2 = patchEson(data2, revert) const result2 = patchEson(data2, revert)
const patchedData2 = result2.data const patchedData2 = result2.data
const revert2 = result2.revert const revert2 = result2.revert
@ -104,23 +124,23 @@ test('jsonpatch replace', t => {
{op: 'replace', path: '/arr/1', value: 200}, {op: 'replace', path: '/arr/1', value: 200},
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const result = patchEson(data, patch) const result = patchEson(data, patch)
const patchedData = result.data const patchedData = result.data
const revert = result.revert const revert = result.revert
const patchedJson = esonToJson(patchedData) const patchedJson = esonToJson(patchedData)
t.deepEqual(patchedJson, { assertDeepEqualEson(t, patchedData, jsonToEson({
arr: [1,200,3], arr: [1,200,3],
obj: {a: 400} obj: {a: 400}
}) }))
t.deepEqual(revert, [ t.deepEqual(revert, [
{op: 'replace', path: '/arr/1', value: 2, jsoneditor: {type: 'value'}}, {op: 'replace', path: '/arr/1', value: 2, jsoneditor: {type: 'value'}},
{op: 'replace', path: '/obj/a', value: 4, jsoneditor: {type: 'value'}} {op: 'replace', path: '/obj/a', value: 4, jsoneditor: {type: 'value'}}
]) ])
// test revert // test revert
const data2 = jsonToEsonOld(patchedJson) const data2 = jsonToEson(patchedJson)
const result2 = patchEson(data2, revert) const result2 = patchEson(data2, revert)
const patchedData2 = result2.data const patchedData2 = result2.data
const revert2 = result2.revert const revert2 = result2.revert
@ -133,20 +153,21 @@ test('jsonpatch replace', t => {
]) ])
}) })
test('jsonpatch replace (keep ids intact)', t => { // // FIXME: keep ids intact
const json = { value: 42 } // test('jsonpatch replace (keep ids intact)', t => {
const patch = [ // const json = { value: 42 }
{op: 'replace', path: '/value', value: 100} // const patch = [
] // {op: 'replace', path: '/value', value: 100}
// ]
const data = jsonToEsonOld(json) //
const valueId = data.props[0].id // const data = jsonToEson(json)
// const valueId = data.value[META].id
const patchedData = patchEson(data, patch).data //
const patchedValueId = patchedData.props[0].id // const patchedData = patchEson(data, patch).data
// const patchedValueId = patchedData.value[META].id
t.is(patchedValueId, valueId) //
}) // t.is(patchedValueId, valueId)
// })
test('jsonpatch copy', t => { test('jsonpatch copy', t => {
const json = { const json = {
@ -158,7 +179,7 @@ test('jsonpatch copy', t => {
{op: 'copy', from: '/obj', path: '/arr/2'}, {op: 'copy', from: '/obj', path: '/arr/2'},
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const result = patchEson(data, patch) const result = patchEson(data, patch)
const patchedData = result.data const patchedData = result.data
const revert = result.revert const revert = result.revert
@ -173,7 +194,7 @@ test('jsonpatch copy', t => {
]) ])
// test revert // test revert
const data2 = jsonToEsonOld(patchedJson) const data2 = jsonToEson(patchedJson)
const result2 = patchEson(data2, revert) const result2 = patchEson(data2, revert)
const patchedData2 = result2.data const patchedData2 = result2.data
const revert2 = result2.revert const revert2 = result2.revert
@ -191,18 +212,15 @@ test('jsonpatch copy (keeps the same ids)', t => {
{op: 'copy', from: '/foo', path: '/copied'} {op: 'copy', from: '/foo', path: '/copied'}
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const fooId = data.props[0].id const fooId = data.foo[META].id
const barId = data.props[0].value.props[0].id const barId = data.foo.bar[META].id
const patchedData = patchEson(data, patch).data const patchedData = patchEson(data, patch).data
const patchedFooId = patchedData.props[0].id const patchedFooId = patchedData.foo[META].id
const patchedBarId = patchedData.props[0].value.props[0].id const patchedBarId = patchedData.foo.bar[META].id
const copiedId = patchedData.props[1].id const copiedId = patchedData.copied[META].id
const patchedCopiedBarId = patchedData.props[1].value.props[0].id const patchedCopiedBarId = patchedData.copied.bar[META].id
t.is(patchedData.props[0].name, 'foo')
t.is(patchedData.props[1].name, 'copied')
t.is(patchedFooId, fooId, 'same foo id') t.is(patchedFooId, fooId, 'same foo id')
t.is(patchedBarId, barId, 'same bar id') t.is(patchedBarId, barId, 'same bar id')
@ -210,7 +228,6 @@ test('jsonpatch copy (keeps the same ids)', t => {
t.not(copiedId, fooId, 'different id of property copied') t.not(copiedId, fooId, 'different id of property copied')
// The id's of the copied childs are the same, that's okish, they will not bite each other // The id's of the copied childs are the same, that's okish, they will not bite each other
// FIXME: better solution for id's either always unique, or unique per object/array
t.is(patchedCopiedBarId, patchedBarId, 'same copied bar id') t.is(patchedCopiedBarId, patchedBarId, 'same copied bar id')
}) })
@ -224,7 +241,7 @@ test('jsonpatch move', t => {
{op: 'move', from: '/obj', path: '/arr/2'}, {op: 'move', from: '/obj', path: '/arr/2'},
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const result = patchEson(data, patch) const result = patchEson(data, patch)
const patchedData = result.data const patchedData = result.data
const revert = result.revert const revert = result.revert
@ -239,7 +256,7 @@ test('jsonpatch move', t => {
]) ])
// test revert // test revert
const data2 = jsonToEsonOld(patchedJson) const data2 = jsonToEson(patchedJson)
const result2 = patchEson(data2, revert) const result2 = patchEson(data2, revert)
const patchedData2 = result2.data const patchedData2 = result2.data
const revert2 = result2.revert const revert2 = result2.revert
@ -260,7 +277,7 @@ test('jsonpatch move before', t => {
{op: 'move', from: '/obj', path: '/arr/2'}, {op: 'move', from: '/obj', path: '/arr/2'},
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const result = patchEson(data, patch) const result = patchEson(data, patch)
const patchedData = result.data const patchedData = result.data
const revert = result.revert const revert = result.revert
@ -276,7 +293,7 @@ test('jsonpatch move before', t => {
]) ])
// test revert // test revert
const data2 = jsonToEsonOld(patchedJson) const data2 = jsonToEson(patchedJson)
const result2 = patchEson(data2, revert) const result2 = patchEson(data2, revert)
const patchedData2 = result2.data const patchedData2 = result2.data
const revert2 = result2.revert const revert2 = result2.revert
@ -293,7 +310,7 @@ test('jsonpatch move and replace', t => {
{op: 'move', from: '/a', path: '/b'}, {op: 'move', from: '/a', path: '/b'},
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const result = patchEson(data, patch) const result = patchEson(data, patch)
const patchedData = result.data const patchedData = result.data
@ -301,24 +318,9 @@ test('jsonpatch move and replace', t => {
const patchedJson = esonToJson(patchedData) const patchedJson = esonToJson(patchedData)
// id of the replaced B must be kept intact // id of the replaced B must be kept intact
t.is(patchedData.props[0].id, data.props[1].id) t.is(patchedData.b[META].id, data.b[META].id)
replaceIds(patchedData)
t.deepEqual(patchedData, {
"type": "Object",
"expanded": true,
"props": [
{
"id": "[ID]",
"name": "b",
"value": {
"type": "value",
"value": 2
}
}
]
})
assertDeepEqualEson(t, patchedData, jsonToEson({b: 2}))
t.deepEqual(patchedJson, { b : 2 }) t.deepEqual(patchedJson, { b : 2 })
t.deepEqual(revert, [ t.deepEqual(revert, [
{op:'move', from: '/b', path: '/a'}, {op:'move', from: '/b', path: '/a'},
@ -326,7 +328,7 @@ test('jsonpatch move and replace', t => {
]) ])
// test revert // test revert
const data2 = jsonToEsonOld(patchedJson) const data2 = jsonToEson(patchedJson)
const result2 = patchEson(data2, revert) const result2 = patchEson(data2, revert)
const patchedData2 = result2.data const patchedData2 = result2.data
const revert2 = result2.revert const revert2 = result2.revert
@ -349,7 +351,7 @@ test('jsonpatch move and replace (nested)', t => {
{op: 'move', from: '/obj', path: '/arr'}, {op: 'move', from: '/obj', path: '/arr'},
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const result = patchEson(data, patch) const result = patchEson(data, patch)
const patchedData = result.data const patchedData = result.data
const revert = result.revert const revert = result.revert
@ -364,7 +366,7 @@ test('jsonpatch move and replace (nested)', t => {
]) ])
// test revert // test revert
const data2 = jsonToEsonOld(patchedJson) const data2 = jsonToEson(patchedJson)
const result2 = patchEson(data2, revert) const result2 = patchEson(data2, revert)
const patchedData2 = result2.data const patchedData2 = result2.data
const revert2 = result2.revert const revert2 = result2.revert
@ -383,32 +385,31 @@ test('jsonpatch move (keep id intact)', t => {
{op: 'move', from: '/value', path: '/moved'} {op: 'move', from: '/value', path: '/moved'}
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const valueId = data.props[0].id const valueId = data.value[META].id
const patchedData = patchEson(data, patch).data const patchedData = patchEson(data, patch).data
const patchedValueId = patchedData.props[0].id const patchedValueId = patchedData.moved[META].id
t.is(patchedValueId, valueId) t.is(patchedValueId, valueId)
}) })
test('jsonpatch move and replace (keep ids intact)', t => { // test('jsonpatch move and replace (keep ids intact)', t => {
const json = { a: 2, b: 3 } // const json = { a: 2, b: 3 }
const patch = [ // const patch = [
{op: 'move', from: '/a', path: '/b'} // {op: 'move', from: '/a', path: '/b'}
] // ]
//
const data = jsonToEsonOld(json) // const data = jsonToEson(json)
const bId = data.props[1].id // const bId = data.b[META].id
//
t.is(data.props[0].name, 'a') // t.deepEqual(data[META].keys, ['a', 'b'])
t.is(data.props[1].name, 'b') //
// const patchedData = patchEson(data, patch).data
const patchedData = patchEson(data, patch).data //
// t.is(patchedData.b[META].id, bId)
t.is(patchedData.props[0].name, 'b') // t.deepEqual(data[META].keys, ['b'])
t.is(patchedData.props[0].id, bId) // })
})
test('jsonpatch test (ok)', t => { test('jsonpatch test (ok)', t => {
const json = { const json = {
@ -421,7 +422,7 @@ test('jsonpatch test (ok)', t => {
{op: 'add', path: '/added', value: 'ok'} {op: 'add', path: '/added', value: 'ok'}
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const result = patchEson(data, patch) const result = patchEson(data, patch)
const patchedData = result.data const patchedData = result.data
const revert = result.revert const revert = result.revert
@ -449,7 +450,7 @@ test('jsonpatch test (fail: path not found)', t => {
{op: 'add', path: '/added', value: 'ok'} {op: 'add', path: '/added', value: 'ok'}
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const result = patchEson(data, patch) const result = patchEson(data, patch)
const patchedData = result.data const patchedData = result.data
const revert = result.revert const revert = result.revert
@ -475,7 +476,7 @@ test('jsonpatch test (fail: value not equal)', t => {
{op: 'add', path: '/added', value: 'ok'} {op: 'add', path: '/added', value: 'ok'}
] ]
const data = jsonToEsonOld(json) const data = jsonToEson(json)
const result = patchEson(data, patch) const result = patchEson(data, patch)
const patchedData = result.data const patchedData = result.data
const revert = result.revert const revert = result.revert
@ -490,23 +491,6 @@ test('jsonpatch test (fail: value not equal)', t => {
t.is(result.error.toString(), 'Error: Test failed, value differs') t.is(result.error.toString(), 'Error: Test failed, value differs')
}) })
// helper function to replace all id properties with a constant value
function replaceIds (data, value = '[ID]') {
if (data.type === 'Object') {
data.props.forEach(prop => {
prop.id = value
replaceIds(prop.value, value)
})
}
if (data.type === 'Array') {
data.items.forEach(item => {
item.id = value
replaceIds(item.value, value)
})
}
}
// helper function to print JSON in the console // helper function to print JSON in the console
function printJSON (json, message = null) { function printJSON (json, message = null) {
if (message) { if (message) {

40
test/utils/assertDeepEqualEson.js Normal file
View File

@ -0,0 +1,40 @@
// TODO: move assertDeepEqualEson into a separate function
import {META} from "../../src/eson"
import lodashTransform from "lodash/transform"
export function assertDeepEqualEson (t, actual, expected, path = [], ignoreIds = true) {
if (expected === undefined) {
throw new Error('Argument "expected" is undefined')
}
// console.log('assertDeepEqualEson', actual, expected)
const actualMeta = ignoreIds ? normalizeMetaIds(actual[META]) : actual[META]
const expectedMeta = ignoreIds ? normalizeMetaIds(expected[META]) : expected[META]
t.deepEqual(actualMeta, expectedMeta, `Meta data not equal, path=[${path.join(', ')}], actual[META]=${JSON.stringify(actualMeta)}, expected[META]=${JSON.stringify(expectedMeta)}`)
if (actualMeta.type === 'Array') {
t.deepEqual(actual.length, expected.length, 'Actual lengths of arrays should be equal, path=[${path.join(\', \')}]')
actual.forEach((item, index) => assertDeepEqualEson(t, actual[index], expected[index], path.concat(index)), ignoreIds)
}
else if (actualMeta.type === 'Object') {
t.deepEqual(Object.keys(actual).sort(), Object.keys(expected).sort(), 'Actual properties should be equal, path=[${path.join(\', \')}]')
actualMeta.keys.forEach(key => assertDeepEqualEson(t, actual[key], expected[key], path.concat(key)), ignoreIds)
}
else { // actual[META].type === 'value'
t.deepEqual(Object.keys(actual), [], 'Value should not contain additional properties, path=[${path.join(\', \')}]')
}
}
function normalizeMetaIds (meta) {
return lodashTransform(meta, (result, value, key) => {
if (key === 'id') {
result[key] = '[ID]'
}
else {
result[key] = value
}
}, {})
}