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
|
# coding=utf-8
"""
History management classes
"""
import re
from typing import List, Optional, Union
from . import utils
from .parsing import Statement
class HistoryItem(str):
"""Class used to represent one command in the History list"""
listformat = ' {:>4} {}\n'
ex_listformat = ' {:>4}x {}\n'
def __new__(cls, statement: Statement):
"""Create a new instance of HistoryItem
We must override __new__ because we are subclassing `str` which is
immutable and takes a different number of arguments as Statement.
"""
hi = super().__new__(cls, statement.raw)
hi.statement = statement
hi.idx = None
return hi
@property
def expanded(self) -> str:
"""Return the command as run which includes shortcuts and aliases resolved plus any changes made in hooks"""
return self.statement.expanded_command_line
def pr(self, script=False, expanded=False, verbose=False) -> str:
"""Represent a HistoryItem in a pretty fashion suitable for printing.
If you pass verbose=True, script and expanded will be ignored
:return: pretty print string version of a HistoryItem
"""
if verbose:
ret_str = self.listformat.format(self.idx, str(self).rstrip())
if self != self.expanded:
ret_str += self.ex_listformat.format(self.idx, self.expanded.rstrip())
else:
if script:
# display without entry numbers
if expanded:
ret_str = self.expanded.rstrip()
else:
ret_str = str(self)
else:
# display a numbered list
if expanded:
ret_str = self.listformat.format(self.idx, self.expanded.rstrip())
else:
ret_str = self.listformat.format(self.idx, str(self).rstrip())
return ret_str
class History(list):
""" A list of HistoryItems that knows how to respond to user requests. """
# noinspection PyMethodMayBeStatic
def _zero_based_index(self, onebased: int) -> int:
"""Convert a one-based index to a zero-based index."""
result = onebased
if result > 0:
result -= 1
return result
def _to_index(self, raw: str) -> Optional[int]:
if raw:
result = self._zero_based_index(int(raw))
else:
result = None
return result
spanpattern = re.compile(r'^\s*(?P<start>-?\d+)?\s*(?P<separator>:|(\.{2,}))?\s*(?P<end>-?\d+)?\s*$')
def span(self, raw: str) -> List[HistoryItem]:
"""Parses the input string search for a span pattern and if if found, returns a slice from the History list.
:param raw: string potentially containing a span of the forms a..b, a:b, a:, ..b
:return: slice from the History list
"""
if raw.lower() in ('*', '-', 'all'):
raw = ':'
results = self.spanpattern.search(raw)
if not results:
raise IndexError
if not results.group('separator'):
return [self[self._to_index(results.group('start'))]]
start = self._to_index(results.group('start')) or 0 # Ensure start is not None
end = self._to_index(results.group('end'))
reverse = False
if end is not None:
if end < start:
(start, end) = (end, start)
reverse = True
end += 1
result = self[start:end]
if reverse:
result.reverse()
return result
rangePattern = re.compile(r'^\s*(?P<start>[\d]+)?\s*-\s*(?P<end>[\d]+)?\s*$')
def append(self, new: Statement) -> None:
"""Append a HistoryItem to end of the History list
:param new: command line to convert to HistoryItem and add to the end of the History list
"""
new = HistoryItem(new)
list.append(self, new)
new.idx = len(self)
def get(self, getme: Optional[Union[int, str]]=None) -> List[HistoryItem]:
"""Get an item or items from the History list using 1-based indexing.
:param getme: optional item(s) to get (either an integer index or string to search for)
:return: list of HistoryItems matching the retrieval criteria
"""
if not getme:
return self
try:
getme = int(getme)
if getme < 0:
return self[:(-1 * getme)]
else:
return [self[getme - 1]]
except IndexError:
return []
except ValueError:
range_result = self.rangePattern.search(getme)
if range_result:
start = range_result.group('start') or None
end = range_result.group('start') or None
if start:
start = int(start) - 1
if end:
end = int(end)
return self[start:end]
getme = getme.strip()
if getme.startswith(r'/') and getme.endswith(r'/'):
finder = re.compile(getme[1:-1], re.DOTALL | re.MULTILINE | re.IGNORECASE)
def isin(hi):
"""Listcomp filter function for doing a regular expression search of History.
:param hi: HistoryItem
:return: bool - True if search matches
"""
return finder.search(hi)
else:
def isin(hi):
"""Listcomp filter function for doing a case-insensitive string search of History.
:param hi: HistoryItem
:return: bool - True if search matches
"""
return utils.norm_fold(getme) in utils.norm_fold(hi)
return [itm for itm in self if isin(itm)]
|
