예제 #1
0
    def __init__(self, name = '', root = '', *args, **kwargs):
        BaseObject.__init__(self)

        self._name = name
        self._root = root

        if 'root' in kwargs:
            self._root = kwars['root']

        self._children = []

        magic = {
            'path': {
                'get': 'getPath',
                'set': None
            },
            'root': {
                'get': '_root',
                'set': 'setRoot'
            },
            'children': {
                'get': '_children',
                'set': '_children'
            }
        }

        self.magic = extend({}, self.magic, magic, True)
예제 #2
0
    def __init__(self, path = '', *args, **kwargs):
        BaseObject.__init__(self)

        filename = ''

        self.category = 'file'
        self._root = ''
        self.extension = ''

        if path:
            dirname, basename = os.path.split(path)

            filename, extension = os.path.splitext(basename)

            self._root = dirname
            self.extension = extension.lower()

        if 'root' in kwargs:
            self._root = kwargs['root']

        if 'extension' in kwargs:
            self.extension = kwargs['extension']

        magic = {
            'name': {
                'get': 'getName',
                'set': 'setName'
            },
            'filename': {
                'get': 'getFilename',
                'set': None
            },
            'path': {
                'get': 'getPath',
                'set': None
            },
            'root': {
                'get': '_root',
                'set': 'setRoot'
            },
            'modified': {
                'get': 'getModified',
                'set': None
            },
            'comment': {
                'get': 'getComment',
                'set': 'setComment'
            },
            'version': {
                'get': 'getVersion',
                'set': 'setVersion'
            }
        }

        self.magic = extend({}, self.magic, magic, True)

        self.naming = NamingObject(filename, config = {
            'parts': map(lambda x: PatternObject(x['name'], x['format'], x['matches'], x['rules'], x['transform']), FilesConfig.naming['parts']),
            'delimiter': FilesConfig.naming['delimiter']
        }, **kwargs)
예제 #3
0
    def __init__(self, config_path = '', config = {}):
        BaseObject.__init__(self)

        default_config = {}

        default_magic = {
            'ready':  {
                'get': '_ready',
                'set': None
            }
        }

        self._ready = False
        self.path = config_path
        self.config = extend({}, default_config, config, True)
        self.changed = ObservableObject(False)
        self.magic = extend({}, default_magic, True)

        self.magicWizard()

        if self.load():
            self._ready = True
예제 #4
0
    def __init__(self, name = '', *args, **kwargs):
        BaseObject.__init__(self)

        config = {}

        default_config = {
            'parts': [],
            'delimiter': '_'
        }

        if 'config' in kwargs:
            config = kwargs['config']

            kwargs = extend({}, kwargs, True)

            del kwargs['config']

        config = extend({}, default_config, config, True)

        self.delimiter = config['delimiter']
        self.parts = config['parts']

        magic = {
            'name': {
                'get': 'getName',
                'set': 'setName'
            },
            'requiredName': {
                'get': 'getRequiredName',
                'set': None
            },
            'matches': {
                'get': 'isMatching',
                'set': None
            },
            'errors': {
                'get': '_errors',
                'set': None
            },
            'valide': {
                'get': 'validate',
                'set': None
            }
        }

        # create private attributes from self.parts
        for index, pattern in enumerate(self.parts):
            if not hasattr(self, self.getPrivateName(pattern.name)):
                setattr(self, self.getPrivateName(pattern.name), None)

            magic[pattern.name] = {
                'get': self.getPrivateName(pattern.name),
                'set': 'setPart',
                'setArgs': [pattern]
            }

        # set name
        self.setName(name)

        # set name parts from kwargs
        self.fromKwargs(**kwargs)

        # create the magic
        self.magic = extend({}, self.magic, magic, True)