Skip to content

Commit e9dfc1b

Browse files
braincorebraincore
committed
More backwards-incompat refactoring.
- stone.lang -> stone.target - stone.stone -> stone.lang - Removed CodeGeneratorMonolingual - Reworked language helpers to just be modules with top-level functions.
1 parent 5865548 commit e9dfc1b

File tree

24 files changed

+341
-412
lines changed

24 files changed

+341
-412
lines changed

‎doc/generator_ref.rst‎

Lines changed: 9 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -686,13 +686,15 @@ Example 3: Define Python Classes for Structs
686686
--------------------------------------------
687687

688688
As a more advanced example, we'll define a generator that makes a Python class
689-
for each struct in our specification. We'll extend from
690-
``MonolingualCodeGenerator``, which enforces that a ``lang`` class variable is
691-
declared::
689+
for each struct in our specification. We'll use some provided helpers from
690+
``stone.target.python``::
692691

693692
from stone.data_type import is_struct_type
694693
from stone.generator import CodeGeneratorMonolingual
695-
from stone.lang.python import PythonTargetLanguage
694+
from stone.target.python import (
695+
fmt_class,
696+
fmt_var,
697+
)
696698

697699
class ExamplePythonGenerator(CodeGeneratorMonolingual):
698700

@@ -716,7 +718,7 @@ declared::
716718
continue
717719

718720
# Define a class for each struct
719-
class_def = 'class {}(object):'.format(self.lang.format_class(data_type.name))
721+
class_def = 'class {}(object):'.format(fmt_class(data_type.name))
720722
self.emit(class_def)
721723

722724
with self.indent():
@@ -730,7 +732,7 @@ declared::
730732
# Define constructor to take each field
731733
args = ['self']
732734
for field in data_type.fields:
733-
args.append(self.lang.format_variable(field.name))
735+
args.append(fmt_var(field.name))
734736
self.generate_multiline_list(args, 'def __init__', ':')
735737

736738
with self.indent():
@@ -740,7 +742,7 @@ declared::
740742
for field in data_type.fields:
741743
if field.doc:
742744
self.emit_wrapped_text(field.doc, '# ', '# ')
743-
member_name = self.lang.format_variable(field.name)
745+
member_name = fmt_var(field.name)
744746
self.emit('self.{0} = {0}'.format(member_name))
745747
else:
746748
self.emit('pass')

‎example/generator/ex3/ex3.stoneg.py‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,9 @@
11
from stone.data_type import is_struct_type
22
from stone.generator import CodeGeneratorMonolingual
3-
from stone.lang.python import PythonTargetLanguage
3+
from stone.target.python import (
4+
fmt_class,
5+
fmt_var,
6+
)
47

58
class ExamplePythonGenerator(CodeGeneratorMonolingual):
69

@@ -24,7 +27,7 @@ def _generate_namespace_module(self, namespace):
2427
continue
2528

2629
# Define a class for each struct
27-
class_def = 'class {}(object):'.format(self.lang.format_class(data_type.name))
30+
class_def = 'class {}(object):'.format(fmt_class(data_type.name))
2831
self.emit(class_def)
2932

3033
with self.indent():
@@ -38,7 +41,7 @@ def _generate_namespace_module(self, namespace):
3841
# Define constructor to take each field
3942
args = ['self']
4043
for field in data_type.fields:
41-
args.append(self.lang.format_variable(field.name))
44+
args.append(fmt_var(field.name))
4245
self.generate_multiline_list(args, 'def __init__', ':')
4346

4447
with self.indent():
@@ -48,7 +51,7 @@ def _generate_namespace_module(self, namespace):
4851
for field in data_type.fields:
4952
if field.doc:
5053
self.emit_wrapped_text(field.doc, '# ', '# ')
51-
member_name = self.lang.format_variable(field.name)
54+
member_name = fmt_var(field.name)
5255
self.emit('self.{0} = {0}'.format(member_name))
5356
else:
5457
self.emit('pass')

‎generator/python/python.stoneg.py‎

Lines changed: 45 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -27,8 +27,13 @@
2727
unwrap_aliases,
2828
unwrap_nullable,
2929
)
30-
from stone.generator import CodeGeneratorMonolingual
31-
from stone.lang.python import PythonTargetLanguage
30+
from stone.generator import CodeGenerator
31+
from stone.target.python import (
32+
fmt_class,
33+
fmt_func,
34+
fmt_obj,
35+
fmt_var,
36+
)
3237

3338
# This will be at the top of every generated file.
3439
validators_import = """\
@@ -64,10 +69,10 @@
6469
help='Route attribute to include in the generated code.',
6570
)
6671

67-
class PythonGenerator(CodeGeneratorMonolingual):
72+
73+
class PythonGenerator(CodeGenerator):
6874
"""Generates Python modules to represent the input Stone spec."""
6975

70-
lang = PythonTargetLanguage()
7176
cmdline_parser = _cmdline_parser
7277

7378
# Instance var of the current namespace being generated
@@ -244,7 +249,7 @@ def _class_name_for_data_type(self, data_type, ns=None):
244249
"""
245250
assert is_user_defined_type(data_type) or is_alias(data_type), \
246251
'Expected composite type, got %r' % type(data_type)
247-
name = self.lang.format_class(data_type.name)
252+
name = fmt_class(data_type.name)
248253
if ns and data_type.namespace != ns:
249254
# If from an imported namespace, add a namespace prefix.
250255
name = '{}.{}'.format(data_type.namespace.name, name)
@@ -283,7 +288,7 @@ def _generate_struct_class(self, ns, data_type):
283288
if not field.doc:
284289
continue
285290
self.emit_wrapped_text(':ivar {}: {}'.format(
286-
self.lang.format_variable(field.name),
291+
fmt_var(field.name),
287292
self.process_doc(field.doc, self._docf)),
288293
subsequent_prefix=' ')
289294
self.emit('"""')
@@ -319,7 +324,7 @@ def _generate_struct_class_slots(self, data_type):
319324
"""
320325
with self.block('__slots__ =', delim=('[', ']')):
321326
for field in data_type.fields:
322-
field_name = self.lang.format_variable(field.name)
327+
field_name = fmt_var(field.name)
323328
self.emit("'_%s_value'," % field_name)
324329
self.emit("'_%s_present'," % field_name)
325330
self.emit()
@@ -368,12 +373,12 @@ def _generate_validator_constructor(self, ns, data_type):
368373
args=[repr(dt.format)],
369374
)
370375
elif is_user_defined_type(dt):
371-
v = self.lang.format_class(dt.name) + '_validator'
376+
v = fmt_class(dt.name) + '_validator'
372377
if ns.name != dt.namespace.name:
373378
v = '{}.{}'.format(dt.namespace.name, v)
374379
elif is_alias(dt):
375380
# Assume that the alias has already been declared elsewhere.
376-
name = self.lang.format_class(dt.name) + '_validator'
381+
name = fmt_class(dt.name) + '_validator'
377382
if ns.name != dt.namespace.name:
378383
name = '{}.{}'.format(dt.namespace.name, name)
379384
v = name
@@ -434,7 +439,7 @@ def _generate_struct_class_reflection_attributes(self, ns, data_type):
434439
parent_type_class_name = None
435440

436441
for field in data_type.fields:
437-
field_name = self.lang.format_variable(field.name)
442+
field_name = fmt_var(field.name)
438443
validator_name = self._generate_validator_constructor(ns, field.data_type)
439444
self.emit('{}._{}_validator = {}'.format(
440445
class_name, field_name, validator_name))
@@ -474,7 +479,7 @@ def _generate_struct_class_reflection_attributes(self, ns, data_type):
474479
if data_type.is_member_of_enumerated_subtypes_tree():
475480
items = []
476481
for field in data_type.fields:
477-
var_name = self.lang.format_variable(field.name)
482+
var_name = fmt_var(field.name)
478483
validator_name = '{}._{}_validator'.format(class_name,
479484
var_name)
480485
items.append("('{}', {})".format(var_name, validator_name))
@@ -499,7 +504,7 @@ def _generate_struct_class_reflection_attributes(self, ns, data_type):
499504
before = '{}._all_fields_ = '.format(class_name)
500505
items = []
501506
for field in data_type.fields:
502-
var_name = self.lang.format_variable(field.name)
507+
var_name = fmt_var(field.name)
503508
validator_name = '{}._{}_validator'.format(
504509
class_name, var_name)
505510
items.append("('{}', {})".format(var_name, validator_name))
@@ -517,7 +522,7 @@ def _generate_struct_class_init(self, data_type):
517522

518523
args = ['self']
519524
for field in data_type.all_fields:
520-
field_name_reserved_check = self.lang.format_variable(field.name, True)
525+
field_name_reserved_check = fmt_var(field.name, True)
521526
args.append('%s=None' % field_name_reserved_check)
522527
self.generate_multiline_list(args, before='def __init__', after=':')
523528

@@ -528,19 +533,19 @@ def _generate_struct_class_init(self, data_type):
528533
if data_type.parent_type:
529534
class_name = self._class_name_for_data_type(data_type)
530535
self.generate_multiline_list(
531-
[self.lang.format_method(f.name, True)
536+
[fmt_func(f.name, True)
532537
for f in data_type.parent_type.all_fields],
533538
before='super({}, self).__init__'.format(class_name))
534539

535540
# initialize each field
536541
for field in data_type.fields:
537-
field_var_name = self.lang.format_variable(field.name)
542+
field_var_name = fmt_var(field.name)
538543
self.emit('self._{}_value = None'.format(field_var_name))
539544
self.emit('self._{}_present = False'.format(field_var_name))
540545

541546
# handle arguments that were set
542547
for field in data_type.fields:
543-
field_var_name = self.lang.format_variable(field.name, True)
548+
field_var_name = fmt_var(field.name, True)
544549
self.emit('if {} is not None:'.format(field_var_name))
545550
with self.indent():
546551
self.emit('self.{0} = {0}'.format(field_var_name))
@@ -553,21 +558,21 @@ def _generate_python_value(self, ns, value):
553558
if is_tag_ref(value):
554559
ref = '{}.{}'.format(
555560
self._class_name_for_data_type(value.union_data_type),
556-
self.lang.format_variable(value.tag_name))
561+
fmt_var(value.tag_name))
557562
if ns != value.union_data_type.namespace:
558563
ref = '%s.%s' % (value.union_data_type.namespace.name, ref)
559564
return ref
560565
else:
561-
return self.lang.format_obj(value)
566+
return fmt_obj(value)
562567

563568
def _generate_struct_class_properties(self, ns, data_type):
564569
"""
565570
Each field of the struct has a corresponding setter and getter.
566571
The setter validates the value being set.
567572
"""
568573
for field in data_type.fields:
569-
field_name = self.lang.format_method(field.name)
570-
field_name_reserved_check = self.lang.format_method(field.name, True)
574+
field_name = fmt_func(field.name)
575+
field_name_reserved_check = fmt_func(field.name, True)
571576
if is_nullable_type(field.data_type):
572577
field_dt = field.data_type.data_type
573578
dt_nullable = True
@@ -648,15 +653,15 @@ def __repr__(self):
648653
with self.indent():
649654
if data_type.all_fields:
650655
constructor_kwargs_fmt = ', '.join(
651-
'{}={{!r}}'.format(self.lang.format_variable(f.name, True))
656+
'{}={{!r}}'.format(fmt_var(f.name, True))
652657
for f in data_type.all_fields)
653658
self.emit("return '{}({})'.format(".format(
654659
self._class_name_for_data_type(data_type),
655660
constructor_kwargs_fmt,
656661
))
657662
with self.indent():
658663
for f in data_type.all_fields:
659-
self.emit("self._{}_value,".format(self.lang.format_variable(f.name)))
664+
self.emit("self._{}_value,".format(fmt_var(f.name)))
660665
self.emit(")")
661666
else:
662667
self.emit("return '%s()'"
@@ -693,7 +698,7 @@ def _generate_enumerated_subtypes_tag_mapping(self, ns, data_type):
693698
items = []
694699
for tag, subtype in data_type.get_all_subtypes_with_tags():
695700
items.append("{0}: ({1}, {2})".format(
696-
self.lang.format_class(subtype.name),
701+
fmt_class(subtype.name),
697702
tag,
698703
self._generate_validator_constructor(ns, subtype)))
699704
self.generate_multiline_list(
@@ -735,17 +740,17 @@ def _generate_union_class(self, ns, data_type):
735740
continue
736741
if is_void_type(field.data_type):
737742
ivar_doc = ':ivar {}: {}'.format(
738-
self.lang.format_variable(field.name),
743+
fmt_var(field.name),
739744
self.process_doc(field.doc, self._docf))
740745
elif is_user_defined_type(field.data_type):
741746
ivar_doc = ':ivar {} {}: {}'.format(
742-
self.lang.format_class(field.data_type.name),
743-
self.lang.format_variable(field.name),
747+
fmt_class(field.data_type.name),
748+
fmt_var(field.name),
744749
self.process_doc(field.doc, self._docf))
745750
else:
746751
ivar_doc = ':ivar {} {}: {}'.format(
747752
self._python_type_mapping(ns, field.data_type),
748-
self.lang.format_variable(field.name), field.doc)
753+
fmt_var(field.name), field.doc)
749754
self.emit_wrapped_text(ivar_doc, subsequent_prefix=' ')
750755
self.emit('"""')
751756
self.emit()
@@ -775,7 +780,7 @@ def _generate_union_class_vars(self, data_type):
775780
# easier time detecting their existence.
776781
for field in data_type.fields:
777782
if is_void_type(field.data_type):
778-
field_name = self.lang.format_variable(field.name)
783+
field_name = fmt_var(field.name)
779784
self.emit('# Attribute is overwritten below the class definition')
780785
self.emit('{} = None'.format(field_name))
781786

@@ -787,18 +792,18 @@ def _generate_union_class_reflection_attributes(self, ns, data_type):
787792
Adds a class attribute for each union member assigned to a validator.
788793
Also adds an attribute that is a map from tag names to validators.
789794
"""
790-
class_name = self.lang.format_class(data_type.name)
795+
class_name = fmt_class(data_type.name)
791796

792797
for field in data_type.fields:
793-
field_name = self.lang.format_variable(field.name)
798+
field_name = fmt_var(field.name)
794799
validator_name = self._generate_validator_constructor(
795800
ns, field.data_type)
796801
self.emit('{}._{}_validator = {}'.format(
797802
class_name, field_name, validator_name))
798803

799804
with self.block('{}._tagmap ='.format(class_name)):
800805
for field in data_type.fields:
801-
var_name = self.lang.format_variable(field.name)
806+
var_name = fmt_var(field.name)
802807
validator_name = '{}._{}_validator'.format(
803808
class_name, var_name)
804809
self.emit("'{}': {},".format(var_name, validator_name))
@@ -817,8 +822,8 @@ def _generate_union_class_variant_creators(self, ns, data_type):
817822
"""
818823
for field in data_type.fields:
819824
if not is_void_type(field.data_type):
820-
field_name = self.lang.format_method(field.name)
821-
field_name_reserved_check = self.lang.format_method(field.name, True)
825+
field_name = fmt_func(field.name)
826+
field_name_reserved_check = fmt_func(field.name, True)
822827
if is_nullable_type(field.data_type):
823828
field_dt = field.data_type.data_type
824829
else:
@@ -834,14 +839,14 @@ def _generate_union_class_variant_creators(self, ns, data_type):
834839
self.emit(':param {} val:'.format(
835840
self._python_type_mapping(ns, field_dt)))
836841
self.emit(':rtype: {}'.format(
837-
self.lang.format_class(data_type.name)))
842+
fmt_class(data_type.name)))
838843
self.emit('"""')
839844
self.emit("return cls('{}', val)".format(field_name))
840845
self.emit()
841846

842847
def _generate_union_class_is_set(self, data_type):
843848
for field in data_type.fields:
844-
field_name = self.lang.format_method(field.name)
849+
field_name = fmt_func(field.name)
845850
self.emit('def is_{}(self):'.format(field_name))
846851
with self.indent():
847852
self.emit('"""')
@@ -858,7 +863,7 @@ def _generate_union_class_get_helpers(self, ns, data_type):
858863
the tag has been switched on.
859864
"""
860865
for field in data_type.fields:
861-
field_name = self.lang.format_method(field.name)
866+
field_name = fmt_func(field.name)
862867

863868
if not is_void_type(field.data_type):
864869
# generate getter for field
@@ -907,19 +912,19 @@ def _generate_union_class_symbol_creators(self, data_type):
907912
Class attributes that represent a symbol are set after the union class
908913
definition.
909914
"""
910-
class_name = self.lang.format_class(data_type.name)
915+
class_name = fmt_class(data_type.name)
911916
lineno = self.lineno
912917
for field in data_type.fields:
913918
if is_void_type(field.data_type):
914-
field_name = self.lang.format_method(field.name)
919+
field_name = fmt_func(field.name)
915920
self.emit("{0}.{1} = {0}('{1}')".format(class_name, field_name))
916921
if lineno != self.lineno:
917922
self.emit()
918923

919924
def _generate_routes(self, namespace):
920925

921926
for route in namespace.routes:
922-
var_name = self.lang.format_method(route.name)
927+
var_name = fmt_func(route.name)
923928
data_types = [route.arg_data_type, route.result_data_type,
924929
route.error_data_type]
925930
with self.block('%s = bb.Route(' % var_name, delim=(None, None), after=')'):
@@ -939,6 +944,6 @@ def _generate_routes(self, namespace):
939944

940945
with self.block('ROUTES =', delim=('{', '}')):
941946
for route in namespace.routes:
942-
var_name = self.lang.format_method(route.name)
947+
var_name = fmt_func(route.name)
943948
self.emit("'{}': {},".format(route.name, var_name))
944949
self.emit()

0 commit comments

Comments
 (0)