docs: def generateExecutable(self, outpath='.', signed=False):
          """
          Generates the executable for this builder in the output path.
          
          :param      outpath | <str>
          """
          if not (self.runtime() or self.specfile()):
              return True
  
          if not self.distributionPath():
              return True
  
          if os.path.exists(self.distributionPath()):
              shutil.rmtree(self.distributionPath())
  
          if os.path.isfile(self.sourcePath()):
              basepath = os.path.normpath(os.path.dirname(self.sourcePath()))
          else:
              basepath = os.path.normpath(self.sourcePath())
  
          # store the plugin table of contents
          self.generatePlugins(basepath)
  
          # generate the specfile if necessary
          specfile = self.specfile()
          # generate the spec file options
          opts = {
              'name': self.name(),
              'exname': self.executableName(),
              'product': self.productName(),
              'runtime': self.runtime(),
              'srcpath': self.sourcePath(),
              'buildpath': self.buildPath(),
              'hookpaths': ',\n'.join(wrap_str(self.hookPaths())),
              'hiddenimports': ',\n'.join(wrap_str(self.hiddenImports())),
              'distpath': self.distributionPath(),
              'platform': sys.platform,
              'excludes': ',\n'.join(wrap_str(self.executableExcludes()))
          }
  
          if not specfile:
              datasets = []
              for typ, data in self.executableData():
                  if typ == 'tree':
                      args = {
                          'path': data[0],
                          'prefix': data[1],
                          'excludes': ','.join(wrap_str(data[2]))
                      }
  
                      datasets.append(templ.SPECTREE.format(**args))
  
                  else:
                      args = {}
                      args.update(data)
                      args.setdefault('type', typ)
                      datasets.append(templ.SPECDATA.format(**args))
  
              opts['datasets'] = '\n'.join(datasets)
  
              opts.update(self._executableOptions)
  
              if self.executableCliName():
                  opts['cliname'] = self.executableCliName()
                  opts['collect'] = templ.SPECFILE_CLI.format(**opts)
              else:
                  opts['collect'] = templ.SPECFILE_COLLECT.format(**opts)
  
              if opts['onefile']:
                  data = templ.SPECFILE_ONEFILE.format(**opts)
              else:
                  data = templ.SPECFILE.format(**opts)
  
              # generate the spec file for building
              specfile = os.path.join(self.buildPath(), self.name() + '.spec')
              f = open(specfile, 'w')
              f.write(data)
              f.close()
  
          cmd = os.path.expandvars(self.executableOption('cmd'))
          success = cmdexec(cmd.format(spec=specfile)) == 0
          if signed:
              binfile = os.path.join(opts['distpath'],
                                     opts['product'],
                                     opts['exname'] + '.exe')
              self.sign(binfile)
  
          return success