Ignore:
Timestamp:
04/15/06 19:54:52 (9 years ago)
Author:
xi
Message:

Major refactoring.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • pyyaml/trunk/lib/yaml/representer.py

    r135 r136  
    2121    pass 
    2222 
    23 class BaseRepresenter(BaseDetector): 
    24  
    25     DEFAULT_SCALAR_TAG = u'tag:yaml.org,2002:str' 
    26     DEFAULT_SEQUENCE_TAG = u'tag:yaml.org,2002:seq' 
    27     DEFAULT_MAPPING_TAG = u'tag:yaml.org,2002:map' 
    28  
    29     def __init__(self, serializer): 
    30         self.serializer = serializer 
     23class BaseRepresenter: 
     24 
     25    yaml_representers = {} 
     26 
     27    def __init__(self): 
    3128        self.represented_objects = {} 
    3229 
    33     def close(self): 
    34         self.serializer.close() 
    35  
    36     def represent(self, native): 
    37         node = self.represent_object(native) 
    38         self.serializer.serialize(node) 
     30    def represent(self, data): 
     31        node = self.represent_object(data) 
     32        self.serialize(node) 
    3933        self.represented_objects = {} 
    4034 
    41     def represent_object(self, native): 
    42         if self.ignore_aliases(native): 
     35    def represent_object(self, data): 
     36        if self.ignore_aliases(data): 
    4337            alias_key = None 
    4438        else: 
    45             alias_key = id(native) 
     39            alias_key = id(data) 
    4640        if alias_key is not None: 
    4741            if alias_key in self.represented_objects: 
    4842                node = self.represented_objects[alias_key] 
    4943                if node is None: 
    50                     raise RepresenterError("recursive objects are not allowed: %r" % native) 
     44                    raise RepresenterError("recursive objects are not allowed: %r" % data) 
    5145                return node 
    5246            self.represented_objects[alias_key] = None 
    53         for native_type in type(native).__mro__: 
    54             if native_type in self.yaml_representers: 
    55                 node = self.yaml_representers[native_type](self, native) 
     47        for data_type in type(data).__mro__: 
     48            if data_type in self.yaml_representers: 
     49                node = self.yaml_representers[data_type](self, data) 
    5650                break 
    5751        else: 
    5852            if None in self.yaml_representers: 
    59                 node = self.yaml_representers[None](self, native) 
     53                node = self.yaml_representers[None](self, data) 
    6054            else: 
    61                 node = ScalarNode(None, unicode(native)) 
     55                node = ScalarNode(None, unicode(data)) 
    6256        if alias_key is not None: 
    6357            self.represented_objects[alias_key] = node 
    6458        return node 
    6559 
    66     def add_representer(cls, native_type, representer): 
     60    def add_representer(cls, data_type, representer): 
    6761        if not 'yaml_representers' in cls.__dict__: 
    6862            cls.yaml_representers = cls.yaml_representers.copy() 
    69         cls.yaml_representers[native_type] = representer 
     63        cls.yaml_representers[data_type] = representer 
    7064    add_representer = classmethod(add_representer) 
    7165 
    72     yaml_representers = {} 
    73  
    7466    def represent_scalar(self, tag, value, style=None): 
    75         detected_tag = self.detect(value) 
    76         if detected_tag is None: 
    77             detected_tag = self.DEFAULT_SCALAR_TAG 
    78         implicit = (tag == detected_tag) 
    79         if tag == self.DEFAULT_SCALAR_TAG: 
    80             tag = None 
    81         return ScalarNode(tag, value, implicit=implicit, style=style) 
     67        return ScalarNode(tag, value, style=style) 
    8268 
    8369    def represent_sequence(self, tag, sequence, flow_style=None): 
    84         if tag == self.DEFAULT_SEQUENCE_TAG: 
    85             tag = None 
    8670        value = [] 
    8771        for item in sequence: 
     
    9074 
    9175    def represent_mapping(self, tag, mapping, flow_style=None): 
    92         if tag == self.DEFAULT_MAPPING_TAG: 
    93             tag = None 
    9476        value = {} 
    9577        if hasattr(mapping, 'keys'): 
     
    10486        return MappingNode(tag, value, flow_style=flow_style) 
    10587 
    106     def ignore_aliases(self, native): 
     88    def ignore_aliases(self, data): 
    10789        return False 
    10890 
    109 class SafeRepresenter(Detector, BaseRepresenter): 
    110  
    111     def ignore_aliases(self, native): 
    112         if native in [None, ()]: 
     91class SafeRepresenter(BaseRepresenter): 
     92 
     93    def ignore_aliases(self, data): 
     94        if data in [None, ()]: 
    11395            return True 
    114         if isinstance(native, (str, unicode, bool, int, float)): 
     96        if isinstance(data, (str, unicode, bool, int, float)): 
    11597            return True 
    11698 
    117     def represent_none(self, native): 
     99    def represent_none(self, data): 
    118100        return self.represent_scalar(u'tag:yaml.org,2002:null', 
    119101                u'null') 
    120102 
    121     def represent_str(self, native): 
     103    def represent_str(self, data): 
    122104        encoding = None 
    123105        try: 
    124             unicode(native, 'ascii') 
     106            unicode(data, 'ascii') 
    125107            encoding = 'ascii' 
    126108        except UnicodeDecodeError: 
    127109            try: 
    128                 unicode(native, 'utf-8') 
     110                unicode(data, 'utf-8') 
    129111                encoding = 'utf-8' 
    130112            except UnicodeDecodeError: 
     
    132114        if encoding: 
    133115            return self.represent_scalar(u'tag:yaml.org,2002:str', 
    134                     unicode(native, encoding)) 
     116                    unicode(data, encoding)) 
    135117        else: 
    136118            return self.represent_scalar(u'tag:yaml.org,2002:binary', 
    137                     unicode(native.encode('base64')), style='|') 
    138  
    139     def represent_unicode(self, native): 
    140         return self.represent_scalar(u'tag:yaml.org,2002:str', native) 
    141  
    142     def represent_bool(self, native): 
    143         if native: 
     119                    unicode(data.encode('base64')), style='|') 
     120 
     121    def represent_unicode(self, data): 
     122        return self.represent_scalar(u'tag:yaml.org,2002:str', data) 
     123 
     124    def represent_bool(self, data): 
     125        if data: 
    144126            value = u'true' 
    145127        else: 
     
    147129        return self.represent_scalar(u'tag:yaml.org,2002:bool', value) 
    148130 
    149     def represent_int(self, native): 
    150         return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(native)) 
    151  
    152     def represent_long(self, native): 
    153         return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(native)) 
     131    def represent_int(self, data): 
     132        return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data)) 
     133 
     134    def represent_long(self, data): 
     135        return self.represent_scalar(u'tag:yaml.org,2002:int', unicode(data)) 
    154136 
    155137    inf_value = 1e300000 
    156138    nan_value = inf_value/inf_value 
    157139 
    158     def represent_float(self, native): 
    159         if native == self.inf_value: 
     140    def represent_float(self, data): 
     141        if data == self.inf_value: 
    160142            value = u'.inf' 
    161         elif native == -self.inf_value: 
     143        elif data == -self.inf_value: 
    162144            value = u'-.inf' 
    163         elif native == self.nan_value or native != native: 
     145        elif data == self.nan_value or data != data: 
    164146            value = u'.nan' 
    165147        else: 
    166             value = unicode(native) 
     148            value = unicode(data) 
    167149        return self.represent_scalar(u'tag:yaml.org,2002:float', value) 
    168150 
    169     def represent_list(self, native): 
    170         pairs = (len(native) > 0) 
    171         for item in native: 
     151    def represent_list(self, data): 
     152        pairs = (len(data) > 0) 
     153        for item in data: 
    172154            if not isinstance(item, tuple) or len(item) != 2: 
    173155                pairs = False 
    174156                break 
    175157        if not pairs: 
    176             return self.represent_sequence(u'tag:yaml.org,2002:seq', native) 
     158            return self.represent_sequence(u'tag:yaml.org,2002:seq', data) 
    177159        value = [] 
    178         for item_key, item_value in native: 
     160        for item_key, item_value in data: 
    179161            value.append(self.represent_mapping(u'tag:yaml.org,2002:map', 
    180162                [(item_key, item_value)])) 
    181163        return SequenceNode(u'tag:yaml.org,2002:pairs', value) 
    182164 
    183     def represent_dict(self, native): 
    184         return self.represent_mapping(u'tag:yaml.org,2002:map', native) 
    185  
    186     def represent_set(self, native): 
     165    def represent_dict(self, data): 
     166        return self.represent_mapping(u'tag:yaml.org,2002:map', data) 
     167 
     168    def represent_set(self, data): 
    187169        value = {} 
    188         for key in native: 
     170        for key in data: 
    189171            value[key] = None 
    190172        return self.represent_mapping(u'tag:yaml.org,2002:set', value) 
    191173 
    192     def represent_date(self, native): 
    193         value = u'%04d-%02d-%02d' % (native.year, native.month, native.day) 
     174    def represent_date(self, data): 
     175        value = u'%04d-%02d-%02d' % (data.year, data.month, data.day) 
    194176        return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value) 
    195177 
    196     def represent_datetime(self, native): 
     178    def represent_datetime(self, data): 
    197179        value = u'%04d-%02d-%02d %02d:%02d:%02d' \ 
    198                 % (native.year, native.month, native.day, 
    199                     native.hour, native.minute, native.second) 
    200         if native.microsecond: 
    201             value += u'.' + unicode(native.microsecond/1000000.0).split(u'.')[1] 
    202         if native.utcoffset(): 
    203             value += unicode(native.utcoffset()) 
     180                % (data.year, data.month, data.day, 
     181                    data.hour, data.minute, data.second) 
     182        if data.microsecond: 
     183            value += u'.' + unicode(data.microsecond/1000000.0).split(u'.')[1] 
     184        if data.utcoffset(): 
     185            value += unicode(data.utcoffset()) 
    204186        return self.represent_scalar(u'tag:yaml.org,2002:timestamp', value) 
    205187 
    206     def represent_undefined(self, native): 
    207         raise RepresenterError("cannot represent an object: %s" % native) 
     188    def represent_yaml_object(self, tag, data, cls, flow_style=None): 
     189        if hasattr(data, '__getstate__'): 
     190            state = data.__getstate__() 
     191        else: 
     192            state = data.__dict__.copy() 
     193        mapping = state 
     194        if hasattr(state, 'keys'): 
     195            mapping = [] 
     196            keys = state.keys() 
     197            keys.sort() 
     198            for key in keys: 
     199                mapping.append((key.replace('_', '-'), state[key])) 
     200        return self.represent_mapping(tag, mapping, flow_style=flow_style) 
     201 
     202    def represent_undefined(self, data): 
     203        raise RepresenterError("cannot represent an object: %s" % data) 
    208204 
    209205SafeRepresenter.add_representer(type(None), 
Note: See TracChangeset for help on using the changeset viewer.