Ejemplo n.º 1
0
    def code_new_instance_varname(classname, attr, value):
        """

        ``fruit_id____1 = Fruit(id=1, name='Apple')`` 中 ``fruit_id____1`` 部分。
        """
        code = "{var}_{attr}____{value}".format(
            var=name_convention.to_variable_name(classname),
            attr=attr,
            value=name_convention.to_index_key(value),
        )
        return code
Ejemplo n.º 2
0
    def __init__(self,
                 classname=None,
                 attrs=None,
                 keys=None,
                 data=None,
                 collection=None,
                 inherit_from="Base",
                 parent=None,
                 indent=0,
                 **kwargs):
        self.classname = classname
        self.attrs = attrs
        self.keys = keys
        self.data = data
        self.collection = collection
        self.inherit_from = inherit_from
        self.parent = parent
        self.indent = indent

        if (self.classname is not None) and \
                (self.attrs is not None) and \
                (self.keys is not None) and \
                (self.collection is not None):
            self.IS_COLLECTION = True

            # validate classname
            if not name_convention.is_valid_class_name(self.classname):
                raise ValidationError("%r is not a valid class name" %
                                      self.classname)

            # validate attrs
            for attr in self.attrs:
                if not name_convention.is_valid_variable_name(attr):
                    raise ValidationError("%r is not a valid attribute name" %
                                          attr)

            # validate keys
            for key in self.keys:
                if not name_convention.is_valid_variable_name(key):
                    raise ValidationError("%r is not a valid attribute name" %
                                          key)

            # validate attrs and keys
            if set.union(set(self.attrs), set(self.keys)) != set(self.attrs):
                raise ValidationError(
                    "keys (%r) has to be subset of attrs (%r)" %
                    (self.keys, self.attrs))

            # validate attrs and data
            for metadata in self.collection:
                for attr, value in metadata["data"].items():
                    try:
                        assert attr in self.attrs
                    except:
                        msg = "{classname}.__attrs__ = {attrs!r} doesn't match: {data!r}!".format(
                            classname=self.classname,
                            attrs=self.attrs,
                            data=metadata["data"],
                        )
                        raise ValidationError(msg)

            self.classnameCol = self.classname + "Col"
            self.variable_name_col = name_convention.to_variable_name(
                self.classname) + "_col"
            self.kwargs_text = "".join([", %s=None" % attr for attr in attrs])
            self.variable_name = name_convention.to_variable_name(
                self.classname)
            # 2 more indent for nested ClassDef
            self.collection = [
                ClassDef(indent=self.indent + 2,
                         inherit_from=self.classname,
                         parent=self,
                         **metadata) for metadata in self.collection
            ]

        elif (self.classname is None) and \
                (self.attrs is None) and \
                (self.keys is None) and \
                (self.collection is None) and \
                (self.data is not None):
            self.IS_COLLECTION = False
            self.classnameCol = self.parent.classname