rewrite-clj.zip — net.vemv/rewrite-clj 0.6.2

->root-string clj deprecated

(->root-string zloc)

DEPRECATED. Use root-string instead.

->string clj deprecated

(->string zloc)

DEPRECATED. Use string instead.

append-child clj

(append-child zloc item)

Insert item as last child of the current node. Will insert a space if necessary.

append-newline clj deprecated

(append-newline zloc & [n])

Append a newline node representing the given number of linebreaks (default: 1).

DEPRECATED: use 'insert-newline-right' instead.

append-space clj deprecated

(append-space zloc & [n])

Append a whitespace node representing the given number of spaces (default: 1).

DEPRECATED: use 'insert-space-right' instead.

assoc clj

(assoc zloc k v)

Set map/seq element to the given value.

child-sexprs clj

(child-sexprs zloc)

Get children as s-expressions.

down clj

(down zloc)

Move down to next non-whitespace/non-comment location.

down* clj

(down* G__2841)

Directly call 'rewrite-clj.custom-zipper.core/down' on the given arguments.

edit clj

(edit zloc f & args)

Apply the given function to the s-expression at the given location, using its result to replace the node there. (The result will be coerced to a node if possible.)

edit* clj

(edit* loc f & args)

Directly call 'rewrite-clj.custom-zipper.core/edit' on the given arguments.

edit-> clj macro

(edit-> zloc & body)

Like ->, applying the given function to the current zipper location. The resulting zipper will be located at the same path (i.e. the same number of downwards and right movements from the root) as the original node.

edit->> clj macro

(edit->> zloc & body)

Like ->>, applying the given function to the current zipper location. The resulting zipper will be located at the same path (i.e. the same number of downwards and right movements from the root) as the original node.

edit-node clj

(edit-node zloc f)

Apply the given function to the current zipper location. The resulting zipper will be located at the same path (i.e. the same number of downwards and right movements from the root) as the original node.

edn clj

(edn node)

(edn node {:keys [track-position?] :as options})

Create zipper over the given Clojure/EDN node and move to the first non-whitespace/non-comment child.

If :track-position? is set, this will create a custom zipper that will return the current row/column using rewrite-clj.zip/position. (Note that this custom zipper will be incompatible with clojure.zip's functions.)

edn* clj

(edn* node)

(edn* node {:keys [track-position?]})

Create zipper over the given Clojure/EDN node.

If :track-position? is set, this will create a custom zipper that will return the current row/column using rewrite-clj.zip/position. (Note that this custom zipper will be incompatible with clojure.zip's functions.)

end? clj

(end? zloc)

Check whether the given node is at the end of the depth-first traversal.

find clj

(find zloc p?)

(find zloc f p?)

Find node satisfying the given predicate by repeatedly applying the given movement function to the initial zipper location.

find-depth-first clj

(find-depth-first zloc p?)

Find node satisfying the given predicate by traversing the zipper in a depth-first way.

find-next clj

(find-next zloc p?)

(find-next zloc f p?)

Find node other than the current zipper location matching the given predicate by applying the given movement function to the initial zipper location.

find-next-depth-first clj

(find-next-depth-first zloc p?)

Find node other than the current zipper location matching the given predicate by traversing the zipper in a depth-first way.

find-next-tag clj

(find-next-tag zloc t)

(find-next-tag zloc f t)

Find node other than the current zipper location with the given tag by repeatedly applying the given movement function to the initial zipper location.

find-next-token clj

(find-next-token zloc p?)

(find-next-token zloc f p?)

Find next token node matching the given predicate by applying the given movement function to the initial zipper location, defaulting to right.

find-next-value clj

(find-next-value zloc v)

(find-next-value zloc f v)

Find next token node whose value matches the given one by applying the given movement function to the initial zipper location, defaulting to right.

find-tag clj

(find-tag zloc t)

(find-tag zloc f t)

Find node with the given tag by repeatedly applying the given movement function to the initial zipper location.

find-token clj

(find-token zloc p?)

(find-token zloc f p?)

Find token node matching the given predicate by applying the given movement function to the initial zipper location, defaulting to right.

find-value clj

(find-value zloc v)

(find-value zloc f v)

Find token node whose value matches the given one by applying the given movement function to the initial zipper location, defaulting to right.

get clj

(get zloc k)

If a map is given, get element with the given key; if a seq is given, get nth element.

insert-child clj

(insert-child zloc item)

Insert item as first child of the current node. Will insert a space if necessary.

insert-left clj

(insert-left zloc item)

Insert item to the right of the left location. Will insert a space if necessary.

insert-left* clj

(insert-left* G__2880 G__2881)

Directly call 'rewrite-clj.custom-zipper.core/insert-left' on the given arguments.

insert-right clj

(insert-right zloc item)

Insert item to the right of the current location. Will insert a space if necessary.

insert-right* clj

(insert-right* G__2884 G__2885)

Directly call 'rewrite-clj.custom-zipper.core/insert-right' on the given arguments.

left clj

(left zloc)

Move left to next non-whitespace/non-comment location.

left* clj

(left* G__2866)

Directly call 'rewrite-clj.custom-zipper.core/left' on the given arguments.

leftmost clj

(leftmost zloc)

Move to the leftmost non-whitespace/non-comment location.

leftmost* clj

(leftmost* G__2873)

Directly call 'rewrite-clj.custom-zipper.core/leftmost' on the given arguments.

leftmost? clj

(leftmost? zloc)

Check if the given location represents the leftmost non-whitespace/ non-comment one.

length clj

(length zloc)

Get length of printable string for the given zipper location.

linebreak? clj

(linebreak? zloc)

list? clj

(list? zloc)

map clj

(map f zloc)

Apply function to all value nodes in the given seq node. Iterates over value nodes of maps but over each element of a seq.

map-keys clj

(map-keys f zloc)

Apply function to all key nodes of the given map node.

map-vals clj

(map-vals f zloc)

Apply function to all value nodes of the given map node.

map? clj

(map? zloc)

next clj

(next zloc)

Move to the next non-whitespace/non-comment location in a depth-first manner.

next* clj

(next* G__2898)

Directly call 'rewrite-clj.custom-zipper.core/next' on the given arguments.

node clj

(node G__2825)

Returns the node at loc

of-file clj

(of-file f)

(of-file f options)

Create zipper from File.

of-string clj

(of-string s)

(of-string s options)

Create zipper from String.

position clj

(position loc)

Returns the ones-based [row col] of the start of the current node

postwalk clj

(postwalk zloc f)

(postwalk zloc p? f)

Perform a depth-first post-order traversal starting at the given zipper location and apply the given function to each child node. If a predicate p? is given, only apply the function to nodes matching it.

prefix clj

(prefix zloc s)

prepend-newline clj deprecated

(prepend-newline zloc & [n])

Prepend a newline node representing the given number of linebreaks (default: 1).

DEPRECATED: use 'insert-newline-left' instead.

prepend-space clj deprecated

(prepend-space zloc & [n])

Prepend a whitespace node representing the given number of spaces (default: 1).

DEPRECATED: use 'insert-space-left' instead.

prev clj

(prev zloc)

Move to the next non-whitespace/non-comment location in a depth-first manner.

prev* clj

(prev* G__2905)

Directly call 'rewrite-clj.custom-zipper.core/prev' on the given arguments.

prewalk clj

(prewalk zloc f)

(prewalk zloc p? f)

Perform a depth-first pre-order traversal starting at the given zipper location and apply the given function to each child node. If a predicate p? is given, only apply the function to nodes matching it.

prewalk* clj

(prewalk* zloc f)

(prewalk* zloc p? f)

Like #'prewalk, but does not skip whitespace or comments.

print clj

(print zloc & [writer])

Print current zipper location.

print-root clj

(print-root zloc & [writer])

Zip up and print root node.

remove clj

(remove zloc)

Remove value at the given zipper location. Returns the first non-whitespace node that would have preceded it in a depth-first walk. Will remove whitespace appropriately.

[1  2  3]   => [1  3]
[1 2]       => [1]
[1 2]       => [2]
[1]         => []
[  1  ]     => []
[1 [2 3] 4] => [1 [2 3]]
[1 [2 3] 4] => [[2 3] 4]

If a node is located rightmost, both preceding and trailing spaces are removed, otherwise only trailing spaces are touched. This means that a following element (no matter whether on the same line or not) will end up in the same position (line/column) as the removed one, unless a comment lies between the original node and the neighbour.

remove* clj

(remove* G__2912)

Directly call 'rewrite-clj.custom-zipper.core/remove' on the given arguments.

replace clj

(replace zloc value)

Replace the node at the given location with one representing the given value. (The value will be coerced to a node if possible.)

replace* clj

(replace* G__2888 G__2889)

Directly call 'rewrite-clj.custom-zipper.core/replace' on the given arguments.

right clj

(right zloc)

Move right to next non-whitespace/non-comment location.

right* clj

(right* G__2856)

Directly call 'rewrite-clj.custom-zipper.core/right' on the given arguments.

rightmost clj

(rightmost zloc)

Move to the rightmost non-whitespace/non-comment location.

rightmost* clj

(rightmost* G__2863)

Directly call 'rewrite-clj.custom-zipper.core/rightmost' on the given arguments.

rightmost? clj

(rightmost? zloc)

Check if the given location represents the leftmost non-whitespace/ non-comment one.

root clj

(root G__2853)

zips all the way up and returns the root node, reflecting any changes.

root-string clj

(root-string zloc)

Create string representing the zipped-up zipper.

seq? clj

(seq? zloc)

set? clj

(set? zloc)

sexpr clj

(sexpr zloc)

Get sexpr represented by the given node.

skip clj

(skip f p? zloc)

Perform the given movement while the given predicate returns true.

skip-whitespace clj

(skip-whitespace zloc)

(skip-whitespace f zloc)

Perform the given movement (default: z/right) until a non-whitespace/ non-comment node is encountered.

skip-whitespace-left clj

(skip-whitespace-left zloc)

Move left until a non-whitespace/non-comment node is encountered.

splice clj

(splice zloc)

Splice the given node, i.e. merge its children into the current one (akin to Clojure's unquote-splicing macro: ~@...).

• if the node is not one that can have children, no modification will be performed.
• if the node has no or only whitespace children, it will be removed.
• otherwise, splicing will be performed, moving the zipper to the first non-whitespace child afterwards.

string clj

(string zloc)

Create string representing the current zipper location.

subedit-> clj macro

(subedit-> zloc & body)

Like ->, applying modifications to the current sub-tree, zipping up to the current location afterwards.

subedit->> clj macro

(subedit->> zloc & body)

Like ->>, applying modifications to the current sub-tree, zipping up to the current location afterwards.

subedit-node clj

(subedit-node zloc f)

Apply the given function to the current sub-tree. The resulting zipper will be located on the root of the modified sub-tree.

suffix clj

(suffix zloc s)

tag clj

(tag zloc)

Get tag of node at the current zipper location.

up clj

(up zloc)

Move up to next non-whitespace/non-comment location.

up* clj

(up* G__2850)

Directly call 'rewrite-clj.custom-zipper.core/up' on the given arguments.

value clj deprecated

(value zloc)

DEPRECATED. Return a tag/s-expression pair for inner nodes, or the s-expression itself for leaves.

vector? clj

(vector? zloc)

whitespace-or-comment? clj

(whitespace-or-comment? zloc)

whitespace? clj

(whitespace? zloc)