docs: def loadYaml(self, ydata, filepath=''):
          """
          Loads properties from the yaml data.
          
          :param      ydata | <dict>
          """
          # build options
          opts = {'platform': sys.platform}
  
          mkpath = lambda x: _mkpath(filepath, x, **opts)
  
          # lookup environment variables
          env = {}
          for key, text in ydata.get('environment', {}).items():
              if text:
                  env[key] = os.path.expandvars(text)
              else:
                  env[key] = ''
  
          self.setEnvironment(env)
  
          # lookup general settings
          for key, val in ydata.get('settings', {}).items():
              attr = '_' + key
              if hasattr(self, attr):
                  setattr(self, attr, val)
  
          # lookup options
          yoptions = ydata.get('options')
          if yoptions is not None:
              options = 0
              for key, value in yoptions.items():
                  if value:
                      try:
                          options |= Builder.Options[key]
                      except KeyError:
                          continue
  
              self._options = options
  
          # lookup path options
          for key, path in ydata.get('paths', {}).items():
              if key.endswith('Paths'):
                  path = map(mkpath, path.split(';'))
              else:
                  path = mkpath(path)
  
              setattr(self, '_' + key, path)
  
          # lookup executable options
          yexe = ydata.get('executable')
          if yexe is not None:
              exe_tags = {'runtime': '_runtime',
                          'exe': '_executableName',
                          'cli': '_executableCliName',
                          'product': '_productName'}
  
              for tag, prop in exe_tags.items():
                  if tag in yexe:
                      value = yexe.pop(tag)
                      if value.startswith('.'):
                          value = mkpath(value)
  
                      setattr(self, prop, value)
  
              # load exclude options
              self.setExecutableExcludes(yexe.get('excludes', []))
  
              # load build data
              yexedata = yexe.get('data', {})
              if yexedata:
                  data = []
                  for key, value in yexedata.items():
                      if key == 'tree':
                          path = value.get('path', '')
                          if path:
                              path = mkpath(path)
                          else:
                              path = self.sourcePath()
  
                          prefix = value.get('prefix', os.path.basename(path))
                          excludes = value.get('excludes', '').split(';')
  
                          if excludes:
                              data.append(('tree', (path, prefix, excludes)))
  
                      else:
                          for item in value:
                              data.append((key, item))
  
                  self.setExecutableData(data)
  
              # load hidden imports
              self.setHiddenImports(yexe.get('hiddenimports', []))
  
              # load options
              for key, value in yexe.get('options', {}).items():
                  value = nstr(value)
                  if value.startswith('.'):
                      value = mkpath(value)
                  self._executableOptions[key] = value
  
          # lookup installer options
          yinstall = ydata.get('installer')
          if yinstall is not None:
              install_tags = {'name': '_installName'}
  
              for tag, prop in install_tags.items():
                  if tag in yinstall:
                      value = yinstall.pop(tag, None)
                      if value.startswith('.'):
                          value = mkpath(value)
                      setattr(self, prop, value)
  
              for key, value in yinstall.get('options', {}).items():
                  if type(value) in (unicode, str) and value.startswith('.'):
                      value = mkpath(value)
  
                  self._installerOptions[key] = value
  
              for path in yinstall.get('additional_directories', []):
                  self._installDirectories[path.get('path', '')] = path.get('source', '')