Remove keybindings fro opening files

Removed unused function

README.org

@@ -1,7 +1,9 @@
 [[file:https://cdn.rawgit.com/syl20bnr/spacemacs/442d025779da2f62fc86c2082703697714db6514/assets/spacemacs-badge.svg]]
 
 #+TITLE: Conlanging layer
-#+author: Lucien “P’undrak” Cartier-Tilet
+#+AUTHOR: Lucien “P’undrak” Cartier-Tilet
+#+PROPERTY: header-args :noweb yes :exports code
+#+PROPERTY: header-args:dot :tangle no :exports code
 
 [[img/conlang_flag.png]]
 
@@ -10,16 +12,19 @@
   - [[#features][Features]]
   - [[#graphviz-trees][Graphviz trees]]
 - [[#install][Install]]
-- [[#key-bindings][Key bindings]]
+- [[#licence][Licence]]
+- [[#documentation][Documentation]]
+  - [[#functionalities][Functionalities]]
+    - [[#graphviz-trees-generation][Graphviz trees generation]]
 
 * Description
-  This layer adds support for conlanging.
+  This layer adds features for conlanging.
 
 ** Features
    - Generate graphviz trees based on Elisp trees
    - Replace  some  text  by  its  runic equivalent  (supports  the  Mattér  and
      Eittlandic languages)
-   - Adds phonetics to Ňyqy text
+   - Adds phonetics to Proto-Ñyqy text
    - Provides custom shortcuts
 
 ** Graphviz trees
@@ -65,9 +70,9 @@
    [[file:img/vowels-example.png]]
 
    This example tree is only a binary tree, but a single node can have up to ten
-   children. See some examples in the [[https://labs.phundrak.fr/phundrak/langue-phundrak-fr/blob/master/nyqy.org][Ňyqy source file]].
+   children. See some examples in the [[https://labs.phundrak.com/phundrak/langue-phundrak-fr/blob/master/proto-nyqy.org][Ñyqy source file]].
 
-   It is planned  to merge [[https://labs.phundrak.fr/phundrak/distinctive-features-chooser][this project]]  into this layer in  order to facilitate
+   It is planned  to merge [[https://labs.phundrak.com/phundrak/distinctive-features-chooser][this project]]  into this layer in  order to facilitate
    the creation of trees based on distinctive features.
 
 * Install
@@ -83,18 +88,84 @@
   You can then reload your configuration file with ~SPC f e R~, or restart Emacs
   with ~SPC q r~ or ~SPC q R~.
 
-* Key bindings
+* Licence
+  All the code included in this  repository is licensed under the GPLv3 license.
+  See [[file:LICENCE]].
 
-  | Key Binding   | Description                                                             |
+* Documentation
-  |---------------+-------------------------------------------------------------------------|
+  The following  is the  documentation of  the source  code of  the ~conlanging~
-  | ~SPC l e l~   | (org-mode only) Translate Einnlandish transliteration into native latin |
+  layer. It is divided  in two main parts, describing the two  main files of the
-  | ~SPC l e r~   | (org-mode only) Translate Einnlandish transliteration into runes        |
+  layer: ~funcs.el~  and ~keybindings.el~. First  of all, let’s  simply describe
-  | ~SPC l m L~   | (org-mode only) Translate Mattér transliteration into LaTeX runes       |
+  the ~layer.el~ file.
-  | ~SPC l m l~   | (org-mode only) Translate Mattér transliteration into native latin      |
+  #+BEGIN_SRC emacs-lisp :tangle layers.el
-  | ~SPC l m r~   | (org-mode only) Translate Mattér transliteration into runes             |
+    (configuration-layer/declare-layer 'conlanging)
-  | ~SPC o l e o~ | Open Eittlandic file                                                    |
+  #+END_SRC
-  | ~SPC o l h o~ | Open Hjelp file                                                         |
+
-  | ~SPC o l m o~ | Open Mattér file                                                        |
+  And that’s enough for the ~layer.el~ file! Now, onto the ~funcs.el~ file.
-  | ~SPC o l n o~ | Open Ňyqy file                                                          |
+
-  | ~SPC o l o~   | Open the conlanging directory                                           |
+** Functionalities
-  | ~SPC o l t o~ | Open Tãso file                                                          |
+   :PROPERTIES:
+   :HEADER-ARGS: :tangle funcs.el
+   :END:
+   Here will be  detailed the functionalities of the ~conlanging~  layer. It can
+   be divided in several parts.
+
+*** Graphviz trees generation
+    As described above, it is possible to create graphviz trees from Elisp trees
+    made from  lists. This feature is  coded in two functions:  one that creates
+    the tree itself, and one that  generates nodes. The first one that generates
+    nodes is declared  as a private function (actually, it’s  just prefixed with
+    ~conlanging//~ following Spacemacs’ [[https://www.spacemacs.org/doc/CONVENTIONS.html#spacemacs-core-and-layer][naming convention]]).
+    #+BEGIN_SRC emacs-lisp
+      (defun conlanging//declare-node (t-node-text t-node-generation)
+        "Declares a node in the graphviz source code. The node’s identifier will be
+      `t-node-generation', and it will bear the label `t-node-text'."
+        (format "%d[label=\"%s\"];" t-node-generation
+                t-node-text))
+    #+END_SRC
+
+    This can result in a graphviz node declared like so:
+    #+BEGIN_SRC dot
+      231[label="This is a label"];
+    #+END_SRC
+
+    All nodes generated by the function have  a unique identifier in the form of
+    a number, and its content is only defined by its label. By default, the tree
+    created from  the graphviz  code gives a  tree from top  to bottom  with the
+    label not surrounded by anything. Let’s declare our whole function:
+    #+BEGIN_SRC emacs-lisp
+      (defun conlanging/tree-to-dot (t-tree &optional t-current-generation t-previous-generation)
+        "Translates an Elisp t-tree with any number of children per node
+      to a corresponding graphviz file that can be executed from dot.
+      Arguments:
+      - `t-tree': t-tree to convert
+      - `t-current-generation': generation number, incremented when
+        changing from a node to another node from the same generation,
+        multiplied by 10 when going from a node to one of its children.
+      - `t-previous-generation': generation number from previous named
+        node"
+        (cond
+         ((null t-previous-generation) ;; first call
+          (concat "graph{graph[dpi=300];node[shape=plaintext];graph[bgcolor=\"transparent\"];"
+                  (conlanging//declare-node (car t-tree) 0)
+                  (conlanging/tree-to-dot (cdr t-tree) 1 0)
+                  "}"))
+         ((null t-tree) "") ;; last call in this branch
+         ((atom (car t-tree)) ;; '("text" () () ()) manage the label
+          (concat (conlanging//declare-node (car t-tree)
+                                            t-current-generation)
+                  ;; make link
+                  (concat (number-to-string t-previous-generation) " -- "
+                          (number-to-string t-current-generation) ";")
+                  (conlanging/tree-to-dot (cdr t-tree)
+                                          (+ 1
+                                             (* 10 t-current-generation))
+                                          t-current-generation)))
+         ((listp (car t-tree)) ;; '(() () ()) manage the branches
+          (concat (conlanging/tree-to-dot (car t-tree) ;; child of current node
+                                          t-current-generation
+                                          t-previous-generation)
+                  (conlanging/tree-to-dot (cdr t-tree)
+                                          (+ 1 t-current-generation)
+                                          t-previous-generation)))))
+    #+END_SRC

funcs.el

@@ -1,9 +1,9 @@
 ;;; funcs.el --- Conlanging Layer functions File for Spacemacs
 ;;
-;; Copyright (c) 2019-2020 Lucien Cartier-Tilet
+;; Copyright (c) 2018-2020 Lucien Cartier-Tilet
 ;;
-;; Author: Lucien Cartier-Tilet <phundrak@phundrak.fr>
+;; Author: Lucien Cartier-Tilet <lucien@phundrak.com>
-;; URL: https://github.com/syl20bnr/spacemacs
+;; URL: https://labs.phundrak.com/phundrak/conlang-layer
 ;;
 ;; This file is not part of GNU Emacs.
 ;;
@@ -12,46 +12,46 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                                         ;                 Tree                ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defun conlanging//declare-node (node-text node-generation)
+(defun conlanging//declare-node (t-node-text t-node-generation)
   "Declares a node in the graphviz source code. The node’s identifier will be
-~node-generation~, and it will bear the label ~node-text~."
+`node-generation', and it will bear the label `node-text'."
-  (format "%d[label=\"%s\"];" node-generation
+  (format "%d[label=\"%s\"];" t-node-generation
-          node-text))
+          t-node-text))
 
-(defun conlanging/tree-to-dot (tree &optional current-generation previous-generation)
+(defun conlanging/tree-to-dot (t-tree &optional t-current-generation t-previous-generation)
-  "Translates an Elisp tree with any number of children per node
+  "Translates an Elisp t-tree with any number of children per node
 to a corresponding graphviz file that can be executed from dot.
 Arguments:
-- `tree': tree to convert
+- `t-tree': t-tree to convert
-- `current-generation': generation number, incremented when
+- `t-current-generation': generation number, incremented when
   changing from a node to another node from the same generation,
   multiplied by 10 when going from a node to one of its children.
-- `previous-generation': generation number from previous named
+- `t-previous-generation': generation number from previous named
   node"
   (cond
-   ((null previous-generation) ;; first call
+   ((null t-previous-generation) ;; first call
     (concat "graph{graph[dpi=300];node[shape=plaintext];graph[bgcolor=\"transparent\"];"
-            (conlanging//declare-node (car tree) 0)
+            (conlanging//declare-node (car t-tree) 0)
-            (conlanging/tree-to-dot (cdr tree) 1 0)
+            (conlanging/tree-to-dot (cdr t-tree) 1 0)
             "}"))
-   ((null tree) "") ;; last call in this branch
+   ((null t-tree) "") ;; last call in this branch
-   ((atom (car tree)) ;; '("text" () () ()) manage the label
+   ((atom (car t-tree)) ;; '("text" () () ()) manage the label
-    (concat (conlanging//declare-node (car tree)
+    (concat (conlanging//declare-node (car t-tree)
-                                      current-generation)
+                                      t-current-generation)
             ;; make link
-            (concat (number-to-string previous-generation) " -- "
+            (concat (number-to-string t-previous-generation) " -- "
-                    (number-to-string current-generation) ";")
+                    (number-to-string t-current-generation) ";")
-            (conlanging/tree-to-dot (cdr tree)
+            (conlanging/tree-to-dot (cdr t-tree)
                                     (+ 1
-                                       (* 10 current-generation))
+                                       (* 10 t-current-generation))
-                                    current-generation)))
+                                    t-current-generation)))
-   ((listp (car tree)) ;; '(() () ()) manage the branches
+   ((listp (car t-tree)) ;; '(() () ()) manage the branches
-    (concat (conlanging/tree-to-dot (car tree) ;; child of current node
+    (concat (conlanging/tree-to-dot (car t-tree) ;; child of current node
-                                    current-generation
+                                    t-current-generation
-                                    previous-generation)
+                                    t-previous-generation)
-            (conlanging/tree-to-dot (cdr tree)
+            (conlanging/tree-to-dot (cdr t-tree)
-                                    (+ 1 current-generation)
+                                    (+ 1 t-current-generation)
-                                    previous-generation)))))
+                                    t-previous-generation)))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                                         ;                Common               ;
@@ -73,13 +73,12 @@ table"
 none the word the cursor is over"
   (interactive)
   (let* ((beg (region-beginning))
-         (end (region-end))
+         (end (region-end)))
-         (boundary-word (bounds-of-thing-at-point 'word)))
     (if (= beg end)
-        boundary-word
+        (bounds-of-thing-at-point 'word)
       (cons beg end))))
 
-(defun conlanging//replace-char-by-table (correspondance-table)
+(defun conlanging//replace-char-by-table (t-correspondance-table)
   "Replaces selected text’s strings according to the table passed
 as argument. The table is a list of pairs, the first element of
 the pair is a regex to be searched in the selected text and the
@@ -87,26 +86,13 @@ second element of the pair the string it has to be replaced
 with."
   (let* ((cur-boundary (conlanging//get-boundary))
          (beg (car cur-boundary))
-         (end (cdr cur-boundary)))
+         (end (cdr cur-boundary))
-    (setq-local regionp
+         (regionp (buffer-substring-no-properties beg end))
-                (buffer-substring-no-properties beg end))
+         (new-regionp (conlanging//replace-string-by-char regionp
-    (setq-local regionp
+                                                          t-correspondance-table)))
-                (conlanging//replace-string-by-char regionp
-                                                    correspondance-table))
     (delete-region beg end)
     (goto-char beg)
-    (insert regionp)))
+    (insert new-regionp)))
-
-(defun conlanging//find-elem-in-list (elem list)
-  "In  a list  containing lists,  returns the  element of  `list'
-whose first element equals `elem'"
-  (if list
-      (if (string= (caar list)
-                   elem)
-          (car list)
-        (conlanging//find-elem-in-list elem
-                                       (cdr list)))
-    nil))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                                         ;                Mattér               ;
@@ -203,90 +189,87 @@ latin writing system"
   (interactive)
   (conlanging//replace-char-by-table conlanging//matter-latin-to-latex))
 
-(defun conlanging/matter-org-export-runes (text)
+(defun conlanging/matter-org-export-runes (t-text)
-  "Replaces the transliterated Mattér `text' with its
+  "Replaces the transliterated Mattér `t-text' with its
 corresponding runes during org-mode export"
   (interactive)
   (if (org-export-derived-backend-p org-export-current-backend
                                     'latex)
       (concat "\\textarm{"
-              (conlanging//replace-string-by-char text conlanging//matter-latin-to-latex)
+              (conlanging//replace-string-by-char t-text conlanging//matter-latin-to-latex)
               "}")
-    (conlanging//replace-string-by-char text conlanging//matter-latin-to-runes)))
+    (conlanging//replace-string-by-char t-text conlanging//matter-latin-to-runes)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-                                        ;              Eittlanda              ;
+                                        ;              Eittlandic              ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defvar conlanging//eittlanda-latin-to-latex '((", *" . "\\\\tripledot")
+(defvar conlanging//eittlandic-latin-to-latex '((", *\\|\\. *" . "\\\\tripledot")
-                                               ("\\. *" . "\\\\tripledot")
+                                                (" +"          . ":")
-                                               (" +" . ":")
+                                                ("hv"          . "x")
-                                               ("hv" . "x")
+                                                ("í"           . "i")
-                                               ("ø" . "\\\\o")
+                                                ("é"           . "\\\\e")
-                                               ("œ" . "\\\\oO")
+                                                ("ę\\|æ"       . "æ")
-                                               ("v" . "w")
+                                                ("ý"           . "y")
-                                               ("ó" . "v")
+                                                ("œ"           . "ø")
-                                               ("ń" . "\\\\ndot"))
+                                                ("ú"           . "u")
+                                                ("ó"           . "o")
+                                                ("á\\|ǫ"       . "a")
+                                                ("j"           . "i"))
   "Equivalence between the Eittlandic orthography in the Latin
 script and the LaTeX code for the Runic script. The first element
 of a pair is the Latin script orthography, the second is the
 Runic LaTeX code equivalent.")
 
-(defvar conlanging//eittlanda-latin-to-runes '((", *" . "⁝")
+(defvar conlanging//eittlandic-latin-to-runes '((", *\\|\\. *"   . "⁝")
-                                               ("\\. *" . "⁝")
+                                                (" +\\|:"        . "᛬")
-                                               (" +" . "᛬")
+                                                ("hv"            . "ᛪ")
-                                               (":" . "᛬")
+                                                ("i\\|í\\|j"     . "ᛁ")
-                                               ("hv" . "ᛪ")
+                                                ("é"             . "ᛂ")
-                                               ("i" . "ᛁ")
+                                                ("e\\|ę\\|æ"     . "ᛅ")
-                                               ("y" . "ᛦ")
+                                                ("y\\|ý"         . "ᛦ")
-                                               ("u" . "ᚢ")
+                                                ("ø\\|œ"         . "ᚯ")
-                                               ("e" . "ᛂ")
+                                                ("u\\|ú\\|v\\|w" . "ᚢ")
-                                               ("ø" . "ᚯ")
+                                                ("o\\|ó"         . "ᚮ")
-                                               ("o" . "ᚮ")
+                                                ("a\\|á\\|ǫ"     . "ᛆ")
-                                               ("œ" . "ᚰ")
+                                                ("p"             . "ᛔ")
-                                               ("ó" . "ᚤ")
+                                                ("b"             . "ᛒ")
-                                               ("æ" . "ᛅ")
+                                                ("f"             . "ᚠ")
-                                               ("a" . "ᛆ")
+                                                ("t"             . "ᛐ")
-                                               ("m" . "ᛘ")
+                                                ("d"             . "ᛑ")
-                                               ("n" . "ᚾ")
+                                                ("þ"             . "ᚦ")
-                                               ("ń" . "ᛀ")
+                                                ("ð"             . "ᚧ")
-                                               ("p" . "ᛔ")
+                                                ("s"             . "ᛋ")
-                                               ("b" . "ᛒ")
+                                                ("k"             . "ᚴ")
-                                               ("t" . "ᛐ")
+                                                ("g"             . "ᚵ")
-                                               ("d" . "ᛑ")
+                                                ("h"             . "ᚼ")
-                                               ("k" . "ᚴ")
+                                                ("m"             . "ᛘ")
-                                               ("g" . "ᚵ")
+                                                ("n"             . "ᚿ")
-                                               ("f" . "ᚠ")
+                                                ("r"             . "ᚱ")
-                                               ("þ" . "ᚦ")
+                                                ("l"             . "ᛚ"))
-                                               ("ð" . "ᚧ")
-                                               ("s" . "ᛋ")
-                                               ("h" . "ᚼ")
-                                               ("v" . "ᚥ")
-                                               ("r" . "ᚱ")
-                                               ("l" . "ᛚ"))
   "Equivalence between the Eittlandic orthography in the Latin
  script and the Runic script. The first element of a pair is the
  Latin script orthography, the second is the Runic equivalent.")
 
-(defun conlanging/eittlanda-to-runes ()
+(defun conlanging/eittlandic-to-runes ()
   "Replaces transliterated Eittlandic with its runic writing system"
   (interactive)
-  (conlanging//replace-char-by-table conlanging//eittlanda-latin-to-runes))
+  (conlanging//replace-char-by-table conlanging//eittlandic-latin-to-runes))
 
-(defun conlanging/eittlanda-to-latex ()
+(defun conlanging/eittlandic-to-latex ()
   "Replaces transliterated Eittlandic with its corresponding runes"
   (interactive)
-  (conlanging//replace-char-by-table conlanging//eittlanda-latin-to-latex))
+  (conlanging//replace-char-by-table conlanging//eittlandic-latin-to-latex))
 
-(defun conlanging/eittlanda-org-export-runes (text)
+(defun conlanging/eittlandic-org-export-runes (t-text)
   "Replaces  transliterated  Eittlandic  with  its  corresponding
 runes during org-mode export"
   (interactive)
   (if (org-export-derived-backend-p org-export-current-backend
                                     'latex)
       (concat "\\textarm{"
-              (conlanging//replace-string-by-char text conlanging//eittlanda-latin-to-latex)
+              (conlanging//replace-string-by-char t-text conlanging//eittlandic-latin-to-latex)
               "}")
-    (conlanging//replace-string-by-char text conlanging//eittlanda-latin-to-runes)))
+    (conlanging//replace-string-by-char t-text conlanging//eittlandic-latin-to-runes)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                                         ;                    Ñyqy             ;
@@ -294,8 +277,8 @@ runes during org-mode export"
 (defvar conlanging//nyqy-phonetics '(("q" t   t   "q" "ħ")
                                      ("g" t   t   "ɢ" "ʢ")
                                      ("ñ" t   t   "ɴ" "m")
-                                     ("c" t   t   "t͡ʃ" "ɬ")
+                                     ("c" t   t   "c" "ɬ")
-                                     ("j" t   t   "d͡ʒ" "ɮ")
+                                     ("j" t   t   "ɟ" "ɮ")
                                      ("w" t   t   "w" "l")
                                      ("p" t   nil "χ" "p")
                                      ("b" t   nil "ʁ" "b")
@@ -307,8 +290,8 @@ runes during org-mode export"
                                      ("ú" nil "u")
                                      ("i" nil "ɪ")
                                      ("u" nil "ʊ")
-                                     ("é" nil "ø")
+                                     ("ø" nil "ø")
-                                     ("ó" nil "ɤ")
+                                     ("œ" nil "ɤ")
                                      ("e" nil "ɛ")
                                      ("o" nil "ɔ")
                                      (" " nil " ")
@@ -327,77 +310,90 @@ dorsal prononciation and its non-dorsal pronunciation.
 If it is not a consonant, then the third value is its
 pronunciation already.")
 
-(defun conlanging//nyqy-is-consonant (elem)
+(defun conlanging//nyqy-is-consonant (t-elem)
-  (nth 1 elem))
+  (nth 1 t-elem))
 
-(defun conlanging//nyqy-is-dorsal (elem)
+(defun conlanging//nyqy-is-dorsal (t-elem)
-  (nth 2 elem))
+  (nth 2 t-elem))
 
-(defun conlanging//nyqy-get-phoneme (phoneme &optional is-consonant is-dorsal)
+(defun conlanging//nyqy-get-phoneme (t-phoneme &optional t-is-consonant t-is-dorsal)
-  "Extracts a phoneme from `phoneme'.
+  "Extracts a phoneme from `t-phoneme'.
 
 Arguments:
-- phoneme: array from `conlanging//nyqy-phonetics'
+- `t-phoneme': array from `conlanging//nyqy-phonetics'
-- is-consonant: whether `phoneme' represents a
+- `t-is-consonant': whether `t-phoneme' represents a
-  consonant (default: nil)
+  consonant (default: `nil')
-- is-dorsal: whether `phoneme' should be a dorsal
+- `t-is-dorsal': whether `t-phoneme' should be a dorsal
-  consonant (default: nil)"
+  consonant (default: `nil')"
-  (if is-consonant
+  (if t-is-consonant
-      (if is-dorsal
+      (if t-is-dorsal
-          (nth 3 phoneme)
+          (nth 3 t-phoneme)
-        (nth 4 phoneme))
+        (nth 4 t-phoneme))
-    (nth 2 phoneme)))
+    (nth 2 t-phoneme)))
 
-(defun conlanging/nyqy-to-phonetics (text &optional nyqy phonetics met-consonant
+(defun conlanging/nyqy-to-phonetics (t-text &optional t-nyqy t-phonetics t-met-consonant
-                                          dorsal)
+                                            t-dorsal)
-  "Returns the phonetics equivalent of the Ñyqy `text', either as
+  "Returns the phonetics equivalent of the Ñyqy `t-text'.
-a tooltip in HTML or plain text for LaTeX exports.
 
 Arguments:
-- text: text to convert to phonetics
+- `t-text': text to convert to phonetics
-- nyqy: for internal use only, `text' argument but as a list of
+- `t-nyqy': for internal use only, `t-text' argument but as a
-  characters
+  list of characters
-- phonetics: for internal use only, result phonetics, array
+- `t-phonetics': for internal use only, result phonetics, array
-- met-consonant: for internal use only, `t' if a consonant has
+- `t-met-consonant': for internal use only, `t' if a consonant
-  been met previously, `nil' otherwise
+  has been met previously, `nil' otherwise
-- dorsal: for internal use only, `t' if the current consonant is
+- `t-dorsal': for internal use only, `t' if the current consonant
-  required to be dorsal, `nil' otherwise"
+  is required to be dorsal, `nil' otherwise"
   (interactive)
   (cond
-   ((eq nil phonetics) ;; first call to the function
+
-    (conlanging/nyqy-to-phonetics text
+   ;; first call to the function
-                                  (split-string (downcase text)
+   ((eq nil t-phonetics)
-                                                ""
+    (conlanging/nyqy-to-phonetics t-text
-                                                t)
+                                  (split-string (downcase t-text) "" t)
                                   ""))
-   ((eq nil nyqy) ;; no more to convert
+
-    (progn
+   ;; no more to convert
-      (format (concat "@@html:<span class=\"tooltip\"><i>%s</i><span class=\"tooltiptext\">/%s/</span></span>@@"
+   ((eq nil t-nyqy)
-                      "@@latex:\\textit{%s} (/%s/)@@")
+    t-phonetics)
-              text
+
-              phonetics
+   ;; default option
-              text
+   (t (let* ((cur-char (car t-nyqy)) ;; default option
-              phonetics)))
-   (t (let* ((cur-char (car nyqy)) ;; default option
              (cur-phon (seq-find (lambda (elt)
                                    (string= (car elt)
                                             cur-char))
                                  conlanging//nyqy-phonetics))
              (is-consonant (conlanging//nyqy-is-consonant cur-phon))
-             (dorsal (if (or met-consonant
+             (t-dorsal (if (or t-met-consonant
-                             (not is-consonant))
+                               (not is-consonant))
-                         dorsal
+                           t-dorsal
-                       (conlanging//nyqy-is-dorsal cur-phon))))
+                         (conlanging//nyqy-is-dorsal cur-phon))))
         (if is-consonant
-            (conlanging/nyqy-to-phonetics text
+            (conlanging/nyqy-to-phonetics t-text
-                                          (cdr nyqy)
+                                          (cdr t-nyqy)
-                                          (concat phonetics
+                                          (concat t-phonetics
-                                                  (conlanging//nyqy-get-phoneme cur-phon t dorsal))
+                                                  (conlanging//nyqy-get-phoneme cur-phon t t-dorsal))
                                           t
-                                          (not dorsal))
+                                          (not t-dorsal))
-          (conlanging/nyqy-to-phonetics text
+          (conlanging/nyqy-to-phonetics t-text
-                                        (cdr nyqy)
+                                        (cdr t-nyqy)
-                                        (concat phonetics
+                                        (concat t-phonetics
                                                 (conlanging//nyqy-get-phoneme cur-phon nil))
-                                        met-consonant
+                                        t-met-consonant
-                                        dorsal))))))
+                                        t-dorsal))))))
+
+(defun conlanging/nyqy-to-org (t-text)
+  "Returns the phonetics equivalent of the Ñygy `t-text' properly
+formatted for org so it gets exported as a tooltip in HTML or as
+LaTeX code for LaTeX exports.
+
+Arguments:
+- `t-text': text to convert to phonetics"
+  (let ((phonetics (conlanging/nyqy-to-phonetics t-text))
+        (text t-text))
+    (format (concat "@@html:<span class=\"tooltip\"><i>%s</i><span class=\"tooltiptext\">/%s/</span></span>@@"
+                    "@@latex:\\textit{%s} (/%s/)@@")
+            text
+            phonetics
+            text
+            phonetics)))

keybindings.el

@@ -1,72 +1,19 @@
-;;; packages.el --- conlanging layer packages file for Spacemacs.
+;;; keybindings.el --- conlanging layer packages file for Spacemacs.
 ;;
-;; Copyright (c) 2012-2018 Sylvain Benner & Contributors
+;; Copyright (c) 2018-2020 Lucien Cartier-Tilet
 ;;
-;; Author: Lucien Cartier-Tilet <phundrak@phundrak.fr>
+;; Author: Lucien Cartier-Tilet <lucien@phundrak.com>
-;; URL: https://github.com/syl20bnr/spacemacs
+;; URL: https://labs.phundrak.com/phundrak/conlang-layer
 ;;
 ;; This file is not part of GNU Emacs.
 ;;
 ;;; License: GPLv3
 
-(spacemacs/declare-prefix "ol" "conlanging")
+(spacemacs/set-leader-keys-for-major-mode 'org-mode
-(spacemacs/declare-prefix "olh" "Hjelp")
+  "ler" 'conlanging/eittlanda-to-runes
-(spacemacs/declare-prefix "olho" "hjelp.org")
+  "lel" 'conlanging/eittlanda-to-latex
-(spacemacs/declare-prefix "olm" "Mattér")
+  "lmr" 'conlanging/matter-to-runes
-(spacemacs/declare-prefix "olmo" "matter.org")
+  "lml" 'conlanging/matter-to-native-latin
-(spacemacs/declare-prefix "ole" "Einnlanda")
-(spacemacs/declare-prefix "oleo" "eittlanda.org")
-(spacemacs/declare-prefix "oln" "Ñyqy")
-(spacemacs/declare-prefix "olno" "nyqy.org")
-(spacemacs/declare-prefix "olne" "nyqy.org (English)")
-(spacemacs/declare-prefix "olo" "Conlang directory")
-(spacemacs/declare-prefix "olO" "Conlang root directory")
-(spacemacs/declare-prefix "olt" "Tãso")
-(spacemacs/declare-prefix "olto" "taso.org")
-(spacemacs/declare-prefix-for-mode 'org-mode
-  "ml" "conlanging")
-(spacemacs/declare-prefix-for-mode 'org-mode
-  "mle" "Eittlanda")
-(spacemacs/declare-prefix-for-mode 'org-mode
-  "mlm" "Mattér")
-
-(spacemacs/set-leader-keys "oleo"
-  (lambda ()
-    (interactive)
-    (find-file "~/Documents/conlanging/web/eittlanda.org"))
-  "olho"
-  (lambda ()
-    (interactive)
-    (find-file "~/Documents/conlanging/web/hjelp.org"))
-  "olmo"
-  (lambda ()
-    (interactive)
-    (find-file "~/Documents/conlanging/web/matter.org"))
-  "olno"
-  (lambda ()
-    (interactive)
-    (find-file "~/Documents/conlanging/web/nyqy.org"))
-  "olne"
-  (lambda ()
-    (interactive)
-    (find-file "~/Documents/conlanging/web/en/nyqy.org"))
-  "olO"
-  (lambda ()
-    (interactive)
-    (dired "~/Documents/conlanging"))
-  "olo"
-  (lambda ()
-    (interactive)
-    (dired "~/Documents/conlanging/web"))
-  "olto"
-  (lambda ()
-    (interactive)
-    (find-file "~/Documents/conlanging/web/taso.org")))
-
-(spacemacs/set-leader-keys-for-major-mode
-  'org-mode "ler" 'conlanging/eittlanda-to-runes
-  "lel" 'conlanging/eittlanda-to-latex "lmr"
-  'conlanging/matter-to-runes "lml" 'conlanging/matter-to-native-latin
   "lmL" 'conlanging/matter-to-latex)
 
 ;;; keybindings.el ends here