commit - 10233ddcfe886c7a1b7622277cd8523b7b77ab72
commit + c1d758392ffa58c9e0257b54b3d9ea517f7b3026
blob - /dev/null
blob + 5a32dba3c19cd9fa74d1e92bb499158543e13308 (mode 644)
--- /dev/null
+++ elpa/jq-mode-0.5.0/jq-mode-autoloads.el
+;;; jq-mode-autoloads.el --- automatically extracted autoloads (do not edit) -*- lexical-binding: t -*-
+;; Generated by the `loaddefs-generate' function.
+
+;; This file is part of GNU Emacs.
+
+;;; Code:
+
+(add-to-list 'load-path (or (and load-file-name (directory-file-name (file-name-directory load-file-name))) (car load-path)))
+
+
+
+;;; Generated autoloads from jq-mode.el
+
+(autoload 'jq-mode "jq-mode" "\
+Major mode for jq scripts.
+\\{jq-mode-map}
+
+(fn)" t)
+(autoload 'jq-interactively "jq-mode" "\
+Runs jq interactively on a json buffer.
+
+(fn BEG END)" t)
+(register-definition-prefixes "jq-mode" '("jq-"))
+
+
+;;; Generated autoloads from ob-jq.el
+
+(register-definition-prefixes "ob-jq" '("org-babel-"))
+
+;;; End of scraped data
+
+(provide 'jq-mode-autoloads)
+
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; no-native-compile: t
+;; coding: utf-8-emacs-unix
+;; End:
+
+;;; jq-mode-autoloads.el ends here
blob - /dev/null
blob + 4834bc235f02e18520b8be82859396aa8b8d19e4 (mode 644)
--- /dev/null
+++ elpa/jq-mode-0.5.0/jq-mode-pkg.el
+;; -*- no-byte-compile: t; lexical-binding: nil -*-
+(define-package "jq-mode" "0.5.0"
+ "Edit jq scripts."
+ '((emacs "25.1"))
+ :url "https://github.com/ljos/jq-mode"
+ :commit "3bda2d1085d5ac28fc6e7e8093ca7e74d3719f56"
+ :revdesc "3bda2d1085d5"
+ :authors '(("Bjarte Johansen" . "BjartedotJohansenatgmaildotcom"))
+ :maintainers '(("Bjarte Johansen" . "BjartedotJohansenatgmaildotcom")))
blob - /dev/null
blob + a02c478447c39e6b3a06b7ea85eac21a92f193fc (mode 644)
--- /dev/null
+++ elpa/jq-mode-0.5.0/jq-mode.el
+;;; jq-mode.el --- Edit jq scripts. -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2015--2018 Bjarte Johansen
+
+;; Author: Bjarte Johansen <Bjarte dot Johansen at gmail dot com>
+;; Homepage: https://github.com/ljos/jq-mode
+;; Package-Requires: ((emacs "25.1"))
+;; Package-Version: 0.5.0
+;; Package-Revision: 3bda2d1085d5
+
+;; This file is not part of GNU Emacs.
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with jq-mode. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Mode for editing jq queries.
+
+;;; Usage:
+
+;; Add to your Emacs config:
+
+;; (add-to-list 'load-path "/path/to/jq-mode-dir")
+;; (autoload 'jq-mode "jq-mode.el"
+;; "Major mode for editing jq files" t)
+;; (add-to-list 'auto-mode-alist '("\\.jq\\'" . jq-mode))
+
+;;; Code:
+(defgroup jq nil
+ "Major mode for editing jq queries."
+ :group 'languages)
+
+(defcustom jq-indent-offset 2
+ "*Indentation offset for `jq-mode'."
+ :group 'jq
+ :type 'integer)
+
+(defconst jq--keywords
+ '("as"
+ "break"
+ "catch"
+ "def"
+ "elif" "else" "end"
+ "foreach"
+ "if" "import" "include"
+ "label"
+ "module"
+ "reduce"
+ "then" "try")
+ "The keywords used in jq.")
+
+(defun jq-indent-line ()
+ "Indent current line as a jq-script."
+ (interactive)
+ (let ((indent-column 0))
+ (save-mark-and-excursion
+ (if (> 0 (forward-line -1))
+ (setq indent-column (current-indentation))
+ (end-of-line)
+ (or (search-backward ";" (line-beginning-position) t)
+ (back-to-indentation))
+ (skip-chars-forward "[:space:]" (line-end-position))
+ (cond ((looking-at-p "#.*$")
+ (setq indent-column (current-indentation)))
+ ((looking-at-p
+ (concat (regexp-opt (remove "end" jq--keywords)) "\\b"))
+ (setq indent-column (+ indent-column jq-indent-offset))))))
+ (save-mark-and-excursion
+ (back-to-indentation)
+ (save-mark-and-excursion
+ (let ((extra (if (looking-at-p ")\\|}\\|\\]") 0 1)))
+ (ignore-errors
+ (up-list -1)
+ (when (looking-at-p "(\\|{\\|\\[")
+ (setq indent-column (+ extra (current-column)))))))
+ (when (looking-at-p "|")
+ (setq indent-column (+ indent-column jq-indent-offset)))
+ (end-of-line)
+ (delete-horizontal-space)
+ (indent-line-to indent-column)))
+ (when (let ((search-spaces-regexp t))
+ (string-match-p "^ *$"
+ (buffer-substring-no-properties
+ (line-beginning-position)
+ (point))))
+ (skip-chars-forward "[:space:]" (line-end-position))))
+
+(defconst jq--builtins
+ '("IN" "INDEX"
+ "JOIN"
+ "acos" "acosh" "add" "all" "any" "arrays" "ascii_downcase" "ascii_upcase"
+ "asin" "asinh" "atan" "atan2" "atanh"
+ "booleans" "bsearch" "builtins"
+ "capture" "cbrt" "ceil" "combinations" "contains" "copysign" "cos" "cosh"
+ "debug" "del" "delpaths" "drem"
+ "empty" "endswith" "env" "erf" "erfc" "error" "exp" "exp10" "exp2"
+ "explode" "expm1"
+ "fabs" "fdim" "finites" "first" "flatten" "floor" "fma" "fmax" "fmin"
+ "fmod" "format" "frexp" "from_entries" "fromdate" "fromdateiso8601"
+ "fromjson" "fromstream"
+ "gamma" "get_jq_origin" "get_prog_origin" "get_search_list" "getpath"
+ "gmtime" "group_by" "gsub"
+ "halt" "halt_error" "has" "hypot"
+ "implode" "in" "index" "indices" "infinite" "input" "input_filename"
+ "input_line_number" "inputs" "inside" "isempty" "isfinite" "isinfinite"
+ "isnan" "isnormal" "iterables"
+ "j0" "j1" "jn" "join"
+ "keys" "keys_unsorted"
+ "last" "ldexp" "leaf_paths" "length" "lgamma" "lgamma_r" "limit"
+ "localtime" "log" "log10" "log1p" "log2" "logb" "ltrimstr"
+ "map" "map_values" "match" "max" "max_by" "min" "min_by" "mktime" "modf"
+ "modulemeta"
+ "nan" "nearbyint" "nextafter" "nexttoward" "normals" "not" "now" "nth"
+ "nulls" "numbers"
+ "objects"
+ "path" "paths" "pow" "pow10"
+ "range" "recurse" "recurse_down" "remainder" "repeat" "reverse" "rindex"
+ "rint" "round" "rtrimstr"
+ "scalars" "scalars_or_empty" "scalb" "scalbln" "scan" "select" "setpath"
+ "significand" "sin" "sinh" "sort" "sort_by" "split" "splits" "sqrt"
+ "startswith" "stderr" "strflocaltime" "strftime" "strings" "strptime" "sub"
+ "tan" "tanh" "test" "tgamma" "to_entries" "todate" "todateiso8601" "tojson"
+ "tonumber" "tostream" "tostring" "transpose" "trunc" "truncate_stream"
+ "type"
+ "unique" "unique_by" "until" "utf8bytelength"
+ "values"
+ "walk" "while" "with_entries"
+ "y0" "y1" "yn")
+ "All builtin functions in jq.")
+
+
+(defconst jq--escapings
+ '("text" "json" "html" "uri" "csv" "tsv" "sh" "base64")
+ "Jq escaping directives.")
+
+(defconst jq-font-lock-keywords
+ `( ;; Variables
+ ("\\$\\w+" 0 font-lock-variable-name-face)
+ ;; Format strings and escaping
+ (,(concat "@" (regexp-opt jq--escapings) "\\b") . font-lock-type-face)
+ ;; Keywords
+ ,(concat "\\b" (regexp-opt jq--keywords) "\\b")
+ ;; Functions
+ ("\\bdef\\s-*\\([_[:alnum:]]+\\)\\s-*\(" (1 font-lock-function-name-face))))
+
+(defvar jq-mode-map
+ (let ((map (make-sparse-keymap)))
+ map)
+ "Keymap for `jq-mode'.")
+
+(defvar jq-mode-syntax-table
+ (let ((syntax-table (make-syntax-table)))
+ ;; Strings
+ (modify-syntax-entry ?\" "\"\"" syntax-table)
+
+ ;; Comments
+ (modify-syntax-entry ?# "<" syntax-table)
+ (modify-syntax-entry ?\n ">" syntax-table)
+ syntax-table)
+ "Syntax table for `jq-mode.'")
+
+(defun jq-completion-at-point ()
+ (when-let ((bnds (bounds-of-thing-at-point 'symbol)))
+ (unless (eq ?$ (char-before (car bnds))) ; Ignore variables
+ (list (car bnds) (cdr bnds) jq--builtins))))
+
+(defvar company-keywords-alist)
+(with-eval-after-load 'company-keywords
+ (add-to-list 'company-keywords-alist
+ `(jq-mode . ,(append jq--keywords
+ jq--builtins))))
+
+;;;###autoload
+(define-derived-mode jq-mode prog-mode "jq"
+ "Major mode for jq scripts.
+\\{jq-mode-map}"
+ :group 'jq
+ (setq-local indent-line-function #'jq-indent-line)
+ (setq-local font-lock-defaults '(jq-font-lock-keywords))
+ (setq-local comment-start "# ")
+ (add-hook 'completion-at-point-functions #'jq-completion-at-point nil t))
+
+;;; jq-interactively
+(defgroup jq-interactive nil
+ "Major mode for editing json with jq."
+ :group 'languages)
+
+(defcustom jq-interactive-command "jq"
+ "Command to use for calling jq."
+ :group 'jq-interactive
+ :type 'string)
+
+(defcustom jq-interactive-default-options ""
+ "Command line options to pass to jq."
+ :group 'jq-interactive
+ :type 'string)
+
+(defcustom jq-interactive-default-prompt "jq: "
+ "Default prompt to use in minibuffer."
+ :group 'jq-interactive
+ :type 'string)
+
+(defvar jq-interactive-history nil)
+
+(defvar jq-interactive--last-minibuffer-contents "")
+(defvar jq-interactive--positions nil)
+(defvar jq-interactive--buffer nil)
+(defvar jq-interactive--overlay nil)
+
+(defun jq-interactive--run-command ()
+ (with-temp-buffer
+ (let ((output (current-buffer)))
+ (with-current-buffer jq-interactive--buffer
+ (call-process-region
+ (point-min)
+ (point-max)
+ shell-file-name
+ nil
+ output
+ nil
+ shell-command-switch
+ (format "%s %s %s"
+ jq-interactive-command
+ jq-interactive-default-options
+ (shell-quote-argument
+ jq-interactive--last-minibuffer-contents))))
+ (ignore-errors
+ (json-mode)
+ (font-lock-fontify-region (point-min) (point-max)))
+ (buffer-string))))
+
+(defun jq-interactive--feedback ()
+ (save-mark-and-excursion
+ (let ((font-lock-defaults '(jq-font-lock-keywords)))
+ (font-lock-fontify-region (point) (point-max))))
+ (with-current-buffer jq-interactive--buffer
+ (overlay-put jq-interactive--overlay
+ 'after-string
+ (jq-interactive--run-command))))
+
+(defun jq-interactive--minibuffer-setup ()
+ (setq-local font-lock-defaults '(jq-font-lock-keywords)))
+
+(defun jq-interactive--quit ()
+ (remove-hook 'after-change-functions #'jq-interactive--update)
+ (remove-hook 'minibuffer-setup-hook #'jq-interactive--minibuffer-setup)
+ (delete-overlay jq-interactive--overlay))
+
+(defun jq-interactive--update (_beg _end _len)
+ (unless (> (minibuffer-depth) 1)
+ (let ((contents (minibuffer-contents-no-properties)))
+ (unless (or (not (minibufferp))
+ (and (string= "" contents)
+ (equal last-command 'previous-history-element))
+ (string= contents jq-interactive--last-minibuffer-contents))
+ (setq jq-interactive--last-minibuffer-contents contents)
+ (jq-interactive--feedback)))))
+
+(defun jq-interactive-indent-line ()
+ "Indents a jq expression in the jq-interactive mini-buffer."
+ (interactive)
+ (jq-indent-line)
+ (save-mark-and-excursion
+ (beginning-of-line)
+ (insert-char ?\s (length jq-interactive-default-prompt)))
+ (skip-chars-forward "[:space:]"))
+
+(defvar jq-interactive-map
+ (let ((map (make-sparse-keymap)))
+ (set-keymap-parent map minibuffer-local-map)
+ (define-key map (kbd "<tab>") #'jq-interactive-indent-line)
+ (define-key map (kbd "C-j") #'electric-newline-and-maybe-indent)
+ map)
+ "Keymap for `jq-interactively'.")
+
+;;;###autoload
+(defun jq-interactively (beg end)
+ "Runs jq interactively on a json buffer."
+ (interactive
+ (if (region-active-p)
+ (list (region-beginning)
+ (region-end))
+ (list (point-min)
+ (point-max))))
+ (unwind-protect
+ (progn
+ (setq jq-interactive--overlay (make-overlay beg end))
+ (overlay-put jq-interactive--overlay 'invisible t)
+ (setq jq-interactive--positions (cons beg end))
+ (setq jq-interactive--buffer (current-buffer))
+ (setq jq-interactive--last-minibuffer-contents "")
+ (jq-interactive--feedback)
+ (add-hook 'after-change-functions #'jq-interactive--update)
+ (add-hook 'minibuffer-setup-hook #'jq-interactive--minibuffer-setup)
+ (save-mark-and-excursion
+ (deactivate-mark)
+ (read-from-minibuffer
+ jq-interactive-default-prompt
+ nil
+ jq-interactive-map
+ nil
+ jq-interactive-history))
+ (goto-char beg)
+ (delete-region beg end)
+ (insert (plist-get (overlay-properties jq-interactive--overlay)
+ 'after-string)))
+ (jq-interactive--quit)))
+
+(provide 'jq-mode)
+
+;;; jq-mode.el ends here
blob - /dev/null
blob + 49c6df8bd353387ea80ccce15af8c508e61dc813 (mode 644)
--- /dev/null
+++ elpa/jq-mode-0.5.0/ob-jq.el
+;;; ob-jq.el --- org-babel functions for jq scripts -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2015 Bjarte Johansen
+
+;; Author: Bjarte Johansen
+;; Keywords: literate programming, reproducible research
+;; Homepage: http://www.github.com/ljos/jq-mode
+
+;;; License:
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+;;
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with jq-mode. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Provides a way to evaluate jq scripts in org-mode.
+
+;;; Usage:
+
+;; Add to your Emacs config:
+
+;; (org-babel-do-load-languages
+;; 'org-babel-load-languages
+;; '((jq . t)))
+
+;;; Code:
+(require 'ob)
+(require 'jq-mode)
+(require 'json)
+
+(defvar org-babel-jq-command "jq"
+ "Name of the jq executable command.")
+
+(defvar org-babel-tangle-lang-exts)
+(add-to-list 'org-babel-tangle-lang-exts '("jq" . "jq"))
+
+(defconst org-babel-header-args:jq
+ '(
+ (:in-file . :any)
+ (:cmd-line . :any)
+ (:compact . ((yes no)))
+ )
+ "Jq specific header arguments.")
+
+(defvar org-babel-default-header-args:jq '(
+ (:results . "output")
+ (:compact . "no")
+ )
+ "Default arguments for evaluating a jq source block.")
+
+(defun org-babel-jq-table-to-json (data)
+ "Convert org table to JSON.
+
+First line specifies the keys."
+ (let* ((header (car data))
+ (data (cdr data)))
+ (while (eq (car data) 'hline)
+ (setq data (cdr data)))
+ (json-encode
+ (mapcar
+ (lambda (row) (cl-mapcar 'cons header row))
+ data))))
+
+(defun org-babel-jq-args (params)
+ "Return an --arg argument for each PARAMS :var"
+ (let ((vars (org-babel--get-vars params)))
+ (and vars
+ (mapconcat
+ (lambda (var)
+ (format "--arg %s %S" (car var) (cdr var)))
+ vars
+ " "))))
+
+(defun org-babel-execute:jq (body params)
+ "Execute a block of jq code with org-babel. This function is
+called by `org-babel-execute-src-block'"
+ (message "executing jq source code block")
+ (let* ((result-params (cdr (assq :result-params params)))
+ (compact (equal "yes" (cdr (assq :compact params))))
+ (cmd-line (cdr (assq :cmd-line params)))
+ (vars (org-babel-jq-args params))
+ (in-file (cdr (assq :in-file params)))
+ (code-file (let ((file (org-babel-temp-file "jq-")))
+ (with-temp-file file
+ (insert body)
+ file)))
+ (stdin (let ((stdin (cdr (assq :stdin params))))
+ (when stdin
+ (let ((tmp (org-babel-temp-file "jq-stdin-"))
+ (res (org-babel-ref-resolve stdin)))
+ (with-temp-file tmp
+ (insert
+ (cond
+ ((listp res) (org-babel-jq-table-to-json res))
+ (t res)))
+ tmp)))))
+ (cmd (mapconcat #'identity
+ (remq nil
+ (list org-babel-jq-command
+ (format "--from-file \"%s\"" code-file)
+ (when compact "--compact-output")
+ cmd-line
+ vars
+ in-file))
+ " ")))
+ (org-babel-reassemble-table
+ (let ((results
+ (cond
+ (stdin (with-temp-buffer
+ (call-process-shell-command cmd stdin (current-buffer))
+ (buffer-string)))
+ (t (org-babel-eval cmd "")))))
+ (when results
+ (org-babel-result-cond result-params
+ results
+ (let ((data (json-read-from-string results)))
+ ;; If we have an array we might have a table
+ (if (and (vectorp data)
+ (> (length data) 0))
+ (cond
+ ;; If the first element is a vector then just "unpack"
+ ;; the vector of vectors
+ ((vectorp (aref data 0))
+ (mapcar (lambda (row) (append row nil)) data))
+ ;; If the first element is a list we will assume we
+ ;; have an array of objects, so generate the colnames
+ ;; accordingly
+ ((consp (aref data 0))
+ (let ((colnames (mapcar 'car (aref data 0))))
+ (unless (assq :colnames params)
+ (push `(:colnames . ,colnames) params))
+ (mapcar (lambda (row) (mapcar 'cdr row)) data)))
+ ;; For a vector of scalars just return it as an
+ ;; array, it will make a single-row table
+ (t (list (append data nil))))
+ ;; If we have an object then just output it as string
+ results)))))
+ (org-babel-pick-name (cdr (assq :colname-names params))
+ (cdr (assq :colnames params)))
+ (org-babel-pick-name (cdr (assq :rowname-names params))
+ (cdr (assq :rownames params))))))
+
+(provide 'ob-jq)
+;;; ob-jq.el ends here
blob - /dev/null
blob + a503d93055d30939bcc72c9e0416036dad264d94 (mode 644)
--- /dev/null
+++ elpa/ob-restclient-20250806.2153/ob-restclient-autoloads.el
+;;; ob-restclient-autoloads.el --- automatically extracted autoloads (do not edit) -*- lexical-binding: t -*-
+;; Generated by the `loaddefs-generate' function.
+
+;; This file is part of GNU Emacs.
+
+;;; Code:
+
+(add-to-list 'load-path (or (and load-file-name (directory-file-name (file-name-directory load-file-name))) (car load-path)))
+
+
+
+;;; Generated autoloads from ob-restclient.el
+
+(autoload 'org-babel-execute:restclient "ob-restclient" "\
+Execute a block of Restclient code with org-babel.
+This function is called by `org-babel-execute-src-block'
+
+(fn BODY PARAMS)")
+(autoload 'org-babel-variable-assignments:restclient "ob-restclient" "\
+Return a list of statements assigning variables specified in PARAMS.
+
+(fn PARAMS)")
+(register-definition-prefixes "ob-restclient" '("org-babel-"))
+
+;;; End of scraped data
+
+(provide 'ob-restclient-autoloads)
+
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; no-native-compile: t
+;; coding: utf-8-emacs-unix
+;; End:
+
+;;; ob-restclient-autoloads.el ends here
blob - /dev/null
blob + 64b666d9d1dfe3a7b27637a6a878735a608a6591 (mode 644)
--- /dev/null
+++ elpa/ob-restclient-20250806.2153/ob-restclient-pkg.el
+;; -*- no-byte-compile: t; lexical-binding: nil -*-
+(define-package "ob-restclient" "20250806.2153"
+ "Org-babel functions for restclient-mode."
+ '((restclient "0"))
+ :url "https://github.com/alf/ob-restclient.el"
+ :commit "94dd9cd98ff50717135ed5089afb378616faf11a"
+ :revdesc "94dd9cd98ff5"
+ :keywords '("literate programming" "reproducible research"))
blob - /dev/null
blob + 067a9cf6888a9da0b238b3e308eca643a7dd1527 (mode 644)
--- /dev/null
+++ elpa/ob-restclient-20250806.2153/ob-restclient.el
+;;; ob-restclient.el --- org-babel functions for restclient-mode -*- lexical-binding: t -*-
+
+;; Copyright (C) Alf Lervåg
+
+;; Author: Alf Lervåg
+;; Keywords: literate programming, reproducible research
+;; Homepage: https://github.com/alf/ob-restclient.el
+;; Package-Version: 20250806.2153
+;; Package-Revision: 94dd9cd98ff5
+;; Package-Requires: ((restclient "0"))
+
+;;; License:
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+;;
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+;; This is a very simple first iteration at integrating restclient.el
+;; and org-mode.
+
+;;; Requirements:
+;; restclient.el
+
+;;; Code:
+(require 'ob)
+(require 'ob-ref)
+(require 'ob-comint)
+(require 'ob-eval)
+(require 'org-table)
+(require 'restclient)
+
+(defvar org-babel-default-header-args:restclient
+ `((:results . "raw"))
+ "Default arguments for evaluating a restclient block.")
+
+(defcustom org-babel-restclient--jq-path "jq"
+ "The path to `jq', for post-processing. Uses the PATH by default"
+ :type '(string)
+ :group 'org-babel)
+
+;;;###autoload
+(defun org-babel-execute:restclient (body params)
+ "Execute a block of Restclient code with org-babel.
+This function is called by `org-babel-execute-src-block'"
+ (message "executing Restclient source code block")
+ (with-temp-buffer
+ (let ((results-buffer (current-buffer))
+ (restclient-same-buffer-response t)
+ (restclient-response-body-only (org-babel-restclient--should-hide-headers-p params))
+ (restclient-same-buffer-response-name (buffer-name))
+ ;; The latest version of restclient puts the result buffer into view mode.
+ ;; This prevents us from wrapping the result, so we must hook in and exit view-mode.
+ (restclient-response-loaded-hook 'org-babel-restclient--maybe-exit-view-mode)
+ (raw-only (org-babel-restclient--raw-payload-p params))
+ (suppress-response-buffer (fboundp #'restclient-http-send-current-suppress-response-buffer))
+ (display-buffer-alist
+ (cons
+ '("\\*temp\\*" display-buffer-no-window (allow-no-window . t))
+ display-buffer-alist)))
+
+ (insert (buffer-name))
+ (with-temp-buffer
+ (insert
+ (org-babel-expand-body:generic
+ body params
+ (org-babel-variable-assignments:restclient params)))
+ (goto-char (point-min))
+ (delete-trailing-whitespace)
+ (goto-char (point-min))
+ (restclient-http-parse-current-and-do 'restclient-http-do raw-only t suppress-response-buffer))
+
+ (while restclient-within-call
+ (sleep-for 0.05))
+
+ (goto-char (point-min))
+ (when (equal (buffer-name) (buffer-string))
+ (error "Restclient encountered an error"))
+
+ (when-let* ((jq-header (assoc :jq params))
+ (jq-path "jq")
+ (jq-args (or (cdr (assoc :jq-args params)) "")))
+ (shell-command-on-region
+ (point-min)
+ (point-max)
+ (format "%s %s--args %s" org-babel-restclient--jq-path
+ (if (assq :jq-args params) (format "%s " jq-args) "")
+ (shell-quote-argument (cdr jq-header)))
+ results-buffer
+ t))
+
+ ;; widen if jq but not pure payload
+ (when (and (assq :jq params)
+ (not (assq :noheaders params))
+ (not (org-babel-restclient--return-pure-payload-result-p params)))
+ (widen))
+
+ (if (member "table" (cdr (assoc :result-params params)))
+ (let* ((separator '(4))
+ (result
+ (condition-case err
+ (let ((pmax (point-max)))
+ ;; If the buffer is empty, don't bother trying to
+ ;; convert the table.
+ (when (> pmax 1)
+ (org-table-convert-region (point-min) pmax separator)
+ (delq nil
+ (mapcar (lambda (row)
+ (and (not (eq row 'hline))
+ (mapcar #'org-babel-string-read row)))
+ (org-table-to-lisp)))))
+ (error
+ (display-warning 'org-babel
+ (format "Error reading results: %S" err)
+ :error)
+ nil))))
+ (pcase result
+ (`((,scalar)) scalar)
+ (`((,_ ,_ . ,_)) result)
+ (`(,scalar) scalar)
+ (_ result)))
+ (when (not (org-babel-restclient--return-pure-payload-result-p params))
+ (org-babel-restclient--wrap-result))
+ (buffer-string)))))
+
+;;;###autoload
+(defun org-babel-variable-assignments:restclient (params)
+ "Return a list of statements assigning variables specified in PARAMS."
+ (mapcar
+ (lambda (pair)
+ (let ((name (car pair))
+ (value (cdr pair))
+ (format-string ":%s = %s\n"))
+ (when (string-match-p "\n" value)
+ (setq format-string ":%s = <<\n%s\n#\n"))
+ (format format-string name value)))
+ (org-babel--get-vars params)))
+
+(defun org-babel-restclient--wrap-result ()
+ "Wrap the contents of the buffer in an `org-mode' src block."
+ (let ((mode-name (substring (symbol-name major-mode) 0 -5)))
+ (insert (format "#+BEGIN_SRC %s\n" mode-name))
+ (goto-char (point-max))
+ (unless (and (bolp) (eolp))
+ (insert "\n"))
+ (insert "#+END_SRC\n")))
+
+(defun org-babel-restclient--should-hide-headers-p (params)
+ "Return `t' if headers should be hidden."
+ (or (org-babel-restclient--return-pure-payload-result-p params)
+ (assq :noheaders params)
+ (assq :jq params)))
+
+(defun org-babel-restclient--return-pure-payload-result-p (params)
+ "Return `t' if the `:results' key in PARAMS contains `value' or `table'."
+ (let ((result-type (cdr (assoc :results params))))
+ (when result-type
+ (string-match "value\\|table" result-type))))
+
+(defun org-babel-prep-session:restclient (_session _params)
+ "Return an error because restclient does not support sessions."
+ (error "Restclient does not support sessions"))
+
+(defun org-babel-restclient--raw-payload-p (params)
+ "Return t if the `:results' key in PARAMS contain `file'."
+ (let ((result-type (cdr (assoc :results params))))
+ (when result-type
+ (and (not (org-babel-restclient--should-hide-headers-p params))
+ (string-match "file" result-type)))))
+
+(defun org-babel-restclient--maybe-exit-view-mode ()
+ (when view-mode
+ (view-mode-exit)))
+
+(provide 'ob-restclient)
+;;; ob-restclient.el ends here
blob - /dev/null
blob + fa3a0af06a5d3678f90256b4a4611fef86a219e6 (mode 644)
--- /dev/null
+++ elpa/restclient-20250817.0/restclient-autoloads.el
+;;; restclient-autoloads.el --- automatically extracted autoloads (do not edit) -*- lexical-binding: t -*-
+;; Generated by the `loaddefs-generate' function.
+
+;; This file is part of GNU Emacs.
+
+;;; Code:
+
+(add-to-list 'load-path (or (and load-file-name (directory-file-name (file-name-directory load-file-name))) (car load-path)))
+
+
+
+;;; Generated autoloads from restclient.el
+
+(autoload 'restclient-http-send-current "restclient" "\
+Sends current request.
+Optional argument RAW don't reformat response if t.
+Optional argument STAY-IN-WINDOW do not move focus to response buffer if t.
+Optional argument SUPPRESS-RESPONSE-BUFFER do not display response buffer if t.
+
+(fn &optional RAW STAY-IN-WINDOW SUPPRESS-RESPONSE-BUFFER)" t)
+(autoload 'restclient-http-send-current-raw "restclient" "\
+Sends current request and get raw result.
+(no reformatting or syntax highlight of XML, JSON or images)." t)
+(autoload 'restclient-http-send-current-stay-in-window "restclient" "\
+Send current request and keep focus in request window." t)
+(autoload 'restclient-http-send-current-suppress-response-buffer "restclient" "\
+Send current request but don't show response buffer." t)
+(autoload 'restclient-mode "restclient" "\
+Turn on restclient mode.
+
+(fn)" t)
+(register-definition-prefixes "restclient" '("restclient-" "url-"))
+
+;;; End of scraped data
+
+(provide 'restclient-autoloads)
+
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; no-native-compile: t
+;; coding: utf-8-emacs-unix
+;; End:
+
+;;; restclient-autoloads.el ends here
blob - /dev/null
blob + 020603294d1d36320d0a10d380e97ed8c1ac0946 (mode 644)
--- /dev/null
+++ elpa/restclient-20250817.0/restclient-pkg.el
+;; -*- no-byte-compile: t; lexical-binding: nil -*-
+(define-package "restclient" "20250817.0"
+ "An interactive HTTP client for Emacs."
+ '((emacs "26.1")
+ (compat "30.1.0.0"))
+ :url "https://github.com/emacsorphanage/restclient"
+ :commit "ad97f666b607b1947aae4bcfb5b91fb3b0d97b87"
+ :revdesc "ad97f666b607"
+ :keywords '("http" "comm" "tools")
+ :authors '(("Pavel Kurnosov" . "pashky@gmail.com"))
+ :maintainers '(("Peder O. Klingenberg" . "peder@klingenberg.no")))
blob - /dev/null
blob + c1b5c0a7f4e10b89a13514debda84a7e49d87112 (mode 644)
--- /dev/null
+++ elpa/restclient-20250817.0/restclient.el
+;;; restclient.el --- An interactive HTTP client for Emacs -*- lexical-binding: t; -*-
+;;
+;; Public domain.
+
+;; Author: Pavel Kurnosov <pashky@gmail.com>
+;; Maintainer: Peder O. Klingenberg <peder@klingenberg.no>
+;; Created: 01 Apr 2012
+;; Keywords: http comm tools
+;; URL: https://github.com/emacsorphanage/restclient
+;; Package-Requires: ((emacs "26.1") (compat "30.1.0.0"))
+;; Package-Version: 20250817.0
+;; Package-Revision: ad97f666b607
+
+;; This file is not part of GNU Emacs.
+;; This file is public domain software. Do what you want.
+
+;;; Commentary:
+;;
+;; This is a tool to manually explore and test HTTP REST
+;; webservices. Runs queries from a plain-text query sheet, displays
+;; results as a pretty-printed XML, JSON and even images.
+
+;;; Code:
+;;
+(require 'url)
+(require 'json)
+(require 'outline)
+(require 'view)
+(require 'compat)
+(eval-when-compile (require 'subr-x))
+(eval-when-compile
+ (if (version< emacs-version "26")
+ (require 'cl)
+ (require 'cl-lib)))
+
+(eval-when-compile
+ (unless (functionp 'hash-table-contains-p)
+ (let ((missing (make-symbol "missing")))
+ (defsubst hash-table-contains-p (key table)
+ "Return non-nil if TABLE has an element with KEY."
+ (declare (side-effect-free t))
+ (not (eq (gethash key table missing) missing))))))
+
+(defgroup restclient nil
+ "An interactive HTTP client for Emacs."
+ :group 'tools)
+
+(defcustom restclient-log-request t
+ "Log restclient requests to *Messages*."
+ :group 'restclient
+ :type 'boolean)
+
+(defcustom restclient-same-buffer-response t
+ "Re-use same buffer for responses or create a new one each time."
+ :group 'restclient
+ :type 'boolean)
+
+(defcustom restclient-same-buffer-response-name "*HTTP Response*"
+ "Name for response buffer."
+ :group 'restclient
+ :type 'string)
+
+(defcustom restclient-response-size-threshold 100000
+ "Size of the response restclient can display without performance impact."
+ :group 'restclient
+ :type 'integer)
+
+(defvar restclient-threshold-multiplier 10
+ "In how many times size-threshold should be exceed to use fundamental mode.")
+
+(defcustom restclient-info-buffer-name "*Restclient Info*"
+ "Name for info buffer."
+ :group 'restclient
+ :type 'string)
+
+(defcustom restclient-inhibit-cookies nil
+ "Inhibit restclient from sending cookies implicitly."
+ :group 'restclient
+ :type 'boolean)
+
+(defcustom restclient-content-type-modes '(("text/xml" . xml-mode)
+ ("text/plain" . text-mode)
+ ("application/xml" . xml-mode)
+ ("application/json" . js-mode)
+ ("image/png" . image-mode)
+ ("image/jpeg" . image-mode)
+ ("image/jpg" . image-mode)
+ ("image/gif" . image-mode)
+ ("text/html" . html-mode))
+ "An association list mapping content types to buffer modes."
+ :group 'restclient
+ :type '(alist :key-type string :value-type symbol))
+
+(defcustom restclient-response-body-only nil
+ "When parsing response, only return its body."
+ :group 'restclient
+ :type 'boolean)
+
+(defcustom restclient-vars-max-passes 10
+ "Maximum number of recursive variable references.
+This is to prevent hanging if two variables reference each other directly or
+indirectly."
+ :group 'restclient
+ :type 'integer)
+
+(defcustom restclient-user-agent nil
+ "User Agent used in the requests.
+Passed to `url-user-agent'. See that variable for valid values.
+Default is nil, to allow requests to set User-Agent as a header."
+ :group 'restclient
+ :type '(choice
+ (string :tag "A static User-Agent string")
+ (function :tag "Call a function to get the User-Agent string")
+ (const :tag "No User-Agent at all" :value nil)
+ (const :tag "An string auto-generated according to `url-privacy-level'"
+ :value default)))
+
+(defcustom restclient-query-use-continuation-lines nil
+ "Whether to allow request parameters to span multiple lines.
+Default is nil, query parameters must be part of the single line URL in the
+request, as the HTTP requires. If non-nil, continuation lines must directly
+follow the initial request line, indented by whitespace.
+
+The value of this parameter also determines how the continuation lines
+are interpreted. Valid values are:
+* nil - Do not allow continuation lines (default).
+* `literal' - Append each continuation line to the query literally.
+* `smart' - Each continuation line is interpreted as a key/value pair,
+ separated by =. Both keys and values are passed through
+ `url-hexify-string' before being appended to the query.
+ Separators between parameters are added automatically."
+ :group 'restclient
+ :type '(choice
+ (const :tag "Do not allow continuation lines.")
+ (const :tag "Append continuation lines literally."
+ :value literal)
+ (const :tag "Continuation liens are key/value pairs."
+ :value smart)))
+
+(defcustom restclient-follow-redirects t
+ "Whether restclient follows redirects.
+If t, the default, restclient will follow up to `url-max-redirections'
+links in the redirection chain before giving up. If nil, no
+redirections will be followed. If an integer, `url-max-redirections'
+will be temporarily set to that number."
+ :group 'restclient
+ :type '(choice
+ (const :tag "Follow redirects" :value t)
+ (const :tag "Do not follow redirects" :value nil)
+ (integer :tag "Follow this many redirects")))
+
+(defcustom restclient-results-in-view-mode t
+ "Determines if the response buffer should be put in view-mode or left
+editable."
+ :group 'restclient
+ :type 'boolean)
+
+(defgroup restclient-faces nil
+ "Faces used in Restclient Mode."
+ :group 'restclient
+ :group 'faces)
+
+(defface restclient-variable-name-face
+ '((t (:inherit font-lock-preprocessor-face)))
+ "Face for variable name."
+ :group 'restclient-faces)
+
+(defface restclient-variable-string-face
+ '((t (:inherit font-lock-string-face)))
+ "Face for variable value (string)."
+ :group 'restclient-faces)
+
+(defface restclient-variable-elisp-face
+ '((t (:inherit font-lock-function-name-face)))
+ "Face for variable value (Emacs Lisp)."
+ :group 'restclient-faces)
+
+(defface restclient-variable-multiline-face
+ '((t (:inherit font-lock-doc-face)))
+ "Face for multi-line variable value marker."
+ :group 'restclient-faces)
+
+(defface restclient-variable-usage-face
+ '((t (:inherit restclient-variable-name-face)))
+ "Face for variable usage.
+\(only used when headers/body is represented as a single variable, not
+highlighted when variable appears in the middle of other text)."
+ :group 'restclient-faces)
+
+(defface restclient-method-face
+ '((t (:inherit font-lock-keyword-face)))
+ "Face for HTTP method."
+ :group 'restclient-faces)
+
+(defface restclient-url-face
+ '((t (:inherit font-lock-function-name-face)))
+ "Face for variable value (Emacs Lisp)."
+ :group 'restclient-faces)
+
+(defface restclient-file-upload-face
+ '((t (:inherit restclient-variable-multiline-face)))
+ "Face for highlighting upload file paths."
+ :group 'restclient-faces)
+
+(defface restclient-header-name-face
+ '((t (:inherit font-lock-variable-name-face)))
+ "Face for HTTP header name."
+ :group 'restclient-faces)
+
+(defface restclient-header-value-face
+ '((t (:inherit font-lock-string-face)))
+ "Face for HTTP header value."
+ :group 'restclient-faces)
+
+(defface restclient-request-hook-face
+ '((t (:inherit font-lock-preprocessor-face)))
+ "Face for single request hook indicator."
+ :group 'restclient-faces)
+
+(defface restclient-request-hook-name-face
+ '((t (:inherit font-lock-function-name-face)))
+ "Face for single request hook type names."
+ :group 'restclient-faces)
+
+(defface restclient-request-hook-args-face
+ '((t (:inherit font-lock-string-face)))
+ "Face for single request hook type arguments."
+ :group 'restclient-faces)
+
+
+(defvar restclient-within-call nil)
+
+(defvar restclient-request-time-start nil)
+(defvar restclient-request-time-end nil)
+
+(defvar restclient-var-overrides nil
+ "An alist of vars that will override any set in the file.
+Also where dynamic vars set on callbacks are stored.")
+
+(defvar restclient-var-defaults nil
+ "An alist of fallback values for vars not defined elsewhere.")
+
+(defvar restclient-current-env-file nil
+ "The file containing current environment definitions.")
+
+(defvar restclient-current-env-name nil
+ "Current environment name, defined in `restclient-current-env-file'.")
+
+(defvar restclient-result-handlers '()
+ "A registry of available completion hooks.
+Stored as an alist of name -> (hook-creation-func . description)")
+
+(defvar restclient-curr-request-functions nil
+ "A list of functions to run once when the next request is loaded.")
+
+(defvar restclient-response-loaded-hook nil
+ "Hook run after response buffer is formatted.")
+
+(defvar restclient-http-do-hook nil
+ "Hook to run before making request.")
+
+(defvar restclient-response-received-hook nil
+ "Hook run after data is loaded into response buffer.")
+
+(defvar restclient-current-request-marker (make-marker)
+ "Marker keeping track of the last executed request.")
+
+(defvar-local restclient--header-start-position nil
+ "Position in the buffer where headers start.")
+
+
+(defconst restclient-comment-separator "#")
+(defconst restclient-comment-start-regexp (concat "^" restclient-comment-separator))
+(defconst restclient-comment-not-regexp (concat "^[^" restclient-comment-separator "]"))
+(defconst restclient-empty-line-regexp "^\\s-*$")
+
+(defconst restclient-method-url-regexp
+ "^[[:blank:]]*\\(GET\\|POST\\|DELETE\\|PUT\\|HEAD\\|OPTIONS\\|PATCH\\|PROPFIND\\) \\(.*\\)$")
+
+(defconst restclient-url-continuation-line-regexp
+ "^[[:blank:]]+\\(.*\\)$")
+
+(defconst restclient-url-continuation-key-value-regexp
+ "\\([^= ]+\\)\\s-*=\\s-*\\(.*\\)$")
+
+(defconst restclient-method-body-prohibited-regexp
+ "^GET\\|HEAD$")
+
+(defconst restclient-header-regexp
+ "^\\([^](),/:;@[\\{}= \t]+\\): \\(.*\\)$")
+
+(defconst restclient-use-var-regexp
+ "^:\\([^: \n]+\\)\\|{{\\([^} \n]+\\)}}$")
+
+(defconst restclient-var-regexp
+ (concat "^\\(?::\\([^:= ]+\\)\\|@\\([^:= ]+\\)\\)[ \t]*\\(:?\\)=[ \t]*\\(<<[ \t]*\n\\(\\(.*\n\\)*?\\)" restclient-comment-separator "\\|\\([^<].*\\)$\\)"))
+
+(defconst restclient-svar-regexp
+ "^\\(:[^:= ]+\\)[ \t]*=[ \t]*\\(.+?\\)$")
+
+(defconst restclient-evar-regexp
+ "^\\(:[^: ]+\\)[ \t]*:=[ \t]*\\(.+?\\)$")
+
+(defconst restclient-mvar-regexp
+ "^\\(:[^: ]+\\)[ \t]*:?=[ \t]*\\(<<\\)[ \t]*$")
+
+(defconst restclient-file-regexp
+ "^<[ \t]*\\([^<>\n\r]+\\)[ \t]*$")
+
+(defconst restclient-content-type-regexp
+ "^Content-[Tt]ype: \\(\\w+\\)/\\(?:[^\\+\r\n]*\\+\\)*\\([^;\r\n]+\\)")
+
+(defconst restclient-response-hook-regexp
+ "^\\(->\\) \\([^[:space:]]+\\) +\\(.*\\)$")
+
+;; The following disables the interactive request for user name and
+;; password should an API call encounter a permission-denied response.
+;; This API is meant to be usable without constant asking for username
+;; and password.
+
+(define-advice url-http-handle-authentication (:around (orig &rest args) restclient-disable-auth)
+ "Disable interactive request for username/password."
+ (if restclient-within-call
+ t ;; Means authorization failed.
+ (apply orig args)))
+
+(define-advice url-cache-extract (:around (orig &rest args) restclient-disable-cache)
+ "Disable cache."
+ (unless restclient-within-call
+ (apply orig args)))
+
+(defvar restclient--globals-stack
+ (make-hash-table))
+
+(defmacro restclient--push-global-var (var new-val)
+ "Save current value of VAR, and set VAR to NEW-VAL.
+Workaround for Emacs bug#61916"
+ `(progn
+ (push ,var (gethash ',var restclient--globals-stack ()))
+ (setq-default ,var ,new-val)))
+
+(defmacro restclient--pop-global-var (var)
+ "Restore old global value of VAR, if any."
+ `(when (and (hash-table-contains-p ',var restclient--globals-stack)
+ (< 0 (length (gethash ',var restclient--globals-stack))))
+ (setq-default ,var (pop (gethash ',var restclient--globals-stack)))))
+
+(defun restclient-http-do (method url headers entity &rest handle-args)
+ "Send ENTITY and HEADERS to URL as a METHOD request."
+ (if restclient-log-request
+ (message "HTTP %s %s Headers:[%s] Body:[%s]" method url headers entity))
+ (let ((url-request-method (encode-coding-string method 'us-ascii))
+ (url-request-extra-headers '())
+ (url-request-data (if (string-match restclient-method-body-prohibited-regexp method)
+ nil
+ (encode-coding-string entity 'utf-8))))
+
+ (restclient--push-global-var url-mime-charset-string (url-mime-charset-string))
+ (restclient--push-global-var url-mime-language-string nil)
+ (restclient--push-global-var url-mime-encoding-string nil)
+ (restclient--push-global-var url-mime-accept-string nil)
+ (restclient--push-global-var url-user-agent restclient-user-agent)
+ (restclient--push-global-var url-max-redirections
+ (cond
+ ((not restclient-follow-redirects)
+ 0)
+ ((integerp restclient-follow-redirects)
+ restclient-follow-redirects)
+ (t
+ url-max-redirections)))
+
+ (dolist (header headers)
+ (let* ((mapped (assoc-string (downcase (car header))
+ '(("from" . url-personal-mail-address)
+ ("accept-encoding" . url-mime-encoding-string)
+ ("accept-charset" . url-mime-charset-string)
+ ("accept-language" . url-mime-language-string)
+ ("accept" . url-mime-accept-string)))))
+
+ (if mapped
+ (set (cdr mapped) (encode-coding-string (cdr header) 'us-ascii))
+ (let* ((hkey (encode-coding-string (car header) 'us-ascii))
+ (hvalue (encode-coding-string (cdr header) 'us-ascii)))
+ (setq url-request-extra-headers (cons (cons hkey hvalue) url-request-extra-headers))))))
+
+ (setq restclient-within-call t)
+ (setq restclient-request-time-start (current-time))
+ (run-hooks 'restclient-http-do-hook)
+ (url-retrieve url 'restclient-http-handle-response
+ (append (list method url (if restclient-same-buffer-response
+ restclient-same-buffer-response-name
+ (format "*HTTP %s %s*" method url)))
+ handle-args)
+ nil restclient-inhibit-cookies)))
+
+(defun restclient--preferred-mode (content-type)
+ "Look up the user's preferred mode for handling content of type CONTENT-TYPE.
+
+The user defines their preferences in `restclient-content-type-modes'."
+ (cdr (assoc-string content-type restclient-content-type-modes t)))
+
+(defun restclient-prettify-response (method url status)
+ "Format the result of the API call in a pleasing way.
+METHOD, URL and STATUS are displayed along with the response headers."
+ (save-excursion
+ (let ((start (point))
+ (guessed-mode)
+ (end-of-headers))
+ (while (and (not (looking-at restclient-empty-line-regexp))
+ (eq (progn
+ (when (looking-at restclient-content-type-regexp)
+ (setq guessed-mode
+ (restclient--preferred-mode (concat
+ (match-string-no-properties 1)
+ "/"
+ (match-string-no-properties 2)))))
+ (forward-line))
+ 0)))
+ (setq end-of-headers (point))
+ (while (and (looking-at restclient-empty-line-regexp)
+ (eq (forward-line) 0)))
+ (unless guessed-mode
+ (setq guessed-mode
+ (or (assoc-default nil
+ ;; magic mode matches
+ `(("<\\?xml " . ,(restclient--preferred-mode "application/xml"))
+ ("{\\s-*\"" . ,(restclient--preferred-mode "application/json")))
+ (lambda (re _dummy)
+ (looking-at re)))
+ (restclient--preferred-mode "application/json"))))
+ (let ((headers (buffer-substring-no-properties start end-of-headers)))
+ (when guessed-mode
+ (delete-region start (point))
+ (unless (eq guessed-mode (restclient--preferred-mode "image/png"))
+ (cond ((and restclient-response-size-threshold
+ (> (buffer-size) (* restclient-response-size-threshold
+ restclient-threshold-multiplier)))
+ (fundamental-mode)
+ (setq comment-start (let ((guessed-mode guessed-mode))
+ (with-temp-buffer
+ (apply guessed-mode '())
+ comment-start)))
+ (message
+ "Response is too huge, using fundamental-mode to display it!"))
+ ((and restclient-response-size-threshold
+ (> (buffer-size) restclient-response-size-threshold))
+ (delay-mode-hooks (apply guessed-mode '()))
+ (message
+ "Response is too big, using bare %s to display it!" guessed-mode))
+ (t
+ (apply guessed-mode '())))
+ (if (fboundp 'font-lock-flush)
+ (font-lock-flush)
+ (with-no-warnings
+ (font-lock-fontify-buffer))))
+
+ (cond
+ ((eq guessed-mode (restclient--preferred-mode "application/xml"))
+ (goto-char (point-min))
+ (while (search-forward-regexp "\>[ \\t]*\<" nil t)
+ (backward-char) (insert "\n"))
+ (indent-region (point-min) (point-max)))
+
+ ((eq guessed-mode (restclient--preferred-mode "image/png"))
+ (let* ((img (buffer-string)))
+ (delete-region (point-min) (point-max))
+ (fundamental-mode)
+ (insert-image (create-image img nil t))))
+
+ ((eq guessed-mode (restclient--preferred-mode "application/json"))
+ (let ((json-special-chars (remq (assoc ?/ json-special-chars) json-special-chars))
+ ;; Emacs 27 json.el uses `replace-buffer-contents' for
+ ;; pretty-printing which is great because it keeps point and
+ ;; markers intact but can be very slow with huge minimized
+ ;; JSON. We don't need that here.
+ (json-pretty-print-max-secs 0))
+ (ignore-errors (json-pretty-print-buffer)))
+ (restclient-prettify-json-unicode)))
+
+ (goto-char (point-max))
+ (or (eq (point) (point-min)) (insert "\n"))
+ (unless restclient-response-body-only
+ (let ((hstart (point)))
+ (setq restclient--header-start-position hstart)
+ (insert method " " url "\n")
+ (cl-loop for (data event) on (reverse status) by #'cddr
+ when (eq event :redirect)
+ do (insert "Redirect: " data "\n"))
+ (insert headers)
+ (insert (format "Request duration: %fs\n" (float-time (time-subtract restclient-request-time-end restclient-request-time-start))))
+ (unless (member guessed-mode (list (restclient--preferred-mode "image/png")
+ (restclient--preferred-mode "text/plain")))
+ (comment-region hstart (point))))))))))
+
+(defun restclient-prettify-json-unicode ()
+ "Convert hex representations of unicode to characters."
+ (save-excursion
+ (goto-char (point-min))
+ (while (re-search-forward "\\\\[Uu]\\([0-9a-fA-F]\\{4\\}\\)" nil t)
+ (replace-match (char-to-string (decode-char 'ucs (string-to-number (match-string 1) 16))) t nil))))
+
+(defun restclient-http-handle-response (status method url bufname raw stay-in-window suppress-response-buffer)
+ "Switch to the buffer returned by `url-retrieve'.
+The buffer contains the raw HTTP response sent by the server.
+STATUS: http status of the response.
+METHOD: http method of the request.
+URL: url of the request.
+BUFNAME; the name of the buffer in which to display results
+RAW: if non-nil, the raw response will be displayed, instead of a pretty-printed
+ version.
+STAY-IN-WINDOW: if non-nil, do not switch to the output buffer, only show it.
+SUPPRESS-RESPONSE-BUFFER: do not show the reponse at all."
+ (setq restclient-within-call nil)
+ (setq restclient-request-time-end (current-time))
+ (restclient--pop-global-var url-mime-charset-string)
+ (restclient--pop-global-var url-mime-language-string)
+ (restclient--pop-global-var url-mime-encoding-string)
+ (restclient--pop-global-var url-mime-accept-string)
+ (restclient--pop-global-var url-user-agent)
+ (restclient--pop-global-var url-max-redirections)
+ (if (= (point-min) (point-max))
+ (let ((error-status (plist-get status :error)))
+ (if error-status
+ (error (format "%s: %s" (car error-status) (cdr error-status)))
+ (error "Empty response from server")))
+ (when (buffer-live-p (current-buffer))
+ (with-current-buffer (restclient-decode-response
+ (current-buffer)
+ bufname
+ restclient-same-buffer-response)
+ (run-hooks 'restclient-response-received-hook)
+ (unless raw
+ (restclient-prettify-response method url status))
+ (buffer-enable-undo)
+ (when restclient-results-in-view-mode
+ (view-mode-enter))
+ (restclient--setup-response-buffer-map)
+ (run-hooks 'restclient-response-loaded-hook)
+ (unless suppress-response-buffer
+ (if stay-in-window
+ (display-buffer (current-buffer) t)
+ (switch-to-buffer-other-window (current-buffer)))))
+ (message "")))) ;; Request complete, remove the "Contacting host"-message from url-http
+
+(defun restclient-decode-response (raw-http-response-buffer target-buffer-name same-name)
+ "Decode the HTTP response.
+Use the charset (encoding) specified in the Content-Type header. If no
+charset is specified, default to UTF-8.
+RAW-HTTP-RESPONSE-BUFFER: the buffer where the URL library has deposited the
+ reponse.
+TARGET-BUFFER-NAME: the name of the buffer into which we will place the decoded
+ result.
+SAME-NAME: if non-nil, reuse the target buffer if it exists, otherwise generate
+ a fresh buffer."
+ (let* ((charset-regexp "^Content-Type.*charset=\\([-A-Za-z0-9]+\\)")
+ (image? (save-excursion
+ (search-forward-regexp "^Content-Type.*[Ii]mage" nil t)))
+ (encoding (if (save-excursion
+ (search-forward-regexp charset-regexp nil t))
+ (intern (downcase (match-string 1)))
+ 'utf-8)))
+ (if image?
+ ;; Don't attempt to decode. Instead, just switch to the raw HTTP response buffer and
+ ;; rename it to target-buffer-name.
+ (with-current-buffer raw-http-response-buffer
+ ;; We have to kill the target buffer if it exists, or `rename-buffer'
+ ;; will raise an error.
+ (when (get-buffer target-buffer-name)
+ (kill-buffer target-buffer-name))
+ (rename-buffer target-buffer-name)
+ raw-http-response-buffer)
+ ;; Else, switch to the new, empty buffer that will contain the decoded HTTP
+ ;; response. Set its encoding, copy the content from the unencoded
+ ;; HTTP response buffer and decode.
+ (let ((decoded-http-response-buffer
+ (get-buffer-create
+ (if same-name target-buffer-name (generate-new-buffer-name target-buffer-name)))))
+ (with-current-buffer decoded-http-response-buffer
+ (view-mode-exit t)
+ (setq buffer-file-coding-system encoding)
+ (setq restclient--header-start-position (point-min))
+ (save-excursion
+ (erase-buffer)
+ (insert-buffer-substring raw-http-response-buffer))
+ (kill-buffer raw-http-response-buffer)
+ (condition-case nil
+ (decode-coding-region (point-min) (point-max) encoding)
+ (error
+ (message (concat "Error when trying to decode http response with encoding: "
+ (symbol-name encoding)))))
+ decoded-http-response-buffer)))))
+
+(defun restclient-current-min ()
+ "Return the position of the start of the current request."
+ (save-excursion
+ (beginning-of-line)
+ (if (looking-at restclient-comment-start-regexp)
+ (if (re-search-forward restclient-comment-not-regexp (point-max) t)
+ (line-beginning-position) (point-max))
+ (if (re-search-backward restclient-comment-start-regexp (point-min) t)
+ (line-beginning-position 2)
+ (point-min)))))
+
+(defun restclient-current-max ()
+ "Return the position of the end of the current request."
+ (save-excursion
+ (if (re-search-forward restclient-comment-start-regexp (point-max) t)
+ (max (- (line-beginning-position) 1) 1)
+ (progn (goto-char (point-max))
+ (if (looking-at "^$") (- (point) 1) (point))))))
+
+(defun restclient-replace-all-in-string (replacements string)
+ "Replace variables in STRING.
+REPLACEMENTS is an alist containing the current variable values.
+Return a string with variables replaced with their values, possibly recursively."
+ (if replacements
+ (let ((current string)
+ (prev nil)
+ (regexp (regexp-opt (append
+ (mapcar #'(lambda (r)
+ (format ":%s" (car r)))
+ replacements)
+ (mapcar #'(lambda (r)
+ (format "{{%s}}" (car r)))
+ replacements))))
+ (pass restclient-vars-max-passes)
+ (continue t))
+ (while (and continue (> pass 0))
+ (setq pass (- pass 1))
+ (setq prev current)
+ (setq current (replace-regexp-in-string
+ regexp
+ (lambda (key)
+ (setq key (restclient-sanitize-var-name key))
+ (cdr (assoc key replacements)))
+ current t t))
+ (setq continue (not (equal prev current))))
+ current)
+ string))
+
+(defun restclient-replace-all-in-header (replacements header)
+ "Calls `restclient-replace-all-in-string' on a header value.
+REPLACEMENTS is an alist containing the current variable values.
+HEADER is an alist element (<header-name> . <value>).
+Returns a new alist elements with the same header name, and a variable-expanded
+value."
+ (cons (car header)
+ (restclient-replace-all-in-string replacements (cdr header))))
+
+(defun restclient-chop (text)
+ "Remove newline at the end of TEXT, if any."
+ (if text (replace-regexp-in-string "\n$" "" text) nil))
+
+(defun restclient-set-env (env-file env-name)
+ "Define variables for the current environment.
+
+ENV-FILE is a json file as defined in
+https://learn.microsoft.com/en-us/aspnet/core/test/http-files?view=aspnetcore-9.0#environment-files.
+Alternatively, a VS Code settings file with the environments defined under the
+key rest-client.environmentVariables is acceptable.
+
+ENV-NAME is the name of a specific environment defined in ENV-FILE.
+
+The special environment name `$shared' will always load in addition to the
+requested env, with lower priority."
+ (interactive (let* ((default-dir (when restclient-current-env-file
+ (file-name-directory restclient-current-env-file)))
+ (default-file (when restclient-current-env-file
+ (file-name-nondirectory restclient-current-env-file)))
+ (filename
+ (read-file-name "Environment file name: "
+ default-dir default-file t))
+ (envs (mapcar #'car (restclient-parse-env-file filename))))
+ (list filename (completing-read "Environment name: " envs nil t))))
+ (setq restclient-current-env-file env-file)
+ (setq restclient-current-env-name env-name)
+ (restclient-reload-current-env))
+
+(defun restclient-parse-env-file (filename)
+ "Read environments from FILENAME.
+Environments contain sets of variable definitions. A file can contain multiple
+environment definitions."
+ (let* ((json-key-type 'string)
+ (envs (json-read-file filename)))
+ (when (assoc "rest-client.environmentVariables" envs)
+ (setq envs (cdr (assoc "rest-client.environmentVariables" envs))))
+ envs))
+
+(defun restclient-reload-current-env ()
+ "Refresh variable definitions from current environment definition."
+ (interactive)
+ (when (and restclient-current-env-file restclient-current-env-name)
+ (let* ((envs (restclient-parse-env-file restclient-current-env-file))
+ (shared-name "$shared")
+ (nonshared (when (not (equal restclient-current-env-name shared-name))
+ (cdr (assoc restclient-current-env-name envs)))))
+ (setq restclient-var-defaults
+ (append nonshared
+ (cdr (assoc shared-name envs)))))
+ (message "Environment \"%s\" loaded" restclient-current-env-name)))
+
+(defun restclient-find-vars-before-point ()
+ "Determine which variables are valid at the current position."
+ (let ((vars nil)
+ (bound (point)))
+ (save-match-data
+ (save-excursion
+ (goto-char (point-min))
+ (while (search-forward-regexp restclient-var-regexp bound t)
+ (let ((name (or (match-string-no-properties 1)
+ (match-string-no-properties 2)))
+ (should-eval (> (length (match-string 3)) 0))
+ (value (or (restclient-chop (match-string-no-properties 5)) (match-string-no-properties 4))))
+ (setq vars (cons (cons name (if should-eval (restclient-eval-var value) value)) vars))))
+ (append restclient-var-overrides vars restclient-var-defaults)))))
+
+(defun restclient-eval-var (string)
+ "Evaluate the Lisp code contained in STRING.
+The result of the evaluation is returned as a string."
+ (with-output-to-string (princ (eval (read string)))))
+
+(defun restclient-make-header (&optional string)
+ "Create an alist element from STRING.
+Match data must be set by caller."
+ (cons (match-string-no-properties 1 string)
+ (match-string-no-properties 2 string)))
+
+(defun restclient-parse-headers (string)
+ "Create a header alist from STRING."
+ (let ((start 0)
+ (headers '()))
+ (while (string-match restclient-header-regexp string start)
+ (setq headers (cons (restclient-make-header string) headers)
+ start (match-end 0)))
+ headers))
+
+(defun restclient-get-response-headers ()
+ "Returns alist of current response headers."
+ (let* ((start restclient--header-start-position)
+ (headers-end (+ 1 (or (string-match "\n\n" (buffer-substring-no-properties start (point-max)))
+ (buffer-size))))
+ (headers-commented-p (and (< 1 start) ;; Catches raw response buffers
+ (not (member major-mode (list (restclient--preferred-mode "image/png")
+ (restclient--preferred-mode "text/plain"))))))
+ (headers-string (buffer-substring-no-properties start headers-end)))
+ (when headers-commented-p
+ ;; Temporarily uncomment to extract string
+ (uncomment-region start headers-end)
+ (setq headers-end (+ 1 (or (string-match "\n\n" (buffer-substring-no-properties start (point-max)))
+ (buffer-size))))
+ (setq headers-string (buffer-substring-no-properties start headers-end))
+ (comment-region start headers-end))
+ (restclient-parse-headers headers-string)))
+
+(defun restclient-set-var-from-header (var header)
+ "Record a dynamic variable VAR from response headers.
+HEADER is the name of the header to look up in the response."
+ (restclient-set-var var (cdr (assoc header (restclient-get-response-headers)))))
+
+(defun restclient-read-file (path)
+ "Return the contents of the file PATH as a string."
+ (with-temp-buffer
+ (insert-file-contents path)
+ (buffer-string)))
+
+(defun restclient-replace-path-with-contents (entity)
+ "Include file contents in request.
+ENTITY is the request body, Possibly with `< /file/path' embeded, which
+will be replaced with the contents of `/file/path' if it exists. If
+`/file/path' does not exist, the construct may be an XML tag or other
+data, not a file embedding, and will not be replaced."
+ (replace-regexp-in-string
+ restclient-file-regexp
+ (lambda (match)
+ (let ((filename (match-string 1 match)))
+ (if (file-exists-p filename)
+ (restclient-read-file filename)
+ match)))
+ entity t t))
+
+(defun restclient-parse-body (entity vars)
+ "Prepare a request body for sending.
+Replace variables with their values, and include file contents.
+ENTITY is the body of the request (a string), VARS is an alist of currently
+defined variables."
+ (restclient-replace-path-with-contents (restclient-replace-all-in-string vars entity)))
+
+(defun restclient-parse-hook (cb-type args-offset args)
+ "Parse a hook definition.
+CB-TYPE is the callback type, must be a previously registered type of handler.
+ARGS-OFFSET is the position in the buffer where the arguments to / contents of
+the hook begin. ARGS is the string from after the CB-TYPE to the end of the
+line.
+
+Registered callback handlers will typically use only one of ARGS or ARGS-OFFSET."
+ (if-let* ((handler (assoc cb-type restclient-result-handlers)))
+ (funcall (cadr handler) args args-offset)
+ `(lambda ()
+ (message "Unknown restclient hook type %s" ,cb-type))))
+
+(defun restclient-register-result-func (name creation-func description)
+ "Register a new callback type.
+NAME: The name of the callback type.
+CREATION-FUNC: A function that interprets the rest of the hook definition and
+returns a function that will be called in the context of the result buffer.
+DESCRIPTION: Descriptive text."
+ (let ((new-cell (cons name (cons creation-func description))))
+ (setq restclient-result-handlers (cons new-cell restclient-result-handlers))))
+
+(defun restclient-sanitize-var-name (var-name)
+ "Return the name of a variable, without decorations like `:' or `{{}}'.
+VAR-NAME: a variable with or without decorations."
+ (save-match-data
+ (cond
+ ((string-match restclient-use-var-regexp var-name)
+ (setq var-name (or (match-string 1 var-name) (match-string 2 var-name))))
+ ((string-match "^@\\([^@ \n]+\\)$" var-name)
+ (setq var-name (match-string 1 var-name)))))
+ var-name)
+
+(defun restclient-remove-var (var-name)
+ "Remove VAR-NAME from the list of dynamic variables."
+ (let ((var-name (restclient-sanitize-var-name var-name)))
+ (setq restclient-var-overrides (compat-call assoc-delete-all var-name restclient-var-overrides))))
+
+(defun restclient-set-var (var-name value)
+ "Set VAR-NAME to VALUE for any subsequent requests."
+ (let ((var-name (restclient-sanitize-var-name var-name)))
+ (restclient-remove-var var-name)
+ (setq restclient-var-overrides (cons (cons var-name value) restclient-var-overrides))))
+
+(defun restclient-get-var-at-point (var-name buffer-name buffer-pos)
+ "Look up the value of VAR-NAME in the current context.
+Context is defined by environment, dynamically set variables, and variables
+defined in BUFFER-NAME prior to BUFFER-POS."
+ ;(message (format "getting var %s from %s at %s" var-name buffer-name buffer-pos))
+ (let* ((var-name (restclient-sanitize-var-name var-name))
+ (vars-at-point (save-excursion
+ (switch-to-buffer buffer-name)
+ (goto-char buffer-pos)
+ ;; if we're called from a restclient buffer we need to lookup vars before the current hook or evar
+ ;; outside a restclient buffer only globals are available so moving the point wont matter
+ (re-search-backward "^:\\|->" (point-min) t)
+ (restclient-find-vars-before-point))))
+ (restclient-replace-all-in-string vars-at-point (cdr (assoc var-name vars-at-point)))))
+
+(defmacro restclient-get-var (var-name)
+ "Get the value of VAR-NAME in the current buffer."
+ (let ((buf-name (buffer-name (current-buffer)))
+ (buf-point (point)))
+ `(restclient-get-var-at-point ,var-name ,buf-name ,buf-point)))
+
+(defun restclient-single-request-function ()
+ "Execute the callbacks/hooks defined for the current request."
+ (dolist (f restclient-curr-request-functions)
+ (save-excursion
+ (ignore-errors
+ (funcall f))))
+ (setq restclient-curr-request-functions nil)
+ (remove-hook 'restclient-response-loaded-hook 'restclient-single-request-function))
+
+(defun restclient--parse-continuation-line (vars line separator)
+ "Read a key/value pair from LINE.
+Return a %-encoded line preceeded by SEPARATOR.
+Restclient variables in are expanded in keys and values separately,
+using definitions passed in VARS."
+ (if (string-match restclient-url-continuation-key-value-regexp line)
+ (let ((key (match-string-no-properties 1 line))
+ (val (match-string-no-properties 2 line)))
+ (concat separator
+ (url-hexify-string (restclient-replace-all-in-string vars key))
+ "="
+ (url-hexify-string (restclient-replace-all-in-string vars val))))
+ (error "Line is not a valid key/value pair")))
+
+(defun restclient-http-parse-current-and-do (func &rest args)
+ "Execute FUNC with the current request.
+FUNC will receive the http method, url, headers and body of the request around
+point as arguments, with ARGS included as the final argument."
+ (set-marker restclient-current-request-marker (point))
+ (save-excursion
+ (goto-char (restclient-current-min))
+ (when (re-search-forward restclient-method-url-regexp (point-max) t)
+ (let* ((vars (restclient-find-vars-before-point))
+ (method (match-string-no-properties 1))
+ (url (restclient-replace-all-in-string
+ vars (string-trim (match-string-no-properties 2))))
+ (q-param-separator (if (memq ?? (string-to-list url))
+ "&"
+ "?"))
+ (headers '()))
+ (forward-line)
+ (while (and restclient-query-use-continuation-lines
+ (looking-at restclient-url-continuation-line-regexp))
+ (let ((line (match-string-no-properties 1)))
+ (setq url
+ (concat url
+ (cond
+ ((eq 'literal restclient-query-use-continuation-lines)
+ (restclient-replace-all-in-string vars (string-trim line)))
+ ((eq 'smart restclient-query-use-continuation-lines)
+ (restclient--parse-continuation-line vars line q-param-separator))
+ (t
+ (error "Unknown value for `restclient-query-use-continuation-lines': %s"
+ restclient-query-use-continuation-lines))))))
+ (setq q-param-separator "&")
+ (forward-line))
+ (while (cond
+ ((looking-at restclient-response-hook-regexp)
+ (when-let* ((hook-function (restclient-parse-hook (match-string-no-properties 2)
+ (match-end 2)
+ (match-string-no-properties 3))))
+ (push hook-function restclient-curr-request-functions)))
+ ((and (looking-at restclient-header-regexp) (not (looking-at restclient-empty-line-regexp)))
+ (setq headers (cons (restclient-replace-all-in-header vars (restclient-make-header)) headers)))
+ ((looking-at restclient-use-var-regexp)
+ (setq headers (append headers (restclient-parse-headers (restclient-replace-all-in-string vars (match-string 0)))))))
+ (forward-line))
+ (when (looking-at restclient-empty-line-regexp)
+ (forward-line))
+ (when restclient-curr-request-functions
+ (add-hook 'restclient-response-loaded-hook 'restclient-single-request-function))
+ (let* ((cmax (restclient-current-max))
+ (entity (restclient-parse-body (buffer-substring (min (point) cmax) cmax) vars)))
+ (apply func method url headers entity args))))))
+
+(defun restclient-copy-curl-command ()
+ "Formats the request as a curl command and copies the command to the clipboard."
+ (interactive)
+ (restclient-http-parse-current-and-do
+ '(lambda (method url headers entity)
+ (let ((include-arg (if restclient-response-body-only
+ ""
+ "-i"))
+ (header-args
+ (mapconcat (lambda (header)
+ (format "-H \"%s: %s\" " (car header) (cdr header)))
+ headers))
+ (method-arg (format "-X %s" method))
+ (url-arg (format "\"%s\"" url))
+ (body-arg (if (< 0 (length entity))
+ (format "-d '%s'"
+ (replace-regexp-in-string "'" "'\\\\''" entity))
+ "")))
+ (kill-new (format "curl %s %s %s %s %s"
+ include-arg
+ header-args
+ method-arg
+ url-arg
+ body-arg)))
+ (message "curl command copied to clipboard."))))
+
+
+(defun restclient-elisp-result-function (_args offset)
+ "This is a hook constructor function.
+Read one S-expression starting from OFFSET.
+Return a function of 0 arguments that evaluates that S-expression.
+ARGS is ignored."
+ (goto-char offset)
+ (let ((form (macroexpand-all (read (current-buffer)))))
+ (lambda ()
+ (eval form))))
+
+(restclient-register-result-func
+ "run-hook" #'restclient-elisp-result-function
+ "Call the provided (possibly multi-line) elisp when the result
+ buffer is formatted. Equivalent to a restclient-response-loaded-hook
+ that only runs for this request.
+ eg. -> run-hook (message \"my hook called\")" )
+
+(defun restclient-save-body-function (filename append)
+ "Save the response to the FILENAME given in args.
+If APPEND is non-nil, appends to the file."
+ (lambda ()
+ (let* ((start (point-min))
+ (end (if (< start restclient--header-start-position)
+ (1- restclient--header-start-position)
+ (point-max))))
+ (write-region start end filename append)
+ (message "Response saved to \"%s\"" filename))))
+
+(restclient-register-result-func
+ "save-body" #'(lambda (args _offset)
+ (restclient-save-body-function args nil))
+ "Save the response body to file. The argument to the hook is the
+name of the file to save.
+eg. -> save-body /tmp/myfile.json")
+
+(restclient-register-result-func
+ "append-body" #'(lambda (args _offset)
+ (restclient-save-body-function args t))
+ "Append the response body to file. The argument to the hook is the
+name of the file to append to.
+eg. -> append-body /tmp/myfile.json")
+
+;;;###autoload
+(defun restclient-http-send-current (&optional raw stay-in-window suppress-response-buffer)
+ "Sends current request.
+Optional argument RAW don't reformat response if t.
+Optional argument STAY-IN-WINDOW do not move focus to response buffer if t.
+Optional argument SUPPRESS-RESPONSE-BUFFER do not display response buffer if t."
+ (interactive)
+ (restclient-http-parse-current-and-do 'restclient-http-do raw stay-in-window suppress-response-buffer))
+
+;;;###autoload
+(defun restclient-http-send-current-raw ()
+ "Sends current request and get raw result.
+\(no reformatting or syntax highlight of XML, JSON or images)."
+ (interactive)
+ (restclient-http-send-current t))
+
+;;;###autoload
+(defun restclient-http-send-current-stay-in-window ()
+ "Send current request and keep focus in request window."
+ (interactive)
+ (restclient-http-send-current nil t))
+
+;;;###autoload
+(defun restclient-http-send-current-suppress-response-buffer ()
+ "Send current request but don't show response buffer."
+ (interactive)
+ (restclient-http-send-current nil nil t))
+
+(defun restclient-jump-next ()
+ "Jump to next request in buffer."
+ (interactive)
+ (let ((last-min nil))
+ (while (not (eq last-min (goto-char (restclient-current-min))))
+ (goto-char (restclient-current-min))
+ (setq last-min (point))))
+ (goto-char (+ (restclient-current-max) 1))
+ (goto-char (restclient-current-min)))
+
+(defun restclient-jump-prev ()
+ "Jump to previous request in buffer."
+ (interactive)
+ (let* ((current-min (restclient-current-min))
+ (end-of-entity
+ (save-excursion
+ (progn (goto-char (restclient-current-min))
+ (while (and (or (looking-at "^\s*\\(#.*\\)?$")
+ (eq (point) current-min))
+ (not (eq (point) (point-min))))
+ (forward-line -1)
+ (beginning-of-line))
+ (point)))))
+ (unless (eq (point-min) end-of-entity)
+ (goto-char end-of-entity)
+ (goto-char (restclient-current-min)))))
+
+(defun restclient-mark-current ()
+ "Mark current request."
+ (interactive)
+ (goto-char (restclient-current-min))
+ (set-mark-command nil)
+ (goto-char (restclient-current-max))
+ (backward-char 1)
+ (setq deactivate-mark nil))
+
+(defun restclient-repeat-last-request ()
+ "Repeat the last executed request."
+ (interactive)
+ (when (marker-buffer restclient-current-request-marker)
+ (save-excursion
+ (with-current-buffer (marker-buffer restclient-current-request-marker)
+ (goto-char restclient-current-request-marker)
+ (restclient-http-send-current-suppress-response-buffer)))))
+
+(declare-function json-navigator-navigate-after-point "ext:json-navigate")
+
+(defun restclient-json-navigate-response ()
+ "Run the current json response through json-navigator, if it's installed."
+ (interactive)
+ (cond ((not (fboundp 'json-navigator-navigate-after-point))
+ (message "json-navigator is not installed"))
+ ((not (eq major-mode (restclient--preferred-mode "application/json")))
+ (message "Response buffer is not in JS mode"))
+ (t
+ (goto-char (point-min))
+ (json-navigator-navigate-after-point))))
+
+(declare-function org-toggle-pretty-entities "org")
+(declare-function org-table-iterate-buffer-tables "org-table")
+
+(defun restclient-show-info ()
+ "Display a buffer with information about the current restclient context."
+ (interactive)
+ (let ((vars-at-point (restclient-find-vars-before-point)))
+ (cl-labels ((non-overidden-vars-at-point ()
+ (seq-filter (lambda (v)
+ (null (assoc (car v) restclient-var-overrides)))
+ vars-at-point))
+ (sanitize-value-cell (var-value)
+ (replace-regexp-in-string
+ "\n" "|\n| |"
+ (replace-regexp-in-string
+ "\|" "\\\\vert{}"
+ (replace-regexp-in-string
+ "_" "\\\\under{}"
+ (restclient-replace-all-in-string vars-at-point var-value)))))
+ (sanitize-name-cell (var-name)
+ (replace-regexp-in-string "_" "\\\\under{}" var-name))
+ (var-row (var-name var-value)
+ (insert "|" (sanitize-name-cell var-name) "|" (sanitize-value-cell var-value) "|\n"))
+ (var-table (table-name)
+ (insert (format "* %s \n|--|\n|Name|Value|\n|---|\n" table-name)))
+ (var-table-footer ()
+ (insert "|--|\n\n")))
+
+ (with-current-buffer (get-buffer-create restclient-info-buffer-name)
+ (view-mode-exit t)
+ ;; insert our info
+ (erase-buffer)
+
+ (insert "\Restclient Info\ \n\n")
+
+ (var-table "Dynamic Variables")
+ (dolist (dv restclient-var-overrides)
+ (var-row (car dv) (cdr dv)))
+ (var-table-footer)
+
+ (var-table "Vars at current position")
+ (dolist (dv (non-overidden-vars-at-point))
+ (var-row (car dv) (cdr dv)))
+ (var-table-footer)
+
+ (insert "* Active environment\n|--|\n|File|Environment name|\n|--|\n")
+ (when (or restclient-current-env-file restclient-current-env-name)
+ (insert "|" (or restclient-current-env-file "") "|" (or restclient-current-env-name "") "|\n"))
+ (var-table-footer)
+
+ ;; registered callbacks
+ (var-table "Registered request hook types")
+ (dolist (handler-name (delete-dups (mapcar 'car restclient-result-handlers)))
+ (var-row handler-name (cddr (assoc handler-name restclient-result-handlers))))
+ (var-table-footer)
+
+ (insert "\n\n'q' to exit\n")
+ (org-mode)
+ (org-toggle-pretty-entities)
+ (org-table-iterate-buffer-tables)
+ (outline-show-all)
+ (view-mode-enter)
+ (goto-char (point-min))))
+ (switch-to-buffer-other-window restclient-info-buffer-name)))
+
+(defun restclient-narrow-to-current ()
+ "Narrow to region of current request."
+ (interactive)
+ (narrow-to-region (restclient-current-min) (restclient-current-max)))
+
+(defun restclient-toggle-body-visibility ()
+ "Hide or show the body of the current request.
+Hide/show only happens if point is on the first line of a request."
+ (interactive)
+ ;; If we are not on the HTTP call line, don't do anything
+ (let ((at-header (save-excursion
+ (beginning-of-line)
+ (looking-at restclient-method-url-regexp))))
+ (when at-header
+ (save-excursion
+ (end-of-line)
+ ;; If the overlays at this point have 'invisible set, toggling
+ ;; must make the region visible. Else it must hide the region
+
+ ;; This part of code is from org-hide-block-toggle method of
+ ;; Org mode
+ (let ((overlays (overlays-at (point))))
+ (if (memq t (mapcar
+ (lambda (o)
+ (eq (overlay-get o 'invisible) 'outline))
+ overlays))
+ (outline-flag-region (point) (restclient-current-max) nil)
+ (outline-flag-region (point) (restclient-current-max) t)))) t)))
+
+(defun restclient-toggle-body-visibility-or-indent ()
+ "Hide of show the body of the current request, or indent current line."
+ (interactive)
+ (unless (restclient-toggle-body-visibility)
+ (indent-for-tab-command)))
+
+(defconst restclient-mode-keywords
+ (list (list restclient-method-url-regexp '(1 'restclient-method-face) '(2 'restclient-url-face))
+ (list restclient-svar-regexp '(1 'restclient-variable-name-face) '(2 'restclient-variable-string-face))
+ (list restclient-evar-regexp '(1 'restclient-variable-name-face) '(2 'restclient-variable-elisp-face t))
+ (list restclient-mvar-regexp '(1 'restclient-variable-name-face) '(2 'restclient-variable-multiline-face t))
+ (list restclient-use-var-regexp '(1 'restclient-variable-usage-face))
+ (list restclient-file-regexp '(0 'restclient-file-upload-face))
+ (list restclient-header-regexp '(1 'restclient-header-name-face t) '(2 'restclient-header-value-face t))
+ (list restclient-response-hook-regexp '(1 ' restclient-request-hook-face t)
+ '(2 'restclient-request-hook-name-face t)
+ '(3 'restclient-request-hook-args-face t))))
+
+(defconst restclient-mode-syntax-table
+ (let ((table (make-syntax-table)))
+ (modify-syntax-entry ?\# "<" table)
+ (modify-syntax-entry ?\n ">#" table)
+ table))
+
+(defvar restclient-mode-map
+ (let ((map (make-sparse-keymap)))
+ (define-key map (kbd "C-c C-c") 'restclient-http-send-current)
+ (define-key map (kbd "C-c C-r") 'restclient-http-send-current-raw)
+ (define-key map (kbd "C-c C-v") 'restclient-http-send-current-stay-in-window)
+ (define-key map (kbd "C-c C-b") 'restclient-http-send-current-suppress-response-buffer)
+ (define-key map (kbd "C-c C-n") 'restclient-jump-next)
+ (define-key map (kbd "C-c C-p") 'restclient-jump-prev)
+ (define-key map (kbd "C-c C-.") 'restclient-mark-current)
+ (define-key map (kbd "C-c C-u") 'restclient-copy-curl-command)
+ (define-key map (kbd "C-c n n") 'restclient-narrow-to-current)
+ (define-key map (kbd "C-c C-i") 'restclient-show-info)
+ (define-key map (kbd "C-c C-e") 'restclient-set-env)
+ (define-key map (kbd "C-c M-e") 'restclient-reload-current-env)
+ map)
+ "Keymap for `restclient-mode'.")
+
+(defvar restclient-response-buffer-map
+ (let ((map (make-sparse-keymap))
+ (view-mode-map (cdr (assoc 'view-mode minor-mode-map-alist))))
+ (set-keymap-parent map view-mode-map)
+ (define-key map (kbd "g") 'restclient-repeat-last-request)
+ (define-key map (kbd "j") 'restclient-json-navigate-response)
+ map)
+ "Keymap for restclient responses.
+Added to the default `view-mode-map' when displaying responses in view mode.")
+
+(defun restclient--setup-response-buffer-map ()
+ "Override `view-mode' keymap in response buffers."
+ (push `(view-mode . ,restclient-response-buffer-map)
+ minor-mode-overriding-map-alist))
+
+(define-minor-mode restclient-outline-mode
+ "Minor mode to allow show/hide of request bodies by TAB."
+ :init-value nil
+ :lighter nil
+ :keymap '(("\t" . restclient-toggle-body-visibility-or-indent)
+ ("\C-c\C-a" . restclient-toggle-body-visibility-or-indent))
+ :group 'restclient)
+
+;;;###autoload
+(define-derived-mode restclient-mode fundamental-mode "REST Client"
+ "Turn on restclient mode."
+ (set (make-local-variable 'comment-start) "# ")
+ (set (make-local-variable 'comment-start-skip) "# *")
+ (set (make-local-variable 'comment-column) 48)
+
+ (set (make-local-variable 'font-lock-defaults) '(restclient-mode-keywords))
+ ;; We use outline-mode's method outline-flag-region to hide/show the
+ ;; body. As a part of it, it sets 'invisibility text property to
+ ;; 'outline. To get ellipsis, we need 'outline to be in
+ ;; buffer-invisibility-spec
+ (add-to-invisibility-spec '(outline . t)))
+
+(add-hook 'restclient-mode-hook 'restclient-outline-mode)
+(add-hook 'restclient-mode-hook #'(lambda ()
+ (setq imenu-generic-expression
+ `((nil ,restclient-method-url-regexp 0)))))
+
+(provide 'restclient)
+
+(eval-after-load 'helm
+ '(ignore-errors (require 'restclient-helm)))
+
+(eval-after-load 'jq-mode
+ '(ignore-errors (require 'restclient-jq)))
+
+;;; restclient.el ends here
blob - /dev/null
blob + 844f5dfd17d695a0e0ed5089e2812de59a1f4d81 (mode 644)
--- /dev/null
+++ elpa/restclient-jq-20250803.2119/restclient-jq-autoloads.el
+;;; restclient-jq-autoloads.el --- automatically extracted autoloads (do not edit) -*- lexical-binding: t -*-
+;; Generated by the `loaddefs-generate' function.
+
+;; This file is part of GNU Emacs.
+
+;;; Code:
+
+(add-to-list 'load-path (or (and load-file-name (directory-file-name (file-name-directory load-file-name))) (car load-path)))
+
+
+
+;;; Generated autoloads from restclient-jq.el
+
+(register-definition-prefixes "restclient-jq" '("restclient-jq-"))
+
+;;; End of scraped data
+
+(provide 'restclient-jq-autoloads)
+
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; no-native-compile: t
+;; coding: utf-8-emacs-unix
+;; End:
+
+;;; restclient-jq-autoloads.el ends here
blob - /dev/null
blob + 4fbf056c0998850332b23995a130f6d606ff6794 (mode 644)
--- /dev/null
+++ elpa/restclient-jq-20250803.2119/restclient-jq-pkg.el
+;; -*- no-byte-compile: t; lexical-binding: nil -*-
+(define-package "restclient-jq" "20250803.2119"
+ "Support for setting restclient vars from jq expressions."
+ '((restclient "20200502.831")
+ (jq-mode "0.4.1")
+ (emacs "24.4"))
+ :url "https://github.com/pashky/restclient.el"
+ :commit "6764278a3d63520eaf117344d8dc23654b640645"
+ :revdesc "6764278a3d63"
+ :keywords '("tools" "comm" "http" "jq")
+ :authors '(("Cameron Dorrat" . "cdorrat@gmail.com"))
+ :maintainers '(("Cameron Dorrat" . "cdorrat@gmail.com")))
blob - /dev/null
blob + f0035091f2f5d4e016403d19ce6c28c036d4f277 (mode 644)
--- /dev/null
+++ elpa/restclient-jq-20250803.2119/restclient-jq.el
+;;; restclient-jq.el --- Support for setting restclient vars from jq expressions -*- lexical-binding: t; -*-
+;;
+;; Public domain.
+
+;; URL: https://github.com/pashky/restclient.el
+;; Author: Cameron Dorrat <cdorrat@gmail.com>
+;; Maintainer: Cameron Dorrat <cdorrat@gmail.com>
+;; Created: 26 Apr 2020
+;; Keywords: tools comm http jq
+;; Package-Version: 20250803.2119
+;; Package-Revision: 6764278a3d63
+;; Package-Requires: ((restclient "20200502.831") (jq-mode "0.4.1") (emacs "24.4"))
+
+;; This file is not part of GNU Emacs.
+;; This file is public domain software. Do what you want.
+
+;;; Commentary:
+;;
+;; This is a companion to restclient.el to add support for setting variables from results using jq expressions
+
+;;; Code:
+;;
+(require 'restclient)
+(require 'jq-mode)
+
+;; --- jq support
+(defun restclient-jq-result-end-point ()
+ "Find the end of a restclient JSON response body."
+ (save-excursion
+ (goto-char (point-max))
+ (or (and (re-search-backward "^[^/].*" nil t)
+ (line-end-position))
+ (point-max))))
+
+(defun restclient-jq-get-var (jq-pattern)
+ "Find value matching the JQ-PATTERN in a restclient JSON response."
+
+ (with-temp-buffer
+ (let ((output (current-buffer)))
+ (with-current-buffer restclient-same-buffer-response-name
+ (call-process-region
+ (point-min)
+ (restclient-jq-result-end-point)
+ shell-file-name
+ nil
+ output
+ nil
+ shell-command-switch
+ (format "%s %s %s"
+ jq-interactive-command
+ "-r"
+ (shell-quote-argument jq-pattern))))
+ (string-trim (buffer-string)))))
+
+(defun restclient-jq-json-var-function (args _args-offset)
+ "A restclient result func for setting variables from a JSON response.
+
+ARGS contains the variable name and a jq pattern to use."
+ (save-match-data
+ (and (string-match "\\(:[^: \n]+\\|@[^@ \n]+\\) \\(.*\\)$" args)
+ (let ((var-name (match-string 1 args))
+ (jq-patt (match-string 2 args)))
+ (lambda ()
+ (let ((resp-val (restclient-jq-get-var jq-patt)))
+ (restclient-remove-var var-name)
+ (restclient-set-var var-name resp-val)
+ (message "restclient var [%s = \"%s\"] " var-name resp-val)))))))
+
+(defun restclient-jq-interactive-result ()
+ "Run jq interactively on a restclient JSON response buffer."
+ (interactive)
+ (flush-lines "^//.*") ;; jq doesn't like comments
+ (jq-interactively (point-min) (restclient-jq-result-end-point)))
+
+(restclient-register-result-func
+ "jq-set-var" #'restclient-jq-json-var-function
+ "Set a restclient variable with the value jq expression,
+takes var & jq expression as args.
+eg. -> jq-set-var :my-token .token")
+(define-key restclient-response-buffer-map (kbd "C-c C-j") #'restclient-jq-interactive-result)
+
+(provide 'restclient-jq)
+
+;;; restclient-jq.el ends here
blob - d938e849bec4f0b3393fef6efb94fb438edf1594
blob + 7508912acf49b083a499de4a5d0b1b84ea47d90a
--- init.el
+++ init.el
("melpa-stable" . 1)
("melpa" . 0))
package-pinned-packages '((sly . "melpa"))
- package-selected-packages '(elfeed magit nhexl-mode notmuch paredit paredit-menu sly))
+ package-selected-packages '(magit nhexl-mode notmuch ob-restclient paredit paredit-menu
+ restclient restclient-jq sly))
(package-initialize)
;;;; Completions
(setopt notmuch-archive-tags '("-inbox" "-unread")
notmuch-poll-script "notmuch-poll") ; TODO: deprecated, use hooks
+;;;; restclient
+(with-eval-after-load 'restclient
+ (require 'restclient-capf))
+
;;;; Misc
(setopt focus-follows-mouse t
frame-resize-pixelwise t
