def visit_wrap(m: Module, *, name: str, prev: str) -> None: accessor_name, name = name.split(".", 2) a = globals()[accessor_name] m.stmt(f"func {name}() error {{") with m.scope(): m.stmt(a.wrap(m, name=name, prev=prev)) m.stmt("}")
def visit_core(m: Module, *, name: str) -> None: accessor_name, name = name.split(".", 2) a = globals()[accessor_name] m.stmt(f"func {name}() error {{") with m.scope(): m.stmt(a.new(m, name=name)) m.stmt("}")
def emit_union(m: Module, item: Item, *, resolver: Resolver) -> Definition: typename = goname(item.type_.__name__) kind_typename = typename + "Kind" # type <typename> { # Kind string `json:"$kind"` # ... # } m.stmt(f"type {typename} struct {{") with m.scope(): m.stmt(f'Kind {kind_typename} `json:"$kind"` // discriminator') for subtype in item.args: gotype: str = resolver.resolve_gotype(subtype) m.append(f"{gotype} *{gotype}") m.stmt( f' `json:"{untitleize(str(gotype)).rstrip("_")},omitempty"`') m.stmt("}") m.sep() # UnmarshalJSON discriminator_field = ("$kind", typeinfo.typeinfo(str), metadata()) discriminator_field[-1]["_override_type"] = kind_typename pseudo_fields = [(sub_type.__name__, typeinfo.typeinfo(sub_type), metadata(required=False)) for sub_type in item.args] pseudo_item = Item( type_=item.type_, fields=[discriminator_field] + pseudo_fields, args=[], ) unmarshalJSON_definition = emit_unmarshalJSON(m, pseudo_item, resolver=resolver) m.sep() # one-of validation assert unmarshalJSON_definition.code_module is not None this = m.symbol(f"{item.type_.__name__[0].lower()}") maperr_pkg = m.import_("github.com/podhmo/maperr") sm = unmarshalJSON_definition.code_module sm.stmt("// one-of?") sm.stmt("{") with sm.scope(): for go_name, info, _ in pseudo_item.fields[1:]: with sm.if_( f'{this}.Kind == "{go_name}" && {this}.{go_name} == nil'): sm.stmt( f'err = err.Add("{go_name}", {maperr_pkg}.Message{{Text: "treated as {go_name}, but no data"}})' ) sm.stmt("}") # enums emit_enums(m, item.type_, resolver=resolver, name=kind_typename) definition = Definition(name=typename, code_module=None) return definition
def visit(m: Module, *, names: t.List[str]) -> None: m.stmt("func run() error {") with m.scope(): m.stmt(f"return {names[0]}()") m.stmt("}") for name, prev in itertools.zip_longest(names, names[1:]): if prev is None: visit_core(m, name=name) else: visit_wrap(m, name=name, prev=prev)
def emit_struct(m: Module, item: Item, *, resolver: Resolver) -> Definition: gopackage = get_gopackage(item.type_) if gopackage is not None: return "" typename = str(resolver.resolve_gotype(item.type_)) # // <typename> ... doc = inspect.getdoc(item.type_) if doc: lines = doc.split("\n") m.stmt(f"// {typename} {lines[0]}") for line in lines[1:]: m.stmt(f"// {line}") # type <typename> struct { # ... # } m.stmt(f"type {typename} struct {{") with m.scope(): for name, info, metadata in item.fields: gotype: str = resolver.resolve_gotype(info.raw) # handling field (private field?, embedded?) if metadata.get("inline", False): m.append(gotype) elif name.startswith("_"): m.append(f"{untitleize(goname(name))} {gotype}") else: m.append(f"{goname(name)} {gotype}") # todo: handling tags if "tags" not in metadata: metadata["tags"] = {} metadata["tags"] = {"json": [name.rstrip("_")]} m.append(f" `{build_gotags(metadata['tags'])}`") # handling comments if metadata.get("inline", False): m.stmt(f" // {metadata}") else: comment = metadata.get("comment", "") m.stmt( f" // {comment.split(_NEWLINE, 1)[0]}" if comment else "") definition = Definition(name=typename, code_module=None) m.stmt("}") return definition
def visit_wrap(m: Module, *, name: str, prev: str) -> None: m.stmt(f"func {name}() error {{") with m.scope(): m.stmt(f'return errors.Wrap({prev}(), "on {name}")') m.stmt("}")
def visit_core(m: Module, *, name: str) -> None: m.stmt(f"func {name}() error {{") with m.scope(): m.stmt('return fmt.Errorf("xxx")') m.stmt("}")
def emit_unmarshalJSON(m: Module, item: Item, *, resolver: Resolver) -> Definition: this = m.symbol(f"{item.type_.__name__[0].lower()}") this_type = f"{resolver.resolve_gotype(item.type_)}" this_type_pointer = f"*{this_type}" # func (ob *Ob) UnmarshalJSON(b []byte) error { b = m.symbol("b") m.stmt( f"func ({this} {this_type_pointer}) UnmarshalJSON({b} []byte) error {{" ) with m.scope(): # var err *maperr.Error err = m.symbol("err") maperr_pkg = m.import_("github.com/podhmo/maperr") m.stmt(f"var {err} *{maperr_pkg}.Error") m.sep() # var inner struct { # ... # } m.stmt("// loading internal data") inner = m.symbol("inner") m.stmt(f"var {inner} struct {{") with m.scope(): for name, info, metadata in item.fields: if name.startswith("_"): continue # xxx: if "_override_type" in metadata: gotype: str = metadata["_override_type"] elif has_class_object(info): json_pkg = m.import_("encoding/json") gotype: str = str(json_pkg.RawMessage) else: gotype: str = resolver.resolve_gotype(info.raw) m.append(f'{goname(name)} *{gotype} `json:"{name}"`') m.stmt("// required" if metadata["required"] else "") m.stmt("}") # if rawErr := json.Unmarshal(b, &inner); rawErr != nil { # ... # } json_pkg = m.import_("encoding/json") raw_err = m.symbol("rawErr") with m.if_( f"{raw_err} := {json_pkg}.Unmarshal(b, &{inner}); {raw_err} != nil" ): m.return_(err.AddSummary(raw_err.Error())) m.sep() # if <field> != nil { # ob.<field> = *<field> # } else { # m.add(<field>, "required") # } rawerr = m.symbol("rawerr") m.stmt("// binding field value and required check") with m.block(): for name, info, metadata in item.fields: field = m.symbol(goname(name)) with m.if_(f"{inner}.{field} != nil"): if has_class_object(info): # pointer if info.is_optional: gotype: str = resolver.resolve_gotype( info.normalized) m.stmt(f"{this}.{goname(name)} = &{gotype}{{}}") ref = f"{this}.{field}" elif hasattr(info, "args"): # xxx gotype: str = resolver.resolve_gotype( info.normalized) m.stmt(f"{this}.{goname(name)} = {gotype}{{}}") ref = f"&{this}.{field}" else: ref = f"&{this}.{field}" with m.if_( f"{rawerr} := json.Unmarshal(*{inner}.{field}, {ref}); {rawerr} != nil" ): m.stmt( f'{err} = {err}.Add("{name}", {maperr_pkg}.Message{{Error: {rawerr}}})' ) else: m.stmt(f"{this}.{field} = *{inner}.{field}") if metadata["required"]: with m.else_(): m.stmt( f'{err} = err.Add("{name}", {maperr_pkg}.Message{{Text: "required"}})' ) m.sep() # NOTE: for injecting code from extrnal area code_module = m.submodule("", newline=False) # return err.Untyped() m.return_(err.Untyped()) m.stmt("}") return Definition(name="UnmarshalJSON", code_module=code_module)