Note Taking Manual

3.1.1 Problems with org-mode

3.1.2 Strengths to org-mode

3.1.3 Use Case

3.1.4 Using pandoc

    input=$(xclip -o -selection clipboard)
  alias xclip='xclip -selection clipboard'
# To Org
  xclip -o |  pandoc -s -f markdown -t org | xclip 
# Back to Markdown
  xclip -o |  pandoc -s -t markdown -f org | xclip 

curl https://orgmode.org/manual/Markdown-Export.html#Markdown-Export | pandoc -f HTML -t gfm | xclip -selection clipboard

   arglink=$(xclip -o -selection clipboard)
 title=$(wget -qO- $arglink |
 perl -l -0777 -ne 'print $1 if /<title.*?>\s*(.*?)\s*<\/title/si' |
 recode html..)
 outputlink="[$title]($arglink)"
echo $outputlink | xclip -selection clipboard

1. Problems with links
   

   Links may become a pain in the ass to maintain, so what i do is copy the file name to the clipboard and use fzf with this bash script to make a relative link to a file:

   #!/bin/bash
   # Don't forget to adjust the permissions with:
   #chmod +x ~/somecrazyfolder/script1
   
   ## Program
   
   
   ### Description
   # This will use fzf to find filenames that might correspond to a path from a broken link in the clipboard.
   
   # so let's say that ~[](~/broken/path/to/rsico.png)~ is a broken link, I can use ~yi(~ to copy that to the clipboard in vim  and run the following bash scipt to return the correct link:
   
   # Requires:
     # * gnu coreutils (specifically realpath)
     # * fzf
     # * xclip
   
   ### Code
   brokenPath=$(xclip -o -selection clipboard)
   #find ~/Dropbox/ -name $(echo $(basename $brokenPath)) | fzf | xclip -selection clipboard
   NewFile=$(find ~/Dropbox/ -name $(echo $(basename $brokenPath)) | fzf)
   echo $NewFile | xclip -selection clipboard
   
   echo "
   Put the path of the source file in the clipboard and Press any Key to Continue
   "
   
   # this will just continue after a key stroke
   read -d'' -s -n1
   
   echo "
   Using:
   
   "
   
   sourceFile=$(xclip -o -selection clipboard)
   
   echo "
   SOURCE_FILE.......$sourceFile
   NEW_ATTACHMENT....$NewFile 
   "
   
   
   sourcePath=$(dirname $sourceFile)
   
   relativePath=$(realpath --relative-to=$sourcePath $NewFile)
   relPathWithDot="./"$relativePath
   echo $relPathWithDot | xclip -selection clipboard
   
   echo "
   
   Success! Relative path is in clipboard
   "
   
   exit 0
   ## vim:fdm=expr:fdl=0
   ## vim:fde=getline(v\:lnum)=~'^##'?'>'.(matchend(getline(v\:lnum),'##*')-2)\:'='
   
   

5.1.1 Apple Pencil

5.1.2 TiKz

5.1.3 InkScape

6.1.1 Yaml Tags

1. Inserting YAML Tags   ATTACH
   

   In order to insert a YAML tag into a note with vim you can use FZF to read a text file and make suggestions from a text file with those entries:

   imap <expr> <C-c><C-y> fzf#vim#complete('cat ~/Notes/MD/notes/00tags.csv')
   

   In order to get that text file you can use an R that leverages RMarkdown to pull the yaml out:

   noteFiles <- c(dir(pattern="*.Rmd"), dir(pattern="*.md"), dir(pattern="*.txt"), dir(pattern="*.markdown"))
   tagVector <- c()
   
   # Run the following code over the entire folder
   for (i in noteFiles){
     yamlExtract <- yaml_front_matter(input = i )
     MDTags      <- (yamlExtract$tags)
     tagVector <- c(MDTags, tagVector)
   
   
   # Generate Symlinks
     for (tagDirPath in MDTags) {
           actDirPath  <- paste0("./aaaamytest/", tagDirPath)
           dir.create(path = actDirPath, recursive = TRUE)
           linkPath=paste0( actDirPath, "/", i)
           print(i)
           print(linkPath)
           createLink(link = linkPath, target = i)
     }
   }
   

   Then you can just regenerate the tags as needed with $ Rscript makeTags.R and insert them with C-c C-y.

   This can be seen in this gif:

   

2. Browsing Yaml Tags
   

   In order to browse YAML tags just search for the verbatim structure with ripgrep, in this context YAML tags are only used to set up notebook directories, so they will always be nested with / characters, hence the number of false positives will be small enough to justify this simplicity:

     cat 00tags.csv  | rg '[a-zA-Z0-9]+/[a-zA-Z0-9/]+'  | fzf | xargs rg -l > /tmp/kdkdjaksd;
     cat /tmp/kdkdjaksd
   # I couldn't get a pipe to work so I had to save to /tmp
   

   1. Folder Structure
      

      You can Also browse through the YAML tags like a folder structure, the above RScript at 6.1.1.1 uses a nested for loop to create a directory structure with symlinks for the corresponding notes.

6.1.2 #Tags

1. Listing already Created tags
   

   This is where #tags really shine, because they are easy to parse and because ripgrep and fzf are both lightning fast all the notes can be searched and all the tags listed on the fly like so:

   imap <expr> <C-c><C-t> fzf#vim#complete('rg --pcre2 "\s#[a-zA-Z-@]+\s" -o --no-filename $HOME/Notes/MD/notes -t md \| sort -u')
   

   Then simply presing C-c C-t in vim will allow you to enter the matching tag.

2. Filtering by the desired tag
   

   This is where #tags are amazing, because they are so simple, they can be recursively filtered for, first create a temporary file to store any notes that have tags in them⁶, then use ripgrep with look-around to extract the tag name:

   First find all the tags and offer the user

      # Make a temp file to store results if necessary
     if test -f 00TagMatchList; then
             echo "subsequent search";
     else
              # List in order of modification Date, top newest
             ls -t *.md > 00TagMatchList;
     fi
   
   tagval=$(cat 00TagMatchList | xargs -d '\n' rg --pcre2 --no-pcre2-unicode --no-filename '(?<=[\n\s]#)[a-zA-z]+(?=[\s\n$])' -o | sort -u | fzf)
   

   After the tags have been identified and passed to the user, save the tagval as a temp file and search through all the notes listed in the file for any matches:

   if [[ ! -z $tagval ]]; then
       echo '
         wait for fzf to finish otherwise ripgrep has
   nothing with which to filter  '
       exit 1
   else
     cat 00TagMatchList | xargs rg ":$tagval:|\s#$tagval\s" -l > 00TagMatchList;
   fi
      bat 00TagMatchList
   

   Now you can re run those last two commands (which I've written into a bash script as tagFilter.sh here, over and over again until the number of listed tags is down to a reasonable number⁷ .

   Once you're satisfied that the results are sufficiently filtered you can dump them as symlinks into a direcory like so:

   mkdir 00TagMatch
   rm 00TagMatch/*
   ln -s $(realpath $(cat 00TagMatchList)) ./00TagMatch; rm 00TagMatchList
   

   Then you can go through that directory using fzf and --preview with ⁸:

   rg --files-with-matches --no-messages "$1" | fzf --preview "highlight -O ansi -l {} 2> /dev/null | rg --colors 'match:bg:yellow' --ignore-case --pretty --context 10 '$1' || rg --ignore-case --pretty --context 10 '$1' {}"
   

   Or you you could preview the files in ranger using glow by appending the following to your scope.sh:⁹

   ...
     md|markdown)
       glow -s dark "${FILE_PATH}" && { dump | trim; exit 5; }
       ;;
    ...
   

   1. Example
      

      This can be seen in the below gif:

      

3. Integrating with TMSU
   

   Alternatively you can leverage TMSU to make all the symlinks, both is probably the way to go because that way you're not tied to TMSU (plus the mounting is a little buggy) but you can still leverage it

   # Piping is still better than a loop because ripgrep acts on everything
       # Unfoutunately you cannot pipe directley into tmsu
     cd ~/Notes/MD/notes
     rg --pcre2 '(?<=\s#)[a-zA-Z]+(?=\s)' *.md -o \
         | sed s+:+\ + | sed s/^/tmsu\ tag\ / | bash
   

   TMSU wouldn't work so well with nested yaml TAGS because TMSU doesn't have any notion of nested tags, instead it would be easier to create symlinks directly from R using R.utils::createLink()

4. Browsing through the Symlinks
   

   Then you can mount the TMSU Virtual File System wherever you like and there is an easy to browse through tags.

   What works really well though is to open nvim in the directory with:

   # any other way causes a crash
   # also confusingly =|= is to vim as =;= is to bash
   nvim -c 'set noautochdir | cd 00tmsutags/ | pwd'#+end_src
   

   and then search through the files using :Files from FZF (mapped to C-p / SPC f f) and/or NerdTree, and use iamcco's preview in Firefox with Tree Style Tab to stay organised. If you'd rather work from bash you can use fzf with the --preview option from before.

   Or you could use vim with and a preview app like iamcco's.

   Or you could preview all the markdown in a rendered state by using MarkText / or Typora, or Zettlr, Abricotine, Typora, MarkdownViewer Chrome Plugin¹⁰ , MkDocs or Docsify, are other options that work in some way.

   Another good option for navigating the 'tags are now folders' structure is to use VSCode and/or atom, both are well suited to navigating through a dense structure.

   Dillinger is also really cool, but, I don't know what I'd use it for, could I get it on the ipad by hosting my own server maybe?

5. Renaming Tags
   

   Just use a careful application of sed if this is necessary:

   sed -i s+#OldTag+#NewTag+g
   

6. Renaming Files
   

   Somewhat integral to the Tag Filtering operation above is reasonable file names, if it's necessary to fix the file name just use chdir "%p"; ! mv "%" newname.md.

   This will break links, but if a note is already linked from elsewhere you'd make a new note and/or delete the old one.

7. Searching Tag Under Cursor
   

   In order to search for the word under the cursor you could just :Rg by FZF , :NV by notational-fzf-vim offers a seamless preview as well so I'll just use that.

   Add the following to .vimrc and you'll be able to search for a tag under the cursor with SPC f g and if you forget keyboard shortcuts SPC Tab will list them.

   "let mapleader="\<Space>"
   map <Space> <Leader>
   
   :set iskeyword+=#
   nmap <Space>fg :NV <C-r><C-w> <CR>
   nmap <leader><tab> <plug>(fzf-maps-n)
   

8.1.1 Using ESS with org-babel

1. Output types
   
   1. Results Type
      

      Notice that this block when executed with C-c will give the STDOUT

      rnorm(9)
      

      [1]  0.6382742  0.8345823  1.7164897 -1.6547841  0.3749552 -0.3740537 -0.1397769
      [8]  1.7248219 -0.6240926
      

      Where as this block will give the expected results:

      rnorm(9)
      

      -0.291413700921148
      -0.842118271320166
      0.607393290039903
      -1.45235488571945
      0.76756412055268
      -0.781050222761955
      -0.00871441944811291
      2.55762250149617
      0.035717298920082

   2. Format Type
      

      You can also change the output to better integrate with org by using :format raw or :format org:

      rnorm(9)
      

      -0.77482993685678
      0.0965881713078849
      -0.14713783099907
      0.872082762958436
      0.430324516204023
      1.09693115216299
      -1.08671165152439
      0.0577277935967486
      1.99238195515524

2. Working with Graphics
   

   Switching back to :results value so we don't get crap from the graphic export:

   library(tidyverse)
   rnorm(9) %>% hist()
   

   We can see that this gives us a popup, which we don't really want, instead, let's deal with an inline image, previously I was able to acheive this by using :results output graphics, that's since stopped working, it would probably better to just bypass the broken org-babel bullshit and deal with it all from R, it's not as nice but theres not much I can do about that.

   library("ggplot2")
   # Using SVG is also an option, but LaTeX sucks.
   svg(filename="pipe.svg")
   
   # Give the filename of the plot and a Description
   plotname="chocolatemouselamp"
   description= "Just a test to get =org-babel= plots"
   
   # Export the Plot into the working directory
   png(filename=paste0(plotname, ".png"))
   print(qplot(mpg, wt, data = mtcars))
   dev.off()
   
   # Print the =org-mode= link syntax
   print(paste0(
   
      "\n",
       "Output:", "\n",
        "[[./", plotname, ".png", "]]"))
   

   Output: