Method _build_object_rule

examples/server/server.py:678–762

(
        self,
        properties: List[Tuple[str, Any]],
        required: set[str],
        name: str,
        additional_properties: Union[bool, Any],
    )

        return rule_name

    def _build_object_rule(
        self,
        properties: List[Tuple[str, Any]],
        required: set[str],
        name: str,
        additional_properties: Union[bool, Any],
    ) -> str:
        prop_order = self._prop_order
        sorted_props = [
            key
            for _, (key, _) in sorted(
                enumerate(properties),
                key=lambda indexed_key: (
                    prop_order.get(indexed_key[1][0], len(prop_order)),
                    indexed_key[0],
                ),
            )
        ]

        property_kv_rule_names: Dict[str, str] = {}
        for prop_name, prop_schema in properties:
            prop_rule_name = self.visit(
                cast(Dict[str, Any], prop_schema),
                f"{name}{'-' if name else ''}{prop_name}",
            )
            property_kv_rule_names[prop_name] = self._add_rule(
                f"{name}{'-' if name else ''}{prop_name}-kv",
                rf'{self._format_literal(json.dumps(prop_name))} space ":" space {prop_rule_name}',
            )

        required_props = [key for key in sorted_props if key in required]
        optional_props = [key for key in sorted_props if key not in required]

        if additional_properties is True or isinstance(additional_properties, dict):
            sub_name = f"{name}{'-' if name else ''}additional"
            value_rule = self.visit(
                {} if additional_properties is True else cast(Dict[str, Any], additional_properties),
                f"{sub_name}-value",
            )
            property_kv_rule_names["*"] = self._add_rule(
                f"{sub_name}-kv",
                self._add_primitive("string", self._primitive_rules()["string"])
                + f' ":" space {value_rule}',
            )
            optional_props.append("*")

        rule = '"{" space '
        rule += ' "," space '.join(property_kv_rule_names[key] for key in required_props)

        if optional_props:
            if required_props:
                rule += ' ( "," space ( '
            else:
                rule += "( "

            def get_recursive_refs(keys: List[str], first_is_optional: bool) -> str:
                head, *rest = keys
                kv_rule_name = property_kv_rule_names[head]