rebel-readline.clojure.line-reader — com.bhauman/rebel-readline 0.1.4

*accept-fn* clj

-accept-line clj multimethod

Takes a string that is represents the current contents of a readline buffer and an integer position into that readline that represents the current position of the cursor.

Returns a boolean indicating wether the line is complete and should be accepted as input.

A service is not required to implement this fn, they would do this to override the default accept line behavior

-apropos clj multimethod

Given a string returns a list of string repesentions of vars that match that string. This fn is already implemented on all the Clojure plaforms.

-complete clj multimethod

Takes a word prefix and an options map}

The options map can contain :ns - the current namespace the completion is occuring in :context - a sexp form that contains a marker 'prefix replacing the given prefix in teh expression where it is being completed. i.e. '(list prefix 1 2)

Returns a list of candidates of the form

{:candidate "alength" :ns "clojure.core" :type :function}

-current-ns clj multimethod

Returns a string representation of the current ns in the current execution environment.

Returns nil if it hasn't been implemented for the current service

-doc clj multimethod

Given a string that represents a var, returns a map with documentation information for the named var or nil if no documentation is found.

A required :doc key which will hold a string of the documentation for the given var.

An optional :url key which will hold a url to the online documentation for the given var.

-eval clj multimethod

Given a clojure form this will evaluate that form and return a map of the outcome.

The returned map will contain a :result key with a clj form that represents the result of it will contain a :printed-result key if the form can only be returned as a printed value.

The returned map will also contain :out and :err keys containing any captured output that occured during the evaluation of the form.

Example: (-eval @api/line-reader 1) => {:result 1 :out "" :err ""}

If an exception is thrown this will return a throwable map under the key :exception

Example: (-eval @api/line-reader '(defn)) => {:exception {:cause ...}}

An important thing to remember abou this eval is that it is used internally by the line-reader to implement various capabilities (line inline eval)

-eval-str clj multimethod

Just like -eval but takes and string and reads it before sending it on to -eval

-read-string clj multimethod

Given a string with that contains clojure forms this will read and return a map containing the first form in the string under the key :form

Example: (-read-string @api/line-reader "1") => {:form 1}

If an exception is thrown this will return a throwable map under the key :exception

Example: (-read-string @api/line-reader "#asdfasdfas") => {:exception {:cause ...}}

-resolve-meta clj multimethod

Currently this finds and returns the meta data for the given string currently we are using the :ns, :name, :doc and :arglist meta data that is found on both vars, namespaces

This function should return the standard or enhanced meta information that is afor a given "word" that and editor can focus on.

(resolve (symbol var-str))

This function shouldn't throw errors but catch them and return nil if the var doesn't exist.

-source clj multimethod

Given a string that represents a var Returns a map with source information for the var or nil if no source is found.

A required :source key which will hold a string of the source code for the given var.

An optional :url key which will hold a url to the source code in the context of the original file or potentially some other helpful url.

DESIGN NOTE the :url isn't currently used

Example result for (-source service "some?"):

{:source "(defn ^boolean some? [x] \n(not (nil? x)))" :url "https://github.com[...]main/cljs/cljs/core.cljs#L243-L245" }

accept-line clj

(accept-line line-str cursor)

add-all-widgets clj

(add-all-widgets line-reader)

add-widgets-and-bindings clj

(add-widgets-and-bindings line-reader)

always-accept-line clj

apropos clj

(apropos wrd)

apropos-at-point-widget clj

beginning-of-buffer clj

bind-clojure-widgets clj

(bind-clojure-widgets km-name)

bind-clojure-widgets-vi-cmd clj

(bind-clojure-widgets-vi-cmd km-name)

bind-indents clj

(bind-indents km-name)

candidate clj

(candidate {:keys [candidate type ns]})

cljs-quit-complete clj

(cljs-quit-complete {:keys [word] :as parsed-line})

clojure-completer clj

(clojure-completer)

clojure-emacs-mode clj

(clojure-emacs-mode km-name)

clojure-highlighter clj

(clojure-highlighter)

clojure-vi-cmd-mode clj

(clojure-vi-cmd-mode km-name)

clojure-vi-insert-mode clj

(clojure-vi-insert-mode km-name)

command-token? clj

(command-token? {:keys [line tokens word]} starts-with)

complete-context clj

(complete-context parsed-line)

completions clj

(completions word)

(completions word options)

create clj

(create service & [options])

Creates a line reader takes a service as an argument.

A service implements the multimethods found in rebel-readline.service

Example: (create (rebel-readline.clojure.service.local/create)) Or: (create (rebel-readline.clojure.service.simple/create))

This function also takes an optional options map.

The available options are:

:completer - to override the clojure based completer :highlighter - to override the clojure based systax highlighter :parser - to override the clojure base word parser

create* clj

(create* terminal service & [{:keys [completer highlighter parser]}])

current-ns clj

default-accept-line clj

(default-accept-line line-str cursor)

default-config clj

default-prompt-fn clj

(default-prompt-fn)

display-argument-help-message clj

(display-argument-help-message)

display-less clj

(display-less at-str)

(display-less at-str options)

divide-into-displayable-columns clj

(divide-into-displayable-columns coll total-width)

doc clj

(doc wrd)

document-at-point-widget clj

eldoc-self-insert-hook clj

(eldoc-self-insert-hook)

This hooks SELF_INSERT to capture most keypresses that get echoed out to the terminal. We are using it here to display interactive behavior based on the state of the buffer at the time of a keypress.

eliminate-long-outliers clj

(eliminate-long-outliers coll)

end-of-buffer clj

ensure-newline clj

(ensure-newline s)

eval-at-point-widget clj

evaluate clj

(evaluate form)

evaluate-str clj

(evaluate-str form-str)

find-completions clj

(find-completions candidates prefix)

find-number-of-columns clj

(find-number-of-columns coll total-width)

format-column clj

(format-column wrd column)

format-data-eval-result clj

(format-data-eval-result {:keys [out err result printed-result exception]
                          :as eval-result})

format-pair-to-width clj

(format-pair-to-width wrd width [ns' name'])

formatted-apropos clj

(formatted-apropos wrd)

highlight-clj-str clj

in-place-eval clj

(in-place-eval)

indent clj

(indent line-reader line cursor)

indent-amount clj

(indent-amount s cursor)

indent-line-widget clj

indent-or-complete-widget clj

indent-proxy-str clj

(indent-proxy-str s cursor)

inline-result-marker clj

(inline-result-marker at-str)

limit-character-size clj

(limit-character-size s)

make-parser clj

(make-parser)

mean clj

(mean coll)

name-arglist-display clj

(name-arglist-display meta-data)

no-greater-than clj

(no-greater-than limit val)

one-space-after-funcall-word? clj

(one-space-after-funcall-word?)

osc-hyper-link clj

(osc-hyper-link url show)

parse-line clj

(parse-line line cursor)

parsed-line clj

(parsed-line {:keys [word-index word word-cursor words tokens line cursor]
              :as parse-data})

parsed-line-word-coords clj

(parsed-line-word-coords parsed-line)

read-form clj

(read-form form-str)

repl-command-complete clj

(repl-command-complete {:keys [word] :as parsed-line})

replace-word-with-prefix clj

(replace-word-with-prefix parsed-line)

resolve-meta clj

(resolve-meta wrd)

row-width clj

(row-width columns)

source clj

(source wrd)

source-at-point clj

(source-at-point)

source-at-point-widget clj

split-into-wrapped-lines clj

(split-into-wrapped-lines at-str columns)

standard-deviation clj

(standard-deviation coll)

two-standards-plus-mean clj

(two-standards-plus-mean coll)

window-lines clj

(window-lines at-str-lines pos rows)

word-at-cursor clj

(word-at-cursor)