def output_if(name, statement_type): execute_with_dictation( name, on_dictation=lambda v: Text("%s %s {" % (statement_type, format_variable_name(name))), on_other=lambda v: replace_in_text("%s $ {" % statement_type), )
def output_binding(value_name, is_pointer=False): pointer_suffix = ".*" if is_pointer else "" execute_with_dictation( value_name, lambda n: Text("%s%s = " % (format_value_name(n), pointer_suffix)), lambda n: replace_in_text("$%s = " % pointer_suffix))
def output_for_loop(name): execute_with_dictation( name, on_dictation=lambda v: replace_in_text("for $ in %s:" % format_name( name)), on_other=lambda v: replace_in_text("for $ in _:"), )
def output_for_loop(name, binding): binding_text = format_name(binding) if binding != "" else "$" execute_with_dictation( name, lambda n: replace_in_text("for %s <- %s do $ end" % (binding_text, format_name(n))), lambda n: replace_in_text("for %s <- $ do end"))
def output_if_comparison(value_name, construct, comparison=None): if comparison is not None: execute_with_dictation( value_name, lambda n: replace_in_text("%s (%s %s $) {}" % ( construct, format_value_name(n), comparison)), lambda n: replace_in_text("%s ($ %s _) {}" % (construct, comparison)))
def output_comparison(name, comparison=None): if comparison is not None: execute_with_dictation( name, on_dictation=lambda v: Text("%s %s " % (format_name(name), comparison)), on_other=lambda v: Text(" %s " % comparison))
def output_if_expression(name): execute_with_dictation( name, on_dictation=lambda v: replace_in_text("$ if %s else _" % format_name( name)), on_other=lambda v: replace_in_text("_ if $ else _"), )
def output_if_comparison(name, construct, comparison=None): if comparison is not None: execute_with_dictation( name, on_dictation=lambda v: replace_in_text("%s %s %s $ {" % ( construct, format_variable_name(v), comparison)), on_other=lambda v: replace_in_text("%s $ %s _ {" % (construct, comparison)))
def output_none_check(name, construct, is_not=False): comparison_output = "!= nil" if is_not else "== nil" execute_with_dictation( name, lambda n: Text("%s %s %s {\n" % ( construct, format_variable_name(n), comparison_output)), lambda n: replace_in_text("%s $ %s {" % (construct, comparison_output)))
def output_alias(module_name, alias_name): alias_suffix = ", as: %s" % format_module_name( alias_name) if alias_name != "" else "" execute_with_dictation( module_name, lambda n: Text("alias %s%s" % (format_module_name(n), alias_suffix)), lambda n: replace_in_text("alias $%s" % alias_suffix))
def output_if_expression_comparison(name, comparison=None): if comparison is not None: execute_with_dictation(name, on_dictation=lambda v: replace_in_text("_ if %s %s $ else _" % (format_name(v), comparison)), on_other=lambda v: replace_in_text( "_ if $ %s _ else _" % comparison))
def output_while_loop(value_name, binding_name=None): maybe_unpack = "|%s| " % format_value_name( binding_name) if binding_name is not None else "" execute_with_dictation( value_name, lambda n: Text("while (%s) %s{}" % (format_value_name(n), maybe_unpack)), lambda n: replace_in_text("while ($) %s {}" % maybe_unpack))
def output_type_annotation(value_name, type_name=None, is_constant=False): constant_prefix = "const " if is_constant else "" if type_name is not None: execute_with_dictation( value_name, lambda n: Text("%s%s %s" % (constant_prefix, type_name, format_value_name(n))), lambda n: replace_in_text("%s%s $" % (constant_prefix, type_name)))
def output_class(class_name, superclass): if superclass != "": superclass = "(" + format_class_name(superclass) + ")" execute_with_dictation( class_name, on_dictation=lambda v: Text("class %s%s:" % (format_class_name(v), superclass)), on_other=lambda v: replace_in_text("class $%s:" % superclass))
def execute_with_type_choice(name): def command_with_name(n): safe_expression = type_choice.get_safe_cast_expression(n) unsafe_expression = type_choice.get_cast_expression(n) return Text(safe_expression if is_safe else unsafe_expression) execute_with_dictation(name, lambda n: command_with_name(n), lambda n: command_with_name("$"))
def output_variable_declaration(name, type_name=None): if type_name is not None: execute_with_dictation( name, lambda n: Text("var %s %s" % (format_variable_name(n), type_name)), lambda n: replace_in_text("var $ %s" % type_name)) else: execute_with_dictation( name, lambda n: Text("var %s " % format_variable_name(n)), lambda n: replace_in_text("var $ _"))
def output_log_statement(name, log_level=None): if log_level is not None: execute_with_dictation( name, lambda n: Text("Logger.%s(\"XXXXXX: #{inspect(%s, pretty: true)}\")" % (log_level, format_name(n))), lambda n: replace_in_text( "Logger.%s(\"XXXXXX: #{inspect($, pretty: true)}\")" % log_level), )
def output_function(name, visibility_attribute=None, is_method=False): method_parameter_output = "_" if name == "" else "$" method_output = "(%s) " % method_parameter_output if is_method else "" parameter_output = "_" if name == "" or is_method else "$" execute_with_dictation( name, lambda n: replace_in_text("func %s%s(%s) _ {" % (method_output, format_name(n, visibility_attribute), parameter_output)), lambda n: replace_in_text("func %s$(_) _ {" % method_output))
def output_if_comparison(name, comparison=None, construct="if"): if comparison is not None: (comparison_text, comparison_command) = comparison execute_with_dictation( name, lambda n: comparison_command("%s (%s %s) {}" % ( construct, format_name(n), comparison_text)), lambda n: replace_in_text("%s ($ %s) {}" % (construct, comparison_text))) else: execute_with_dictation( name, lambda n: Text("%s (%s) {}" % (construct, format_name(n))), lambda n: replace_in_text("%s ($) {}" % construct))
def output_for_loop(value_name, binding_name=None): def output_with_value_name(name): if binding_name is not None: return Text("for (%s) |%s| {}" % (format_value_name(name), binding)) else: return replace_in_text("for (%s) |$| {}" % format_value_name(name)) binding = format_value_name( binding_name) if binding_name is not None else "_" execute_with_dictation( value_name, output_with_value_name, lambda n: replace_in_text("for ($) |%s| {}" % binding))
def output_function_call(function_name, name): def do_output(fn): with_function_name = with_dictation( name, lambda n: Text("%s(%s)" % (format_function_name(fn), format_name(n))), lambda n: replace_in_text("%s($)" % format_function_name(fn))) without_function_name = with_dictation( name, lambda n: replace_in_text("$(%s)" % format_name(n)), lambda n: replace_in_text("$(_)")) return without_function_name if fn == "$" else with_function_name execute_with_dictation(function_name, lambda n: do_output(n), lambda n: do_output("$"))
def output_function(function_name, visibility_attribute=None, asynchronous=False): attribute_output = "" if visibility_attribute is not None: attribute_output = "%s " % visibility_attribute asynchronous_output = "" if asynchronous: asynchronous_output = "async " execute_with_dictation( function_name, lambda n: replace_in_text("%s%sfunction %s($): _ {}" % ( attribute_output, asynchronous_output, format_function_name(n))), lambda n: replace_in_text("%s%sfunction $(_): _ {}" % (attribute_output, asynchronous_output)))
def output_function(function_name, type_name, visibility_attribute=None): attribute_string = visibility_attribute + " " if visibility_attribute is not None else "" def output_with_type_name(name): type_name_components = str(name).split(" ") type_name_output = format_type_name( name) if len(type_name_components) != 1 else name command_with_function_name = replace_in_text( "%sfn %s($) %s {}" % (attribute_string, format_function_name(function_name), type_name_output)) command_without_function_name = replace_in_text( "%sfn $(_) %s {}" % (attribute_string, type_name_output)) return with_dictation(function_name, lambda n: command_with_function_name, lambda n: command_without_function_name) execute_with_dictation(type_name, output_with_type_name, lambda n: output_with_type_name("_"))
def output_size_of(type_name): execute_with_dictation(type_name, lambda n: Text("@sizeOf(%s)" % format_type_name(n)), lambda n: replace_in_text("@sizeOf($)"))
def output_type_definition(type_name, definition_type): execute_with_dictation( type_name, lambda n: replace_in_text("const %s = %s {$};" % (proper(str(n)), definition_type)), lambda n: Text("%s {}" % definition_type))
def output_import(value_name): execute_with_dictation( value_name, lambda v: replace_in_text("const %s = import(\"$\");" % format_value_name(v)), lambda v: replace_in_text("const $ = import(\"_\");"))
def output_return(value_name): execute_with_dictation(value_name, lambda n: Text("return %s;" % format_value_name(n)), lambda n: replace_in_text("return $;"))
def output_test(test_name): execute_with_dictation(test_name, lambda v: Text("test \"%s\" {\n" % v), lambda v: replace_in_text("test \"$\" {}"))
def output_comparison(value_name, comparison=None): if comparison is not None: execute_with_dictation( value_name, lambda n: Text("%s %s " % (format_value_name(n), comparison)), lambda n: replace_in_text("$ %s _" % comparison))
def execute_without_type_choice(name): execute_with_dictation( name, lambda n: replace_in_text("@as($, %s)" % format_value_name(n)), lambda n: replace_in_text("@as($, _)"))