{{ message }}
Repository navigation
Expand file tree
/
Copy pathcli.py
More file actions
1007 lines (810 loc) · 30.9 KB
/
Copy pathcli.py
File metadata and controls
1007 lines (810 loc) · 30.9 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# -*- coding: utf-8 -*-
"""Command line tool for managing tmux workspaces and tmuxp configurations.
tmuxp.cli
~~~~~~~~~
"""
from __future__ import absolute_import
import importlib
import logging
import os
import sys
import click
import kaptan
from click.exceptions import FileError
from libtmux.common import has_gte_version, has_minimum_version, which
from libtmux.exc import TmuxCommandNotFound
from libtmux.server import Server
from . import config, exc, log, util
from .__about__ import __version__
from ._compat import string_types
from .workspacebuilder import WorkspaceBuilder, freeze
logger = logging.getLogger(__name__)
VALID_CONFIG_DIR_FILE_EXTENSIONS = ['.yaml', '.yml', '.json']
def get_cwd():
return os.getcwd()
def get_config_dir():
"""
Return tmuxp configuration directory.
``TMUXP_CONFIGDIR`` environmental variable has precedence if set. We also
evaluate XDG default directory from XDG_CONFIG_HOME environmental variable
if set or its default. Then the old default ~/.tmuxp is returned for
compatibility.
Returns
-------
str :
absolute path to tmuxp config directory
"""
paths = []
if 'TMUXP_CONFIGDIR' in os.environ:
paths.append(os.environ['TMUXP_CONFIGDIR'])
if 'XDG_CONFIG_HOME' in os.environ:
paths.append(os.path.join(os.environ['XDG_CONFIG_HOME'], 'tmuxp'))
else:
paths.append('~/.config/tmuxp/')
paths.append('~/.tmuxp')
for path in paths:
path = os.path.expanduser(path)
if os.path.isdir(path):
return path
# Return last path as default if none of the previous ones matched
return path
def get_tmuxinator_dir():
"""
Return tmuxinator configuration directory.
Checks for ``TMUXINATOR_CONFIG`` environmental variable.
Returns
-------
str :
absolute path to tmuxinator config directory
See Also
--------
:meth:`tmuxp.config.import_tmuxinator`
"""
if 'TMUXINATOR_CONFIG' in os.environ:
return os.path.expanduser(os.environ['TMUXINATOR_CONFIG'])
return os.path.expanduser('~/.tmuxinator/')
def get_teamocil_dir():
"""
Return teamocil configuration directory.
Returns
-------
str :
absolute path to teamocil config directory
See Also
--------
:meth:`tmuxp.config.import_teamocil`
"""
return os.path.expanduser('~/.teamocil/')
def _validate_choices(options):
"""
Callback wrapper for validating click.prompt input.
Parameters
----------
options : list
List of allowed choices
Returns
-------
:func:`callable`
callback function for value_proc in :func:`click.prompt`.
Raises
------
:class:`click.BadParameter`
"""
def func(value):
if value not in options:
raise click.BadParameter(
'Possible choices are: {0}.'.format(', '.join(options))
)
return value
return func
def set_layout_hook(session, hook_name):
"""Set layout hooks to normalize layout.
References:
- tmuxp issue: https://github.com/tmux-python/tmuxp/issues/309
- tmux issue: https://github.com/tmux/tmux/issues/1106
tmux 2.6+ requires that the window be viewed with the client before
select-layout adjustments can take effect.
To handle this, this function creates temporary hook for this session to
iterate through all windows and select the layout.
In order for layout changes to take effect, a client must at the very
least be attached to the window (not just the session).
hook_name is provided to allow this to set to multiple scenarios, such
as 'client-attached' (which the user attaches the session). You may
also want 'after-switch-client' for cases where the user loads tmuxp
sessions inside tmux since tmuxp offers to switch for them.
Also, the hooks are set immediately unbind after they're invoked via -u.
Parameters
----------
session : :class:`libtmux.session.Session`
session to bind hook to
hook_name : str
hook name to bind to, e.g. 'client-attached'
"""
cmd = ['set-hook', '-t', session.id, hook_name]
hook_cmd = []
attached_window = session.attached_window
for window in session.windows:
# unfortunately, select-layout won't work unless
# we've literally selected the window at least once
# with the client
hook_cmd.append('selectw -t {}'.format(window.id))
# edit: removed -t, or else it won't respect main-pane-w/h
hook_cmd.append('selectl')
hook_cmd.append('selectw -p')
# unset the hook immediately after executing
hook_cmd.append(
'set-hook -u -t {target_session} {hook_name}'.format(
target_session=session.id, hook_name=hook_name
)
)
hook_cmd.append('selectw -t {}'.format(attached_window.id))
# join the hook's commands with semicolons
hook_cmd = '{}'.format('; '.join(hook_cmd))
# append the hook command
cmd.append(hook_cmd)
# create the hook
session.cmd(*cmd)
def is_pure_name(path):
"""
Return True if path is a name and not a file path.
Parameters
----------
path : str
Path (can be absolute, relative, etc.)
Returns
-------
bool
True if path is a name of config in config dir, not file path.
"""
return (
not os.path.isabs(path)
and len(os.path.dirname(path)) == 0
and not os.path.splitext(path)[1]
and path != '.'
and path != ''
)
class ConfigPath(click.Path):
def __init__(self, config_dir=None, *args, **kwargs):
super(ConfigPath, self).__init__(*args, **kwargs)
self.config_dir = config_dir
def convert(self, value, param, ctx):
config_dir = self.config_dir
if callable(config_dir):
config_dir = config_dir()
value = scan_config(value, config_dir=config_dir)
return super(ConfigPath, self).convert(value, param, ctx)
def scan_config_argument(ctx, param, value, config_dir=None):
"""Validate / translate config name/path values for click config arg.
Wrapper on top of :func:`cli.scan_config`."""
if callable(config_dir):
config_dir = config_dir()
if not config:
click.echo("Enter at least one CONFIG")
click.echo(ctx.get_help(), color=ctx.color)
ctx.exit()
if isinstance(value, string_types):
value = scan_config(value, config_dir=config_dir)
elif isinstance(value, tuple):
value = tuple([scan_config(v, config_dir=config_dir) for v in value])
return value
def get_abs_path(config):
path = os.path
join, isabs = path.join, path.isabs
dirname, normpath = path.dirname, path.normpath
cwd = os.getcwd()
config = os.path.expanduser(config)
if not isabs(config) or len(dirname(config)) > 1:
config = normpath(join(cwd, config))
return config
def _resolve_path_no_overwrite(config):
path = get_abs_path(config)
if os.path.exists(path):
raise click.exceptions.UsageError('%s exists. Pick a new filename.' % path)
return path
def scan_config(config, config_dir=None):
"""
Return the real config path or raise an exception.
If config is directory, scan for .tmuxp.{yaml,yml,json} in directory. If
one or more found, it will warn and pick the first.
If config is ".", "./" or None, it will scan current directory.
If config is has no path and only a filename, e.g. "myconfig.yaml" it will
search config dir.
If config has no path and only a name with no extension, e.g. "myconfig",
it will scan for file name with yaml, yml and json. If multiple exist, it
will warn and pick the first.
Parameters
----------
config : str
config file, valid examples:
- a file name, myconfig.yaml
- relative path, ../config.yaml or ../project
- a period, .
Raises
------
:class:`click.exceptions.FileError`
"""
if not config_dir:
config_dir = get_config_dir()
path = os.path
exists, join, isabs = path.exists, path.join, path.isabs
dirname, normpath, splitext = path.dirname, path.normpath, path.splitext
cwd = os.getcwd()
is_name = False
file_error = None
config = os.path.expanduser(config)
# if purename, resolve to confg dir
if is_pure_name(config):
is_name = True
elif (
not isabs(config)
or len(dirname(config)) > 1
or config == '.'
or config == ""
or config == "./"
): # if relative, fill in full path
config = normpath(join(cwd, config))
# no extension, scan
if not splitext(config)[1]:
if is_name:
candidates = [
x
for x in [
'%s%s' % (join(config_dir, config), ext)
for ext in VALID_CONFIG_DIR_FILE_EXTENSIONS
]
if exists(x)
]
if not len(candidates):
file_error = (
'config not found in config dir (yaml/yml/json) %s '
'for name' % (config_dir)
)
else:
candidates = [
x
for x in [
join(config, ext)
for ext in ['.tmuxp.yaml', '.tmuxp.yml', '.tmuxp.json']
]
if exists(x)
]
if len(candidates) > 1:
click.secho(
'Multiple .tmuxp.{yml,yaml,json} configs in %s' % dirname(config),
fg="red",
)
click.echo(
click.wrap_text(
'This is undefined behavior, use only one. '
'Use file names e.g. myproject.json, coolproject.yaml. '
'You can load them by filename.'
)
)
elif not len(candidates):
file_error = 'No tmuxp files found in directory'
if len(candidates):
config = candidates[0]
elif not exists(config):
file_error = 'file not found'
if file_error:
raise FileError(file_error, config)
return config
def load_plugins(sconf):
"""
Load and return plugins in config
"""
plugins = []
if 'plugins' in sconf:
for plugin in sconf['plugins']:
try:
module_name = plugin.split('.')
module_name = '.'.join(module_name[:-1])
plugin_name = plugin.split('.')[-1]
plugin = getattr(importlib.import_module(module_name), plugin_name)
plugins.append(plugin())
except exc.TmuxpPluginException as error:
if not click.confirm(
'%sSkip loading %s?'
% (click.style(str(error), fg='yellow'), plugin_name),
default=True,
):
click.echo(
click.style('[Not Skipping] ', fg='yellow')
+ 'Plugin versions constraint not met. Exiting...'
)
sys.exit(1)
except Exception as error:
click.echo(
click.style('[Plugin Error] ', fg='red')
+ "Couldn\'t load {0}\n".format(plugin)
+ click.style('{0}'.format(error), fg='yellow')
)
sys.exit(1)
return plugins
def _reattach(builder):
"""
Reattach session (depending on env being inside tmux already or not)
Parameters
----------
builder: :class:`workspacebuilder.WorkspaceBuilder`
Notes
-----
If ``TMUX`` environmental variable exists in the environment this script is
running, that means we're in a tmux client. So ``tmux switch-client`` will
load the session.
If not, ``tmux attach-session`` loads the client to the target session.
"""
for plugin in builder.plugins:
plugin.reattach(builder.session)
proc = builder.session.cmd('display-message', '-p', "'#S'")
for line in proc.stdout:
print(line)
if 'TMUX' in os.environ:
builder.session.switch_client()
else:
builder.session.attach_session()
def load_workspace(
config_file,
socket_name=None,
socket_path=None,
new_session_name=None,
colors=None,
detached=False,
answer_yes=False,
):
"""
Load a tmux "workspace" session via tmuxp file.
Parameters
----------
config_file : str
absolute path to config file
socket_name : str, optional
``tmux -L <socket-name>``
socket_path: str, optional
``tmux -S <socket-path>``
new_session_name: str, options
``tmux new -s <new_session_name>``
colors : str, optional
'-2'
Force tmux to support 256 colors
detached : bool
Force detached state. default False.
answer_yes : bool
Assume yes when given prompt. default False.
Notes
-----
tmuxp will check and load a configuration file. The file will use kaptan
to load a JSON/YAML into a :py:obj:`dict`. Then :func:`config.expand` and
:func:`config.trickle` will be used to expand any shorthands, template
variables, or file paths relative to where the config/script is executed
from.
:func:`config.expand` accepts the directory of the config file, so the
user's configuration can resolve absolute paths relative to where the
config file is. In otherwords, if a config file at */var/moo/hi.yaml*
has *./* in its configs, we want to be sure any file path with *./* is
relative to */var/moo*, not the user's PWD.
A :class:`libtmux.Server` object is created. No tmux server is started yet,
just the object.
The prepared configuration and the server object is passed into an instance
of :class:`~tmuxp.workspacebuilder.WorkspaceBuilder`.
A sanity check against :meth:`libtmux.common.which` is ran. It will raise
an exception if tmux isn't found.
If a tmux session under the same name as ``session_name`` in the tmuxp
configuration exists, tmuxp offers to attach the session. Currently, tmuxp
does not allow appending a workspace / incremental building on top of a
current session (pull requests are welcome!).
:meth:`~tmuxp.workspacebuilder.WorkspaceBuilder.build` will build the session in
the background via using tmux's detached state (``-d``).
After the session (workspace) is built, unless the user decided to load
the session in the background via ``tmuxp -d`` (which is in the spirit
of tmux's ``-d``), we need to prompt the user to attach the session.
If the user is already inside a tmux client, which we detect via the
``TMUX`` environment variable bring present, we will prompt the user to
switch their current client to it.
If they're outside of tmux client - in a plain-old PTY - we will
automatically ``attach``.
If an exception is raised during the building of the workspace, tmuxp will
prompt to cleanup (``$ tmux kill-session``) the session on the user's
behalf. An exception raised during this process means it's not easy to
predict how broken the session is.
.. versionchanged:: tmux 2.6+
In tmux 2.6, the way layout and proportion's work when interfacing
with tmux in a detached state (outside of a client) changed. Since
tmuxp builds workspaces in a detached state, the WorkspaceBuilder isn't
able to rely on functionality requiring awarness of session geometry,
e.g. ``set-layout``.
Thankfully, tmux is able to defer commands to run after the user
performs certain actions, such as loading a client via
``attach-session`` or ``switch-client``.
Upon client switch, ``client-session-changed`` is triggered [1]_.
References
----------
.. [1] cmd-switch-client.c hook. GitHub repo for tmux.
https://github.com/tmux/tmux/blob/2.6/cmd-switch-client.c#L132.
Accessed April 8th, 2018.
"""
# get the canonical path, eliminating any symlinks
config_file = os.path.realpath(config_file)
# kaptan allows us to open a yaml or json file as a dict
sconfig = kaptan.Kaptan()
sconfig = sconfig.import_config(config_file).get()
# shapes configurations relative to config / profile file location
sconfig = config.expand(sconfig, os.path.dirname(config_file))
# Overwrite session name
if new_session_name:
sconfig['session_name'] = new_session_name
# propagate config inheritance (e.g. session -> window, window -> pane)
sconfig = config.trickle(sconfig)
t = Server( # create tmux server object
socket_name=socket_name, socket_path=socket_path, colors=colors
)
which('tmux') # raise exception if tmux not found
try: # load WorkspaceBuilder object for tmuxp config / tmux server
builder = WorkspaceBuilder(
sconf=sconfig, plugins=load_plugins(sconfig), server=t
)
except exc.EmptyConfigException:
click.echo('%s is empty or parsed no config data' % config_file, err=True)
return
session_name = sconfig['session_name']
# if the session already exists, prompt the user to attach. tmuxp doesn't
# support incremental session building or appending (yet, PR's welcome!)
if builder.session_exists(session_name):
if not detached and (
answer_yes
or click.confirm(
'%s is already running. Attach?'
% click.style(session_name, fg='green'),
default=True,
)
):
_reattach(builder)
return
try:
click.echo(
click.style('[Loading] ', fg='green')
+ click.style(config_file, fg='blue', bold=True)
)
builder.build() # load tmux session via workspace builder
if 'TMUX' in os.environ: # tmuxp ran from inside tmux
if not detached and (
answer_yes or click.confirm('Already inside TMUX, switch to session?')
):
# unset TMUX, save it, e.g. '/tmp/tmux-1000/default,30668,0'
tmux_env = os.environ.pop('TMUX')
if has_gte_version('2.6'):
set_layout_hook(builder.session, 'client-session-changed')
builder.session.switch_client() # switch client to new session
os.environ['TMUX'] = tmux_env # set TMUX back again
return builder.session
else: # session created in the background, from within tmux
if has_gte_version('2.6'): # prepare for both cases
set_layout_hook(builder.session, 'client-attached')
set_layout_hook(builder.session, 'client-session-changed')
sys.exit('Session created in detached state.')
else: # tmuxp ran from inside tmux
if has_gte_version('2.6'):
# if attaching for first time
set_layout_hook(builder.session, 'client-attached')
# for cases where user switches client for first time
set_layout_hook(builder.session, 'client-session-changed')
if not detached:
builder.session.attach_session()
except exc.TmuxpException as e:
import traceback
click.echo(traceback.format_exc(), err=True)
click.echo(e, err=True)
choice = click.prompt(
'Error loading workspace. (k)ill, (a)ttach, (d)etach?',
value_proc=_validate_choices(['k', 'a', 'd']),
default='k',
)
if choice == 'k':
builder.session.kill_session()
click.echo('Session killed.')
elif choice == 'a':
_reattach(builder)
else:
sys.exit()
# Runs after before_script
for plugin in builder.plugins:
plugin.before_script(builder.session)
return builder.session
@click.group(context_settings={'obj': {}})
@click.version_option(__version__, '-V', '--version', message='%(prog)s %(version)s')
@click.option(
'--log_level',
default='INFO',
help='Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)',
)
def cli(log_level):
"""Manage tmux sessions.
Pass the "--help" argument to any command to see detailed help.
See detailed documentation and examples at:
http://tmuxp.git-pull.com/"""
try:
has_minimum_version()
except TmuxCommandNotFound:
click.echo('tmux not found. tmuxp requires you install tmux first.')
sys.exit()
except exc.TmuxpException as e:
click.echo(e, err=True)
sys.exit()
setup_logger(level=log_level.upper())
def setup_logger(logger=None, level='INFO'):
"""
Setup logging for CLI use.
Tries to do some conditionals to prevent handlers from being added twice.
Just to be safe.
Parameters
----------
logger : :py:class:`Logger`
logger instance for tmuxp
"""
if not logger: # if no logger exists, make one
logger = logging.getLogger()
if not logger.handlers: # setup logger handlers
channel = logging.StreamHandler()
channel.setFormatter(log.DebugLogFormatter())
# channel.setFormatter(log.LogFormatter())
logger.setLevel(level)
logger.addHandler(channel)
def startup(config_dir):
"""
Initialize CLI.
Parameters
----------
str : get_config_dir(): Config directory to search
"""
if not os.path.exists(config_dir):
os.makedirs(config_dir)
@cli.command(name='freeze')
@click.argument('session_name', nargs=1, required=False)
@click.option('-S', 'socket_path', help='pass-through for tmux -S')
@click.option('-L', 'socket_name', help='pass-through for tmux -L')
@click.option('--force', 'force', help='overwrite the config file', is_flag=True)
def command_freeze(session_name, socket_name, socket_path, force):
"""Snapshot a session into a config.
If SESSION_NAME is provided, snapshot that session. Otherwise, use the
current session."""
t = Server(socket_name=socket_name, socket_path=socket_path)
try:
if session_name:
session = t.find_where({'session_name': session_name})
else:
session = t.list_sessions()[0]
if not session:
raise exc.TmuxpException('Session not found.')
except exc.TmuxpException as e:
print(e)
return
sconf = freeze(session)
configparser = kaptan.Kaptan()
newconfig = config.inline(sconf)
configparser.import_config(newconfig)
config_format = click.prompt(
'Convert to', value_proc=_validate_choices(['yaml', 'json']), default='yaml'
)
if config_format == 'yaml':
newconfig = configparser.export(
'yaml', indent=2, default_flow_style=False, safe=True
)
elif config_format == 'json':
newconfig = configparser.export('json', indent=2)
else:
sys.exit('Unknown config format.')
print(newconfig)
print(
'---------------------------------------------------------------'
'\n'
'Freeze does its best to snapshot live tmux sessions.\n'
)
if click.confirm(
'The new config *WILL* require adjusting afterwards. Save config?'
):
dest = None
while not dest:
save_to = os.path.abspath(
os.path.join(
get_config_dir(),
'%s.%s' % (sconf.get('session_name'), config_format),
)
)
dest_prompt = click.prompt(
'Save to: %s' % save_to, value_proc=get_abs_path, default=save_to
)
if not force and os.path.exists(dest_prompt):
print('%s exists. Pick a new filename.' % dest_prompt)
continue
dest = dest_prompt
dest = os.path.abspath(os.path.relpath(os.path.expanduser(dest)))
if click.confirm('Save to %s?' % dest):
destdir = os.path.dirname(dest)
if not os.path.isdir(destdir):
os.makedirs(destdir)
buf = open(dest, 'w')
buf.write(newconfig)
buf.close()
print('Saved to %s.' % dest)
else:
print(
'tmuxp has examples in JSON and YAML format at '
'<http://tmuxp.git-pull.com/examples.html>\n'
'View tmuxp docs at <http://tmuxp.git-pull.com/>.'
)
sys.exit()
@cli.command(name='load', short_help='Load tmuxp workspaces.')
@click.pass_context
@click.argument('config', type=ConfigPath(exists=True), nargs=-1)
@click.option('-S', 'socket_path', help='pass-through for tmux -S')
@click.option('-L', 'socket_name', help='pass-through for tmux -L')
@click.option('-s', 'new_session_name', help='start new session with new session name')
@click.option('--yes', '-y', 'answer_yes', help='yes', is_flag=True)
@click.option(
'-d', 'detached', help='Load the session without attaching it', is_flag=True
)
@click.option(
'colors',
'-2',
flag_value=256,
default=True,
help='Force tmux to assume the terminal supports 256 colours.',
)
@click.option(
'colors',
'-8',
flag_value=88,
help='Like -2, but indicates that the terminal supports 88 colours.',
)
def command_load(
ctx,
config,
socket_name,
socket_path,
new_session_name,
answer_yes,
detached,
colors,
):
"""Load a tmux workspace from each CONFIG.
CONFIG is a specifier for a configuration file.
If CONFIG is a path to a directory, tmuxp will search it for
".tmuxp.{yaml,yml,json}".
If CONFIG is has no directory component and only a filename, e.g.
"myconfig.yaml", tmuxp will search the users's config directory for that
file.
If CONFIG has no directory component, and only a name with no extension,
e.g. "myconfig", tmuxp will search the users's config directory for any
file with the extension ".yaml", ".yml", or ".json" that matches that name.
If multiple configuration files that match a given CONFIG are found, tmuxp
will warn and pick the first one found.
If multiple CONFIGs are provided, workspaces will be created for all of
them. The last one provided will be attached. The others will be created in
detached mode.
"""
util.oh_my_zsh_auto_title()
tmux_options = {
'socket_name': socket_name,
'socket_path': socket_path,
'new_session_name': new_session_name,
'answer_yes': answer_yes,
'colors': colors,
'detached': detached,
}
if not config:
click.echo("Enter at least one CONFIG")
click.echo(ctx.get_help(), color=ctx.color)
ctx.exit()
if isinstance(config, string_types):
load_workspace(config, **tmux_options)
elif isinstance(config, tuple):
config = list(config)
# Load each configuration but the last to the background
for cfg in config[:-1]:
opt = tmux_options.copy()
opt.update({'detached': True, 'new_session_name': None})
load_workspace(cfg, **opt)
# todo: obey the -d in the cli args only if user specifies
load_workspace(config[-1], **tmux_options)
@cli.group(name='import')
def import_config_cmd():
"""Import a teamocil/tmuxinator config."""
pass
def import_config(configfile, importfunc):
configparser = kaptan.Kaptan(handler='yaml')
configparser.import_config(configfile)
newconfig = importfunc(configparser.get())
configparser.import_config(newconfig)
config_format = click.prompt(
'Convert to', value_proc=_validate_choices(['yaml', 'json']), default='yaml'
)
if config_format == 'yaml':
newconfig = configparser.export('yaml', indent=2, default_flow_style=False)
elif config_format == 'json':
newconfig = configparser.export('json', indent=2)
else:
sys.exit('Unknown config format.')
click.echo(
newconfig + '---------------------------------------------------------------'
'\n'
'Configuration import does its best to convert files.\n'
)
if click.confirm(
'The new config *WILL* require adjusting afterwards. Save config?'
):
dest = None
while not dest:
dest_path = click.prompt(
'Save to [%s]' % os.getcwd(), value_proc=_resolve_path_no_overwrite
)
# dest = dest_prompt
if click.confirm('Save to %s?' % dest_path):
dest = dest_path
buf = open(dest, 'w')
buf.write(newconfig)
buf.close()
click.echo('Saved to %s.' % dest)
else:
click.echo(
'tmuxp has examples in JSON and YAML format at '
'<http://tmuxp.git-pull.com/examples.html>\n'
'View tmuxp docs at <http://tmuxp.git-pull.com/>'
)
sys.exit()
@import_config_cmd.command(
name='teamocil', short_help='Convert and import a teamocil config.'
)
@click.argument(
'configfile', type=ConfigPath(exists=True, config_dir=get_teamocil_dir), nargs=1
)
def command_import_teamocil(configfile):
"""Convert a teamocil config from CONFIGFILE to tmuxp format and import
it into tmuxp."""
import_config(configfile, config.import_teamocil)
@import_config_cmd.command(
name='tmuxinator', short_help='Convert and import a tmuxinator config.'
)
@click.argument(
'configfile', type=ConfigPath(exists=True, config_dir=get_tmuxinator_dir), nargs=1
)
def command_import_tmuxinator(configfile):
"""Convert a tmuxinator config from CONFIGFILE to tmuxp format and import
it into tmuxp."""
import_config(configfile, config.import_tmuxinator)
@cli.command(name='convert')
@click.option(
'--yes', '-y', 'confirmed', help='Auto confirms with "yes".', is_flag=True
)
@click.argument('config', type=ConfigPath(exists=True), nargs=1)
def command_convert(confirmed, config):
"""Convert a tmuxp config between JSON and YAML."""
_, ext = os.path.splitext(config)
if 'json' in ext:
to_filetype = 'yaml'
elif 'yaml' in ext:
to_filetype = 'json'
configparser = kaptan.Kaptan()
configparser.import_config(config)
newfile = config.replace(ext, '.%s' % to_filetype)
export_kwargs = {'default_flow_style': False} if to_filetype == 'yaml' else {}
newconfig = configparser.export(to_filetype, indent=2, **export_kwargs)
if not confirmed:
if click.confirm('convert to <%s> to %s?' % (config, to_filetype)):
if click.confirm('Save config to %s?' % newfile):
confirmed = True
if confirmed:
buf = open(newfile, 'w')
buf.write(newconfig)
buf.close()
print('New config saved to <%s>.' % newfile)
@cli.command(
name='ls', short_help='List configured sessions in {}.'.format(get_config_dir())
)
def command_ls():
You can’t perform that action at this time.