Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://github.com/xenodium/dwim-shell-command below:

xenodium/dwim-shell-command: Save your shell commands/scripts and apply from Emacs with ease.

👉 Support this work via GitHub Sponsors

Use dwim-shell-command-on-marked-files to define new functions that apply command-line utilities to current buffer or dired files.

For example:

(defun my/dwim-shell-command-convert-to-gif ()
  "Convert all marked videos to optimized gif(s)."
  (interactive)
  (dwim-shell-command-on-marked-files
   "Convert to gif"
   "ffmpeg -loglevel quiet -stats -y -i '<<f>>' -pix_fmt rgb24 -r 15 '<<fne>>.gif'"
   :utils "ffmpeg"))

Can be applied as:

This makes wrapping one-liners a breeze, so let’s do some more…

(defun my/dwim-shell-command-convert-image-to-jpg ()
  "Convert all marked images to jpg(s)."
  (interactive)
  (dwim-shell-command-on-marked-files
   "Convert to jpg"
   "convert -verbose '<<f>>' '<<fne>>.jpg'"
   :utils "convert"))

(defun my/dwim-shell-command-convert-audio-to-mp3 ()
  "Convert all marked audio to mp3(s)."
  (interactive)
  (dwim-shell-command-on-marked-files
   "Convert to mp3"
   "ffmpeg -stats -n -i '<<f>>' -acodec libmp3lame '<<fne>>.mp3'"
   :utils "ffmpeg"))

(defun dwim-shell-commands-http-serve-dir ()
  "HTTP serve current directory."
  (interactive)
  (dwim-shell-command-on-marked-files
   "HTTP serve current dir"
   "python3 -m http.server"
   :utils "python3"
   :focus-now t
   :no-progress t))

(defun dwim-shell-commands-image-view-location-in-openstreetmap ()
  "Open image(s) location in map/browser."
  (interactive)
  (dwim-shell-command-on-marked-files
   "Browse location"
   "lat=\"$(exiftool -csv -n -gpslatitude -gpslongitude '<<f>>' | tail -n 1 | cut -s -d',' -f2-2)\"
        if [ -z \"$lat\" ]; then
          echo \"no latitude\"
          exit 1
        fi
        lon=\"$(exiftool -csv -n -gpslatitude -gpslongitude '<<f>>' | tail -n 1 | cut -s -d',' -f3-3)\"
        if [ -z \"$lon\" ]; then
          echo \"no longitude\"
          exit 1
        fi
        if [[ $OSTYPE == darwin* ]]; then
          open \"http://www.openstreetmap.org/?mlat=${lat}&mlon=${lon}&layers=C\"
        else
          xdg-open \"http://www.openstreetmap.org/?mlat=${lat}&mlon=${lon}&layers=C\"
        fi"
   :utils "exiftool"
   :error-autofocus t
   :silent-success t))

(defun dwim-shell-command-csv-to-json-via-python ()
  "Convert csv file to json (via Python)."
  (interactive)
  (dwim-shell-command-on-marked-files
   "Convert csv file to json (via Python)."
   "
import csv
import json
text = json.dumps({ \"values\": list(csv.reader(open('<<f>>')))})
fpath = '<<fne>>.json'
with open(fpath , 'w') as f:
  f.write(text)"
   :shell-util "python"
   :shell-args "-c"))

(defun dwim-shell-command-csv-to-json-via-swift ()
  "Convert csv file to json (via Swift)."
  (interactive)
  (dwim-shell-command-on-marked-files
   "Convert csv file to json (via Swift)."
   "import Foundation
    import TabularData
    let filePath = \"<<f>>\"
    print(\"reading \\(filePath)\")
    let content = try String(contentsOfFile: filePath).trimmingCharacters(in: .whitespacesAndNewlines)
    let parsedCSV = content.components(separatedBy: CSVWritingOptions().newline).map{
      $0.components(separatedBy: \",\")
    }
    let jsonEncoder = JSONEncoder()
    let jsonData = try jsonEncoder.encode([\"value\": parsedCSV])
    let json = String(data: jsonData, encoding: String.Encoding.utf8)
    let outURL = URL(fileURLWithPath:\"<<fne>>.json\")
    try json!.write(to: outURL, atomically: true, encoding: String.Encoding.utf8)
    print(\"wrote \\(outURL)\")"
   :shell-pipe "swift -"))

While you may want to build your own command toolbox over time, I’ve also shared my toolbox (close to 100 commands).

If you create new command not found in my list, I’d love to hear about it. File an issue or just ping me (Mastodon / Twitter / Reddit / Email).

• Asynchronously.
• Using noweb templates.
• Automatically injecting files (from dired or other buffers) or kill ring.
• Managing buffer focus with heuristics.
• Showing progress bar.
• Quick buffer exit.
• More reusable history.

dwim-shell-command determines which file(s) you want the command to operate on.

If visiting a dired buffer, draw the marked file(s).

If visiting a buffer with an associated file, use that.

Operate on drawn files using either the following:

• <<f>> (file path)
• <<fne>> (file path without extension)
• <<e>> (extension)
• <<td>> (generate a temporary directory)
• <<*>> (all files joined)
• <<cb>> (clipboard)

For example:

With drawn files path/to/image1.png and path/to/image2.png

convert <<f>> <<fne>>.jpg expands to

convert path/to/image1.png path/to/image1.jpg
convert path/to/image2.png path/to/image2.jpg

while ls -lh <<*>> expands to

ls -lh path/to/image1.png path/to/image2.png

dwim-shell-command creates a process buffer to capture command output, but neither displays nor focuses on it by default. Instead, it tries to guess what’s more convenient to focus on.

While the process is busy, show a spinner in the minibuffer. No focus changes.

After process is finished:

If there were any files created in the default-directory, jump to a dired buffer and move point to the new file (via dired-jump).

If no new files were created, automatically switch focus to the process buffer and display its output.

Note: You can prevent this automatic focus by prepending your command with whitespace.

” convert ‘<<f>>’ ‘<<fne>>.jpg’”

If the shell command caused any errors, offer to focus the process buffer and display its output.

Command-line utilities like ffmpeg can be easily integrated into Emacs flows (without the need to remember any flags or parameters) by wrapping command invocations into functions and invoking via M-x (or your favorite binding). Same DWIM behavior from dwim-shell-command is inherited.

Process buffers are read-only and can be quickly closed by pressing q.

Because of templates, command history becomes automatically reusable in other contexts.

dwim-shell-command is available on MELPA.

1. Install via M-x package-install.
2. Require, set edit style, and add company backend:

(require 'dwim-shell-command)

Now you’re ready to run

M-x dwim-shell-command

Alternatively, can also install via use-package, define your own commands and remap to shell-command’s existing binding using something like:

(use-package dwim-shell-command
  :ensure t
  :bind (([remap shell-command] . dwim-shell-command)
         :map dired-mode-map
         ([remap dired-do-async-shell-command] . dwim-shell-command)
         ([remap dired-do-shell-command] . dwim-shell-command)
         ([remap dired-smart-shell-command] . dwim-shell-command))
  :config
  (defun my/dwim-shell-command-convert-to-gif ()
    "Convert all marked videos to optimized gif(s)."
    (interactive)
    (dwim-shell-command-on-marked-files
     "Convert to gif"
     "ffmpeg -loglevel quiet -stats -y -i '<<f>>' -pix_fmt rgb24 -r 15 '<<fne>>.gif'"
     :utils "ffmpeg")))

I’m including an optional package (dwim-shell-commands.el), with all the command line utilities I’ve brought in over time. You can load this optional package via:

(require 'dwim-shell-commands)

Note: dwim-shell-command(s).el gives you all commands, while dwim-shell-command.el provides only the building blocks.

Here are all the commands I’ve added so far…

This can be done with either of the following:

emacs --quick --batch --eval '(message "<<f>>")'

emacsclient --eval '(message "<<f>>")'

👉 Support my work via GitHub Sponsors

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4