def create(context, resolver, *tokens, **kwargs):
if context is None:
context = HotwireContext()
accept_partial = (('accept_partial' in kwargs) and kwargs['accept_partial'])
components = []
undoable = None
idempotent = True
prev = None
pipeline_input_type = 'unknown'
pipeline_input_optional = 'unknown'
pipeline_output_type = None
prev_locality = None
pipeline_singlevalue = None
pipeline_type_validates = True
pushback = []
tokens = list(tokens)
def pull_token():
if pushback:
return pushback.pop(0)
else:
return tokens.pop(0)
while tokens or pushback:
builtin_token = pull_token()
_logger.debug("token = %r", builtin_token)
def forcetoken(t):
# Allow passing plain strings for convenience from Python.
# Treat them as quoted.
if isinstance(t, basestring):
return ParsedToken(t, -1, quoted=True)
return t
builtin_token = forcetoken(builtin_token)
# Attempt to determine which builtin we're using
if isinstance(builtin_token, Builtin):
b = builtin_token
cmdargs = []
# If we're parsing without a resolver, assume we're using sys
elif isinstance(builtin_token, ParsedToken):
try:
b = BuiltinRegistry.getInstance()[builtin_token.text]
cmdargs = []
except KeyError, e:
if resolver:
(b, cmdargs) = resolver.resolve(builtin_token.text, context)
_logger.debug("resolved: %r to %r %r", builtin_token.text, b, cmdargs)
if not b:
raise PipelineParseException(_('No matches for %s') % (builtin_token.text,))
else:
b = BuiltinRegistry.getInstance()['sys']
cmdargs = [ParsedToken(builtin_token.text, builtin_token.start, end=builtin_token.end)]
elif builtin_token in (hotwire.script.PIPE, hotwire.script.REDIR_IN, hotwire.script.REDIR_OUT, hotwire.script.REDIR_OUT_APPEND):
raise PipelineParseException(_("Unexpected token %d") % (builtin_token,))
def create(context, resolver, *tokens, **kwargs):
if context is None:
context = HotwireContext()
accept_partial = (('accept_partial' in kwargs) and kwargs['accept_partial'])
components = []
undoable = None
idempotent = True
prev = None
pipeline_input_type = 'unknown'
pipeline_input_optional = 'unknown'
pipeline_output_type = None
prev_locality = None
pipeline_singlevalue = None
pipeline_type_validates = True
pushback = []
tokens = list(tokens)
def pull_token():
if pushback:
return pushback.pop(0)
else:
return tokens.pop(0)
while tokens or pushback:
builtin_token = pull_token()
_logger.debug("token = %r", builtin_token)
def forcetoken(t):
# Allow passing plain strings for convenience from Python.
# Treat them as quoted.
if isinstance(t, basestring):
return ParsedToken(t, -1, quoted=True)
return t
builtin_token = forcetoken(builtin_token)
# Attempt to determine which builtin we're using
if isinstance(builtin_token, Builtin):
b = builtin_token
cmdargs = []
# If we're parsing without a resolver, assume we're using sys
elif isinstance(builtin_token, ParsedToken):
try:
b = BuiltinRegistry.getInstance()[builtin_token.text]
cmdargs = []
except KeyError, e:
if resolver:
(b, cmdargs) = resolver.resolve(builtin_token.text, context)
_logger.debug("resolved: %r to %r %r", builtin_token.text, b, cmdargs)
if not b:
raise PipelineParseException(_('No matches for %s') % (gobject.markup_escape_text(builtin_token.text),))
else:
b = BuiltinRegistry.getInstance()['sys']
cmdargs = [ParsedToken(builtin_token.text, builtin_token.start, end=builtin_token.end)]
elif builtin_token in (hotwire.script.PIPE, hotwire.script.REDIR_IN, hotwire.script.REDIR_OUT, hotwire.script.REDIR_OUT_APPEND):
raise PipelineParseException(_("Unexpected token %d") % (builtin_token,))
def completions(self, text, cwd, context=None):
for builtin in BuiltinRegistry.getInstance():
compl = self._match(builtin.name, text, builtin)
if compl: yield compl
for alias in builtin.aliases:
compl = self._match(alias, text, builtin)
if compl: yield compl
def completions(self, text, cwd, context=None):
for builtin in BuiltinRegistry.getInstance():
compl = self._match(builtin.name, text, builtin)
if compl: yield compl
for alias in builtin.aliases:
compl = self._match(alias, text, builtin)
if compl: yield compl
def execute(self, context, args, options=[]):
regexp = args[0]
if len(args) == 2:
path = args[1]
else:
path = context.cwd
regexp = args[0]
comp_regexp = re.compile(
regexp, (('-i' in options) and re.IGNORECASE or 0) | re.UNICODE)
walk_builtin = BuiltinRegistry.getInstance()['walk']
newctx = HotwireContext(context.cwd)
for fobj in walk_builtin.execute(newctx, [path]):
fp = None
try:
fp = open_text_file(fobj.path)
for i, line in enumerate(fp):
match = comp_regexp.search(line)
if match:
yield FileStringMatch(fobj.path, line[:-1], i,
match.start(), match.end())
fp.close()
except OSError, e:
pass
except UnicodeDecodeError, e:
pass
def __help_items(self, items):
builtins = BuiltinRegistry.getInstance()
for name in items:
builtin = builtins[name]
self.__append_builtin_base_help(builtin)
self.__append_builtin_aliases(builtin)
self.__append_builtin_arghelp(builtin)
self.__append_builtin_doc(builtin)
def __help_all(self):
pbcache = PixbufCache.getInstance()
self._buf.insert_markup('Hotwire <i>%s</i>\n\n' % (__version__,))
self._buf.insert_markup(_('Documentation on the web: '))
self._buf.insert_markup(' ')
self.append_link(_('Tutorial'), 'http://code.google.com/p/hotwire-shell/wiki/GettingStarted0700')
self._buf.insert_markup(' ')
external_pixbuf = pbcache.get('external.png', size=10)
self._buf.insert_pixbuf(self._buf.get_end_iter(), external_pixbuf)
self._buf.insert_markup('\n\n')
registry = BuiltinRegistry.getInstance()
for (setname,builtins) in zip((_('User'), _('Standard'), _('System')), map(list, [registry.user_set, registry.hotwire_set, registry.system_set])):
if len(builtins) == 0:
continue
self._buf.insert_markup('<larger>%s:</larger>\n' % (_('%s Builtin Commands' % (setname,)),))
builtins.sort(lambda a,b: cmp(a.name, b.name))
for builtin in builtins:
self.__append_builtin_base_help(builtin)
self.__append_builtin_aliases(builtin)
self.__append_builtin_arghelp(builtin)
self.__append_builtin_doc(builtin)
self._buf.insert_markup('\n')
self._buf.insert_markup('<larger>%s:</larger>\n' % (_('Languages'),))
langreg = PipelineLanguageRegistry.getInstance()
hotwire_lang = langreg['62270c40-a94a-44dd-aaa0-689f882acf34']
python_lang = langreg['da3343a0-8bce-46ed-a463-2d17ab09d9b4']
self.__append_language(hotwire_lang)
self.__append_language(python_lang)
languages = list(langreg)
languages.sort(lambda a,b: cmp(a.langname, b.langname))
for language in languages:
if language in [hotwire_lang, python_lang]:
continue
self.__append_language(language)
self._buf.insert_markup('\n<larger>%s:</larger>\n' % (_('Aliases'),))
aliases = list(AliasRegistry.getInstance())
aliases.sort(lambda a,b: cmp(a.name,b.name))
for alias in aliases:
self._buf.insert_markup(' <b>%s</b> - %s\n' % tuple(map(gobject.markup_escape_text, (alias.name, alias.target))))
def execute(self, context, args, options=[]):
regexp = args[0]
if len(args) == 2:
path = args[1]
else:
path = context.cwd
regexp = args[0]
comp_regexp = re.compile(regexp, (('-i' in options) and re.IGNORECASE or 0) | re.UNICODE)
walk_builtin = BuiltinRegistry.getInstance()['walk']
newctx = HotwireContext(context.cwd)
for fobj in walk_builtin.execute(newctx, [path]):
fp = None
try:
fp = open_text_file(fobj.path)
for i,line in enumerate(fp):
match = comp_regexp.search(line)
if match:
yield FileStringMatch(fobj.path, line[:-1], i, match.start(), match.end())
fp.close()
except OSError as e:
pass
except UnicodeDecodeError as e:
pass
def _expand_verb_completion(self, completion):
target = completion.target
if isinstance(target, File):
return (BuiltinRegistry.getInstance()['sys'], [target.path])
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
from hotwire.builtin import Builtin, BuiltinRegistry, OutputStreamSchema
if '_' not in globals(): globals()['_'] = lambda x: x
class CurrentBuiltin(Builtin):
__doc__ = _("""Returns objects generated by currently visible command.""")
def __init__(self):
super(CurrentBuiltin, self).__init__('current', aliases=['cur'],
idempotent=True,
argspec=None,
output=OutputStreamSchema('any'),
threaded=False)
def execute(self, context, args):
meta = context.current_output_metadata
current = context.snapshot_current_output()
if current is None:
return
if meta.single:
yield current
else:
for obj in current:
yield obj
BuiltinRegistry.getInstance().register_hotwire(CurrentBuiltin())
options=[['-i', '--ignore-case']])
def execute(self, context, args, options=[]):
regexp = args[0]
if len(args) == 2:
path = args[1]
else:
path = context.cwd
regexp = args[0]
comp_regexp = re.compile(
regexp, (('-i' in options) and re.IGNORECASE or 0) | re.UNICODE)
walk_builtin = BuiltinRegistry.getInstance()['walk']
newctx = HotwireContext(context.cwd)
for fobj in walk_builtin.execute(newctx, [path]):
fp = None
try:
fp = open_text_file(fobj.path)
for i, line in enumerate(fp):
match = comp_regexp.search(line)
if match:
yield FileStringMatch(fobj.path, line[:-1], i,
match.start(), match.end())
fp.close()
except OSError, e:
pass
except UnicodeDecodeError, e:
pass
BuiltinRegistry.getInstance().register_hotwire(FSearchBuiltin())
from hotwire.builtin import Builtin, BuiltinRegistry, MultiArgSpec
from hotwire.fs import FilePath
from hotwire.sysdep.fs import Filesystem
class EditBuiltin(Builtin):
__doc__ = _("""Launch the text editor.""")
_ws_re = re.compile(r"\s+")
def __init__(self):
super(EditBuiltin, self).__init__(
"edit",
aliases=["ed"],
argspec=MultiArgSpec("paths", min=1),
nodisplay=True,
idempotent=True,
threaded=False,
)
def execute(self, context, args):
from hotwire_ui.adaptors.editors import EditorRegistry
prefeditor = EditorRegistry.getInstance().get_preferred()
prefeditor.run_many(context.cwd, *args)
return []
BuiltinRegistry.getInstance().register_hotwire(EditBuiltin())
PYMAP_CONTENT = '''
import os,sys,re
def execute(context, input):
for it in input:
yield %s'''
def __init__(self):
super(PyMapBuiltin,
self).__init__('py-map',
argspec=(ArgSpec('expression'), ),
input=InputStreamSchema('any', optional=True),
output=OutputStreamSchema('any'))
def execute(self, context, args, options=[]):
buf = self.PYMAP_CONTENT % (args[0], )
code = compile(buf, '<input>', 'exec')
locals = {}
exec(code, locals)
execute = locals['execute']
custom_out = execute(context, context.input)
if custom_out is None:
return
if hasattr(custom_out, '__iter__'):
for o in custom_out:
yield o
else:
yield custom_out
BuiltinRegistry.getInstance().register_hotwire(PyMapBuiltin())
def __init__(self):
super(SelectionBuiltin, self).__init__(
'selection',
aliases=['sel'],
argspec=(ArgSpec('index', opt=True), ),
threaded=False,
output=OutputStreamSchema(
'any',
typefunc=lambda hotwire: hotwire.get_current_output_type()))
def execute(self, context, args):
current = context.hotwire.snapshot_current_selected_output()
if len(args) == 0:
if current is None:
return
for obj in current.value:
yield obj
elif len(args) == 1:
idx = int(args[0])
for i, obj in enumerate(current.value):
if i == idx:
yield obj
return
raise ValueError(_("Index %d out of range") % (idx, ))
elif len(args) > 2:
raise ValueError(_("Too many arguments specified"))
BuiltinRegistry.getInstance().register_hotwire(SelectionBuiltin())
options=[['-a', '--append'], ['-p', '--pickle'],
['-n', '--newline']])
def execute(self, context, args, options=[]):
open_mode = ('-a' in options) and 'a+' or 'w'
do_pickle = '-p' in options
with_newline = '-n' in options
if do_pickle:
open_mode = 'wb'
if not context.input:
return
streams = map(
lambda x: open_text_file(FilePath(x, context.cwd), open_mode),
args)
if not do_pickle:
for arg in context.input:
for stream in streams:
stream.write('%s' % (unicode(arg), ))
if with_newline:
stream.write('\n')
else:
# Kind of annoying pickle makes you do this.
arglist = list(context.input)
for stream in streams:
pickle.dump(arglist, stream)
map(lambda x: x.close(), streams)
return []
BuiltinRegistry.getInstance().register_hotwire(WriteBuiltin())
def __init__(self):
super(FSearchBuiltin, self).__init__('fsearch',
output=FileStringMatch,
argspec=('regexp', ArgSpec('directory', opt=True)),
options=[['-i', '--ignore-case']])
def execute(self, context, args, options=[]):
regexp = args[0]
if len(args) == 2:
path = args[1]
else:
path = context.cwd
regexp = args[0]
comp_regexp = re.compile(regexp, (('-i' in options) and re.IGNORECASE or 0) | re.UNICODE)
walk_builtin = BuiltinRegistry.getInstance()['walk']
newctx = HotwireContext(context.cwd)
for fobj in walk_builtin.execute(newctx, [path]):
fp = None
try:
fp = open_text_file(fobj.path)
for i,line in enumerate(fp):
match = comp_regexp.search(line)
if match:
yield FileStringMatch(fobj.path, line[:-1], i, match.start(), match.end())
fp.close()
except OSError as e:
pass
except UnicodeDecodeError as e:
pass
BuiltinRegistry.getInstance().register_hotwire(FSearchBuiltin())
def create(context, resolver, *tokens, **kwargs):
if context is None:
context = HotwireContext()
accept_partial = (('accept_partial' in kwargs) and kwargs['accept_partial'])
components = []
undoable = None
idempotent = True
prev = None
pipeline_input_type = 'unknown'
pipeline_input_optional = 'unknown'
pipeline_output_type = None
prev_locality = None
pipeline_singlevalue = None
pipeline_type_validates = True
pushback = []
tokens = list(tokens)
def pull_token():
if pushback:
return pushback.pop(0)
else:
return tokens.pop(0)
while tokens or pushback:
builtin_token = pull_token()
_logger.debug("token = %r", builtin_token)
def forcetoken(t):
# Allow passing plain strings for convenience from Python.
# Treat them as quoted.
if isinstance(t, str):
return ParsedToken(t, -1, quoted=True)
return t
builtin_token = forcetoken(builtin_token)
# Attempt to determine which builtin we're using
if isinstance(builtin_token, Builtin):
b = builtin_token
cmdargs = []
# If we're parsing without a resolver, assume we're using sys
elif isinstance(builtin_token, ParsedToken):
try:
b = BuiltinRegistry.getInstance()[builtin_token.text]
cmdargs = []
except KeyError as e:
if resolver:
(b, cmdargs) = resolver.resolve(builtin_token.text, context)
_logger.debug("resolved: %r to %r %r", builtin_token.text, b, cmdargs)
if not b:
raise PipelineParseException(_('No matches for %s') % (builtin_token.text,))
else:
b = BuiltinRegistry.getInstance()['sys']
cmdargs = [ParsedToken(builtin_token.text, builtin_token.start, end=builtin_token.end)]
elif builtin_token in (hotwire.script.PIPE, hotwire.script.REDIR_IN, hotwire.script.REDIR_OUT, hotwire.script.REDIR_OUT_APPEND):
raise PipelineParseException(_("Unexpected token %d") % (builtin_token,))
else:
_logger.error("unknown in parse stream: %r", builtin_token)
assert False
_logger.debug("target builtin is %r", b)
# We maintain the set of all tokens we processed in the command so that the completion system can use them.
alltokens = [builtin_token]
cmdargs = list(map(forcetoken, cmdargs))
alltokens.extend(cmdargs)
in_redir = None
out_redir = None
# Pull from the stream to get all the arguments
while tokens:
cmdarg = forcetoken(pull_token())
if cmdarg == hotwire.script.PIPE:
break
elif cmdarg == hotwire.script.REDIR_IN:
if not tokens:
raise PipelineParseException(_('Must specify target for input redirection'))
in_redir_token = pull_token()
in_redir = in_redir_token.text
alltokens.append(in_redir_token)
elif cmdarg == hotwire.script.REDIR_OUT:
if not tokens:
raise PipelineParseException(_('Must specify target for output redirection'))
out_redir_token = pull_token()
out_redir = out_redir_token.text
alltokens.append(out_redir_token)
else:
alltokens.append(cmdarg)
cmdargs.append(cmdarg)
builtin_opts = b.options
options = []
expanded_cmdargs = []
options_ended = False
raise_on_invalid_options = not (b.options_passthrough or accept_partial)
_logger.debug("raise: %r valid options %r, argument/option pool: %r", raise_on_invalid_options,
builtin_opts, cmdargs)
for token in cmdargs:
arg = CommandArgument(token.text, quoted=token.quoted)
if token.text == '--':
options_ended = True
elif options_ended:
expanded_cmdargs.append(arg)
else:
argopts = Pipeline.__parse_option_or_arg(builtin_opts, token.text,
raise_on_invalid=raise_on_invalid_options)
if argopts:
options.extend(argopts)
else:
expanded_cmdargs.append(arg)
argspec = b.argspec
if argspec is False or accept_partial:
# If we don't have an argspec, don't do any checking
pass
elif argspec is None:
if len(expanded_cmdargs) > 0:
raise PipelineParseException(_('Command %s takes no arguments, %d given') % (b.name, len(expanded_cmdargs)))
elif isinstance(argspec, MultiArgSpec):
if len(expanded_cmdargs) < argspec.min:
raise PipelineParseException(_("Command %s requires %d args, %d given") % (b.name,
argspec.min,
len(expanded_cmdargs)))
elif isinstance(argspec, tuple):
mincount = 0
for o in argspec:
if not o.opt:
mincount += 1
if len(expanded_cmdargs) > len(argspec):
raise PipelineParseException(_("Command %s takes at most %d args, %d given") % (b.name,
len(argspec),
len(expanded_cmdargs)))
if len(expanded_cmdargs) < mincount:
raise PipelineParseException(_("Command %s requires %d args, %d given") % (b.name,
mincount,
len(expanded_cmdargs)))
cmdtokens = [builtin_token]
cmdtokens.extend(cmdargs)
cmd = Command(b, expanded_cmdargs, options, context, tokens=alltokens, in_redir=in_redir, out_redir=out_redir)
components.append(cmd)
if (not in_redir) and prev:
cmd.set_input(prev.output)
if pipeline_output_type:
cmd.set_input_type(pipeline_output_type)
input_accepts_type = cmd.builtin.input_type
input_optional = cmd.builtin.input_is_optional
if pipeline_input_optional == 'unknown':
pipeline_input_optional = input_optional
_logger.debug("Validating input %s vs prev %s", input_accepts_type, pipeline_output_type)
if prev and not pipeline_output_type:
raise PipelineParseException(_("Command %s yields no output for pipe") % \
(prev.builtin.name))
if (not prev) and input_accepts_type and not (input_optional):
raise PipelineParseException(_("Command %s requires input of type %s") % \
(cmd.builtin.name, input_accepts_type))
if input_accepts_type and prev \
and not Pipeline.streamtype_is_assignable(pipeline_output_type, input_accepts_type, input_optional):
raise PipelineParseException(_("Command %s yields '%s' but %s accepts '%s'") % \
(prev.builtin.name, pipeline_output_type, cmd.builtin.name, input_accepts_type))
if (not input_optional) and (not input_accepts_type) and pipeline_output_type:
raise PipelineParseException(_("Command %s takes no input but type '%s' given") % \
(cmd.builtin.name, pipeline_output_type))
locality = cmd.builtin.locality
if prev_locality and locality and (locality != prev_locality):
raise PipelineParseException(_("Command %s locality conflict with '%s'") % \
(cmd.builtin.name, prev.builtin.name))
prev_locality = locality
if out_redir:
prev = None
else:
prev = cmd
if pipeline_input_type == 'unknown':
pipeline_input_type = input_accepts_type
if pipeline_singlevalue is None or (pipeline_singlevalue):
pipeline_singlevalue = cmd.builtin.singlevalue
if cmd.builtin.output_type != 'identity':
if context and cmd.builtin.output_typefunc:
pipeline_output_type = cmd.builtin.output_typefunc(context)
_logger.debug("retrieved type %r from typefunc", pipeline_output_type)
else:
pipeline_output_type = cmd.builtin.output_type
if undoable is None:
undoable = cmd.builtin.undoable
elif not cmd.builtin.undoable:
undoable = False
if not cmd.builtin.idempotent:
idempotent = False
if len(components) == 0:
raise PipelineParseException(_("Empty pipeline"))
if undoable is None:
undoable = False
pipeline = Pipeline(components,
input_type=pipeline_input_type,
input_optional=pipeline_input_optional,
output_type=pipeline_output_type,
locality=prev_locality,
undoable=undoable,
idempotent=idempotent,
singlevalue=pipeline_singlevalue)
_logger.debug("Parsed pipeline %s (%d components, input %s, output %s)",
pipeline, len(components),
pipeline.get_input_type(),
pipeline.get_output_type())
return pipeline
if name.startswith('_'):
continue
name_repr[name] = str(type(member))
return self.encode(name_repr)
class JsonBuiltin(Builtin):
__doc__ = _("""Convert object stream to JSON.""")
def __init__(self):
super(JsonBuiltin, self).__init__(
'json',
output=str, # 'any'
input=InputStreamSchema('any'),
idempotent=True,
argspec=None)
def execute(self, context, args, options=[]):
out = StringIO()
for o in context.input:
simplejson.dump(o, out, indent=2, cls=LossyObjectJSONDumper)
# Should support binary streaming
for line in StringIO(out.getvalue()):
if line.endswith('\n'):
yield line[0:-1]
else:
yield line
BuiltinRegistry.getInstance().register_hotwire(JsonBuiltin())
class PathBuiltin(Builtin):
__doc__ = _("""Display or modify the external program execution path.""")
def __init__(self):
super(PathBuiltin, self).__init__('path',
output=str,
argspec=(ArgSpec('path', opt=True),),
options=[['-a', '--prefix'], ['-s', '--suffix'], ['-d', '--del']],
threaded=False)
def execute(self, context, args, options=[]):
curval = os.environ['PATH']
if len(args) == 0:
return curval
if len(options) > 1:
raise ValueError(_("At most one option can be specified"))
arg = args[0]
elts = curval.split(os.pathsep)
if '-d' in options:
if arg not in elts:
raise ValueError(_("Not in path: %s") % (arg,))
elts.remove(arg)
elif '-a' in options:
elts.insert(0, arg)
elif '-s' in options:
elts.append(arg)
else:
assert False
os.environ['PATH'] = os.pathsep.join(elts)
return os.environ['PATH']
BuiltinRegistry.getInstance().register_hotwire(PathBuiltin())
from hotwire.builtin import Builtin, BuiltinRegistry, MultiArgSpec
from hotwire.externals.singletonmixin import Singleton
from hotwire.sysdep.fs import Filesystem
class HotSudoBuiltin(Builtin):
__doc__ = _("""Run a command as root.""")
def __init__(self):
super(HotSudoBuiltin, self).__init__('sudo',
nodisplay=True,
argspec=MultiArgSpec('args'),
options_passthrough=True)
def execute(self, context, args, options=[]):
subproc_args = {}
if context.gtk_event_time:
env = dict(os.environ)
env['DESKTOP_STARTUP_ID'] = 'hotwire%d_TIME%d' % (
os.getpid(),
context.gtk_event_time,
)
subproc_args['env'] = env
argv = ['hotwire-sudo']
argv.extend(args)
subprocess.Popen(argv, cwd=context.cwd, **subproc_args)
return []
BuiltinRegistry.getInstance().register_hotwire(HotSudoBuiltin())
super(LossyObjectJSONDumper, self).__init__(*args, **kwargs)
def default(self, o):
name_repr = {}
for name,member in sorted(inspect.getmembers(o), lambda a,b: locale.strcoll(a[0],b[0])):
if name.startswith('_'):
continue
name_repr[name] = str(type(member))
return self.encode(name_repr)
class JsonBuiltin(Builtin):
__doc__ = _("""Convert object stream to JSON.""")
def __init__(self):
super(JsonBuiltin, self).__init__('json',
output=str, # 'any'
input=InputStreamSchema('any'),
idempotent=True,
argspec=None)
def execute(self, context, args, options=[]):
out = StringIO()
for o in context.input:
simplejson.dump(o, out, indent=2, cls=LossyObjectJSONDumper)
# Should support binary streaming
for line in StringIO(out.getvalue()):
if line.endswith('\n'):
yield line[0:-1]
else:
yield line
BuiltinRegistry.getInstance().register_hotwire(JsonBuiltin())
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
from hotwire.builtin import Builtin, BuiltinRegistry, MultiArgSpec
class TermBuiltin(Builtin):
__doc__ = _("""Execute a system command in a new terminal.""")
def __init__(self):
super(TermBuiltin, self).__init__('term',
nodisplay=True,
argspec=MultiArgSpec('args'),
options_passthrough=True,
threaded=False)
def execute(self, context, args):
if len(args) > 0 and args[0] == '-e':
autoclose = True
args = args[1:]
else:
autoclose = False
context.hotwire.open_term(context.cwd, context.pipeline, args, window=True, autoclose=autoclose)
return []
BuiltinRegistry.getInstance().register_hotwire(TermBuiltin())
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import re
from hotwire.builtin import Builtin, BuiltinRegistry, InputStreamSchema
class NewlineBuiltin(Builtin):
__doc__ = _("""Convert output to a string, and add a newline if necessary.""")
def __init__(self):
super(NewlineBuiltin, self).__init__('newline',
input=InputStreamSchema('any'),
output=str,
argspec=None)
def execute(self, context, args, options=[]):
for arg in context.input:
if not isinstance(arg, str):
arg = str(arg)
if not arg.endswith('\n'):
arg += '\n'
yield arg
BuiltinRegistry.getInstance().register_hotwire(NewlineBuiltin())
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import re
from hotwire.builtin import Builtin, BuiltinRegistry, InputStreamSchema
class StringifyBuiltin(Builtin):
__doc__ = _("""Convert output to a string.""")
def __init__(self):
super(StringifyBuiltin, self).__init__('stringify',
input=InputStreamSchema('any'),
output=str,
argspec=None)
def execute(self, context, args, options=[]):
if len(args) != 0:
raise ValueError(_("Too many arguments specified"))
for arg in context.input:
if not isinstance(arg, basestring):
yield str(arg)
else:
yield arg
BuiltinRegistry.getInstance().register_hotwire(StringifyBuiltin())
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
# of the Software, and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
from hotwire.builtin import Builtin, BuiltinRegistry, OutputStreamSchema
class HistoryBuiltin(Builtin):
def __init__(self):
super(HistoryBuiltin, self).__init__('history', output=str)
def execute(self, context, args):
return context.hotwire.get_history()
BuiltinRegistry.getInstance().register_hotwire(HistoryBuiltin())
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import re
from hotwire.builtin import Builtin, BuiltinRegistry, InputStreamSchema
class NewlineBuiltin(Builtin):
__doc__ = _(
"""Convert output to a string, and add a newline if necessary.""")
def __init__(self):
super(NewlineBuiltin, self).__init__('newline',
input=InputStreamSchema('any'),
output=str,
argspec=None)
def execute(self, context, args, options=[]):
for arg in context.input:
if not isinstance(arg, str):
arg = str(arg)
if not arg.endswith('\n'):
arg += '\n'
yield arg
BuiltinRegistry.getInstance().register_hotwire(NewlineBuiltin())
class HttpGetBuiltin(Builtin):
__doc__ = _("""Perform a HTTP GET.""")
def __init__(self):
super(HttpGetBuiltin,
self).__init__('http-get',
output=HTTPResponse,
input=None,
singlevalue=True,
argspec=(ArgSpec('host'), ArgSpec('path',
opt=True)))
def execute(self, context, args, options=[]):
if len(args) == 1:
host = args[0]
path = '/'
elif len(args) == 2:
host = args[0]
path = args[1]
else:
assert False
conn = httplib.HTTPConnection(host)
conn.request('GET', path)
response = conn.getresponse()
return response
BuiltinRegistry.getInstance().register_hotwire(HttpGetBuiltin())
super(WriteBuiltin, self).__init__('write',
input=InputStreamSchema('any', optional=False),
argspec=MultiArgSpec('paths', min=1),
options=[['-a', '--append'],['-p', '--pickle'],
['-n', '--newline']])
def execute(self, context, args, options=[]):
open_mode = ('-a' in options) and 'a+' or 'w'
do_pickle = '-p' in options
with_newline = '-n' in options
if do_pickle:
open_mode = 'wb'
if not context.input:
return
streams = map(lambda x: open_text_file(FilePath(x, context.cwd), open_mode), args)
if not do_pickle:
for arg in context.input:
for stream in streams:
stream.write('%s' % (unicode(arg),))
if with_newline:
stream.write('\n')
else:
# Kind of annoying pickle makes you do this.
arglist = list(context.input)
for stream in streams:
pickle.dump(arglist, stream)
map(lambda x: x.close(), streams)
return []
BuiltinRegistry.getInstance().register_hotwire(WriteBuiltin())
from http.client import HTTPResponse
from io import StringIO
from hotwire.fs import FilePath
from hotwire.builtin import Builtin, BuiltinRegistry, InputStreamSchema, ArgSpec
class HttpGetBuiltin(Builtin):
__doc__ = _("""Perform a HTTP GET.""")
def __init__(self):
super(HttpGetBuiltin, self).__init__('http-get',
output=HTTPResponse,
input=None,
singlevalue=True,
argspec=(ArgSpec('host'), ArgSpec('path', opt=True)))
def execute(self, context, args, options=[]):
if len(args) == 1:
host = args[0]
path = '/'
elif len(args) == 2:
host = args[0]
path = args[1]
else:
assert False
conn = http.client.HTTPConnection(host)
conn.request('GET', path)
response = conn.getresponse()
return response
BuiltinRegistry.getInstance().register_hotwire(HttpGetBuiltin())
def execute(self, context, args):
builtins = BuiltinRegistry.getInstance()
yield HelpItem([builtins[x] for x in args])
import hotwire.fs
from hotwire.fs import FilePath
from hotwire.builtin import Builtin, BuiltinRegistry, MultiArgSpec
from hotwire.builtins.fileop import FileOpBuiltin
class MkdirBuiltin(FileOpBuiltin):
__doc__ = _("""Create directories.""")
def __init__(self):
super(MkdirBuiltin, self).__init__('mkdir',
hasstatus=True,
argspec=MultiArgSpec('paths',
min=1))
def execute(self, context, args):
sources_total = len(args)
for i, arg in enumerate(args):
arg_path = FilePath(arg, context.cwd)
try:
os.makedirs(arg_path)
except OSError, e:
pass
self._status_notify(context, sources_total, i + 1)
return []
BuiltinRegistry.getInstance().register_hotwire(MkdirBuiltin())
class SelectionBuiltin(Builtin):
__doc__ = _("""With no arguments, returns currently selected objects.
Single integer argument selects object at that index.""")
def __init__(self):
super(SelectionBuiltin, self).__init__('selection',
aliases=['sel'],
argspec=(ArgSpec('index', opt=True),),
threaded=False,
output=OutputStreamSchema('any',
typefunc=lambda hotwire: hotwire.get_current_output_type()))
def execute(self, context, args):
current = context.hotwire.snapshot_current_selected_output()
if len(args) == 0:
if current is None:
return
for obj in current.value:
yield obj
elif len(args) == 1:
idx = int(args[0])
for i,obj in enumerate(current.value):
if i == idx:
yield obj
return
raise ValueError(_("Index %d out of range") % (idx,))
elif len(args) > 2:
raise ValueError(_("Too many arguments specified"))
BuiltinRegistry.getInstance().register_hotwire(SelectionBuiltin())
def execute(self, context, args):
signum = signal.SIGTERM
sigidx = -1
for i,arg in enumerate(args):
if not arg.startswith('-'):
continue
optval = arg[1:]
if optval in _sigsym_to_value:
signum = _sigsym_to_value[optval]
sigidx = i
break
else:
optnum = int(optval)
if optnum in _sigvalue_to_sym:
signum = optnum
sigidx = i
break
else:
raise ValueError("Invalid signal number: %d", optnum)
if sigidx >= 0:
del args[sigidx]
for arg in map(int, args):
os.kill(arg, signum)
if context.input is not None:
for arg in context.input:
os.kill(arg.pid, signum)
return []
BuiltinRegistry.getInstance().register_hotwire(KillBuiltin())
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import re
from hotwire.builtin import Builtin, BuiltinRegistry, InputStreamSchema
class StringifyBuiltin(Builtin):
__doc__ = _("""Convert output to a string.""")
def __init__(self):
super(StringifyBuiltin, self).__init__('stringify',
input=InputStreamSchema('any'),
output=str,
argspec=None)
def execute(self, context, args, options=[]):
if len(args) != 0:
raise ValueError(_("Too many arguments specified"))
for arg in context.input:
if not isinstance(arg, str):
yield str(arg)
else:
yield arg
BuiltinRegistry.getInstance().register_hotwire(StringifyBuiltin())
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import os, sys, re
from hotwire.builtin import Builtin, BuiltinRegistry, InputStreamSchema, ArgSpec
class ReplaceBuiltin(Builtin):
__doc__ = _(
"""Replace input objects by regular expression, matching on a property (or repr)"""
)
def __init__(self):
super(ReplaceBuiltin, self).__init__('replace',
input=InputStreamSchema('any'),
output='identity',
argspec=(ArgSpec('regexp'),
ArgSpec('replacement')))
def execute(self, context, args, options=[]):
regexp = args[0]
replacement = args[1]
stringify = '-s' in options
compiled_re = re.compile(
regexp, (('-i' in options) and re.IGNORECASE or 0) | re.UNICODE)
for arg in context.input:
yield compiled_re.sub(regexp, replacement, arg)
BuiltinRegistry.getInstance().register_hotwire(ReplaceBuiltin())
prop = args[1]
else:
prop = None
regexp = args[0]
target_prop = prop
invert = '-v' in options
stringify = '-s' in options
compiled_re = re.compile(regexp, (('-i' in options) and re.IGNORECASE or 0) | re.UNICODE)
for arg in context.input:
if target_prop is not None:
target_propvalue = getattr(arg, target_prop)
else:
target_propvalue = arg
if not isinstance(target_propvalue, str):
if not stringify:
raise ValueError(_("Value not a string: %r" % (target_propvalue,)))
else:
target_propvalue = repr(target_propvalue)
elif not isinstance(target_propvalue, str):
target_propvalue = str(target_propvalue, 'utf-8')
match = compiled_re.search(target_propvalue)
if invert:
match = not match
if match:
if isinstance(arg, str):
yield StringMatch(target_propvalue, match)
else:
yield arg
BuiltinRegistry.getInstance().register_hotwire(FilterBuiltin())
def execute(self, context, args, options=[]):
if len(args) == 1:
target_prop = args[0]
else:
target_prop = None
count_obj = '-c' in options
order_unique_items = []
unique_items = {}
for arg in context.input:
if target_prop is not None:
value = getattr(arg, target_prop)
else:
value = arg
if value in unique_items:
if count_obj:
unique_items[value] += 1
continue
unique_items[value] = 1
if count_obj:
# keep order while counting
order_unique_items.append(value)
else:
yield value
if count_obj:
for item in order_unique_items:
yield (unique_items[item], item)
BuiltinRegistry.getInstance().register_hotwire(UniqBuiltin())
def create(context, resolver, *tokens, **kwargs):
if context is None:
context = HotwireContext()
accept_partial = (('accept_partial' in kwargs)
and kwargs['accept_partial'])
components = []
undoable = None
idempotent = True
prev = None
pipeline_input_type = 'unknown'
pipeline_input_optional = 'unknown'
pipeline_output_type = None
prev_locality = None
pipeline_singlevalue = None
pipeline_type_validates = True
pushback = []
tokens = list(tokens)
def pull_token():
if pushback:
return pushback.pop(0)
else:
return tokens.pop(0)
while tokens or pushback:
builtin_token = pull_token()
_logger.debug("token = %r", builtin_token)
def forcetoken(t):
# Allow passing plain strings for convenience from Python.
# Treat them as quoted.
if isinstance(t, str):
return ParsedToken(t, -1, quoted=True)
return t
builtin_token = forcetoken(builtin_token)
# Attempt to determine which builtin we're using
if isinstance(builtin_token, Builtin):
b = builtin_token
cmdargs = []
# If we're parsing without a resolver, assume we're using sys
elif isinstance(builtin_token, ParsedToken):
try:
b = BuiltinRegistry.getInstance()[builtin_token.text]
cmdargs = []
except KeyError as e:
if resolver:
(b,
cmdargs) = resolver.resolve(builtin_token.text,
context)
_logger.debug("resolved: %r to %r %r",
builtin_token.text, b, cmdargs)
if not b:
raise PipelineParseException(
_('No matches for %s') %
(builtin_token.text, ))
else:
b = BuiltinRegistry.getInstance()['sys']
cmdargs = [
ParsedToken(builtin_token.text,
builtin_token.start,
end=builtin_token.end)
]
elif builtin_token in (hotwire.script.PIPE,
hotwire.script.REDIR_IN,
hotwire.script.REDIR_OUT,
hotwire.script.REDIR_OUT_APPEND):
raise PipelineParseException(
_("Unexpected token %d") % (builtin_token, ))
else:
_logger.error("unknown in parse stream: %r", builtin_token)
assert False
_logger.debug("target builtin is %r", b)
# We maintain the set of all tokens we processed in the command so that the completion system can use them.
alltokens = [builtin_token]
cmdargs = list(map(forcetoken, cmdargs))
alltokens.extend(cmdargs)
in_redir = None
out_redir = None
# Pull from the stream to get all the arguments
while tokens:
cmdarg = forcetoken(pull_token())
if cmdarg == hotwire.script.PIPE:
break
elif cmdarg == hotwire.script.REDIR_IN:
if not tokens:
raise PipelineParseException(
_('Must specify target for input redirection'))
in_redir_token = pull_token()
in_redir = in_redir_token.text
alltokens.append(in_redir_token)
elif cmdarg == hotwire.script.REDIR_OUT:
if not tokens:
raise PipelineParseException(
_('Must specify target for output redirection'))
out_redir_token = pull_token()
out_redir = out_redir_token.text
alltokens.append(out_redir_token)
else:
alltokens.append(cmdarg)
cmdargs.append(cmdarg)
builtin_opts = b.options
options = []
expanded_cmdargs = []
options_ended = False
raise_on_invalid_options = not (b.options_passthrough
or accept_partial)
_logger.debug(
"raise: %r valid options %r, argument/option pool: %r",
raise_on_invalid_options, builtin_opts, cmdargs)
for token in cmdargs:
arg = CommandArgument(token.text, quoted=token.quoted)
if token.text == '--':
options_ended = True
elif options_ended:
expanded_cmdargs.append(arg)
else:
argopts = Pipeline.__parse_option_or_arg(
builtin_opts,
token.text,
raise_on_invalid=raise_on_invalid_options)
if argopts:
options.extend(argopts)
else:
expanded_cmdargs.append(arg)
argspec = b.argspec
if argspec is False or accept_partial:
# If we don't have an argspec, don't do any checking
pass
elif argspec is None:
if len(expanded_cmdargs) > 0:
raise PipelineParseException(
_('Command %s takes no arguments, %d given') %
(b.name, len(expanded_cmdargs)))
elif isinstance(argspec, MultiArgSpec):
if len(expanded_cmdargs) < argspec.min:
raise PipelineParseException(
_("Command %s requires %d args, %d given") %
(b.name, argspec.min, len(expanded_cmdargs)))
elif isinstance(argspec, tuple):
mincount = 0
for o in argspec:
if not o.opt:
mincount += 1
if len(expanded_cmdargs) > len(argspec):
raise PipelineParseException(
_("Command %s takes at most %d args, %d given") %
(b.name, len(argspec), len(expanded_cmdargs)))
if len(expanded_cmdargs) < mincount:
raise PipelineParseException(
_("Command %s requires %d args, %d given") %
(b.name, mincount, len(expanded_cmdargs)))
cmdtokens = [builtin_token]
cmdtokens.extend(cmdargs)
cmd = Command(b,
expanded_cmdargs,
options,
context,
tokens=alltokens,
in_redir=in_redir,
out_redir=out_redir)
components.append(cmd)
if (not in_redir) and prev:
cmd.set_input(prev.output)
if pipeline_output_type:
cmd.set_input_type(pipeline_output_type)
input_accepts_type = cmd.builtin.input_type
input_optional = cmd.builtin.input_is_optional
if pipeline_input_optional == 'unknown':
pipeline_input_optional = input_optional
_logger.debug("Validating input %s vs prev %s", input_accepts_type,
pipeline_output_type)
if prev and not pipeline_output_type:
raise PipelineParseException(_("Command %s yields no output for pipe") % \
(prev.builtin.name))
if (not prev) and input_accepts_type and not (input_optional):
raise PipelineParseException(_("Command %s requires input of type %s") % \
(cmd.builtin.name, input_accepts_type))
if input_accepts_type and prev \
and not Pipeline.streamtype_is_assignable(pipeline_output_type, input_accepts_type, input_optional):
raise PipelineParseException(_("Command %s yields '%s' but %s accepts '%s'") % \
(prev.builtin.name, pipeline_output_type, cmd.builtin.name, input_accepts_type))
if (not input_optional) and (
not input_accepts_type) and pipeline_output_type:
raise PipelineParseException(_("Command %s takes no input but type '%s' given") % \
(cmd.builtin.name, pipeline_output_type))
locality = cmd.builtin.locality
if prev_locality and locality and (locality != prev_locality):
raise PipelineParseException(_("Command %s locality conflict with '%s'") % \
(cmd.builtin.name, prev.builtin.name))
prev_locality = locality
if out_redir:
prev = None
else:
prev = cmd
if pipeline_input_type == 'unknown':
pipeline_input_type = input_accepts_type
if pipeline_singlevalue is None or (pipeline_singlevalue):
pipeline_singlevalue = cmd.builtin.singlevalue
if cmd.builtin.output_type != 'identity':
if context and cmd.builtin.output_typefunc:
pipeline_output_type = cmd.builtin.output_typefunc(context)
_logger.debug("retrieved type %r from typefunc",
pipeline_output_type)
else:
pipeline_output_type = cmd.builtin.output_type
if undoable is None:
undoable = cmd.builtin.undoable
elif not cmd.builtin.undoable:
undoable = False
if not cmd.builtin.idempotent:
idempotent = False
if len(components) == 0:
raise PipelineParseException(_("Empty pipeline"))
if undoable is None:
undoable = False
pipeline = Pipeline(components,
input_type=pipeline_input_type,
input_optional=pipeline_input_optional,
output_type=pipeline_output_type,
locality=prev_locality,
undoable=undoable,
idempotent=idempotent,
singlevalue=pipeline_singlevalue)
_logger.debug(
"Parsed pipeline %s (%d components, input %s, output %s)",
pipeline, len(components), pipeline.get_input_type(),
pipeline.get_output_type())
return pipeline
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import os,sys,re,os.path, stat,subprocess
from hotwire.builtin import Builtin, BuiltinRegistry, MultiArgSpec
from hotwire.fs import FilePath
from hotwire.sysdep.fs import Filesystem
class ViewBuiltin(Builtin):
__doc__ = _("""Launch the text viewer.""")
def __init__(self):
super(ViewBuiltin, self).__init__('view',
nodisplay=True,
argspec=MultiArgSpec('paths', min=1),
idempotent=True,
threaded=False)
def execute(self, context, args):
from hotwire_ui.adaptors.editors import EditorRegistry
prefeditor = EditorRegistry.getInstance().get_preferred()
prefeditor.run_many_readonly(context.cwd, *args)
return []
BuiltinRegistry.getInstance().register_hotwire(ViewBuiltin())
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
from hotwire.builtin import Builtin, BuiltinRegistry, ArgSpec
from hotwire.completion import BuiltinCompleter
class HelpItem(object):
def __init__(self, items):
self.items = items
class HelpBuiltin(Builtin):
__doc__ = _("""Display help.""")
def __init__(self):
super(HelpBuiltin, self).__init__('help',
output=HelpItem,
argspec=(ArgSpec('builtin', opt=True),))
def get_completer(self, context, args, i):
return BuiltinCompleter()
def execute(self, context, args):
yield HelpItem(args)
BuiltinRegistry.getInstance().register_hotwire(HelpBuiltin())
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import os,sys,re
from hotwire.builtin import Builtin, BuiltinRegistry, InputStreamSchema, ArgSpec
class ReplaceBuiltin(Builtin):
__doc__ = _("""Replace input objects by regular expression, matching on a property (or repr)""")
def __init__(self):
super(ReplaceBuiltin, self).__init__('replace',
input=InputStreamSchema('any'),
output='identity',
argspec=(ArgSpec('regexp'), ArgSpec('replacement')))
def execute(self, context, args, options=[]):
regexp = args[0]
replacement = args[1]
stringify = '-s' in options
compiled_re = re.compile(regexp, (('-i' in options) and re.IGNORECASE or 0) | re.UNICODE)
for arg in context.input:
yield compiled_re.sub(regexp,replacement,arg)
BuiltinRegistry.getInstance().register_hotwire(ReplaceBuiltin())
def execute(self, context, args, options=[]):
if len(args) == 1:
target_prop = args[0]
else:
target_prop = None
count_obj = '-c' in options
order_unique_items = []
unique_items = {}
for arg in context.input:
if target_prop is not None:
value = getattr(arg, target_prop)
else:
value = arg
if value in unique_items:
if count_obj:
unique_items[value] += 1
continue
unique_items[value] = 1
if count_obj:
# keep order while counting
order_unique_items.append(value)
else:
yield value
if count_obj:
for item in order_unique_items:
yield (unique_items[item], item)
BuiltinRegistry.getInstance().register_hotwire(UniqBuiltin())
def _expand_verb_completion(self, completion):
target = completion.target
if isinstance(target, File):
return (BuiltinRegistry.getInstance()['sys'], [target.path])
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import os, sys, re, os.path, stat, subprocess
from hotwire.builtin import Builtin, BuiltinRegistry, MultiArgSpec
from hotwire.fs import FilePath
from hotwire.sysdep.fs import Filesystem
class EditBuiltin(Builtin):
__doc__ = _("""Launch the text editor.""")
_ws_re = re.compile(r'\s+')
def __init__(self):
super(EditBuiltin, self).__init__('edit',
aliases=['ed'],
argspec=MultiArgSpec('paths', min=1),
nodisplay=True,
idempotent=True,
threaded=False)
def execute(self, context, args):
from hotwire_ui.adaptors.editors import EditorRegistry
prefeditor = EditorRegistry.getInstance().get_preferred()
prefeditor.run_many(context.cwd, *args)
return []
BuiltinRegistry.getInstance().register_hotwire(EditBuiltin())
# THE USE OR OTHER DEALINGS IN THE SOFTWARE.
import os, sys, subprocess
from hotwire.builtin import Builtin, BuiltinRegistry, MultiArgSpec
from hotwire.externals.singletonmixin import Singleton
from hotwire.sysdep.fs import Filesystem
class HotSudoBuiltin(Builtin):
__doc__ = _("""Run a command as root.""")
def __init__(self):
super(HotSudoBuiltin, self).__init__(
"sudo", nodisplay=True, argspec=MultiArgSpec("args"), options_passthrough=True
)
def execute(self, context, args, options=[]):
subproc_args = {}
if context.gtk_event_time:
env = dict(os.environ)
env["DESKTOP_STARTUP_ID"] = "hotwire%d_TIME%d" % (os.getpid(), context.gtk_event_time)
subproc_args["env"] = env
argv = ["hotwire-sudo"]
argv.extend(args)
subprocess.Popen(argv, cwd=context.cwd, **subproc_args)
return []
BuiltinRegistry.getInstance().register_hotwire(HotSudoBuiltin())
