public String[] getLicenseNames() {
   checkInit("getLicenseNames");
   List<String> result = new ArrayList<String>(licenses.size());
   for (License license : this) {
     result.add(license.getName());
   }
   return result.toArray(new String[result.size()]);
 }
Esempio n. 2
0
  @Test(expectedExceptions = LicenseRejectedException.class)
  public void shouldThrowExceptionOnRejection() {
    // Given
    License license = new License("...", "...");

    // When
    license.reject();

    // Then this should never be reached
  }
Esempio n. 3
0
  @Test
  public void shouldRecordAcceptance() {
    // Given
    License license = new License("...", "...");

    // When
    license.accept();

    // Then
    assertTrue(license.isAccepted());
  }
Esempio n. 4
0
  @Test
  public void shouldNotBeAcceptedByDefault() {
    // Given
    License license = new License("...", "...");

    // When
    boolean result = license.isAccepted();

    // Then
    assertFalse(result);
  }
Esempio n. 5
0
  @Test
  public void shouldGetLicenseFilename() {
    // Given
    String licenseFilename = "filename";
    License license = new License(licenseFilename, "...");

    // When
    String filename = license.getFilename();

    // Then
    assertEquals(filename, licenseFilename);
  }
  /**
   * Adds information about references licenses.
   *
   * @param pomDescriptor The descriptor for the current POM.
   * @param model The Maven Model.
   * @param store The database.
   */
  private void addLicenses(MavenPomDescriptor pomDescriptor, Model model, Store store) {
    List<License> licenses = model.getLicenses();
    for (License license : licenses) {
      MavenLicenseDescriptor licenseDescriptor = store.create(MavenLicenseDescriptor.class);
      licenseDescriptor.setUrl(license.getUrl());
      licenseDescriptor.setComments(license.getComments());
      licenseDescriptor.setName(license.getName());
      licenseDescriptor.setDistribution(license.getDistribution());

      pomDescriptor.getLicenses().add(licenseDescriptor);
    }
  }
Esempio n. 7
0
  @Test
  public void shouldReturnCorrectLicenseText() {
    // Given
    String filename = "...";
    String licenseText = "Some license text";
    License license = new License(filename, licenseText);

    // When
    String result = license.getLicenseText();

    // Then
    assertEquals(result, licenseText);
  }
Esempio n. 8
0
  @Test(expectedExceptions = LicenseRejectedException.class)
  public void shouldIncludeRejectedLicenseInException() throws Exception {
    // Given
    License license = new License("...", "...");

    // When
    try {
      license.reject();
    } catch (LicenseRejectedException ex) {
      // Then
      assertEquals(ex.getRejectedLicense(), license);
      throw ex;
    }
  }
Esempio n. 9
0
  @Test
  public void testGetUnknownLicense() throws Exception {
    final DbLicense dbLicense = new DbLicense();
    dbLicense.setName("name");
    dbLicense.setLongName("");
    dbLicense.setComments("");
    dbLicense.setRegexp("");
    dbLicense.setUrl("");

    final ModelMapper modelMapper = new ModelMapper(mock(RepositoryHandler.class));
    final License license = modelMapper.getLicense(dbLicense);

    assertEquals(true, license.isUnknown());
  }
Esempio n. 10
0
  @Test
  public void shouldRecordRejection() {
    // Given
    License license = new License("...", "...");
    license.accept();

    // When
    try {
      license.reject();
    } catch (LicenseRejectedException ignored) {
    }

    // Then: last action should win
    assertFalse(license.isAccepted());
  }
Esempio n. 11
0
  @Test
  public void shouldReturnCorrectLines() {
    // Given
    String licenseText = "line1\nline2\nline3\n";
    License license = new License("...", licenseText);

    // When
    Iterable<String> lines = license.lines();
    StringBuilder sb = new StringBuilder();
    for (String line : lines) {
      sb.append(line).append('\n');
    }

    // Then
    assertEquals(sb.toString(), licenseText);
  }
  protected URL getFileURL(License license, String filename) throws IOException {

    URL licenseBaseURL = license.getBaseURL();
    URL result = MojoHelper.getUrl(licenseBaseURL, filename);
    if (!checkExists(result)) {
      // let's try with a .ftl suffix
      URL resultWithFtlSuffix =
          MojoHelper.getUrl(licenseBaseURL, filename + License.TEMPLATE_SUFFIX);

      if (checkExists(resultWithFtlSuffix)) {
        result = resultWithFtlSuffix;
      } else {
        throw new IllegalArgumentException(
            "Could not find license ("
                + license
                + ") content file at ["
                + result
                + "], nor at ["
                + resultWithFtlSuffix
                + "] for resolver "
                + this);
      }
    }
    return result;
  }
  public License getLicense(String licenseName) {
    checkInit("getLicense");
    if (StringUtils.isEmpty(licenseName)) {
      throw new IllegalArgumentException("licenceName can not be null, nor empty");
    }

    License license = null;
    for (License l : this) {
      if (licenseName.equals(l.getName())) {
        // got it
        license = l;
        break;
      }
    }
    return license;
  }
Esempio n. 14
0
  private void generateDocs(DOMFace rootEle) throws Exception {
    DOMFace allDocs = rootEle.createChild("documents", DOMFace.class);
    for (AttachmentRecord att : ngp.getAllAttachments()) {

      // first check if this license has access
      if (att.getVisibility() == 1) {
        // public document, so everyone can get it
      } else if (isMember) {
        // members can access everything
      } else if (att.roleCanAccess(license.getRole())) {
        // license role has access
      } else {
        // no access, so skip to next attachment
        continue;
      }

      DOMFace oneDoc = allDocs.createChild("doc", DOMFace.class);
      oneDoc.setAttribute("id", att.getId());
      oneDoc.setScalar("universalid", att.getUniversalId());
      oneDoc.setScalar("name", att.getNiceName());
      oneDoc.setScalar("size", Long.toString(att.getFileSize(ngp)));
      setScalarTime(oneDoc, "modifiedtime", att.getModifiedDate());
      oneDoc.setScalar("modifieduser", att.getModifiedBy());
    }
  }
Esempio n. 15
0
  private void generateResponse() throws Exception {

    String lic = ar.reqParam("lic");
    license = ngp.getLicense(lic);
    if (license == null) {
      throw new Exception("Can not access this page, license id is no longer valid: " + lic);
    }
    String lRole = license.getRole();
    if (lRole.equals(ngp.getPrimaryRole().getName())) {
      isMember = true;
    }
    if (lRole.equals(ngp.getSecondaryRole().getName())) {
      isMember = true;
      isAdmin = true;
    }

    Document mainDoc = DOMUtils.createDocument("case");
    DOMFace rootEle = new DOMFace(mainDoc, mainDoc.getDocumentElement(), null);

    generateDocs(rootEle);
    generateNotes(rootEle);
    generateGoals(rootEle);

    DOMUtils.writeDom(mainDoc, ar.w);
  }
Esempio n. 16
0
 private static Set<DistributionType> deserializeDistribs(List<String> distributions)
     throws PackageDeserializationException {
   try {
     return License.parseDistributions(distributions);
   } catch (LicenseParsingException e) {
     throw new PackageDeserializationException(e);
   }
 }
Esempio n. 17
0
 public synchronized boolean equals(java.lang.Object obj) {
   if (!(obj instanceof License)) return false;
   License other = (License) obj;
   if (obj == null) return false;
   if (this == obj) return true;
   if (__equalsCalc != null) {
     return (__equalsCalc == obj);
   }
   __equalsCalc = obj;
   boolean _equals;
   _equals =
       true
           && ((this.p == null && other.getP() == null)
               || (this.p != null && java.util.Arrays.equals(this.p, other.getP())))
           && ((this.licenseType == null && other.getLicenseType() == null)
               || (this.licenseType != null && this.licenseType.equals(other.getLicenseType())));
   __equalsCalc = null;
   return _equals;
 }
Esempio n. 18
0
  private static License deserializeLicense(Build.License licensePb)
      throws PackageDeserializationException {
    List<String> licenseStrings = new ArrayList<>();
    licenseStrings.addAll(licensePb.getLicenseTypeList());
    for (String exception : licensePb.getExceptionList()) {
      licenseStrings.add("exception=" + exception);
    }

    try {
      return License.parseLicense(licenseStrings);
    } catch (LicenseParsingException e) {
      throw new PackageDeserializationException(e);
    }
  }
Esempio n. 19
0
  @Test
  public void testGetDbLicense() throws Exception {
    final License license =
        DataModelFactory.createLicense("name", "longName", "comments", "regexp", "url");
    final ModelMapper modelMapper = new ModelMapper(mock(RepositoryHandler.class));
    final DbLicense dbLicense = modelMapper.getDbLicense(license);

    assertEquals(license.getName(), dbLicense.getName());
    assertEquals(license.getLongName(), dbLicense.getLongName());
    assertEquals(license.getComments(), dbLicense.getComments());
    assertEquals(license.getRegexp(), dbLicense.getRegexp());
    assertEquals(license.getUrl(), dbLicense.getUrl());
  }
Esempio n. 20
0
  @Test
  public void testGetLicense() throws Exception {
    final DbLicense dbLicense = new DbLicense();
    dbLicense.setName("name");
    dbLicense.setLongName("long name");
    dbLicense.setComments("comment");
    dbLicense.setRegexp("regexp");
    dbLicense.setUrl("url");

    final ModelMapper modelMapper = new ModelMapper(mock(RepositoryHandler.class));
    final License license = modelMapper.getLicense(dbLicense);

    assertEquals(dbLicense.getName(), license.getName());
    assertEquals(dbLicense.getLongName(), license.getLongName());
    assertEquals(dbLicense.getComments(), license.getComments());
    assertEquals(dbLicense.getRegexp(), license.getRegexp());
    assertEquals(dbLicense.getUrl(), license.getUrl());
  }
  public void load() throws IOException {
    checkNotInit("load");
    try {
      if (baseURL == null || StringUtils.isEmpty(baseURL.toString())) {
        throw new IllegalStateException("no baseURL defined in " + this);
      }

      URL definitionURL = MojoHelper.getUrl(getBaseURL(), REPOSITORY_DEFINITION_FILE);
      if (licenses != null) {
        licenses.clear();
      } else {
        licenses = new ArrayList<License>();
      }

      if (!checkExists(definitionURL)) {
        throw new IllegalArgumentException(
            "no licenses.properties found with url [" + definitionURL + "] for resolver " + this);
      }
      Properties p = new Properties();
      p.load(definitionURL.openStream());

      for (Entry<Object, Object> entry : p.entrySet()) {
        String licenseName = (String) entry.getKey();
        licenseName = licenseName.trim().toLowerCase();
        URL licenseBaseURL = MojoHelper.getUrl(baseURL, licenseName);

        License license = new License();
        license.setName(licenseName);
        license.setBaseURL(licenseBaseURL);

        String licenseDescription = (String) entry.getValue();
        Matcher matcher = LICENSE_DESCRIPTION_PATTERN.matcher(licenseDescription);
        String licenseFile;
        String headerFile;

        if (matcher.matches()) {
          licenseDescription = matcher.group(1).trim();
          licenseFile = matcher.group(2).trim();
          headerFile = matcher.group(3).trim();
        } else {
          licenseFile = License.LICENSE_CONTENT_FILE;
          headerFile = License.LICENSE_HEADER_FILE;
        }

        URL licenseFileURL = getFileURL(license, licenseFile);
        license.setLicenseURL(licenseFileURL);
        URL headerFileURL = getFileURL(license, headerFile);
        license.setHeaderURL(headerFileURL);

        license.setDescription(licenseDescription);

        if (LOG.isInfoEnabled()) {
          LOG.info("register " + license.getDescription());
        }
        if (LOG.isDebugEnabled()) {
          LOG.debug(license);
        }
        licenses.add(license);
      }
      licenses = Collections.unmodifiableList(licenses);
    } finally {
      // mark repository as available
      init = true;
    }
  }
  @Override
  public List<File> generate() {
    Boolean generateApis = null;
    Boolean generateModels = null;
    Boolean generateSupportingFiles = null;

    Set<String> modelsToGenerate = null;
    Set<String> apisToGenerate = null;
    Set<String> supportingFilesToGenerate = null;

    // allows generating only models by specifying a CSV of models to generate, or empty for all
    if (System.getProperty("models") != null) {
      String modelNames = System.getProperty("models");
      generateModels = true;
      if (!modelNames.isEmpty()) {
        modelsToGenerate = new HashSet<String>(Arrays.asList(modelNames.split(",")));
      }
    }
    if (System.getProperty("apis") != null) {
      String apiNames = System.getProperty("apis");
      generateApis = true;
      if (!apiNames.isEmpty()) {
        apisToGenerate = new HashSet<String>(Arrays.asList(apiNames.split(",")));
      }
    }
    if (System.getProperty("supportingFiles") != null) {
      String supportingFiles = System.getProperty("supportingFiles");
      generateSupportingFiles = true;
      if (!supportingFiles.isEmpty()) {
        supportingFilesToGenerate = new HashSet<String>(Arrays.asList(supportingFiles.split(",")));
      }
    }

    if (generateApis == null && generateModels == null && generateSupportingFiles == null) {
      // no specifics are set, generate everything
      generateApis = true;
      generateModels = true;
      generateSupportingFiles = true;
    } else {
      if (generateApis == null) {
        generateApis = false;
      }
      if (generateModels == null) {
        generateModels = false;
      }
      if (generateSupportingFiles == null) {
        generateSupportingFiles = false;
      }
    }

    if (swagger == null || config == null) {
      throw new RuntimeException("missing swagger input or config!");
    }
    if (System.getProperty("debugSwagger") != null) {
      Json.prettyPrint(swagger);
    }
    List<File> files = new ArrayList<File>();
    config.processOpts();
    config.preprocessSwagger(swagger);

    config.additionalProperties().put("generatedDate", DateTime.now().toString());
    config.additionalProperties().put("generatorClass", config.getClass().toString());

    if (swagger.getInfo() != null) {
      Info info = swagger.getInfo();
      if (info.getTitle() != null) {
        config.additionalProperties().put("appName", info.getTitle());
      }
      if (info.getVersion() != null) {
        config.additionalProperties().put("appVersion", info.getVersion());
      }
      if (info.getDescription() != null) {
        config
            .additionalProperties()
            .put("appDescription", config.escapeText(info.getDescription()));
      }
      if (info.getContact() != null) {
        Contact contact = info.getContact();
        config.additionalProperties().put("infoUrl", contact.getUrl());
        if (contact.getEmail() != null) {
          config.additionalProperties().put("infoEmail", contact.getEmail());
        }
      }
      if (info.getLicense() != null) {
        License license = info.getLicense();
        if (license.getName() != null) {
          config.additionalProperties().put("licenseInfo", license.getName());
        }
        if (license.getUrl() != null) {
          config.additionalProperties().put("licenseUrl", license.getUrl());
        }
      }
      if (info.getVersion() != null) {
        config.additionalProperties().put("version", info.getVersion());
      }
    }

    StringBuilder hostBuilder = new StringBuilder();
    String scheme;
    if (swagger.getSchemes() != null && swagger.getSchemes().size() > 0) {
      scheme = swagger.getSchemes().get(0).toValue();
    } else {
      scheme = "https";
    }
    hostBuilder.append(scheme);
    hostBuilder.append("://");
    if (swagger.getHost() != null) {
      hostBuilder.append(swagger.getHost());
    } else {
      hostBuilder.append("localhost");
    }
    if (swagger.getBasePath() != null) {
      hostBuilder.append(swagger.getBasePath());
    }
    String contextPath = swagger.getBasePath() == null ? "" : swagger.getBasePath();
    String basePath = hostBuilder.toString();
    String basePathWithoutHost = swagger.getBasePath();

    // resolve inline models
    InlineModelResolver inlineModelResolver = new InlineModelResolver();
    inlineModelResolver.flatten(swagger);

    List<Object> allOperations = new ArrayList<Object>();
    List<Object> allModels = new ArrayList<Object>();

    // models
    Map<String, Model> definitions = swagger.getDefinitions();
    if (definitions != null) {
      List<String> sortedModelKeys = sortModelsByInheritance(definitions);

      if (generateModels) {
        if (modelsToGenerate != null && modelsToGenerate.size() > 0) {
          List<String> updatedKeys = new ArrayList<String>();
          for (String m : sortedModelKeys) {
            if (modelsToGenerate.contains(m)) {
              updatedKeys.add(m);
            }
          }
          sortedModelKeys = updatedKeys;
        }

        for (String name : sortedModelKeys) {
          try {
            // don't generate models that have an import mapping
            if (config.importMapping().containsKey(name)) {
              continue;
            }

            Model model = definitions.get(name);
            Map<String, Model> modelMap = new HashMap<String, Model>();
            modelMap.put(name, model);
            Map<String, Object> models = processModels(config, modelMap, definitions);
            models.putAll(config.additionalProperties());

            allModels.add(((List<Object>) models.get("models")).get(0));

            for (String templateName : config.modelTemplateFiles().keySet()) {
              String suffix = config.modelTemplateFiles().get(templateName);
              String filename =
                  config.modelFileFolder() + File.separator + config.toModelFilename(name) + suffix;
              if (!config.shouldOverwrite(filename)) {
                continue;
              }
              String templateFile = getFullTemplateFile(config, templateName);
              String template = readTemplate(templateFile);
              Template tmpl =
                  Mustache.compiler()
                      .withLoader(
                          new Mustache.TemplateLoader() {
                            @Override
                            public Reader getTemplate(String name) {
                              return getTemplateReader(
                                  getFullTemplateFile(config, name + ".mustache"));
                            }
                          })
                      .defaultValue("")
                      .compile(template);
              writeToFile(filename, tmpl.execute(models));
              files.add(new File(filename));
            }

            // to generate model test files
            for (String templateName : config.modelTestTemplateFiles().keySet()) {
              String suffix = config.modelTestTemplateFiles().get(templateName);
              String filename =
                  config.modelTestFileFolder()
                      + File.separator
                      + config.toModelTestFilename(name)
                      + suffix;
              if (!config.shouldOverwrite(filename)) {
                continue;
              }
              String templateFile = getFullTemplateFile(config, templateName);
              String template = readTemplate(templateFile);
              Template tmpl =
                  Mustache.compiler()
                      .withLoader(
                          new Mustache.TemplateLoader() {
                            @Override
                            public Reader getTemplate(String name) {
                              return getTemplateReader(
                                  getFullTemplateFile(config, name + ".mustache"));
                            }
                          })
                      .defaultValue("")
                      .compile(template);
              writeToFile(filename, tmpl.execute(models));
              files.add(new File(filename));
            }
          } catch (Exception e) {
            throw new RuntimeException("Could not generate model '" + name + "'", e);
          }
        }
      }
    }
    if (System.getProperty("debugModels") != null) {
      LOGGER.info("############ Model info ############");
      Json.prettyPrint(allModels);
    }

    // apis
    Map<String, List<CodegenOperation>> paths = processPaths(swagger.getPaths());
    if (generateApis) {
      if (apisToGenerate != null && apisToGenerate.size() > 0) {
        Map<String, List<CodegenOperation>> updatedPaths =
            new TreeMap<String, List<CodegenOperation>>();
        for (String m : paths.keySet()) {
          if (apisToGenerate.contains(m)) {
            updatedPaths.put(m, paths.get(m));
          }
        }
        paths = updatedPaths;
      }
      for (String tag : paths.keySet()) {
        try {
          List<CodegenOperation> ops = paths.get(tag);
          Map<String, Object> operation = processOperations(config, tag, ops);

          operation.put("basePath", basePath);
          operation.put("basePathWithoutHost", basePathWithoutHost);
          operation.put("contextPath", contextPath);
          operation.put("baseName", tag);
          operation.put("modelPackage", config.modelPackage());
          operation.putAll(config.additionalProperties());
          operation.put("classname", config.toApiName(tag));
          operation.put("classVarName", config.toApiVarName(tag));
          operation.put("importPath", config.toApiImport(tag));

          // Pass sortParamsByRequiredFlag through to the Mustache template...
          boolean sortParamsByRequiredFlag = true;
          if (this.config
              .additionalProperties()
              .containsKey(CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG)) {
            sortParamsByRequiredFlag =
                Boolean.valueOf(
                    (String)
                        this.config
                            .additionalProperties()
                            .get(CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG)
                            .toString());
          }
          operation.put("sortParamsByRequiredFlag", sortParamsByRequiredFlag);

          processMimeTypes(swagger.getConsumes(), operation, "consumes");
          processMimeTypes(swagger.getProduces(), operation, "produces");

          allOperations.add(new HashMap<String, Object>(operation));
          for (int i = 0; i < allOperations.size(); i++) {
            Map<String, Object> oo = (Map<String, Object>) allOperations.get(i);
            if (i < (allOperations.size() - 1)) {
              oo.put("hasMore", "true");
            }
          }

          for (String templateName : config.apiTemplateFiles().keySet()) {
            String filename = config.apiFilename(templateName, tag);
            if (!config.shouldOverwrite(filename) && new File(filename).exists()) {
              continue;
            }

            String templateFile = getFullTemplateFile(config, templateName);
            String template = readTemplate(templateFile);
            Template tmpl =
                Mustache.compiler()
                    .withLoader(
                        new Mustache.TemplateLoader() {
                          @Override
                          public Reader getTemplate(String name) {
                            return getTemplateReader(
                                getFullTemplateFile(config, name + ".mustache"));
                          }
                        })
                    .defaultValue("")
                    .compile(template);

            writeToFile(filename, tmpl.execute(operation));
            files.add(new File(filename));
          }

          // to generate api test files
          for (String templateName : config.apiTestTemplateFiles().keySet()) {
            String filename = config.apiTestFilename(templateName, tag);
            if (!config.shouldOverwrite(filename) && new File(filename).exists()) {
              continue;
            }

            String templateFile = getFullTemplateFile(config, templateName);
            String template = readTemplate(templateFile);
            Template tmpl =
                Mustache.compiler()
                    .withLoader(
                        new Mustache.TemplateLoader() {
                          @Override
                          public Reader getTemplate(String name) {
                            return getTemplateReader(
                                getFullTemplateFile(config, name + ".mustache"));
                          }
                        })
                    .defaultValue("")
                    .compile(template);

            writeToFile(filename, tmpl.execute(operation));
            files.add(new File(filename));
          }

        } catch (Exception e) {
          throw new RuntimeException("Could not generate api file for '" + tag + "'", e);
        }
      }
    }
    if (System.getProperty("debugOperations") != null) {
      LOGGER.info("############ Operation info ############");
      Json.prettyPrint(allOperations);
    }

    // supporting files
    Map<String, Object> bundle = new HashMap<String, Object>();
    bundle.putAll(config.additionalProperties());
    bundle.put("apiPackage", config.apiPackage());

    Map<String, Object> apis = new HashMap<String, Object>();
    apis.put("apis", allOperations);
    if (swagger.getHost() != null) {
      bundle.put("host", swagger.getHost());
    }
    bundle.put("swagger", this.swagger);
    bundle.put("basePath", basePath);
    bundle.put("scheme", scheme);
    bundle.put("contextPath", contextPath);
    bundle.put("apiInfo", apis);
    bundle.put("models", allModels);
    bundle.put("apiFolder", config.apiPackage().replace('.', File.separatorChar));
    bundle.put("modelPackage", config.modelPackage());
    List<CodegenSecurity> authMethods = config.fromSecurity(swagger.getSecurityDefinitions());
    if (authMethods != null && !authMethods.isEmpty()) {
      bundle.put("authMethods", authMethods);
      bundle.put("hasAuthMethods", true);
    }
    if (swagger.getExternalDocs() != null) {
      bundle.put("externalDocs", swagger.getExternalDocs());
    }
    for (int i = 0; i < allModels.size() - 1; i++) {
      HashMap<String, CodegenModel> cm = (HashMap<String, CodegenModel>) allModels.get(i);
      CodegenModel m = cm.get("model");
      m.hasMoreModels = true;
    }

    config.postProcessSupportingFileData(bundle);

    if (System.getProperty("debugSupportingFiles") != null) {
      LOGGER.info("############ Supporting file info ############");
      Json.prettyPrint(bundle);
    }

    if (generateSupportingFiles) {
      for (SupportingFile support : config.supportingFiles()) {
        try {
          String outputFolder = config.outputFolder();
          if (isNotEmpty(support.folder)) {
            outputFolder += File.separator + support.folder;
          }
          File of = new File(outputFolder);
          if (!of.isDirectory()) {
            of.mkdirs();
          }
          String outputFilename = outputFolder + File.separator + support.destinationFilename;
          if (!config.shouldOverwrite(outputFilename)) {
            continue;
          }

          String templateFile = getFullTemplateFile(config, support.templateFile);

          boolean shouldGenerate = true;
          if (supportingFilesToGenerate != null && supportingFilesToGenerate.size() > 0) {
            if (supportingFilesToGenerate.contains(support.destinationFilename)) {
              shouldGenerate = true;
            } else {
              shouldGenerate = false;
            }
          }
          if (shouldGenerate) {
            if (templateFile.endsWith("mustache")) {
              String template = readTemplate(templateFile);
              Template tmpl =
                  Mustache.compiler()
                      .withLoader(
                          new Mustache.TemplateLoader() {
                            @Override
                            public Reader getTemplate(String name) {
                              return getTemplateReader(
                                  getFullTemplateFile(config, name + ".mustache"));
                            }
                          })
                      .defaultValue("")
                      .compile(template);

              writeToFile(outputFilename, tmpl.execute(bundle));
              files.add(new File(outputFilename));
            } else {
              InputStream in = null;

              try {
                in = new FileInputStream(templateFile);
              } catch (Exception e) {
                // continue
              }
              if (in == null) {
                in =
                    this.getClass()
                        .getClassLoader()
                        .getResourceAsStream(getCPResourcePath(templateFile));
              }
              File outputFile = new File(outputFilename);
              OutputStream out = new FileOutputStream(outputFile, false);
              if (in != null) {
                LOGGER.info("writing file " + outputFile);
                IOUtils.copy(in, out);
              } else {
                if (in == null) {
                  LOGGER.error("can't open " + templateFile + " for input");
                }
              }
              files.add(outputFile);
            }
          }
        } catch (Exception e) {
          throw new RuntimeException("Could not generate supporting file '" + support + "'", e);
        }
      }
    }
    config.processSwagger(swagger);
    return files;
  }
  /** Builds the document header of the swagger model */
  private void overview() {
    Info info = swagger.getInfo();
    this.markupDocBuilder.documentTitle(info.getTitle());
    this.markupDocBuilder.sectionTitleLevel1(OVERVIEW);
    if (isNotBlank(info.getDescription())) {
      this.markupDocBuilder.textLine(info.getDescription());
    }
    if (isNotBlank(info.getVersion())) {
      this.markupDocBuilder.sectionTitleLevel2(CURRENT_VERSION);
      this.markupDocBuilder.textLine(VERSION + info.getVersion());
    }
    Contact contact = info.getContact();
    if (contact != null) {
      this.markupDocBuilder.sectionTitleLevel2(CONTACT_INFORMATION);
      if (isNotBlank(contact.getName())) {
        this.markupDocBuilder.textLine(CONTACT_NAME + contact.getName());
      }
      if (isNotBlank(contact.getEmail())) {
        this.markupDocBuilder.textLine(CONTACT_EMAIL + contact.getEmail());
      }
    }

    License license = info.getLicense();
    if (license != null && (isNotBlank(license.getName()) || isNotBlank(license.getUrl()))) {
      this.markupDocBuilder.sectionTitleLevel2(LICENSE_INFORMATION);
      if (isNotBlank(license.getName())) {
        this.markupDocBuilder.textLine(LICENSE + license.getName());
      }
      if (isNotBlank(license.getUrl())) {
        this.markupDocBuilder.textLine(LICENSE_URL + license.getUrl());
      }
    }
    if (isNotBlank(info.getTermsOfService())) {
      this.markupDocBuilder.textLine(TERMS_OF_SERVICE + info.getTermsOfService());
    }

    if (isNotBlank(swagger.getHost())
        || isNotBlank(swagger.getBasePath())
        || isNotEmpty(swagger.getSchemes())) {
      this.markupDocBuilder.sectionTitleLevel2(URI_SCHEME);
      if (isNotBlank(swagger.getHost())) {
        this.markupDocBuilder.textLine(HOST + swagger.getHost());
      }
      if (isNotBlank(swagger.getBasePath())) {
        this.markupDocBuilder.textLine(BASE_PATH + swagger.getBasePath());
      }
      if (isNotEmpty(swagger.getSchemes())) {
        List<String> schemes = new ArrayList<>();
        for (Scheme scheme : swagger.getSchemes()) {
          schemes.add(scheme.toString());
        }
        this.markupDocBuilder.textLine(SCHEMES + join(schemes, ", "));
      }
    }

    if (isNotEmpty(swagger.getTags())) {
      this.markupDocBuilder.sectionTitleLevel2(TAGS);
      List<String> tags = new ArrayList<>();
      for (Tag tag : swagger.getTags()) {
        String name = tag.getName();
        String description = tag.getDescription();
        if (isNoneBlank(description)) {
          tags.add(name + ": " + description);
        } else {
          tags.add(name);
        }
      }
      this.markupDocBuilder.unorderedList(tags);
    }

    if (isNotEmpty(swagger.getConsumes())) {
      this.markupDocBuilder.sectionTitleLevel2(CONSUMES);
      this.markupDocBuilder.unorderedList(swagger.getConsumes());
    }

    if (isNotEmpty(swagger.getProduces())) {
      this.markupDocBuilder.sectionTitleLevel2(PRODUCES);
      this.markupDocBuilder.unorderedList(swagger.getProduces());
    }
  }