Copyright | Copyright 2015 Peter Harpending |
---|---|
License | Apache-2.0 |
Maintainer | Peter Harpending <[email protected]> |
Stability | experimental |
Portability | POSIX |
Safe Haskell | Safe-Inferred |
Language | Haskell2010 |
Text.Editor
Description
You know when you run git commit
, and a little editor pops up?
This is a Haskell library that does that.
Synopsis
- runUserEditorDWIM :: Template -> ByteString -> IO ByteString
- runUserEditorDWIMFile :: Template -> FilePath -> IO ByteString
- runUserEditor :: IO ByteString
- runUserEditorWithTemplate :: Template -> IO ByteString
- bracketConduit :: Template -> Producer (ResourceT IO) ByteString -> Consumer ByteString (ResourceT IO) b -> ResourceT IO b
- type Template = String
- mkTemplate :: String -> Template
- htmlTemplate :: Template
- jsonTemplate :: Template
- markdownTemplate :: Template
- oldMarkdownTemplate :: Template
- plainTemplate :: Template
- xmlTemplate :: Template
- txtTemplate :: Template
- yamlTemplate :: Template
- runSpecificEditor :: String -> Template -> ByteString -> IO ByteString
- userEditor :: IO (Maybe String)
- userEditorDefault :: String -> IO String
- _default_editor :: String
- _editors :: [String]
- _ftempl :: String
- wrapStr :: ByteString -> String
Documentation
Arguments
:: Template | Template for the file name |
-> ByteString | Initial contents (strict ByteString) |
-> IO ByteString | Resulting (strict) ByteString |
This is most likely the function you want to use. It takes a file type template as an argument, along with what you want displayed when the user opens the editor. It then runs the editor, and returns the version of the text that the user modified.
Examples:
>>>
:set -XOverloadedStrings
>>>
runUserEditorDWIM jsonTemplate "{\n\n}\n"
This will open up the user's $EDITOR
configured to edit JSON, and
with the initial text:
{ }
There are a bunch of templates. See the "File-type extensions" section. It's also trivially easy to make your own templates. Say you want one for, I dunno, Python:
pythonTemplate = mkTemplate "py"
The argument to mkTemplate
should be the file extension you
want. In that case, I used "py"
, because Python's file extension
is .py
.
runUserEditorDWIMFile Source #
Arguments
:: Template | Template for the file name |
-> FilePath | File containing initial contents |
-> IO ByteString | Resulting ByteString |
This is the same as above, it just takes a file as an argument instead of the ByteString
runUserEditorDWIMFile templ fp = B.readFile fp >>= runUserEditorDWIM templ
runUserEditor :: IO ByteString Source #
Open up the user's editor with no initial contents.
runUserEditorWithTemplate Source #
Arguments
:: Template | Template for the file name |
-> IO ByteString | Resulting ByteString |
This is probably the second-simplest function.
bracketConduit :: Template -> Producer (ResourceT IO) ByteString -> Consumer ByteString (ResourceT IO) b -> ResourceT IO b Source #
mkTemplate :: String -> Template Source #
Make a template
mkTemplate ext = _ftempl <> "." <> ext
>>>
mkTemplate "blah"
tmp.blah
htmlTemplate :: Template Source #
File-type template for HTML
htmlTemplate = mkTemplate "html"
jsonTemplate :: Template Source #
File-type template for JSON
jsonTemplate = mkTemplate "json"
markdownTemplate :: Template Source #
File-type template for Markdown
markdownTemplate = mkTemplate "md"
oldMarkdownTemplate :: Template Source #
Older file-type template for Markdown
markdownTemplate = mkTemplate "markdown"
plainTemplate :: Template Source #
File-type template for plain text
plainTemplate = mkTemplate "txt"
xmlTemplate :: Template Source #
File-type template for XML
xmlTemplate = mkTemplate "xml"
txtTemplate :: Template Source #
Same as plainTemplate
yamlTemplate :: Template Source #
File-type template for YAML
yamlTemplate = mkTemplate "yaml"
Arguments
:: String | Name of the editor. |
-> Template | Template for the file name. |
-> ByteString | Initial contents of the file. |
-> IO ByteString | Resulting ByteString. |
Open an editor. You probably don't want to use this function.
userEditor :: IO (Maybe String) Source #
This uses getEnv
from System.Posix to attempt to
get the user's $EDITOR
variable. Failing that, try the $VISUAL
variable.
Wrapper around userEditor
that includes a fallback option if the
$EDITOR
variable doesn't exist.
userEditorDefault def = userEditor >>= case
Just e -> return e
Nothing -> return def
_default_editor :: String Source #
The default editor if no other editor is found
_default_editor = "vi"
The list of variables we should search when finding the user's editor.
_editor = ["EDITOR", "VISUAL"]
Since: 0.6.0.0
wrapStr :: ByteString -> String Source #
If you don't want to use ByteString, use this function.
>>>
:type runUserEditorDWIM plainTemplate mempty
IO ByteString>>>
:type fmap wrapStr (runUserEditorDWIM plainTemplate mempty)
IO String