Pass regex names to action (#61)

Pass the name of the matched regular expression to the action via the
`FASTCOPY_REGEX_NAME` environment variable.

If multiple regular expressions matched the text, the environment
variable holds a space-separated list rather than a singular value.

Refs #56

Author: abhinav

CHANGELOG.md

@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+### Added
+- Expose the name of the matched regex to the action with the
+  `FASTCOPY_REGEX_NAME` environment variable.
+
 ## 0.7.2 - 2022-02-19
 ### Added
 - For 32-bit ARM binaries, support ARM v5, v6, and v7.

README.md

@@ -187,6 +187,37 @@ If `{}` is absent from the command, tmux-fastcopy will pass the selected text
 to the command over stdin. For example,
 
     set-option -g @fastcopy-action pbcopy  # for macOS
+    
+#### Accessing the regex name
+    
+tmux-fastcopy executes the action with the `FASTCOPY_REGEX_NAME` environment
+variable set. This holds the [name of the regex](#regex-names) that matched the
+selected string.
+If multiple different regexes matched the string, `FASTCOPY_REGEX_NAME` holds a
+space-separated list of them.
+
+You can use this to customize the action on a per-regex basis.
+
+For example, the following will copy most strings to the tmux buffer as usual.
+However, if the string is matched by the "path" regular expression and it
+represents an existing directory, this will open that directory in the file
+browser.
+
+```bash
+#!/usr/bin/env bash
+
+# Place this inside a file like "fastcopy.sh",
+# mark it executable (chmod +x fastcopy.sh),
+# and set the @fastcopy-action setting to:
+#   '/path/to/fastcopy.sh {}'
+
+if [ "$FASTCOPY_REGEX_NAME" == path ] && [ -d "$1" ]; then
+    xdg-open "$1"  # on macOS, use "open" instead
+    exit 0
+fi
+
+tmux set-buffer -w "$1"
+```
 
 ### `@fastcopy-alphabet`
 
@@ -272,6 +303,10 @@ them to a blank string.
 
     set-option -g @fastcopy-regex-isodate ""
 
+The name of the regular expression that matched the selection is available to
+the [`@fastcopy-action`][] via the `FASTCOPY_REGEX_NAME` environment variable.
+See [Accessing the regex name](#accessing-the-regex-name) for more details.
+
 ## FAQ
 
 ### <a id="clipboard"></a> How do I copy text to my clipboard?
@@ -361,6 +396,15 @@ For example, the following deletes the `isodate` regular expression.
 
     set-option -g @fastcopy-regex-isodate ""
 
+### Can I have different actions for different regexes?
+
+The `FASTCOPY_REGEX_NAME` environment variable holds the name of the regex that
+matched your selection.
+You can run different actions on a per-regex basis by inspecting the
+`FASTCOPY_REGEX_NAME` environment variable in your [`@fastcopy-action`][].
+
+See [Accessing the regex name](#accessing-the-regex-name) for more details.
+
 ## Credits
 
 The plugin is inspired by functionality provided by the [Vimium][] and

action.go

@@ -5,14 +5,23 @@ import (
 	"os/exec"
 	"strings"
 
+	"github.com/abhinav/tmux-fastcopy/internal/fastcopy"
 	"github.com/abhinav/tmux-fastcopy/internal/log"
 	shellwords "github.com/mattn/go-shellwords"
 )
 
-const _placeholderArg = "{}"
+const (
+	_placeholderArg   = "{}"
+	_regexNamesEnvKey = "FASTCOPY_REGEX_NAME"
+)
+
+func regexNamesEnvEntry(matchers []string) string {
+	return _regexNamesEnvKey + "=" + strings.Join(matchers, " ")
+}
 
 type actionFactory struct {
-	Log *log.Logger
+	Log     *log.Logger
+	Environ func() []string
 }
 
 // New builds a command handler from the provided string.
@@ -38,59 +47,67 @@ func (f *actionFactory) New(action string) (action, error) {
 				BeforeArgs: args[:i],
 				AfterArgs:  args[i+1:],
 				Log:        f.Log,
+				Environ:    f.Environ,
 			}, nil
 		}
 	}
 
 	// No "{}" use stdin.
 	return &stdinAction{
-		Cmd:  cmd,
-		Args: args,
-		Log:  f.Log,
+		Cmd:     cmd,
+		Args:    args,
+		Log:     f.Log,
+		Environ: f.Environ,
 	}, nil
 }
 
 // action specifies how to handle the user's selection.
-type action interface{ Run(selection string) error }
+type action interface {
+	Run(fastcopy.Selection) error
+}
 
 type stdinAction struct {
-	Cmd  string
-	Args []string
-	Log  *log.Logger
+	Cmd     string
+	Args    []string
+	Log     *log.Logger
+	Environ func() []string // == os.Environ
 }
 
-func (h *stdinAction) Run(text string) error {
+func (h *stdinAction) Run(sel fastcopy.Selection) error {
 	logw := &log.Writer{
 		Log: h.Log.WithName(h.Cmd),
 	}
 	defer logw.Close()
 
 	cmd := exec.Command(h.Cmd, h.Args...)
-	cmd.Stdin = strings.NewReader(text)
+	cmd.Stdin = strings.NewReader(sel.Text)
 	cmd.Stdout = logw
 	cmd.Stderr = logw
+	cmd.Env = append(h.Environ(), regexNamesEnvEntry(sel.Matchers))
 	return cmd.Run()
 }
 
 type argAction struct {
 	Cmd                   string
 	BeforeArgs, AfterArgs []string
 	Log                   *log.Logger
+	Environ               func() []string // == os.Environ
 }
 
-func (h *argAction) Run(text string) error {
+func (h *argAction) Run(sel fastcopy.Selection) error {
 	logw := &log.Writer{
 		Log: h.Log.WithName(h.Cmd),
 	}
 	defer logw.Close()
 
 	args := make([]string, 0, len(h.BeforeArgs)+len(h.AfterArgs)+1)
 	args = append(args, h.BeforeArgs...)
-	args = append(args, text)
+	args = append(args, sel.Text)
 	args = append(args, h.AfterArgs...)
 
 	cmd := exec.Command(h.Cmd, args...)
 	cmd.Stdout = logw
 	cmd.Stderr = logw
+	cmd.Env = append(h.Environ(), regexNamesEnvEntry(sel.Matchers))
 	return cmd.Run()
 }

action_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"testing"
 
+	"github.com/abhinav/tmux-fastcopy/internal/fastcopy"
 	"github.com/abhinav/tmux-fastcopy/internal/log"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -81,13 +82,37 @@ func TestStdinAction(t *testing.T) {
 	var buff bytes.Buffer
 
 	action := stdinAction{
-		Cmd: "cat",
-		Log: log.New(&buff),
+		Cmd:     "cat",
+		Log:     log.New(&buff),
+		Environ: func() []string { return nil },
 	}
-	require.NoError(t, action.Run("foo"))
+	require.NoError(t, action.Run(fastcopy.Selection{
+		Text:     "foo",
+		Matchers: []string{"x"},
+	}))
 	assert.Equal(t, "[cat] foo\n", buff.String())
 }
 
+func TestStdinAction_RegexesEnv(t *testing.T) {
+	t.Parallel()
+
+	var buff bytes.Buffer
+
+	action := stdinAction{
+		Cmd: "env",
+		Log: log.New(&buff),
+		Environ: func() []string {
+			return []string{"FOO=bar"}
+		},
+	}
+	require.NoError(t, action.Run(fastcopy.Selection{
+		Text:     "foo",
+		Matchers: []string{"x", "y"},
+	}))
+	assert.Contains(t, buff.String(), "[env] FASTCOPY_REGEX_NAME=x y\n")
+	assert.Contains(t, buff.String(), "[env] FOO=bar\n")
+}
+
 func TestArgAction(t *testing.T) {
 	t.Parallel()
 
@@ -97,7 +122,31 @@ func TestArgAction(t *testing.T) {
 		BeforeArgs: []string{"1", "2"},
 		AfterArgs:  []string{"3", "4"},
 		Log:        log.New(&buff),
+		Environ:    func() []string { return nil },
 	}
-	require.NoError(t, action.Run("foo"))
+	require.NoError(t, action.Run(fastcopy.Selection{
+		Text:     "foo",
+		Matchers: []string{"x"},
+	}))
 	assert.Equal(t, "[echo] 1 2 foo 3 4\n", buff.String())
 }
+
+func TestArgAction_RegexesEnv(t *testing.T) {
+	t.Parallel()
+
+	var buff bytes.Buffer
+	action := argAction{
+		Cmd:        "bash",
+		BeforeArgs: []string{"-c", "env"},
+		Log:        log.New(&buff),
+		Environ: func() []string {
+			return []string{"FOO=bar"}
+		},
+	}
+	require.NoError(t, action.Run(fastcopy.Selection{
+		Text:     "foo",
+		Matchers: []string{"x", "y"},
+	}))
+	assert.Contains(t, buff.String(), "[bash] FASTCOPY_REGEX_NAME=x y\n")
+	assert.Contains(t, buff.String(), "[bash] FOO=bar\n")
+}

app.go

@@ -145,7 +145,7 @@ type ctrl struct {
 
 	w   *fastcopy.Widget
 	ui  *ui.App
-	sel string
+	sel fastcopy.Selection
 }
 
 func (c *ctrl) Init() {
@@ -176,12 +176,12 @@ func (c *ctrl) Init() {
 	c.ui.Start()
 }
 
-func (c *ctrl) Wait() (string, error) {
+func (c *ctrl) Wait() (fastcopy.Selection, error) {
 	err := c.ui.Wait()
 	return c.sel, err
 }
 
-func (c *ctrl) HandleSelection(_ string, text string) {
-	c.sel = text
+func (c *ctrl) HandleSelection(sel fastcopy.Selection) {
+	c.sel = sel
 	c.ui.Stop()
 }