Thank you! about bashlex

[idank]

Hey, that's awesome, glad you found a use for it. :)

I don't think anyone has, but it sounds pretty doable. As far as getting it to look like a real shell like bash, that'd be a different story I think. It does beg the question why you can't just pass it through the shell.

[joerick]

I don't think anyone has, but it sounds pretty doable.

Agreed! I'm taking a crack at it today :)

It does beg the question why you can't just pass it through the shell.

Long story short, Windows compatibility.

I'll let you know if I get anywhere.

[joerick]

Here's what I did, for reference.

It evaluates values like "variable: $USERNAME, computed $(pwd)", as used in environment variable declarations VAR=somevalue. Pretty simple. The only thing that was tricky (and might not be 100% correct) is the 'bash-like quotes/whitespace treatment' at the end of evaluate_word_node, but it's been pretty accurate in my testing.

bashlex_eval.py

import subprocess, shlex
from collections import namedtuple
import bashlex

NodeExecutionContext = namedtuple('NodeExecutionContext', ['environment', 'input'])

def evaluate(value, environment):
    if not value:
        # empty string evaluates to empty string
        # (but trips up bashlex)
        return ''

    command_node = bashlex.parsesingle(value)

    if len(command_node.parts) != 1:
        raise ValueError('"%s" has too many parts' % value)

    value_word_node = command_node.parts[0]
    
    return evaluate_node(
        value_word_node, 
        context=NodeExecutionContext(environment=environment, input=value)
    )


def evaluate_node(node, context):
    if node.kind == 'word':
        return evaluate_word_node(node, context=context)
    elif node.kind == 'commandsubstitution':
        return evaluate_command_node(node.command, context=context)
    elif node.kind == 'parameter':
        return evaluate_parameter_node(node, context=context)
    else:
        raise ValueError('Unsupported bash construct: "%s"' % node.word)


def evaluate_word_node(node, context):
    word_start = node.pos[0]
    word_end = node.pos[1]
    word_string = context.input[word_start:word_end]
    letters = list(word_string)

    for part in node.parts:
        part_start = part.pos[0] - word_start
        part_end = part.pos[1] - word_start

        # Set all the characters in the part to None
        for i in range(part_start, part_end):
            letters[i] = None

        letters[part_start] = evaluate_node(part, context=context)

    # remove the None letters and concat
    value = ''.join(l for l in letters if l is not None)

    # apply bash-like quotes/whitespace treatment
    return ' '.join(word.strip() for word in shlex.split(value))


def evaluate_command_node(node, context):
    words = [evaluate_node(part, context=context) for part in node.parts]
    command = ' '.join(words)
    return subprocess.check_output(shlex.split(command), env=context.environment)


def evaluate_parameter_node(node, context):
    return context.environment.get(node.value, '')

[idank]

Nice, glad you got something working. You could also use a nodevisitor to traverse the parsed statement.