(let ((food-path "~/SR-Leg_ASC/")
     (output-path "~/SR-Leg_ASC/out")
     (out (get-buffer-create "*out*")))
 (when (and (file-exists-p output-path)
            (directory-files output-path))
   (condition-case nil
       (delete-directory output-path t)
     (error "unable to delete the output directory %s" output-path)))
 (condition-case nil
     (mkdir output-path)
   (error "unable to create output directory %s" output-path))
 (switch-to-buffer out)
 (setq buffer-read-only nil)
 (erase-buffer)
 (goto-char (point-min))
 (let ((weight (concat food-path "WEIGHT.txt"))
       (desc (concat food-path "FOOD_DES.txt"))
       (nutr (concat food-path "NUT_DATA.txt"))
       (ndef (concat food-path "NUTR_DEF.txt")))
   (dolist (f (list weight desc nutr ndef))
     (when (not (file-exists-p f))
       (error "Could not find file %s" f)))
   (find-file desc)
   (goto-char (point-min))
   (let (name file n count)
     (setq count 0)
     ;; Loop for every type of food we find in FOOD_DES.txt:
     ;; add a section to our output file.
     (while (and (re-search-forward "^~" nil t) (> count -1))
       (when (equal 0 (mod count 100)) (message (format "%s" count)))
       (let ((items (split-string (thing-at-point 'line) "\\^")))
         (setq n (replace-regexp-in-string
                  "~" "" (elt items 0)))
         (setq name (replace-regexp-in-string
                     "~" "" (elt items 2)))
         (setq name (replace-regexp-in-string
                     "(Includes.*)" "" name))
         ;; filename has only numbers, letters,
         ;; and replace spaces with dashes
         (setq file
               (with-temp-buffer
                 (insert name)
                 (goto-char (point-min))
                 (while (< (point) (point-max))
                   (cond
                    ((= (char-after) 32)
                     (delete-char 1)
                     (insert "-"))
                    ((or
                      (= (char-after) 32)
                      (and (>= (char-after) 65)
                           (<= (char-after) 90))
                      (and (>= (char-after) 97)
                           (<= (char-after) 122))
                      (and (>= (char-after) 48)
                           (<= (char-after) 57)))
                     (forward-char))
                    (t (delete-char 1))))
                 (concat
                  (buffer-substring (point-min) (point-max))
                  (format "-%s.txt" n)))))
       (setq count (+ count 1))
       (save-excursion
         (switch-to-buffer out)
         (insert (format "* %s (%s)" name n)) (newline) (newline)
         (insert (format "%s" file)) (newline) (newline))
       ;; loop for every weight equivalent we can find
       ;; in WEIGHT.txt for this food
       (save-excursion
         (find-file weight)
         (goto-char (point-min))
         (let (all count measure grams items)
           (while (search-forward (concat "~" n "~") nil t)
             (let ((items (split-string (thing-at-point 'line) "\\^")))
               (setq count (elt items 2))
               (let ((nth (elt items 3)))
                 (when nth
                   (setq measure (replace-regexp-in-string
                                  "~" "" nth))))
               (setq grams (elt items 4))
               (when (and count measure grams)
                 (save-excursion
                   (switch-to-buffer out)
                   (insert count) (insert " ")
                   (insert measure) (insert " = ")
                   (insert grams) (insert "g")
                   (dotimes (i 1) (newline))))))
           (save-excursion
             (switch-to-buffer out)
             (dotimes (i 1) (newline)))))
       ;; Now the weights are done for this food.
       ;; Write the nutritional information for it
       ;; into the alphabet directory.
       (let  ((char1d (format "%s/%s"
                              output-path
                              (char-to-string (elt name 0)))))
         (condition-case nil
             (mkdir char1d)
           (error "could not create directory %s" char1d))
         (save-excursion
           (get-buffer-create "nutrition")
           (switch-to-buffer "nutrition")
           (setq buffer-read-only nil)
           (erase-buffer))
         (save-excursion
           (find-file nutr)
           (goto-char (point-min))
           (let (nutr-id nutr-units nutr-name nutr-amount)
             (while (re-search-forward (concat "^" "~" n "~") nil t)
               (let ((items (split-string (thing-at-point 'line) "\\^")))
                 (setq nutr-id (elt items 1))
                 (setq nutr-id (replace-regexp-in-string "~" "" nutr-id))
                 (setq nutr-amount (elt items 2))
                 (save-excursion
                   (find-file ndef)
                   (goto-char (point-min))
                   (search-forward (concat "~" nutr-id "~"))
                   (setq nutr-name
                         (elt (split-string (thing-at-point 'line) "\\^") 3))
                   (setq nutr-name  (replace-regexp-in-string "~" "" nutr-name))
                   (setq nutr-units
                         (elt (split-string (thing-at-point 'line) "\\^") 1))
                   (setq nutr-units (replace-regexp-in-string "~" "" nutr-units)))
                 ;; write nutrient line to file, except for the ones that start
                 ;; with a number. i don't know what those mean.
                 (unless (and (>= (elt nutr-name 0) 48) (<= (elt nutr-name 0) 57))
                   (save-excursion
                     (switch-to-buffer "nutrition")
                     (goto-char (point-max))
                     (newline)
                     (insert (format "%s %s %s"
                                     nutr-name
                                     (string-to-number nutr-amount)
                                     nutr-units))))))
             (let ((food-file-name file))
               (save-excursion
                 (switch-to-buffer "nutrition")
                 (sort-lines nil (point-min) (point-max))
                 (goto-char (point-min))
                 (insert (format "%s (%s)" name n)) (newline)
                 (insert "100 g") (newline)
                 (write-region (point-min) (point-max)
                               (format "%s/%s"
                                       char1d
                                       food-file-name)))))))
       )))
 (switch-to-buffer out)
 (goto-char (point-max))
 (newline)
 (goto-char (point-min))
 (org-mode)
 (goto-char (point-min))
 (mark-whole-buffer)
 (org-sort-entries nil ?a)
 (setq buffer-read-only t)
 (condition-case nil
     (write-region (point-min) (point-max)
                   (format "%s/00-food-weights.org" output-path))
   (error "could not save file 00-food-weights.org")))

You are viewing proxied material from republic.circumlunar.space. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.