pygments-shell-console 0.0.3__tar.gz → 0.0.4__tar.gz
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- {pygments_shell_console-0.0.3 → pygments_shell_console-0.0.4}/PKG-INFO +1 -1
- pygments_shell_console-0.0.4/git_lexer.py +166 -0
- {pygments_shell_console-0.0.3 → pygments_shell_console-0.0.4}/pyproject.toml +1 -1
- {pygments_shell_console-0.0.3 → pygments_shell_console-0.0.4}/shellconsole_lexer.py +46 -22
- {pygments_shell_console-0.0.3 → pygments_shell_console-0.0.4}/shellconsole_style.py +6 -0
- pygments_shell_console-0.0.4/test/__init__.py +0 -0
- pygments_shell_console-0.0.4/test/test_git_log.py +165 -0
- pygments_shell_console-0.0.4/test/test_git_show.py +141 -0
- pygments_shell_console-0.0.4/test/test_git_status.py +73 -0
- pygments_shell_console-0.0.4/test/test_prompts.py +214 -0
- {pygments_shell_console-0.0.3 → pygments_shell_console-0.0.4}/test.exmpl +1 -1
- {pygments_shell_console-0.0.3 → pygments_shell_console-0.0.4}/test.sh +1 -1
- pygments_shell_console-0.0.3/git_lexer.py +0 -112
- {pygments_shell_console-0.0.3 → pygments_shell_console-0.0.4}/.github/workflows/publish-to-pypi.yml +0 -0
- {pygments_shell_console-0.0.3 → pygments_shell_console-0.0.4}/.gitignore +0 -0
- {pygments_shell_console-0.0.3 → pygments_shell_console-0.0.4}/README.md +0 -0
|
@@ -0,0 +1,166 @@
|
|
|
1
|
+
"""An example plugin lexer for Pygments."""
|
|
2
|
+
|
|
3
|
+
from pygments.lexer import Lexer
|
|
4
|
+
from pygments.lexer import RegexLexer, ExtendedRegexLexer, include, bygroups, \
|
|
5
|
+
default, using, line_re, do_insertions
|
|
6
|
+
from pygments.token import Token, Punctuation, Whitespace, \
|
|
7
|
+
Text, Comment, Operator, Keyword, Name, String, Number, Generic
|
|
8
|
+
from pygments.lexers.diff import DiffLexer
|
|
9
|
+
from pygments.token import STANDARD_TYPES
|
|
10
|
+
|
|
11
|
+
import re
|
|
12
|
+
|
|
13
|
+
__all__ = ['GitLexer']
|
|
14
|
+
|
|
15
|
+
STANDARD_TYPES.update({
|
|
16
|
+
Token.Git: 'git',
|
|
17
|
+
Token.Git.BranchLine: 'git-bl',
|
|
18
|
+
Token.Git.CommitHash: 'git-ch',
|
|
19
|
+
Token.Git.CommitDate: 'git-cd',
|
|
20
|
+
Token.Git.CommitMessage: 'git-cm',
|
|
21
|
+
Token.Git.CommitAuthor: 'git-ca',
|
|
22
|
+
Token.Git.Refs: 'git-r',
|
|
23
|
+
Token.Git.Untracked: 'git-untr',
|
|
24
|
+
Token.Git.Modified: 'git-mod',
|
|
25
|
+
Token.Git.Staged: 'git-stg',
|
|
26
|
+
Token.Git.Show: 'git-show',
|
|
27
|
+
Token.Git.Show.Header: 'git-show-h',
|
|
28
|
+
Token.Git.Refs.RemoteHead: 'git-rh',
|
|
29
|
+
Token.Git.Refs.Head: 'git-h',
|
|
30
|
+
Token.Git.Refs.Tag: 'git-t',
|
|
31
|
+
Token.Git.Refs.RemoteBranch: 'git-rb',
|
|
32
|
+
Token.Git.Refs.Branch: 'git-b',
|
|
33
|
+
})
|
|
34
|
+
|
|
35
|
+
class GitLogLexer(Lexer):
|
|
36
|
+
name = "Git"
|
|
37
|
+
aliases = ["git"]
|
|
38
|
+
filenames = ['*.git']
|
|
39
|
+
version_added = '1.0'
|
|
40
|
+
|
|
41
|
+
_branch_line_rgx = r'([\|\\\/ ]*)'
|
|
42
|
+
_logrgx_groups = [
|
|
43
|
+
_branch_line_rgx, # 1. Branch line
|
|
44
|
+
r'(\*)', # 2. Commit asterisk
|
|
45
|
+
_branch_line_rgx, # 3. Branch line
|
|
46
|
+
r'( +)', # 4. Space
|
|
47
|
+
r'([a-f0-9]+)', # 5. Commit hash
|
|
48
|
+
r'( +)', # 6. Space
|
|
49
|
+
r'(-)', # 7. Commit separator
|
|
50
|
+
r'( +)', # 8. Space
|
|
51
|
+
r'(\([0-9A-Za-zÀ-ÖØ-öø-ÿ ]+\))', # 9. Date
|
|
52
|
+
r'(\s+)', # 10. Space
|
|
53
|
+
r'([0-9A-Za-zÀ-ÖØ-öø-ÿ \.\:\_\'\"\!\?\(\)\\\/\-]+)', # 11. Commit message
|
|
54
|
+
r'( +)', # 12. Space
|
|
55
|
+
r'(-)', # 13. Commit separator
|
|
56
|
+
r'( +)', # 14. Space
|
|
57
|
+
r'([0-9A-Za-zÀ-ÖØ-öø-ÿ ]+)', # 15. Author
|
|
58
|
+
r'( +)', # 16. Space
|
|
59
|
+
r'((\([\w ->,:]+\))?)', # 17. Refs
|
|
60
|
+
r'$', # End
|
|
61
|
+
]
|
|
62
|
+
|
|
63
|
+
# Combine the regex patterns into a single pattern
|
|
64
|
+
_logrgx = re.compile(r''.join(_logrgx_groups))
|
|
65
|
+
|
|
66
|
+
_log_tokens = {
|
|
67
|
+
1: Token.Git.BranchLine,
|
|
68
|
+
3: Token.Git.BranchLine,
|
|
69
|
+
4: Whitespace,
|
|
70
|
+
5: Token.Git.CommitHash,
|
|
71
|
+
6: Whitespace,
|
|
72
|
+
8: Whitespace,
|
|
73
|
+
9: Token.Git.CommitDate,
|
|
74
|
+
10: Whitespace,
|
|
75
|
+
11: Token.Git.CommitMessage,
|
|
76
|
+
12: Whitespace,
|
|
77
|
+
14: Whitespace,
|
|
78
|
+
15: Token.Git.CommitAuthor,
|
|
79
|
+
16: Whitespace,
|
|
80
|
+
17: Token.Git.Refs,
|
|
81
|
+
}
|
|
82
|
+
|
|
83
|
+
def get_tokens_unprocessed(self, text):
|
|
84
|
+
pos = 0
|
|
85
|
+
|
|
86
|
+
for match in line_re.finditer(text):
|
|
87
|
+
line = match.group()
|
|
88
|
+
|
|
89
|
+
match_log = self._logrgx.match(line)
|
|
90
|
+
match_branch_line = re.match(r'^' + self._branch_line_rgx + r'$', line)
|
|
91
|
+
|
|
92
|
+
## Line is log
|
|
93
|
+
if match_log:
|
|
94
|
+
for i in range(1, len(match_log.groups())):
|
|
95
|
+
if match_log.group(i):
|
|
96
|
+
if self._log_tokens.get(i):
|
|
97
|
+
yield match_log.start(i), self._log_tokens[i], match_log.group(i)
|
|
98
|
+
else:
|
|
99
|
+
yield match_log.start(i), Generic.Output, match_log.group(i)
|
|
100
|
+
yield match.end(), Whitespace, '\n'
|
|
101
|
+
elif match_branch_line:
|
|
102
|
+
yield match.start(), Token.Git.BranchLine, line
|
|
103
|
+
|
|
104
|
+
else:
|
|
105
|
+
yield match.start(), Generic.Output, line
|
|
106
|
+
|
|
107
|
+
class GitStatusLexer(RegexLexer):
|
|
108
|
+
tokens = {
|
|
109
|
+
'root': [
|
|
110
|
+
(r'^\n', Whitespace),
|
|
111
|
+
(r'\s*Untracked files:\n', Generic.Output, 'untracked'),
|
|
112
|
+
(r'\s*Changes not staged for commit:\n', Generic.Output, 'modified'),
|
|
113
|
+
(r'\s*Changes to be committed:\n', Generic.Output, 'staged'),
|
|
114
|
+
(r'^.*\n', Generic.Output),
|
|
115
|
+
],
|
|
116
|
+
'untracked': [
|
|
117
|
+
(r'^\s*\n', Whitespace, '#pop'),
|
|
118
|
+
(r'^\s+\(.*\)\n', Generic.Output),
|
|
119
|
+
(r'^(\s*)([^\n]+)(\n)', bygroups(
|
|
120
|
+
Whitespace,
|
|
121
|
+
Token.Git.Untracked,
|
|
122
|
+
Whitespace
|
|
123
|
+
)),
|
|
124
|
+
],
|
|
125
|
+
'modified': [
|
|
126
|
+
(r'^\s*\n', Whitespace, '#pop'),
|
|
127
|
+
(r'^\s+\(.*\)\n', Generic.Output),
|
|
128
|
+
(r'^(\s*)([^\n]+)(\n)', bygroups(
|
|
129
|
+
Whitespace,
|
|
130
|
+
Token.Git.Modified,
|
|
131
|
+
Whitespace
|
|
132
|
+
)),
|
|
133
|
+
],
|
|
134
|
+
'staged': [
|
|
135
|
+
(r'^\s*\n', Whitespace, '#pop'),
|
|
136
|
+
(r'^\s+\(.*\)\n', Generic.Output),
|
|
137
|
+
(r'^(\s*)([^\n]+)(\n)', bygroups(
|
|
138
|
+
Whitespace,
|
|
139
|
+
Token.Git.Staged,
|
|
140
|
+
Whitespace
|
|
141
|
+
)),
|
|
142
|
+
],
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
class GitShowLexer(RegexLexer):
|
|
146
|
+
tokens = {
|
|
147
|
+
'root': [
|
|
148
|
+
(r'^\n', Whitespace),
|
|
149
|
+
(r'^diff .*\n', using(DiffLexer), 'diff'),
|
|
150
|
+
(r'^(commit [0-9a-f]+)', Token.Git.Show.Header, 'header'),
|
|
151
|
+
(r'^.*\n', Generic.Output),
|
|
152
|
+
],
|
|
153
|
+
'header': [
|
|
154
|
+
(r' +', Whitespace),
|
|
155
|
+
(r'(\(|\)|->|,)', Token.Git.Show.Header),
|
|
156
|
+
(r'origin/HEAD', Token.Git.Refs.RemoteHead),
|
|
157
|
+
(r'HEAD', Token.Git.Refs.Head),
|
|
158
|
+
(r'tag: [\w.-]+', Token.Git.Refs.Tag),
|
|
159
|
+
(r'origin/[\w/_-]+', Token.Git.Refs.RemoteBranch),
|
|
160
|
+
(r'[\w/_-]+', Token.Git.Refs.Branch),
|
|
161
|
+
(r'\n', Whitespace, '#pop'),
|
|
162
|
+
],
|
|
163
|
+
'diff': [
|
|
164
|
+
(r'^.*\n', using(DiffLexer)),
|
|
165
|
+
],
|
|
166
|
+
}
|
|
@@ -8,7 +8,7 @@ from pygments.token import Token, Punctuation, Whitespace, \
|
|
|
8
8
|
from pygments.lexers.diff import DiffLexer
|
|
9
9
|
from pygments.lexers.shell import BashLexer
|
|
10
10
|
from pygments.lexers.diff import DiffLexer
|
|
11
|
-
from git_lexer import GitLogLexer, GitStatusLexer
|
|
11
|
+
from git_lexer import GitLogLexer, GitStatusLexer, GitShowLexer
|
|
12
12
|
from pygments.token import STANDARD_TYPES
|
|
13
13
|
|
|
14
14
|
import re
|
|
@@ -31,11 +31,41 @@ class ShellConsoleLexer(Lexer):
|
|
|
31
31
|
version_added = '1.0'
|
|
32
32
|
|
|
33
33
|
_bare_continuation = False
|
|
34
|
-
_venv = re.compile(r'^(\([^)]*\))(\s*)')
|
|
35
34
|
|
|
36
|
-
|
|
37
|
-
r'
|
|
38
|
-
|
|
35
|
+
_ps1_groups = [
|
|
36
|
+
r'(?P<venv>\([^\)]*\))?', # Virtualenv
|
|
37
|
+
r'(\s*)?', # Whitespace
|
|
38
|
+
r'\[?', # Start bracketed prompt
|
|
39
|
+
r'(?P<user_host>[^\s@]+@[^\s]+?)', # user@host
|
|
40
|
+
r'(\s*)', # Whitespace
|
|
41
|
+
r'(?:(\:)|(\s+))', # Separator: colon or space
|
|
42
|
+
r'(\s*)', # Whitespace
|
|
43
|
+
r'(?P<current_dir>[^\s\]]+)', # Current directory
|
|
44
|
+
r'(?:(\s+)(?P<git_branch>\([^)]+\)))?', # Whitespace + Git branch
|
|
45
|
+
r'\]?', # End bracketed prompt
|
|
46
|
+
r'(\s*)', # Whitespace
|
|
47
|
+
r'([$#%]\n?)', # End of prompt
|
|
48
|
+
r'(\s*)', # Whitespace
|
|
49
|
+
r'(?P<command>.*\n?)' # Command
|
|
50
|
+
]
|
|
51
|
+
_ps1rgx = re.compile(r''.join(_ps1_groups))
|
|
52
|
+
print(_ps1rgx.pattern)
|
|
53
|
+
|
|
54
|
+
_ps1_tokens = [
|
|
55
|
+
Token.Generic.Prompt.VirtualEnv,
|
|
56
|
+
Whitespace,
|
|
57
|
+
Token.Generic.Prompt.UserHost,
|
|
58
|
+
Whitespace,
|
|
59
|
+
Token.Generic.Prompt, # Separator: colon
|
|
60
|
+
Whitespace, # Separator: space
|
|
61
|
+
Whitespace,
|
|
62
|
+
Token.Generic.Prompt.Directory,
|
|
63
|
+
Whitespace,
|
|
64
|
+
Token.Generic.Prompt.GitBranch,
|
|
65
|
+
Whitespace,
|
|
66
|
+
Token.Generic.Prompt,
|
|
67
|
+
Whitespace
|
|
68
|
+
]
|
|
39
69
|
|
|
40
70
|
|
|
41
71
|
_ps2 = '> '
|
|
@@ -47,6 +77,7 @@ class ShellConsoleLexer(Lexer):
|
|
|
47
77
|
difflexer = DiffLexer()
|
|
48
78
|
gitloglexer = GitLogLexer()
|
|
49
79
|
gitstatuslexer = GitStatusLexer()
|
|
80
|
+
gitshowlexer = GitShowLexer()
|
|
50
81
|
|
|
51
82
|
pos = 0
|
|
52
83
|
# Bash command
|
|
@@ -60,18 +91,6 @@ class ShellConsoleLexer(Lexer):
|
|
|
60
91
|
for match in line_re.finditer(text):
|
|
61
92
|
line = match.group()
|
|
62
93
|
|
|
63
|
-
# Check for virtualenv prompt
|
|
64
|
-
venv_match = self._venv.match(line)
|
|
65
|
-
if venv_match:
|
|
66
|
-
venv = venv_match.group(1)
|
|
67
|
-
venv_whitespace = venv_match.group(2)
|
|
68
|
-
insertions.append((len(curcode),
|
|
69
|
-
[(0, Generic.Prompt.VirtualEnv, venv)]))
|
|
70
|
-
if venv_whitespace:
|
|
71
|
-
insertions.append((len(curcode),
|
|
72
|
-
[(0, Text, venv_whitespace)]))
|
|
73
|
-
line = line[venv_match.end():]
|
|
74
|
-
|
|
75
94
|
m = self._ps1rgx.match(line)
|
|
76
95
|
## If line starts with a prompt
|
|
77
96
|
if m:
|
|
@@ -93,20 +112,23 @@ class ShellConsoleLexer(Lexer):
|
|
|
93
112
|
pos = match.start()
|
|
94
113
|
|
|
95
114
|
prompt_pos = 0
|
|
96
|
-
for i, t in enumerate(self.
|
|
115
|
+
for i, t in enumerate(self._ps1_tokens):
|
|
97
116
|
if m.group(i + 1):
|
|
98
117
|
group_pos = m.start(i + 1)
|
|
99
118
|
before_content = line[prompt_pos:group_pos]
|
|
100
|
-
|
|
119
|
+
if before_content:
|
|
120
|
+
insertions.append((len(curcode), [(0, Generic.Prompt, before_content)]))
|
|
101
121
|
|
|
102
122
|
insertions.append((len(curcode), [(0, t, m.group(i + 1))]))
|
|
103
123
|
prompt_pos += len(before_content) + len(m.group(i+1))
|
|
104
124
|
|
|
105
|
-
|
|
125
|
+
last_group_index = len(self._ps1_tokens) + 1
|
|
126
|
+
group_pos = m.start(last_group_index)
|
|
106
127
|
before_content = line[prompt_pos:group_pos]
|
|
107
|
-
|
|
128
|
+
if before_content:
|
|
129
|
+
insertions.append((len(curcode), [(0, Generic.Prompt, before_content)]))
|
|
108
130
|
|
|
109
|
-
curcode += m.group(
|
|
131
|
+
curcode += m.group(last_group_index)
|
|
110
132
|
backslash_continuation = curcode.endswith('\\\n')
|
|
111
133
|
|
|
112
134
|
# If line is a continuation of a previous line
|
|
@@ -143,6 +165,8 @@ class ShellConsoleLexer(Lexer):
|
|
|
143
165
|
custom_lexer = gitloglexer
|
|
144
166
|
elif curcode.startswith('git status'):
|
|
145
167
|
custom_lexer = gitstatuslexer
|
|
168
|
+
elif curcode.startswith('git show'):
|
|
169
|
+
custom_lexer = gitshowlexer
|
|
146
170
|
|
|
147
171
|
output += line
|
|
148
172
|
insertions = []
|
|
@@ -18,7 +18,13 @@ class ShellConsoleStyle(Style):
|
|
|
18
18
|
Token.Git.CommitDate: "#008000",
|
|
19
19
|
Token.Git.CommitMessage: "#FFFFFF",
|
|
20
20
|
Token.Git.CommitAuthor: "#aaaaaa",
|
|
21
|
+
|
|
21
22
|
Token.Git.Refs: "#00ffff",
|
|
23
|
+
Token.Git.Refs.Tag: "#ffff00",
|
|
24
|
+
Token.Git.Refs.Head: "#00ffff",
|
|
25
|
+
Token.Git.Refs.Branch: "#00ff00",
|
|
26
|
+
Token.Git.Refs.RemoteHead: "#ffcc00",
|
|
27
|
+
Token.Git.Refs.RemoteBranch: "#ffcc00",
|
|
22
28
|
|
|
23
29
|
Token.Git.Untracked: "#f00",
|
|
24
30
|
Token.Git.Modified: "#f00",
|
|
File without changes
|
|
@@ -0,0 +1,165 @@
|
|
|
1
|
+
import pytest
|
|
2
|
+
from pygments.token import Token
|
|
3
|
+
from shellconsole_lexer import ShellConsoleLexer
|
|
4
|
+
from git_lexer import GitLogLexer
|
|
5
|
+
|
|
6
|
+
def test_full_git_log():
|
|
7
|
+
lexer = ShellConsoleLexer()
|
|
8
|
+
text = (
|
|
9
|
+
"user@host:~/directory (main) $ git lga\n"
|
|
10
|
+
"* f853946 - (7 minutes ago) README: Afegits autors - Mar (origin/feature/author)\n"
|
|
11
|
+
"| * cc8c388 - (9 minutes ago) LICENSE: Afegida llicència - Pau (origin/feature/license)\n"
|
|
12
|
+
"* | 9e34bb0 - (15 minutes ago) README: Afegida descripció del projecte - Anna (HEAD -> develop, origin/develop, feature/readme, origin/feature/readme)\n"
|
|
13
|
+
"|/\n"
|
|
14
|
+
"* 0fb88ef - (29 minutes ago) 1. Primer commit - Joan Puigcerver (origin/main, origin/HEAD, main)\n"
|
|
15
|
+
)
|
|
16
|
+
|
|
17
|
+
tokens = list(lexer.get_tokens(text))
|
|
18
|
+
|
|
19
|
+
assert tokens == [
|
|
20
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
21
|
+
(Token.Generic.Prompt, ":"),
|
|
22
|
+
(Token.Generic.Prompt.Directory, "~/directory"),
|
|
23
|
+
(Token.Text.Whitespace, " "),
|
|
24
|
+
(Token.Generic.Prompt.GitBranch, "(main)"),
|
|
25
|
+
(Token.Text.Whitespace, " "),
|
|
26
|
+
(Token.Generic.Prompt, "$"),
|
|
27
|
+
(Token.Text.Whitespace, " "),
|
|
28
|
+
(Token.Text, "git"),
|
|
29
|
+
(Token.Text.Whitespace, " "),
|
|
30
|
+
(Token.Text, "lga"),
|
|
31
|
+
(Token.Text.Whitespace, "\n"),
|
|
32
|
+
# First commit
|
|
33
|
+
(Token.Generic.Output, "*",),
|
|
34
|
+
(Token.Text.Whitespace, " "),
|
|
35
|
+
(Token.Git.CommitHash, "f853946"),
|
|
36
|
+
(Token.Text.Whitespace, " "),
|
|
37
|
+
(Token.Generic.Output, "-"),
|
|
38
|
+
(Token.Text.Whitespace, " "),
|
|
39
|
+
(Token.Git.CommitDate, "(7 minutes ago)"),
|
|
40
|
+
(Token.Text.Whitespace, " "),
|
|
41
|
+
(Token.Git.CommitMessage, "README: Afegits autors"),
|
|
42
|
+
(Token.Text.Whitespace, " "),
|
|
43
|
+
(Token.Generic.Output, "-"),
|
|
44
|
+
(Token.Text.Whitespace, " "),
|
|
45
|
+
(Token.Git.CommitAuthor, "Mar"),
|
|
46
|
+
(Token.Text.Whitespace, " "),
|
|
47
|
+
(Token.Git.Refs, "(origin/feature/author)"),
|
|
48
|
+
(Token.Text.Whitespace, "\n"),
|
|
49
|
+
# Second commit
|
|
50
|
+
(Token.Git.BranchLine, "| "),
|
|
51
|
+
(Token.Generic.Output, "*"),
|
|
52
|
+
(Token.Text.Whitespace, " "),
|
|
53
|
+
(Token.Git.CommitHash, "cc8c388"),
|
|
54
|
+
(Token.Text.Whitespace, " "),
|
|
55
|
+
(Token.Generic.Output, "-"),
|
|
56
|
+
(Token.Text.Whitespace, " "),
|
|
57
|
+
(Token.Git.CommitDate, "(9 minutes ago)"),
|
|
58
|
+
(Token.Text.Whitespace, " "),
|
|
59
|
+
(Token.Git.CommitMessage, "LICENSE: Afegida llicència"),
|
|
60
|
+
(Token.Text.Whitespace, " "),
|
|
61
|
+
(Token.Generic.Output, "-"),
|
|
62
|
+
(Token.Text.Whitespace, " "),
|
|
63
|
+
(Token.Git.CommitAuthor, "Pau"),
|
|
64
|
+
(Token.Text.Whitespace, " "),
|
|
65
|
+
(Token.Git.Refs, "(origin/feature/license)"),
|
|
66
|
+
(Token.Text.Whitespace, "\n"),
|
|
67
|
+
# Third commit
|
|
68
|
+
(Token.Generic.Output, "*"),
|
|
69
|
+
(Token.Git.BranchLine, " |"),
|
|
70
|
+
(Token.Text.Whitespace, " "),
|
|
71
|
+
(Token.Git.CommitHash, "9e34bb0"),
|
|
72
|
+
(Token.Text.Whitespace, " "),
|
|
73
|
+
(Token.Generic.Output, "-"),
|
|
74
|
+
(Token.Text.Whitespace, " "),
|
|
75
|
+
(Token.Git.CommitDate, "(15 minutes ago)"),
|
|
76
|
+
(Token.Text.Whitespace, " "),
|
|
77
|
+
(Token.Git.CommitMessage, "README: Afegida descripció del projecte"),
|
|
78
|
+
(Token.Text.Whitespace, " "),
|
|
79
|
+
(Token.Generic.Output, "-"),
|
|
80
|
+
(Token.Text.Whitespace, " "),
|
|
81
|
+
(Token.Git.CommitAuthor, "Anna"),
|
|
82
|
+
(Token.Text.Whitespace, " "),
|
|
83
|
+
(Token.Git.Refs, "(HEAD -> develop, origin/develop, feature/readme, origin/feature/readme)"),
|
|
84
|
+
(Token.Text.Whitespace, "\n"),
|
|
85
|
+
# Branch line
|
|
86
|
+
(Token.Git.BranchLine, "|/\n"),
|
|
87
|
+
# Fourth commit
|
|
88
|
+
(Token.Generic.Output, "*"),
|
|
89
|
+
(Token.Text.Whitespace, " "),
|
|
90
|
+
(Token.Git.CommitHash, "0fb88ef"),
|
|
91
|
+
(Token.Text.Whitespace, " "),
|
|
92
|
+
(Token.Generic.Output, "-"),
|
|
93
|
+
(Token.Text.Whitespace, " "),
|
|
94
|
+
(Token.Git.CommitDate, "(29 minutes ago)"),
|
|
95
|
+
(Token.Text.Whitespace, " "),
|
|
96
|
+
(Token.Git.CommitMessage, "1. Primer commit"),
|
|
97
|
+
(Token.Text.Whitespace, " "),
|
|
98
|
+
(Token.Generic.Output, "-"),
|
|
99
|
+
(Token.Text.Whitespace, " "),
|
|
100
|
+
(Token.Git.CommitAuthor, "Joan Puigcerver"),
|
|
101
|
+
(Token.Text.Whitespace, " "),
|
|
102
|
+
(Token.Git.Refs, "(origin/main, origin/HEAD, main)"),
|
|
103
|
+
(Token.Text.Whitespace, "\n"),
|
|
104
|
+
]
|
|
105
|
+
|
|
106
|
+
def test_git_log_with_other_command():
|
|
107
|
+
|
|
108
|
+
lexer = ShellConsoleLexer()
|
|
109
|
+
text = (
|
|
110
|
+
"user@host:~/directory (main) $ git lga\n"
|
|
111
|
+
"* f853946 - (7 minutes ago) README: Afegits autors - Mar (origin/feature/author)\n"
|
|
112
|
+
"(venv) [user@host ~ (main)] $ echo 'Hello, world!'\n"
|
|
113
|
+
)
|
|
114
|
+
|
|
115
|
+
tokens = list(lexer.get_tokens(text))
|
|
116
|
+
|
|
117
|
+
assert tokens == [
|
|
118
|
+
# First command
|
|
119
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
120
|
+
(Token.Generic.Prompt, ":"),
|
|
121
|
+
(Token.Generic.Prompt.Directory, "~/directory"),
|
|
122
|
+
(Token.Text.Whitespace, " "),
|
|
123
|
+
(Token.Generic.Prompt.GitBranch, "(main)"),
|
|
124
|
+
(Token.Text.Whitespace, " "),
|
|
125
|
+
(Token.Generic.Prompt, "$"),
|
|
126
|
+
(Token.Text.Whitespace, " "),
|
|
127
|
+
(Token.Text, "git"),
|
|
128
|
+
(Token.Text.Whitespace, " "),
|
|
129
|
+
(Token.Text, "lga"),
|
|
130
|
+
(Token.Text.Whitespace, "\n"),
|
|
131
|
+
# First commit
|
|
132
|
+
(Token.Generic.Output, "*",),
|
|
133
|
+
(Token.Text.Whitespace, " "),
|
|
134
|
+
(Token.Git.CommitHash, "f853946"),
|
|
135
|
+
(Token.Text.Whitespace, " "),
|
|
136
|
+
(Token.Generic.Output, "-"),
|
|
137
|
+
(Token.Text.Whitespace, " "),
|
|
138
|
+
(Token.Git.CommitDate, "(7 minutes ago)"),
|
|
139
|
+
(Token.Text.Whitespace, " "),
|
|
140
|
+
(Token.Git.CommitMessage, "README: Afegits autors"),
|
|
141
|
+
(Token.Text.Whitespace, " "),
|
|
142
|
+
(Token.Generic.Output, "-"),
|
|
143
|
+
(Token.Text.Whitespace, " "),
|
|
144
|
+
(Token.Git.CommitAuthor, "Mar"),
|
|
145
|
+
(Token.Text.Whitespace, " "),
|
|
146
|
+
(Token.Git.Refs, "(origin/feature/author)"),
|
|
147
|
+
(Token.Text.Whitespace, "\n"),
|
|
148
|
+
# Second command
|
|
149
|
+
(Token.Generic.Prompt.VirtualEnv, "(venv)"),
|
|
150
|
+
(Token.Text.Whitespace, " "),
|
|
151
|
+
(Token.Generic.Prompt, "["),
|
|
152
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
153
|
+
(Token.Text.Whitespace, " "),
|
|
154
|
+
(Token.Generic.Prompt.Directory, "~"),
|
|
155
|
+
(Token.Text.Whitespace, " "),
|
|
156
|
+
(Token.Generic.Prompt.GitBranch, "(main)"),
|
|
157
|
+
(Token.Generic.Prompt, "]"),
|
|
158
|
+
(Token.Text.Whitespace, " "),
|
|
159
|
+
(Token.Generic.Prompt, "$"),
|
|
160
|
+
(Token.Text.Whitespace, " "),
|
|
161
|
+
(Token.Name.Builtin, "echo"),
|
|
162
|
+
(Token.Text.Whitespace, " "),
|
|
163
|
+
(Token.Literal.String.Single, "'Hello, world!'"),
|
|
164
|
+
(Token.Text.Whitespace, "\n"),
|
|
165
|
+
]
|
|
@@ -0,0 +1,141 @@
|
|
|
1
|
+
import pytest
|
|
2
|
+
from pygments.token import Token
|
|
3
|
+
from shellconsole_lexer import ShellConsoleLexer
|
|
4
|
+
from git_lexer import GitStatusLexer
|
|
5
|
+
|
|
6
|
+
def test_git_show():
|
|
7
|
+
lexer = ShellConsoleLexer()
|
|
8
|
+
text = (
|
|
9
|
+
"user@host:~/directory (main) $ git show\n"
|
|
10
|
+
"commit 8e702933d5dbec9ee71100a1599ae4491085e1aa\n"
|
|
11
|
+
"Author: Author <author@localhost>\n"
|
|
12
|
+
"Date: Fri Oct 13 16:06:59 2023 +0200\n"
|
|
13
|
+
"\n"
|
|
14
|
+
" Added README.md\n"
|
|
15
|
+
"\n"
|
|
16
|
+
"diff --git a/README.md b/README.md\n"
|
|
17
|
+
"new file mode 100644\n"
|
|
18
|
+
"index 0000000..6d747b3\n"
|
|
19
|
+
"--- /dev/null\n"
|
|
20
|
+
"+++ b/README.md\n"
|
|
21
|
+
"@@ -0,0 +1,2 @@\n"
|
|
22
|
+
"+Addition\n"
|
|
23
|
+
"-Deletion\n"
|
|
24
|
+
)
|
|
25
|
+
|
|
26
|
+
tokens = list(lexer.get_tokens(text))
|
|
27
|
+
|
|
28
|
+
assert tokens == [
|
|
29
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
30
|
+
(Token.Generic.Prompt, ":"),
|
|
31
|
+
(Token.Generic.Prompt.Directory, "~/directory"),
|
|
32
|
+
(Token.Text.Whitespace, " "),
|
|
33
|
+
(Token.Generic.Prompt.GitBranch, "(main)"),
|
|
34
|
+
(Token.Text.Whitespace, " "),
|
|
35
|
+
(Token.Generic.Prompt, "$"),
|
|
36
|
+
(Token.Text.Whitespace, " "),
|
|
37
|
+
(Token.Text, "git"),
|
|
38
|
+
(Token.Text.Whitespace, " "),
|
|
39
|
+
(Token.Text, "show"),
|
|
40
|
+
(Token.Text.Whitespace, "\n"),
|
|
41
|
+
(Token.Git.Show.Header, "commit 8e702933d5dbec9ee71100a1599ae4491085e1aa"),
|
|
42
|
+
(Token.Text.Whitespace, "\n"),
|
|
43
|
+
(Token.Generic.Output, "Author: Author <author@localhost>\n"),
|
|
44
|
+
(Token.Generic.Output, "Date: Fri Oct 13 16:06:59 2023 +0200\n"),
|
|
45
|
+
(Token.Text.Whitespace, "\n"),
|
|
46
|
+
(Token.Generic.Output, " Added README.md\n"),
|
|
47
|
+
(Token.Text.Whitespace, "\n"),
|
|
48
|
+
(Token.Generic.Heading, "diff --git a/README.md b/README.md"),
|
|
49
|
+
(Token.Text.Whitespace, "\n"),
|
|
50
|
+
(Token.Text, "new file mode 100644"),
|
|
51
|
+
(Token.Text.Whitespace, "\n"),
|
|
52
|
+
(Token.Generic.Heading, "index 0000000..6d747b3"),
|
|
53
|
+
(Token.Text.Whitespace, "\n"),
|
|
54
|
+
(Token.Generic.Deleted, "--- /dev/null"),
|
|
55
|
+
(Token.Text.Whitespace, "\n"),
|
|
56
|
+
(Token.Generic.Inserted, "+++ b/README.md"),
|
|
57
|
+
(Token.Text.Whitespace, "\n"),
|
|
58
|
+
(Token.Generic.Subheading, "@@ -0,0 +1,2 @@"),
|
|
59
|
+
(Token.Text.Whitespace, "\n"),
|
|
60
|
+
(Token.Generic.Inserted, "+Addition"),
|
|
61
|
+
(Token.Text.Whitespace, "\n"),
|
|
62
|
+
(Token.Generic.Deleted, "-Deletion"),
|
|
63
|
+
(Token.Text.Whitespace, "\n"),
|
|
64
|
+
]
|
|
65
|
+
|
|
66
|
+
def test_git_show_with_refs():
|
|
67
|
+
lexer = ShellConsoleLexer()
|
|
68
|
+
text = (
|
|
69
|
+
"user@host:~/directory (main) $ git show\n"
|
|
70
|
+
"commit 8e702933d5dbec9ee71100a1599ae4491085e1aa (HEAD -> main, tag: v1, origin/main, origin/HEAD)\n"
|
|
71
|
+
"Author: Author <author@localhost>\n"
|
|
72
|
+
"Date: Fri Oct 13 16:06:59 2023 +0200\n"
|
|
73
|
+
"\n"
|
|
74
|
+
" Added README.md\n"
|
|
75
|
+
"\n"
|
|
76
|
+
"diff --git a/README.md b/README.md\n"
|
|
77
|
+
"new file mode 100644\n"
|
|
78
|
+
"index 0000000..6d747b3\n"
|
|
79
|
+
"--- /dev/null\n"
|
|
80
|
+
"+++ b/README.md\n"
|
|
81
|
+
"@@ -0,0 +1,2 @@\n"
|
|
82
|
+
"+Addition\n"
|
|
83
|
+
"-Deletion\n"
|
|
84
|
+
)
|
|
85
|
+
|
|
86
|
+
tokens = list(lexer.get_tokens(text))
|
|
87
|
+
|
|
88
|
+
assert tokens == [
|
|
89
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
90
|
+
(Token.Generic.Prompt, ":"),
|
|
91
|
+
(Token.Generic.Prompt.Directory, "~/directory"),
|
|
92
|
+
(Token.Text.Whitespace, " "),
|
|
93
|
+
(Token.Generic.Prompt.GitBranch, "(main)"),
|
|
94
|
+
(Token.Text.Whitespace, " "),
|
|
95
|
+
(Token.Generic.Prompt, "$"),
|
|
96
|
+
(Token.Text.Whitespace, " "),
|
|
97
|
+
(Token.Text, "git"),
|
|
98
|
+
(Token.Text.Whitespace, " "),
|
|
99
|
+
(Token.Text, "show"),
|
|
100
|
+
(Token.Text.Whitespace, "\n"),
|
|
101
|
+
(Token.Git.Show.Header, "commit 8e702933d5dbec9ee71100a1599ae4491085e1aa"),
|
|
102
|
+
(Token.Text.Whitespace, " "),
|
|
103
|
+
(Token.Git.Show.Header, "("),
|
|
104
|
+
(Token.Git.Refs.Head, "HEAD"),
|
|
105
|
+
(Token.Text.Whitespace, " "),
|
|
106
|
+
(Token.Git.Show.Header, "->"),
|
|
107
|
+
(Token.Text.Whitespace, " "),
|
|
108
|
+
(Token.Git.Refs.Branch, "main"),
|
|
109
|
+
(Token.Git.Show.Header, ","),
|
|
110
|
+
(Token.Text.Whitespace, " "),
|
|
111
|
+
(Token.Git.Refs.Tag, "tag: v1"),
|
|
112
|
+
(Token.Git.Show.Header, ","),
|
|
113
|
+
(Token.Text.Whitespace, " "),
|
|
114
|
+
(Token.Git.Refs.RemoteBranch, "origin/main"),
|
|
115
|
+
(Token.Git.Show.Header, ","),
|
|
116
|
+
(Token.Text.Whitespace, " "),
|
|
117
|
+
(Token.Git.Refs.RemoteHead, "origin/HEAD"),
|
|
118
|
+
(Token.Git.Show.Header, ")"),
|
|
119
|
+
(Token.Text.Whitespace, "\n"),
|
|
120
|
+
(Token.Generic.Output, "Author: Author <author@localhost>\n"),
|
|
121
|
+
(Token.Generic.Output, "Date: Fri Oct 13 16:06:59 2023 +0200\n"),
|
|
122
|
+
(Token.Text.Whitespace, "\n"),
|
|
123
|
+
(Token.Generic.Output, " Added README.md\n"),
|
|
124
|
+
(Token.Text.Whitespace, "\n"),
|
|
125
|
+
(Token.Generic.Heading, "diff --git a/README.md b/README.md"),
|
|
126
|
+
(Token.Text.Whitespace, "\n"),
|
|
127
|
+
(Token.Text, "new file mode 100644"),
|
|
128
|
+
(Token.Text.Whitespace, "\n"),
|
|
129
|
+
(Token.Generic.Heading, "index 0000000..6d747b3"),
|
|
130
|
+
(Token.Text.Whitespace, "\n"),
|
|
131
|
+
(Token.Generic.Deleted, "--- /dev/null"),
|
|
132
|
+
(Token.Text.Whitespace, "\n"),
|
|
133
|
+
(Token.Generic.Inserted, "+++ b/README.md"),
|
|
134
|
+
(Token.Text.Whitespace, "\n"),
|
|
135
|
+
(Token.Generic.Subheading, "@@ -0,0 +1,2 @@"),
|
|
136
|
+
(Token.Text.Whitespace, "\n"),
|
|
137
|
+
(Token.Generic.Inserted, "+Addition"),
|
|
138
|
+
(Token.Text.Whitespace, "\n"),
|
|
139
|
+
(Token.Generic.Deleted, "-Deletion"),
|
|
140
|
+
(Token.Text.Whitespace, "\n"),
|
|
141
|
+
]
|
|
@@ -0,0 +1,73 @@
|
|
|
1
|
+
import pytest
|
|
2
|
+
from pygments.token import Token
|
|
3
|
+
from shellconsole_lexer import ShellConsoleLexer
|
|
4
|
+
from git_lexer import GitStatusLexer
|
|
5
|
+
|
|
6
|
+
def test_full_git_status():
|
|
7
|
+
lexer = ShellConsoleLexer()
|
|
8
|
+
text = (
|
|
9
|
+
"user@host:~/directory (main) $ git status\n"
|
|
10
|
+
"On branch main\n"
|
|
11
|
+
"\n"
|
|
12
|
+
"No commits yet\n"
|
|
13
|
+
"\n"
|
|
14
|
+
"Untracked files:\n"
|
|
15
|
+
" (use \"git add <file>...\" to include in what will be committed)\n"
|
|
16
|
+
" README.md\n"
|
|
17
|
+
"\n"
|
|
18
|
+
"Changes not staged for commit:\n"
|
|
19
|
+
" (use \"git add <file>...\" to update what will be committed)\n"
|
|
20
|
+
" (use \"git restore <file>...\" to discard changes in working directory)\n"
|
|
21
|
+
" deleted: README.md\n"
|
|
22
|
+
" modified: mkdocs.yml\n"
|
|
23
|
+
" modified: requirements.txt\n"
|
|
24
|
+
"\n"
|
|
25
|
+
"Changes to be committed:\n"
|
|
26
|
+
" (use \"git rm --cached <file>...\" to unstage)\n"
|
|
27
|
+
" new file: README.md\n"
|
|
28
|
+
)
|
|
29
|
+
|
|
30
|
+
tokens = list(lexer.get_tokens(text))
|
|
31
|
+
|
|
32
|
+
assert tokens == [
|
|
33
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
34
|
+
(Token.Generic.Prompt, ":"),
|
|
35
|
+
(Token.Generic.Prompt.Directory, "~/directory"),
|
|
36
|
+
(Token.Text.Whitespace, " "),
|
|
37
|
+
(Token.Generic.Prompt.GitBranch, "(main)"),
|
|
38
|
+
(Token.Text.Whitespace, " "),
|
|
39
|
+
(Token.Generic.Prompt, "$"),
|
|
40
|
+
(Token.Text.Whitespace, " "),
|
|
41
|
+
(Token.Text, "git"),
|
|
42
|
+
(Token.Text.Whitespace, " "),
|
|
43
|
+
(Token.Text, "status"),
|
|
44
|
+
(Token.Text.Whitespace, "\n"),
|
|
45
|
+
(Token.Generic.Output, "On branch main\n"),
|
|
46
|
+
(Token.Text.Whitespace, "\n"),
|
|
47
|
+
(Token.Generic.Output, "No commits yet\n"),
|
|
48
|
+
(Token.Text.Whitespace, "\n"),
|
|
49
|
+
(Token.Generic.Output, "Untracked files:\n"),
|
|
50
|
+
(Token.Generic.Output, " (use \"git add <file>...\" to include in what will be committed)\n"),
|
|
51
|
+
(Token.Text.Whitespace, " "),
|
|
52
|
+
(Token.Git.Untracked, "README.md"),
|
|
53
|
+
(Token.Text.Whitespace, "\n"),
|
|
54
|
+
(Token.Text.Whitespace, "\n"),
|
|
55
|
+
(Token.Generic.Output, "Changes not staged for commit:\n"),
|
|
56
|
+
(Token.Generic.Output, " (use \"git add <file>...\" to update what will be committed)\n"),
|
|
57
|
+
(Token.Generic.Output, " (use \"git restore <file>...\" to discard changes in working directory)\n"),
|
|
58
|
+
(Token.Text.Whitespace, " "),
|
|
59
|
+
(Token.Git.Modified, "deleted: README.md"),
|
|
60
|
+
(Token.Text.Whitespace, "\n"),
|
|
61
|
+
(Token.Text.Whitespace, " "),
|
|
62
|
+
(Token.Git.Modified, "modified: mkdocs.yml"),
|
|
63
|
+
(Token.Text.Whitespace, "\n"),
|
|
64
|
+
(Token.Text.Whitespace, " "),
|
|
65
|
+
(Token.Git.Modified, "modified: requirements.txt"),
|
|
66
|
+
(Token.Text.Whitespace, "\n"),
|
|
67
|
+
(Token.Text.Whitespace, "\n"),
|
|
68
|
+
(Token.Generic.Output, "Changes to be committed:\n"),
|
|
69
|
+
(Token.Generic.Output, " (use \"git rm --cached <file>...\" to unstage)\n"),
|
|
70
|
+
(Token.Text.Whitespace, " "),
|
|
71
|
+
(Token.Git.Staged, "new file: README.md"),
|
|
72
|
+
(Token.Text.Whitespace, "\n"),
|
|
73
|
+
]
|
|
@@ -0,0 +1,214 @@
|
|
|
1
|
+
import pytest
|
|
2
|
+
from pygments.token import Token
|
|
3
|
+
from shellconsole_lexer import ShellConsoleLexer
|
|
4
|
+
|
|
5
|
+
def test_basic_bash_prompt():
|
|
6
|
+
lexer = ShellConsoleLexer()
|
|
7
|
+
prompt = "user@host:~$"
|
|
8
|
+
|
|
9
|
+
tokens = list(lexer.get_tokens(prompt))
|
|
10
|
+
|
|
11
|
+
assert tokens == [
|
|
12
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
13
|
+
(Token.Generic.Prompt, ":"),
|
|
14
|
+
(Token.Generic.Prompt.Directory, "~"),
|
|
15
|
+
(Token.Generic.Prompt, "$\n"),
|
|
16
|
+
]
|
|
17
|
+
|
|
18
|
+
def test_basic_bash_prompt_with_space():
|
|
19
|
+
lexer = ShellConsoleLexer()
|
|
20
|
+
prompt = "user@host:~ $"
|
|
21
|
+
|
|
22
|
+
tokens = list(lexer.get_tokens(prompt))
|
|
23
|
+
|
|
24
|
+
assert tokens == [
|
|
25
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
26
|
+
(Token.Generic.Prompt, ":"),
|
|
27
|
+
(Token.Generic.Prompt.Directory, "~"),
|
|
28
|
+
(Token.Text.Whitespace, " "),
|
|
29
|
+
(Token.Generic.Prompt, "$\n"),
|
|
30
|
+
]
|
|
31
|
+
|
|
32
|
+
def test_bash_prompt_with_git_branch():
|
|
33
|
+
lexer = ShellConsoleLexer()
|
|
34
|
+
prompt = "user@host:~/project (main) $"
|
|
35
|
+
|
|
36
|
+
tokens = list(lexer.get_tokens(prompt))
|
|
37
|
+
|
|
38
|
+
assert tokens == [
|
|
39
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
40
|
+
(Token.Generic.Prompt, ":"),
|
|
41
|
+
(Token.Generic.Prompt.Directory, "~/project"),
|
|
42
|
+
(Token.Text.Whitespace, " "),
|
|
43
|
+
(Token.Generic.Prompt.GitBranch, "(main)"),
|
|
44
|
+
(Token.Text.Whitespace, " "),
|
|
45
|
+
(Token.Generic.Prompt, "$\n"),
|
|
46
|
+
]
|
|
47
|
+
|
|
48
|
+
def test_bash_prompt_with_virtualenv():
|
|
49
|
+
lexer = ShellConsoleLexer()
|
|
50
|
+
prompt = "(venv) user@host:~/project $"
|
|
51
|
+
|
|
52
|
+
tokens = list(lexer.get_tokens(prompt))
|
|
53
|
+
|
|
54
|
+
assert tokens == [
|
|
55
|
+
(Token.Generic.Prompt.VirtualEnv, "(venv)"),
|
|
56
|
+
(Token.Text.Whitespace, " "),
|
|
57
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
58
|
+
(Token.Generic.Prompt, ":"),
|
|
59
|
+
(Token.Generic.Prompt.Directory, "~/project"),
|
|
60
|
+
(Token.Text.Whitespace, " "),
|
|
61
|
+
(Token.Generic.Prompt, "$\n"),
|
|
62
|
+
]
|
|
63
|
+
|
|
64
|
+
def test_bash_prompt_with_virtualenv_and_git_branch():
|
|
65
|
+
lexer = ShellConsoleLexer()
|
|
66
|
+
prompt = "(venv) user@host:~/project (main) $"
|
|
67
|
+
|
|
68
|
+
tokens = list(lexer.get_tokens(prompt))
|
|
69
|
+
|
|
70
|
+
assert tokens == [
|
|
71
|
+
(Token.Generic.Prompt.VirtualEnv, "(venv)"),
|
|
72
|
+
(Token.Text.Whitespace, " "),
|
|
73
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
74
|
+
(Token.Generic.Prompt, ":"),
|
|
75
|
+
(Token.Generic.Prompt.Directory, "~/project"),
|
|
76
|
+
(Token.Text.Whitespace, " "),
|
|
77
|
+
(Token.Generic.Prompt.GitBranch, "(main)"),
|
|
78
|
+
(Token.Text.Whitespace, " "),
|
|
79
|
+
(Token.Generic.Prompt, "$\n"),
|
|
80
|
+
]
|
|
81
|
+
def test_bracketed_bash_prompt():
|
|
82
|
+
lexer = ShellConsoleLexer()
|
|
83
|
+
prompt = "[user@host:~/project] $"
|
|
84
|
+
|
|
85
|
+
tokens = list(lexer.get_tokens(prompt))
|
|
86
|
+
|
|
87
|
+
assert tokens == [
|
|
88
|
+
(Token.Generic.Prompt, "["),
|
|
89
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
90
|
+
(Token.Generic.Prompt, ":"),
|
|
91
|
+
(Token.Generic.Prompt.Directory, "~/project"),
|
|
92
|
+
(Token.Generic.Prompt, "]"),
|
|
93
|
+
(Token.Text.Whitespace, " "),
|
|
94
|
+
(Token.Generic.Prompt, "$\n"),
|
|
95
|
+
]
|
|
96
|
+
|
|
97
|
+
def test_bracketed_bash_prompt_with_git_branch():
|
|
98
|
+
lexer = ShellConsoleLexer()
|
|
99
|
+
prompt = "[user@host:~/project (main)] $"
|
|
100
|
+
|
|
101
|
+
tokens = list(lexer.get_tokens(prompt))
|
|
102
|
+
|
|
103
|
+
assert tokens == [
|
|
104
|
+
(Token.Generic.Prompt, "["),
|
|
105
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
106
|
+
(Token.Generic.Prompt, ":"),
|
|
107
|
+
(Token.Generic.Prompt.Directory, "~/project"),
|
|
108
|
+
(Token.Text.Whitespace, " "),
|
|
109
|
+
(Token.Generic.Prompt.GitBranch, "(main)"),
|
|
110
|
+
(Token.Generic.Prompt, "]"),
|
|
111
|
+
(Token.Text.Whitespace, " "),
|
|
112
|
+
(Token.Generic.Prompt, "$\n"),
|
|
113
|
+
]
|
|
114
|
+
|
|
115
|
+
def test_bracketed_bash_prompt_with_virtualenv():
|
|
116
|
+
lexer = ShellConsoleLexer()
|
|
117
|
+
prompt = "(venv) [user@host:~/project] $"
|
|
118
|
+
|
|
119
|
+
tokens = list(lexer.get_tokens(prompt))
|
|
120
|
+
|
|
121
|
+
assert tokens == [
|
|
122
|
+
(Token.Generic.Prompt.VirtualEnv, "(venv)"),
|
|
123
|
+
(Token.Text.Whitespace, " "),
|
|
124
|
+
(Token.Generic.Prompt, "["),
|
|
125
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
126
|
+
(Token.Generic.Prompt, ":"),
|
|
127
|
+
(Token.Generic.Prompt.Directory, "~/project"),
|
|
128
|
+
(Token.Generic.Prompt, "]"),
|
|
129
|
+
(Token.Text.Whitespace, " "),
|
|
130
|
+
(Token.Generic.Prompt, "$\n"),
|
|
131
|
+
]
|
|
132
|
+
|
|
133
|
+
def test_bash_prompt_with_virtualenv_and_git_branch_and_command():
|
|
134
|
+
lexer = ShellConsoleLexer()
|
|
135
|
+
prompt = "(venv) user@host:~/project (main) $ echo 'Hello world!'\n"
|
|
136
|
+
|
|
137
|
+
tokens = list(lexer.get_tokens(prompt))
|
|
138
|
+
|
|
139
|
+
assert tokens == [
|
|
140
|
+
(Token.Generic.Prompt.VirtualEnv, "(venv)"),
|
|
141
|
+
(Token.Text.Whitespace, " "),
|
|
142
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
143
|
+
(Token.Generic.Prompt, ":"),
|
|
144
|
+
(Token.Generic.Prompt.Directory, "~/project"),
|
|
145
|
+
(Token.Text.Whitespace, " "),
|
|
146
|
+
(Token.Generic.Prompt.GitBranch, "(main)"),
|
|
147
|
+
(Token.Text.Whitespace, " "),
|
|
148
|
+
(Token.Generic.Prompt, "$"),
|
|
149
|
+
(Token.Text.Whitespace, " "),
|
|
150
|
+
(Token.Name.Builtin, "echo"),
|
|
151
|
+
(Token.Text.Whitespace, " "),
|
|
152
|
+
(Token.Literal.String.Single, "'Hello world!'"),
|
|
153
|
+
(Token.Text.Whitespace, "\n"),
|
|
154
|
+
]
|
|
155
|
+
|
|
156
|
+
def test_bash_prompt_with_virtualenv_and_git_branch_and_command_backslash():
|
|
157
|
+
lexer = ShellConsoleLexer()
|
|
158
|
+
prompt = (
|
|
159
|
+
"(venv) user@host:~/project (main) $ echo 'Hello world!' && \\\n"
|
|
160
|
+
"cd /tmp\n"
|
|
161
|
+
)
|
|
162
|
+
|
|
163
|
+
tokens = list(lexer.get_tokens(prompt))
|
|
164
|
+
|
|
165
|
+
assert tokens == [
|
|
166
|
+
(Token.Generic.Prompt.VirtualEnv, "(venv)"),
|
|
167
|
+
(Token.Text.Whitespace, " "),
|
|
168
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
169
|
+
(Token.Generic.Prompt, ":"),
|
|
170
|
+
(Token.Generic.Prompt.Directory, "~/project"),
|
|
171
|
+
(Token.Text.Whitespace, " "),
|
|
172
|
+
(Token.Generic.Prompt.GitBranch, "(main)"),
|
|
173
|
+
(Token.Text.Whitespace, " "),
|
|
174
|
+
(Token.Generic.Prompt, "$"),
|
|
175
|
+
(Token.Text.Whitespace, " "),
|
|
176
|
+
(Token.Name.Builtin, "echo"),
|
|
177
|
+
(Token.Text.Whitespace, " "),
|
|
178
|
+
(Token.Literal.String.Single, "'Hello world!'"),
|
|
179
|
+
(Token.Text.Whitespace, " "),
|
|
180
|
+
(Token.Operator, "&&"),
|
|
181
|
+
(Token.Text.Whitespace, " "),
|
|
182
|
+
(Token.Literal.String.Escape, "\\\n"),
|
|
183
|
+
(Token.Name.Builtin, "cd"),
|
|
184
|
+
(Token.Text.Whitespace, " "),
|
|
185
|
+
(Token.Text, "/tmp"),
|
|
186
|
+
(Token.Text.Whitespace, "\n"),
|
|
187
|
+
]
|
|
188
|
+
|
|
189
|
+
def test_bash_prompt_with_virtualenv_and_git_branch_and_command_output():
|
|
190
|
+
lexer = ShellConsoleLexer()
|
|
191
|
+
prompt = (
|
|
192
|
+
"(venv) user@host:~/project (main) $ echo 'Hello world!'\n"
|
|
193
|
+
"Hello world!\n"
|
|
194
|
+
)
|
|
195
|
+
|
|
196
|
+
tokens = list(lexer.get_tokens(prompt))
|
|
197
|
+
|
|
198
|
+
assert tokens == [
|
|
199
|
+
(Token.Generic.Prompt.VirtualEnv, "(venv)"),
|
|
200
|
+
(Token.Text.Whitespace, " "),
|
|
201
|
+
(Token.Generic.Prompt.UserHost, "user@host"),
|
|
202
|
+
(Token.Generic.Prompt, ":"),
|
|
203
|
+
(Token.Generic.Prompt.Directory, "~/project"),
|
|
204
|
+
(Token.Text.Whitespace, " "),
|
|
205
|
+
(Token.Generic.Prompt.GitBranch, "(main)"),
|
|
206
|
+
(Token.Text.Whitespace, " "),
|
|
207
|
+
(Token.Generic.Prompt, "$"),
|
|
208
|
+
(Token.Text.Whitespace, " "),
|
|
209
|
+
(Token.Name.Builtin, "echo"),
|
|
210
|
+
(Token.Text.Whitespace, " "),
|
|
211
|
+
(Token.Literal.String.Single, "'Hello world!'"),
|
|
212
|
+
(Token.Text.Whitespace, "\n"),
|
|
213
|
+
(Token.Generic.Output, "Hello world!\n"),
|
|
214
|
+
]
|
|
@@ -51,7 +51,7 @@ Changes to be committed:
|
|
|
51
51
|
new file: README.md
|
|
52
52
|
|
|
53
53
|
joapuiib@FP:~/01_introduccio (main) $ git show 8e70293
|
|
54
|
-
commit 8e702933d5dbec9ee71100a1599ae4491085e1aa
|
|
54
|
+
commit 8e702933d5dbec9ee71100a1599ae4491085e1aa (HEAD -> main, tag: v1, origin/main)
|
|
55
55
|
Author: Joan Puigcerver Ibáñez <j.puigcerveribanez@edu.gva.es>
|
|
56
56
|
Date: Fri Oct 13 16:06:59 2023 +0200
|
|
57
57
|
|
|
@@ -1,2 +1,2 @@
|
|
|
1
1
|
#!/bin/bash
|
|
2
|
-
./venv/bin/pygmentize -l shellconsole -O style=shellconsole-style test.exmpl
|
|
2
|
+
./venv/bin/pygmentize -l shellconsole -O style=shellconsole-style test.exmpl $@
|
|
@@ -1,112 +0,0 @@
|
|
|
1
|
-
"""An example plugin lexer for Pygments."""
|
|
2
|
-
|
|
3
|
-
from pygments.lexer import Lexer
|
|
4
|
-
from pygments.lexer import RegexLexer, ExtendedRegexLexer, include, bygroups, \
|
|
5
|
-
default, using, line_re, do_insertions
|
|
6
|
-
from pygments.token import Token, Punctuation, Whitespace, \
|
|
7
|
-
Text, Comment, Operator, Keyword, Name, String, Number, Generic
|
|
8
|
-
from pygments.lexers.diff import DiffLexer
|
|
9
|
-
from pygments.token import STANDARD_TYPES
|
|
10
|
-
|
|
11
|
-
import re
|
|
12
|
-
|
|
13
|
-
__all__ = ['GitLexer']
|
|
14
|
-
|
|
15
|
-
STANDARD_TYPES.update({
|
|
16
|
-
Token.Git: 'git',
|
|
17
|
-
Token.Git.BranchLine: 'git-bl',
|
|
18
|
-
Token.Git.CommitHash: 'git-ch',
|
|
19
|
-
Token.Git.CommitDate: 'git-cd',
|
|
20
|
-
Token.Git.CommitMessage: 'git-cm',
|
|
21
|
-
Token.Git.CommitAuthor: 'git-ca',
|
|
22
|
-
Token.Git.Refs: 'git-r',
|
|
23
|
-
Token.Git.Untracked: 'git-untr',
|
|
24
|
-
Token.Git.Modified: 'git-mod',
|
|
25
|
-
Token.Git.Staged: 'git-stg',
|
|
26
|
-
})
|
|
27
|
-
|
|
28
|
-
class GitLogLexer(Lexer):
|
|
29
|
-
name = "Git"
|
|
30
|
-
aliases = ["git"]
|
|
31
|
-
filenames = ['*.git']
|
|
32
|
-
version_added = '1.0'
|
|
33
|
-
|
|
34
|
-
_branch_line_rgx = r'([\|\\\/ ]*)'
|
|
35
|
-
_logrgx_groups = [
|
|
36
|
-
_branch_line_rgx, # Branch line
|
|
37
|
-
r'(\*)', # Commit asterisk
|
|
38
|
-
_branch_line_rgx, # Branch line
|
|
39
|
-
r'( +)', # Space
|
|
40
|
-
r'([a-f0-9]+)', # Commit hash
|
|
41
|
-
r'( +- +)', # Commit separator
|
|
42
|
-
r'(\([0-9A-Za-zÀ-ÖØ-öø-ÿ ]+\))', # Date
|
|
43
|
-
r'(\s+[0-9A-Za-zÀ-ÖØ-öø-ÿ \.\:\_\'\"\!\?\(\)\\\/\-]+ +- +)', # Commit message
|
|
44
|
-
r'([0-9A-Za-zÀ-ÖØ-öø-ÿ ]+)', # Author
|
|
45
|
-
r'((\([\w ->,:]+\))?)', # Refs
|
|
46
|
-
r'$', # End
|
|
47
|
-
]
|
|
48
|
-
|
|
49
|
-
# Combine the regex patterns into a single pattern
|
|
50
|
-
_logrgx = re.compile(r''.join(_logrgx_groups))
|
|
51
|
-
|
|
52
|
-
_log_tokens = {
|
|
53
|
-
1: Token.Git.BranchLine,
|
|
54
|
-
3: Token.Git.BranchLine,
|
|
55
|
-
4: Whitespace,
|
|
56
|
-
5: Token.Git.CommitHash,
|
|
57
|
-
7: Token.Git.CommitDate,
|
|
58
|
-
8: Token.Git.CommitMessage,
|
|
59
|
-
9: Token.Git.CommitAuthor,
|
|
60
|
-
10: Token.Git.Refs,
|
|
61
|
-
}
|
|
62
|
-
|
|
63
|
-
def get_tokens_unprocessed(self, text):
|
|
64
|
-
pos = 0
|
|
65
|
-
|
|
66
|
-
for match in line_re.finditer(text):
|
|
67
|
-
line = match.group()
|
|
68
|
-
|
|
69
|
-
match_log = self._logrgx.match(line)
|
|
70
|
-
match_branch_line = re.match(r'^' + self._branch_line_rgx + r'$', line)
|
|
71
|
-
|
|
72
|
-
## Line is log
|
|
73
|
-
if match_log:
|
|
74
|
-
for i in range(1, len(match_log.groups())):
|
|
75
|
-
if match_log.group(i):
|
|
76
|
-
if self._log_tokens.get(i):
|
|
77
|
-
yield match_log.start(i), self._log_tokens[i], match_log.group(i)
|
|
78
|
-
else:
|
|
79
|
-
yield match_log.start(i), Generic.Output, match_log.group(i)
|
|
80
|
-
yield match.end(), Whitespace, '\n'
|
|
81
|
-
elif match_branch_line:
|
|
82
|
-
yield match.start(), Token.Git.BranchLine, line
|
|
83
|
-
|
|
84
|
-
else:
|
|
85
|
-
yield match.start(), Generic.Output, line
|
|
86
|
-
|
|
87
|
-
class GitStatusLexer(RegexLexer):
|
|
88
|
-
tokens = {
|
|
89
|
-
'root': [
|
|
90
|
-
(r'\s*Untracked files:\n', Text, 'untracked'),
|
|
91
|
-
(r'\s*Changes not staged for commit:\n', Text, 'modified'),
|
|
92
|
-
(r'\s*Changes to be committed:\n', Text, 'staged'),
|
|
93
|
-
],
|
|
94
|
-
'untracked': [
|
|
95
|
-
(r'^\s+\(.*\)\n', Text),
|
|
96
|
-
(r'^[^\n]+\n', Token.Git.Untracked),
|
|
97
|
-
(r'^\s+\n', Text, '#pop'),
|
|
98
|
-
],
|
|
99
|
-
'modified': [
|
|
100
|
-
(r'^\s+\(.*\)\n', Text),
|
|
101
|
-
(r'^[^\n]+\n', Token.Git.Modified),
|
|
102
|
-
(r'^\s+\n', Text, '#pop'),
|
|
103
|
-
],
|
|
104
|
-
'staged': [
|
|
105
|
-
(r'^\s+\(.*\)\n', Text),
|
|
106
|
-
(r'^[^\n]+\n', Token.Git.Staged),
|
|
107
|
-
(r'^\s+\n', Text, '#pop'),
|
|
108
|
-
],
|
|
109
|
-
}
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
{pygments_shell_console-0.0.3 → pygments_shell_console-0.0.4}/.github/workflows/publish-to-pypi.yml
RENAMED
|
File without changes
|
|
File without changes
|
|
File without changes
|