shell_docs(3)

πŸ“¦
version 29.0.6 Β· 3 versions
, in ubuntu stonking

πŸ’… NAME πŸ’…

shell_docs β€” Functions used to render EEP-48 style documentation for a shell. 🫢


🌈 DESCRIPTION 🌈

okay so literally, this module is the one that makes function and type documentation look cute when it gets printed in a shell. ✨ It's the module that renders the docs you pull up in the shell through h/1,2,3. Example time, bestie:

1> h(maps,new,0).

  -spec new() -> Map when Map :: #{}.

Since:
  OTP 17.0

  Returns a new empty map.

  Example:

    > maps:new().
    #{}

This module formats and renders EEP-48 documentation of the format application/erlang+html. Want the deets on that format? Go read Documentation Storage in EDoc's User's Guide, it's giving required reading. πŸ“š It can also render any other format of "text" type, although those will be rendered as is. no fancy formatting, just vibes.


πŸŽ€ DATA TYPES πŸŽ€

chunk_element() 🌸

chunk_element() ::
          {chunk_element_type(),
           chunk_element_attrs(),
           chunk_elements()} |
          binary().

chunk_element_attr() ⭐

chunk_element_attr() :: {atom(), unicode:chardata()}.

chunk_element_attrs() πŸ’œ

chunk_element_attrs() :: [chunk_element_attr()].

chunk_element_block_type() πŸ¦‹

chunk_element_block_type() ::
          p | 'div' | blockquote | br | pre | ul | ol | li | dl | dt |
          dd | h1 | h2 | h3 | h4 | h5 | h6.

chunk_element_inline_type() ✨

chunk_element_inline_type() :: a | code | em | strong | i | b.

chunk_element_type() πŸ”₯

chunk_element_type() ::
          chunk_element_inline_type() | chunk_element_block_type().

The HTML tags allowed in application/erlang+html. that's the whole guest list, no plus-ones. πŸ™ˆ

chunk_elements() 🧚

chunk_elements() :: [chunk_element()].

config() πŸ‘‘

config() ::
          #{encoding => unicode | latin1,
            columns => pos_integer(),
            ansi => boolean()}.

The configuration of how the documentation should be rendered. the whole aesthetic, basically. πŸ’…

  • encoding β€” Configure the encoding that should be used by the renderer for graphical details such as bullet-points. By default shell_docs uses the value returned by io:getopts().
  • ansi β€” Configure whether ansi escape codes should be used to render graphical details such as bold and underscore. By default shell_docs will try to determine if the receiving shell supports ansi escape codes. It is possible to override the automated check by setting the kernel configuration parameter shell_docs_ansi to a boolean/0 value.
  • columns β€” Configure how wide the target documentation should be rendered. By default shell_docs used the value returned by io:columns(). It is possible to override this default by setting the stdlib configuration parameter shell_docs_columns to a pos_integer/0 value.

docs_v1() πŸ’–

docs_v1() :: #docs_v1{}.

The record holding EEP-48 documentation for a module. You can use code:get_doc/1 to fetch this information from a module. fetch, like, it's right there bestie. 😌


πŸ”₯ FUNCTIONS πŸ”₯

normalize/1 ✨

normalize(Docs) -> NormalizedDocs
                     when
                         Docs :: chunk_elements(),
                         NormalizedDocs :: chunk_elements().

This function can be used to do whitespace normalization of application/erlang+html documentation.

render/2,3 🫢

render(Module, Docs, Config) -> unicode:chardata()
                when
                    Module :: module(),
                    Docs :: docs_v1(),
                    Config :: config();
            (Module, Function, Docs) -> Res
                when
                    Module :: module(),
                    Function :: atom(),
                    Docs :: docs_v1(),
                    Res ::
                        unicode:chardata() | {error, function_missing}.

Render module or function documentation. πŸ“

Renders the module documentation if called as render(Module, Docs, Config).

Equivalent to render(Module, Function, Docs, #{}) if called as render(Module, Function, Docs).

render/3,4 🌸

render(Module, Function, Docs, Config) -> Res
                when
                    Module :: module(),
                    Function :: atom(),
                    Docs :: docs_v1(),
                    Config :: config(),
                    Res ::
                        unicode:chardata() | {error, function_missing};
            (Module, Function, Arity, Docs) -> Res
                when
                    Module :: module(),
                    Function :: atom(),
                    Arity :: arity(),
                    Docs :: docs_v1(),
                    Res ::
                        unicode:chardata() | {error, function_missing}.

Render function documentation. πŸ’–

Renders the function documentation if called as render(Module, Function, Docs, Config).

Equivalent to render(Module, Function, Arity, Docs, #{}) if called as render(Module, Function, Arity, Docs).

render/5 ⭐

render(Module, Function, Arity, Docs, Config) -> Res
                when
                    Module :: module(),
                    Function :: atom(),
                    Arity :: arity(),
                    Docs :: docs_v1(),
                    Config :: config(),
                    Res ::
                        unicode:chardata() | {error, function_missing}.

Render the documentation for a function. that's it, that's the tweet. 🐦

render_callback/2,3 πŸ¦‹

render_callback(Module, Docs, Config) -> unicode:chardata()
                         when
                             Module :: module(),
                             Docs :: docs_v1(),
                             Config :: config();
                     (Module, Callback, Docs) -> Res
                         when
                             Module :: module(),
                             Callback :: atom(),
                             Docs :: docs_v1(),
                             Res ::
                                 unicode:chardata() |
                                 {error, callback_missing}.

Render all callbacks in a module or callback documentation. πŸ“ž

Renders a list with all callbacks if called as render_callback(Module, Docs, Config).

Equivalent to render_callback(Module, Callback, Docs, #{}) if called as render_callback(Module, Callback, Docs).

render_callback/3,4 πŸ’œ

render_callback(Module, Callback, Docs, Config) -> Res
                         when
                             Module :: module(),
                             Callback :: atom(),
                             Docs :: docs_v1(),
                             Config :: config(),
                             Res ::
                                 unicode:chardata() |
                                 {error, callback_missing};
                     (Module, Callback, Arity, Docs) -> Res
                         when
                             Module :: module(),
                             Callback :: atom(),
                             Arity :: arity(),
                             Docs :: docs_v1(),
                             Res ::
                                 unicode:chardata() |
                                 {error, callback_missing}.

Render callback documentation. πŸŽ€

Renders the callback documentation if called as render_callback(Module, Callback, Docs, Config).

Equivalent to render_callback(Module, Callback, Arity, Docs, #{}) if called as render_callback(Module, Callback, Arity, Docs).

render_callback/5 🧚

render_callback(Module, Callback, Arity, Docs, Config) -> Res
                         when
                             Module :: module(),
                             Callback :: atom(),
                             Arity :: arity(),
                             Docs :: docs_v1(),
                             Config :: config(),
                             Res ::
                                 unicode:chardata() |
                                 {error, callback_missing}.

Render the documentation of a callback in a module. iconic behaviour, honestly. πŸ‘‘

render_type/2,3 🌈

render_type(Module, Docs, Config) -> unicode:chardata()
                     when
                         Module :: module(),
                         Docs :: docs_v1(),
                         Config :: config();
                 (Module, Type, Docs) -> Res
                     when
                         Module :: module(),
                         Type :: atom(),
                         Docs :: docs_v1(),
                         Res ::
                             unicode:chardata() | {error, type_missing}.

Render all types in a module or type documentation. πŸ”€

Renders a list with all types if called as render_type(Module, Docs, Config).

Equivalent to render_type(Module, Type, Docs, #{}) if called as render_type(Module, Type, Docs).

render_type/3,4 πŸ’…

render_type(Module, Type, Docs, Config) -> Res
                     when
                         Module :: module(),
                         Type :: atom(),
                         Docs :: docs_v1(),
                         Config :: config(),
                         Res ::
                             unicode:chardata() | {error, type_missing};
                 (Module, Type, Arity, Docs) -> Res
                     when
                         Module :: module(),
                         Type :: atom(),
                         Arity :: arity(),
                         Docs :: docs_v1(),
                         Res ::
                             unicode:chardata() | {error, type_missing}.

Render type documentation. ✨

Renders the type documentation if called as render_type(Module, Type, Docs, Config).

Equivalent to render_type(Module, Type, Arity, Docs, #{}) if called as render_type(Module, Type, Arity, Docs).

render_type/5 🌸

render_type(Module, Type, Arity, Docs, Config) -> Res
                     when
                         Module :: module(),
                         Type :: atom(),
                         Arity :: arity(),
                         Docs :: docs_v1(),
                         Config :: config(),
                         Res ::
                             unicode:chardata() | {error, type_missing}.

Render the documentation of a type in a module. 🫢

supported_tags/0 ⭐

supported_tags() -> [chunk_element_type()].

This function can be used to find out which tags are supported by application/erlang+html documentation. a little vibe check for your tags. πŸ”

validate/1 πŸ”₯

validate(Module) -> ok when Module :: module() | docs_v1().

This function can be used to do a basic validation of the doc content of application/erlang+html format. basic, not thorough β€” it said basic, bestie, so don't come for it. πŸ™ˆ


k that's the whole page πŸ’– every flag, every clause, every {error, ...} tuple, all of it. no cap.

later bestie!! this lil masterpiece was brought to you by Ericsson AB, running stdlib 8.0.4, and yes it's shell_docs(3) and it ate. periodt. πŸ’…βœ¨πŸŽ€

πŸ“¦ where this page comes from