| // Copyright (C) 2019 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| package com.googlesource.gerrit.plugins.copyright.lib; |
| |
| import static java.nio.charset.StandardCharsets.UTF_8; |
| |
| import com.google.common.annotations.VisibleForTesting; |
| import com.google.common.base.Joiner; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.hash.Hashing; |
| import java.util.NoSuchElementException; |
| import org.apache.commons.lang.StringUtils; |
| |
| /** Constants declaring match patterns for common copyright licenses and owners. */ |
| public abstract class CopyrightPatterns { |
| |
| // No instances |
| private CopyrightPatterns() {} |
| |
| // All of the MAX parameters below have been chosen empirically similar to MATCH_SEARCH_LENGTH to |
| // minimize computing cost while still catching virtually all of the important matches. |
| |
| /** Maximum length of consecutive text characters to match. */ |
| public static final int MAX_NAME_LENGTH = 30; |
| /** Maximum number of potential names to match. */ |
| public static final int MAX_NAME_REPETITION = 35; |
| /** Maximum length of consecutive space/comment characters to match. */ |
| public static final int MAX_SPACE_LENGTH = 47; |
| /** Maximum repetition of potential dates to match. Might have to revisit this in future. */ |
| public static final int MAX_DATE_REPETITION = 30; |
| |
| /** Regular expression matching whitespace or a comment character. */ |
| public static final String WS = "[\\p{Z}\\s*/#ᤦ ]"; |
| /** Regular expression matching whitespace, a comment character, or punctuation. */ |
| public static final String WSPCT = "[-,;.\\p{Z}\\s*/#ᤦ ]"; |
| /** Regular expression matching a text character. */ |
| public static final String NAME_CHAR = "[-\\p{L}\\p{N}]"; // \p{L}->letter, \p{N}->numeral |
| /** Regular expression matching an UPPER CASE text character. */ |
| public static final String UPPER_CHAR = "\\p{Lu}"; |
| /** Regular expression matching a lower case text character. */ |
| public static final String LOWER_CHAR = "\\p{Ll}"; |
| /** Regular expression matching an email character. */ |
| public static final String EMAIL_CHAR = "[-.\\p{L}\\p{N}_]"; |
| /** Regular expression matching a URL character. */ |
| public static final String URL_CHAR = "[-.\\p{L}\\p{N}_=%+]"; |
| /** Regular experssion matching a web address. */ |
| public static final String URL = |
| "https?[:]/(?:[/?&]" // http://example.com/path/?var=val&var=val |
| + URL_CHAR |
| + "{1," |
| + MAX_NAME_LENGTH |
| + "}){1,25}" |
| + "|www[.]" // www.domain or www.domain/path |
| + URL_CHAR |
| + "{1," |
| + MAX_NAME_LENGTH |
| + "}(?:[.]com|[.]net|[.]org|[.]\\p{L}\\p{L})(?:[/?&#]" |
| + URL_CHAR |
| + "{0," |
| + MAX_NAME_LENGTH |
| + "}){0,25}"; |
| /** Regular expression matching a text or email address. */ |
| public static final String NAME = |
| "(?:(?:" |
| + URL // web address |
| + "|[\\p{L}\\p{N}]" // regular text |
| + NAME_CHAR |
| + "{0,mnl}\\b" |
| + "|[<]?[\\p{L}\\p{N}]" // email@domain or <email@domain> |
| + EMAIL_CHAR |
| + "{1,mnl}[@][\\p{L}\\p{N}]" |
| + EMAIL_CHAR |
| + "{1,mnl}\\b[>]?" |
| + "|\\b\\p{N}{1,2}(?:[.]\\p{N}{1,2}){1,5}\\b" // version number |
| + "|\\p{Pi}[^\\p{Pf}]{0,65}\\p{Pf}" // quoted string |
| + "|(?-i:\\p{Lu}[-.]){1,5}" // Initials A.G. or S.A. etc. \\p{Lu} -> uppercase letter |
| + "|" // domain text |
| + EMAIL_CHAR |
| + "{1,mnl}(?:[.]com|[.]org|[.]net|[.]\\p{L}\\p{L})" |
| + ")[,;:]?)"; // punctuation following text |
| /** Regular expression matching an UPPERCASE text. */ |
| public static final String UPPER_NAME = "(?-i:\\b" + UPPER_CHAR + "{1," + MAX_NAME_LENGTH + "})"; |
| /** Regular expression matching a Proper Case text. */ |
| public static final String PROPER_NAME = |
| "(?-i:\\b" + UPPER_CHAR + LOWER_CHAR + "{0," + MAX_NAME_LENGTH + "})"; |
| /** Regular expression matching any text, email address, or quote character. */ |
| public static final String ANY_CHAR = "[-.,\\p{L}\\p{N}]"; |
| /** Regular expression matching any text, email address, or quoted string. */ |
| public static final String ANY_WORD = "(?:" + ANY_CHAR + "{1," + MAX_NAME_LENGTH + "})"; |
| |
| /** Academic Freedom License Version 2.1 */ |
| public static final Rule AFL2_1 = |
| license( |
| ImmutableList.of( |
| ".*SPDX-License-Identifier: AFL-2[.]1", |
| "<license> <name> ?AFL-2[.]1 ?</name>.*", |
| "Academic Free License 2[.]1")); |
| |
| /** Academic Freedom License Version 3.0 */ |
| public static final Rule AFL3_0 = |
| license( |
| ImmutableList.of( |
| ".*SPDX-License-Identifier: AFL-3[.]0", |
| "<license> <name> ?AFL-3[.]0 ?</name>.*", |
| "Academic Free Licen[cs]e 3[.]0")); |
| |
| /** Affero General Public License */ |
| public static final Rule AGPL = |
| license( |
| ImmutableList.of( |
| // "Affero" appears thrice in GPL 3.0 -- match to exclude below. |
| "Use with the GNU Affero General Public License[.]?", |
| "link or combine any covered work with a work licensed under version 3 of the GNU" |
| + " Affero General Public License into a single combined work[,.;:]?", |
| "but the special requirements of the GNU Affero General Public License,?", |
| // "Affero" appears in Mozilla Public License (MPL) -- match to exclude below. |
| "means either the GNU General Public License,?" |
| + " Version 2[.]0,? the GNU Lesser General Public License,?" |
| + " Version 2[.]1,? the GNU Affero General Public License,?", |
| // Otherwise, any occurrence of "Affero" suggests AGPL. |
| "Affero"), |
| ImmutableList.of( |
| // "Affero" appears thrice in GPL 3.0 |
| "Use with the GNU Affero General Public License[.]?", |
| "link or combine any covered work with a work licensed under version 3 of the GNU" |
| + " Affero General Public License into a single combined work[,.;:]?", |
| "but the special requirements of the GNU Affero General Public License,?", |
| // "Affero" appears in Mozilla Public License (MPL) |
| "means either the GNU General Public License,?" |
| + " Version 2[.]0,? the GNU Lesser General Public License,?" |
| + " Version 2[.]1,? the GNU Affero General Public License,?")); |
| |
| /** Android owned or licensed */ |
| public static final Rule ANDROID = |
| new Rule( |
| ImmutableList.of("Android(?:-x86)? Open(?: |-)Source Project", "LK Trusty Authors"), |
| ImmutableList.of("Android Software Development Kit Licen[cs]e Agreement")); |
| |
| /** Apache Software License 1.1 */ |
| public static final Rule APACHE1_1 = |
| license( |
| ImmutableList.of( |
| ".*SPDX-License-Identifier: Apache-1[.]1?", |
| "<license> <name> ?Apache(?: Software)?(?: Public)?(?: Licen[cs]e)?,?" |
| + "(?: |-)1[.]1 ?</name>.*", |
| "<license> <name> ?(?:The )?Apache(?: Software)?(?: Public)?" |
| + " Licen[cs]e,? Version 1[.]1 ?</name>.*", |
| "http://www[.]apache[.]org/licenses/LICENSE-1[.]1", |
| "(?:the )?Apache 1[.]1 Licen[cs]e", |
| ".*Licen[cs]ed under (?:both )?(?:the )?Apache Licen[cs]e,? version 1[.]1", |
| ".+Licen[cs]ed under (?:both )?(?:the )?Apache Licen[cs]e v1[.]1", |
| ".+licen[cs]ed under (?:the )?Apache 1[.]1", |
| "(?:the )?Apache(?: Software)?(?: Public)? Licen[cs]e,? Version 1[.]1", |
| "(?:the )?Apache(?: Software)?(?: Public)? Licen[cs]e,? v1[.]1", |
| "^terms of the Apache 1[.]1 licen[cs]e")); |
| |
| /** Apache 2 owned or licensed */ |
| public static final Rule APACHE2 = |
| new Rule( |
| ImmutableList.of( |
| "(?:by )?(?:The )?Apache Software Foundation.?", |
| "Apache Software Foundation.?" |
| + " This product includes software developed" |
| + " (?:by|at) The Apache Software Foundation"), |
| ImmutableList.of( |
| ".*SPDX-License-Identifier: Apache-2[.]?[0]?", |
| "<license> <name> ?Apache(?: Software)?(?: Public)?(?: Licen[cs]e)?,?" |
| + "(?: |-)2[.]?[0]? ?</name>.*", |
| "<license> <name> ?(?:The )?Apache(?: Software)?(?: Public)?" |
| + " Licen[cs]e,? Version 2[.]?[0]? ?</name>.*", |
| "https?://www[.]apache[.]org/licenses/LICENSE-2[.]0", |
| "Apache 2[.]?[0]? Licen[cs]e", |
| ".*Licen[cs]ed under (?:both )?(?:the )?Apache Licen[cs]e,?(?: version 2[.]?0?)?", |
| ".+Licen[cs]ed under (?:both )?(?:the )?Apache Licen[cs]e v2[.]?(?:[\\p{L}\\p{N}]+)?", |
| ".+licen[cs]ed under (?:the )?Apache 2[.]?", |
| ".+licen[cs]es this file to you under (?:the )?Apache Licen[cs]e,?", |
| "Apache(?: Software)?(?: Public)? Licen[cs]e,? Version 2[.]?[0]?", |
| "^apache2(?:-android)?", |
| "^the apache licen[cs]e", |
| "^terms of the Apache 2[.]?[0]? licen[cs]e", |
| ".+under the terms of (?:either )the Apache Licen[cs]e[,.;]?"), |
| ImmutableList.of("owner as \\p{Pi}?Not a Contribution[.,;:]{0,3}\\p{Pf}?")); |
| |
| /** The Artistic License version 1 or 2 */ |
| public static final Rule ARTISTIC_LICENSE = |
| license( |
| ImmutableList.of( |
| ".*SPDX-License-Identifier: Artistic-[12][.]?[0]?", |
| "<license> <name> ?Artistic-[12][.]?[0]? ?</name>.*", |
| "(?:The )?\\p{Pi}?Artistic Licen[cs]e\\p{Pf}?(?: [12][.]?[0]?)?")); |
| |
| /** The BEER-WARE License */ |
| public static final Rule BEER_WARE = license(ImmutableList.of("\\bTHE BEER-WARE LICEN[CS]E")); |
| |
| /** BSD licensed */ |
| public static final Rule BSD = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?BSD \\p{N}-clause(?: License)? ?</name>.*", |
| "<license> <name> ?BSD(?: |-)style(?: License)? ?</name>.*", |
| "<license> <name> ?(?:New )?BSD(?: New)?(?: Licen[cs]e)? ?</name>.*", |
| "<license> <name> ?Berkeley Software Distribution [(]BSD[)] Licen[cs]e ?</name>.*", |
| ".*SPDX-License-Identifier: BSD-2-Clause", |
| ".*SPDX-License-Identifier: BSD-2-Clause-FreeBSD", |
| ".*SPDX-License-Identifier: BSD-3-Clause", |
| ".*SPDX-License-Identifier: BSD-4-Clause", |
| "^BSD(?:[.]|, see LICEN[CS]E for (?:more )details[.])?", |
| ".*under the terms and conditions of the BSD Licen[cs]e.*", |
| ".*(?:\\p{N}-clause |a )?BSD (?:\\p{N}-clause )?licen[cs]e.*", |
| ".*Redistribution and use in source and binary forms,? with or without modification,?" |
| + " are permitted provided that the following conditions are met[:]?", |
| ".*This header is BSD licen[cs]ed so anyone can use the definitions to implement" |
| + " compatible drivers servers[.:]?.*", |
| ".*Redistribution and use is allowed according to the terms of the" |
| + " (?:\\p{N}-clause )?BSD licen[cs]e[.:]?.*", |
| ".*(?:[-\\p{L}\\p{N}] )?redistributions (?:of|in) source code must retain the" |
| + " (?:(?:above|accompanying) )?copyright notice(?: unmodified)?[,.:;]? this list" |
| + " of conditions[,.;:]? and the following disclaimers?[,.;:]?" |
| + " (?:[-\\p{L}\\p{N}] )?redistributions (?:in|of) binary form must reproduce the" |
| + " (?:above|accompanying) copyright notice[,.;:]? this list of conditions[,.:;]?" |
| + " and the following disclaimer in the documentation[,.;:]? and(?: |[/])or other" |
| + " materials(?: provided with the distribution)?[,.:;]{0,3}")); |
| |
| /** The Boost Software License */ |
| public static final Rule BSL1_0 = |
| license( |
| ImmutableList.of( |
| ".*SPDX-License-Identifier: BSL-1[.]?0?", |
| "<license> <name> ?Boost(?:,? Version 1[.]?0?)? ?</name>.*", |
| "<license> <name> ?Boost Software License(?:,? Version 1[.]?0?)? ?</name>.*", |
| "<license> <name> ?BSL-1[.]?0? ?</name>.*", |
| "https?://www[.]boost[.]org/LICENSE_1_0[.]txt(?: [(]?Boost license[)]?)?", |
| "Boost Software License 1[.]?0?.*", |
| ".*(?:The )?Boost Software License(?:,| ?-)?(?: Version 1[.]?0?)?")); |
| |
| /** Creative Commons Public Domain-like License */ |
| public static final Rule CC0 = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?CC0 ?</name>.*", |
| "https?://[\\p{L}\\p{N}.]*creativecommons[.]org/publicdomain/zero(?:/[\\p{N}.]*)?", |
| "To the extent possible under law[,;:]? the person who associated CC0 with this code" |
| + " has waived all copyright and related or neighboring rights to this code[.]?", |
| "To the greatest extent permitted by,? but not in contravention of,? applicable law,?" |
| + " Affirmer hereby overtly,? fully,? permanently,? irrevocably and" |
| + " unconditionally waives,? abandons,? and surrenders all of Affirmer'?s" |
| + " Copyright and Related Rights and associated claims and causes of action,?" |
| + " whether (?:now )?known or unknown", |
| "Affirmer hereby grants to each affected person a royalty-?free,?" |
| + " non(?: |-)?transferable,? non(?: |-)?sublicensable,? non(?: |-)?exclusive,?" |
| + " irrevocable,? and unconditional license to exercise Affirmer'?s Copyright" |
| + " and Related Rights in the Work")); |
| |
| /** Creative Commons Attribution -- allows commercial */ |
| public static final Rule CC_BY_C = |
| license( |
| ImmutableList.of( |
| "\\bhttps?://[\\p{L}\\p{N}.]*creativecommons[.]org/licen[cs]es/by[-\\p{L}\\p{N}.]*", |
| "(?-i:\\bAttribution(?:-(?:Share ?Alike|NoDerivs)){0,2} )")); |
| |
| /** Creative Commons Non-Commercial License */ |
| public static final Rule CC_BY_NC = |
| license( |
| ImmutableList.of( |
| "\\bhttps?://[\\p{L}\\p{N}.]*creativecommons[.]org/licenses/by" |
| + "(?:-nd)?(?:-sa)?-nc[-/\\p{L}\\p{N}.]*", |
| "\\bAttribution(?:-NoDerivs)?(?:-Share ?Alike)?" |
| + "-NonCommercial(?:-NoDerivs)?(?:-Share ?Alike)?")); |
| |
| /** Clang/LLVM License (NCSA version of MIT) */ |
| public static final Rule CLANG_LLVM = |
| license( |
| ImmutableList.of( |
| "This file is dual licensed under the MIT and the University of Illinois Open" |
| + " Source Licenses[,.;:]?", |
| "to deal with the Software without restriction,? including without limitation")); |
| |
| /** Commons Clause License */ |
| public static final Rule COMMONS_CLAUSE = license(ImmutableList.of("\\bCommons Clause")); |
| |
| /** Common Public Attribution License */ |
| public static final Rule CPAL = |
| license(ImmutableList.of("\\bCommon Public Attribution Licen[cs]e")); |
| |
| /** Eclipse Distribution License (basically BSD 3-clause plus below) */ |
| public static final Rule EDL = |
| license( |
| ImmutableList.of( |
| "https?://www[.]eclipse[.]org/org/documents/edl-v10[.]php", |
| "Eclipse Distribution Licen[cs]e(?: -)? v? ?1[.]0")); |
| |
| /** Eclipse Public License */ |
| public static final Rule EPL = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?Eclipse Public Licen[cs]e" |
| + "(?: -)?(?: (?:v ?|version )?1[.]?[0]?)? ?</name>.*", |
| "^Eclipse Public Licen[cs]e[.]?", |
| ".*under (?:(?:the|this) )?(?:terms of )?(?:the )?eclipse" |
| + " (?:public )?licen[cs]e[,.;:]?.*", |
| ".*terms of (?:(?:the|this) )?eclipse public licen[cs]e[,.;:]?.*")); |
| |
| /** European Union Public License */ |
| public static final Rule EUPL = license(ImmutableList.of(" [(]?EUPL[)]? ")); |
| |
| /** Appears in tests similar to using example.com as a test domain */ |
| public static final Rule EXAMPLES = owner(ImmutableList.of("Your Company[.]?")); |
| |
| /** FreeType Project License */ |
| public static final Rule FTL = |
| new Rule( |
| ImmutableList.of("The FreeType ProjectI(?: [(]?www[.]freetype[.]org[)]?)[,;:.]?"), |
| ImmutableList.of( |
| ".*SPDX-License-Identifier: FTL", |
| "<license> <name> ?(?:The )?Freetype Project ?</name>.*", |
| "<license> <name> ?FTL ?</name>.*", |
| "This license was inspired by the BSD,? Artistic,? and IJG [(]?Independent JPEG" |
| + " Group[)]? licenses,? which all encourage inclusion and use of free software" |
| + " in commercial and freeware products alike[,;:.]?", |
| "you must acknowledge somewhere in your documentation that you have used the FreeType" |
| + " code[.;:.]?", |
| "The FreeType Project LICENSE", |
| "The FreeType Project is distributed in several archive packages[,;.:]?", |
| "This file is part of the FreeType project,? and may only be used,? modified,? and" |
| + " distributed under the terms of the FreeType project license[,.;:]?")); |
| |
| /** Google owned */ |
| public static final Rule GOOGLE = owner(ImmutableList.of("Google,? Inc[.]?", "Google LLC")); |
| |
| /** Generic GNU General Public License */ |
| public static final Rule GPL = |
| license( |
| ImmutableList.of( |
| "\\bIn addition to the permissions in the GNU General Public License[,.;:]?", |
| "See the [\\[]?GNU[\\]]? General Public Licen[cs]e for more details[,.;:]?", |
| "\\bGNU General Public Licen[cs]e", |
| ".*gnu (?:library|lesser) general public licen[cs]e.*"), |
| ImmutableList.of( |
| "See the [\\[]?GNU[\\]]? General Public Licen[cs]e for more details[,.;:]?", |
| "In addition to the permissions in the GNU General Public License[,.;:]?")); |
| |
| /** GNU General Public License v2 */ |
| public static final Rule GPL2 = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?GNU General Public License, Version 2 ?</name>.*", |
| "<license> <name> ?The GPLv2 License ?</name>.*", |
| "<license> <name> ?GPLv2 ?</name>.*", |
| ".*SPDX-License-Identifier: GPL-2.0[+]?", |
| ".*SPDX-License-Identifier: GPL-2.0-only", |
| ".*SPDX-License-Identifier: GPL-2.0-or-later", |
| ".*[\\[]?GNU[\\]]? GPL[,;]? version 2[,.;:]?.*", |
| ".*[\\[]?GNU[\\]]? General Public Licen[cs]e[,;]? version 2[,.;:]?.*", |
| "See the [\\[]?GNU[\\]]? General Public Licen[cs]e for more details[,.;:]?", |
| "You should have received a copy of the [\\[]?GNU[\\]]? General Public Licen[cs]e", |
| ".*[\\[]?GNU[\\]]? General Public Licen[cs]e as published by the Free Software" |
| + " Foundation?(?:[']s)?[,.;:]? (?:either )?version 2.*"), |
| ImmutableList.of( |
| "See the [\\[]?GNU[\\]]? General Public Licen[cs]e for more details[,.;:]?", |
| "In addition to the permissions in the GNU General Public License[,.;:]?")); |
| |
| /** GNU General Public License v3 */ |
| public static final Rule GPL3 = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?GPLv3 ?</name>.*", |
| ".*SPDX-License-Identifier: GPL-3.0[+]?", |
| ".*[\\[]?GNU[\\]]? GPL[,;]? version 3[,.;:]?.*", |
| ".*[\\[]?GNU[\\]]? General Public Licen[cs]e[,;]? version 3[,.;:]?.*", |
| "See the [\\[]?GNU[\\]]? General Public Licen[cs]e for more details[,.;:]?", |
| "You should have received a copy of the [\\[]?GNU[\\]]? General Public Licen[cs]e", |
| ".*[\\[]?GNU[\\]]? General Public Licen[cs]e as published by the Free Software" |
| + " Foundation?(?:[']s)?[,.;:]? (?:either )?version 3.*"), |
| ImmutableList.of( |
| "See the [\\[]?GNU[\\]]? General Public Licen[cs]e for more details[,.;:]?", |
| "In addition to the permissions in the GNU General Public License[,.;:]?")); |
| |
| /** The ISC License */ |
| public static final Rule ISC = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?(?:The )?ISC(?: Licen[cs]e)? ?</name>.*", |
| ".*SPDX-License-Identifier: ISC", |
| "https?://(?:www[.])?spdx[.]org/licenses/ISC", |
| "(?:The )?ISC Licen[cs]e", |
| "Files that are completely new have a Google copyright and an ISC license[,;:.]?", |
| "ISC license used for completely new code in BoringSSL[,.;:]?", |
| "this file is available under an ISC license[,;:.]?", |
| "ISC")); |
| |
| /** The JSON License (MIT plus the sentence below) */ |
| public static final Rule JSON = |
| license(ImmutableList.of("The Software shall be used for Good,? not Evil[.]?")); |
| |
| /** GNU Lessor or Library General Public License */ |
| public static final Rule LGPL = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?GNU (?:Lesser|Library) General Public License ?</name>.*", |
| ".*SPDX-License-Identifier: LGPL.*", |
| ".*LGPL.*", |
| ".*gnu (?:library|lesser) general public licen[cs]e.*")); |
| |
| /** LibTIFF Library */ |
| public static final Rule LIBTIFF = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?libtiff(?: license)? ?</name>.*", |
| ".*SPDX-License-Identifier: libtiff", |
| "https?://(?:www[.])?fedoraproject[.]org/wiki/Licensing/libtiff", |
| "Permission to use,? copy,? modify,? distribute,? and sell this software and its" |
| + " documentation for any purpose is hereby granted without fee,? provided that" |
| + " [(]i[)] the above copyright notices and this permission notice appear in all" |
| + " copies of the software and related documentation,? and [(]ii[)] the names of" |
| + " Sam Leffler and Silicon Graphics may not be used in any advertising")); |
| |
| /** Lucent Public License v 1.02 */ |
| public static final Rule LPL1_02 = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?LPL-1[.]02 ?</name>.*", |
| ".*SPDX-License-Identifier: LPL-1[.]02", |
| "https?://plan9[.]bell-labs[.]com/plan9dist/license[.]html", |
| "https?://(?:www[.])?opensource[.]org/licenses/LPL-1[.]02", |
| "This software is (?:also )?made available under the Lucent Public License,? version" |
| + " 1[.]02", |
| "Lucent Public License,? version 1[.]02", |
| "Lucent Public License v1[.]02")); |
| |
| /** MIT licensed */ |
| public static final Rule MIT = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?(?:The )?MIT Licen[cs]e(?: [(]MIT[)])? ?</name>.*", |
| "<license> <name> ?MIT ?</name>.*", |
| ".*SPDX-License-Identifier: MIT", |
| "http://www.opensource.org/licenses/mit-license.php", |
| "^the mit licen[cs]e(?:[:] http://www.opensource.org/licenses/mit-license.php)?", |
| "^MIT licen[cs]e[,.;:]? http://www.ibiblio.org/pub/Linux/LICENSE", |
| ".*under (?:(?:the|this) )?(?:terms of )?(?:the )?mit" |
| + " (?:open source )?licen[cs]e[,.;:]?.*", |
| ".*MIT licen[cs]ed", |
| ".*terms of (?:(?:the|this) )?mit licen[cs]e[,.;:]?.*", |
| ".*this code is licen[cs]ed under the mit licen[cs]e[,;.:]?.*", |
| ".*the mit or psf open source licen[cs]es[,.]?.*", |
| ".*Dual licen[cs]ed under the MIT or.*", |
| ".*Use of this software is governed by the MIT licen[cs]e[,.;:]?.*", |
| ".*This library is free software[,.;:]? you can redistribute it and or modify it" |
| + " under the terms of the MIT licen[cs]e[,.;:]?.*", |
| ".*may be distributed under the MIT or PSF open source licen[cs]es[,.;:]?.*", |
| ".*permission is (?:hereby )?granted[,;]? free of charge[,;]? to any person.*", |
| "(?:the mit licen[cs]e )?permission is (?:hereby )?granted[,;]? free of charge[,;]?" |
| + " to any person obtaining a copy of this software and associated documentation" |
| + " files [(]?the \\p{Pi}?software\\p{Pf}[)]?[,;]? to deal (?:in|with) the" |
| + " software without restriction[,;.:]? including without limitation the rights" |
| + " to use[,;]? copy[,;]? modify[,;]? merge[,;]? publish[,;]? distribute[,;]?" |
| + " sublicense[,;]? and(?: |[/])or sell copies of the software[,;]? and to permit" |
| + " persons to whom the software is furnished to do so[,;.:]? subject to the" |
| + " following conditions[,;.:]? the above copyright notice[,;]? and this" |
| + " permission notice shall be included in all copies[,;]? or substantial" |
| + " portions of the software[,;.:]?", |
| ".*permission to use[,;]? copy[,;]? modify[,;]? (?:and )?distribute" |
| + " (?:and sell )?this software (?:and its documentation )?(?:for any purpose )?" |
| + "(?:(?:and|with or) without fee)?is (?:hereby )?granted[,;]?" |
| + " (?:without fee )?provided that the above copyright notice.*", |
| ".*I hereby give permission[,;]? free of charge[,;]? to copy[,;]? modify[,;]? and" |
| + " redistribute this software[,;]? in source or binary form[,;]? provided that" |
| + " the above copyright notice and the following disclaimer are included.*")); |
| |
| /** Microsoft Public License */ |
| public static final Rule MSPL = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?(?:The )?Microsoft Public Licen[cs]e ?</name>.*", |
| "<license> <name> ?MS-PL ?</name>.*", |
| ".*SPDX-License-Identifier: MS-PL")); |
| |
| /** NCSA License */ |
| public static final Rule NCSA = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?NCSA ?</name>.*", |
| ".*SPDX-License-Identifier: NCSA", |
| "https?://otm[.]illinois[.]edu/uiuc_openSource", |
| "https?://(?:www[.])?opensource[.]org/licenses/NCSA", |
| "University of Illinois[/]NCSA Open Source Licen[cs]e", |
| "University of Illinois NCSA Open Source Licen[cs]e", |
| "Redistributions of source code must retain the above copyright notice,? this list of" |
| + " conditions and the following disclaimers[,;:.]?")); |
| |
| /** Generic non-commercial disclaimer. */ |
| public static final Rule NON_COMMERCIAL = |
| license(ImmutableList.of("\\bNON-?COMMERCIAL LICEN[CS]E")); |
| |
| /** Rejects distribution under APACHE */ |
| public static final Rule NOT_A_CONTRIBUTION = |
| license( |
| ImmutableList.of( |
| ".*(?:" |
| + ANY_WORD |
| + " ){2}\\p{Pi}?" // 2 words to exclude false +ves |
| + "Not a Contribution[.,;:]{0,3}\\p{Pf}?.*"), // explicitly disclaims license |
| ImmutableList.of("owner as \\p{Pi}?Not a Contribution[.,;:]{0,3}\\p{Pf}?")); |
| |
| /** OpenSSL License */ |
| public static final Rule OPENSSL = |
| new Rule( |
| ImmutableList.of("The OpenSSL Project[,.;:]?"), |
| ImmutableList.of( |
| "<license> <name> ?OpenSSL ?</name>.*", |
| ".*SPDX-License-Identifier: OpenSSL", |
| "https?://(?:www[.])?openssl[.]org/source/license[.]html", |
| "Licensed under the OpenSSL license(?: [(]?the \\p{Pi}?License\\p{Pf}?[)]?)?[,.;:]?", |
| "\\p{Pi}?This product includes software developed by the OpenSSL Project for use in" |
| + " the OpenSSL Toolkit[,;:.]?" |
| + "(?: [(]?https?://(?:www[.])?openssl[.]org(?:/| )?[)]?\\p{Pf}?)?", |
| "The names \\p{Pi}?OpenSSL Toolkit\\p{Pf}? and \\p{Pi}?OpenSSL Project\\p{Pf}? must" |
| + " not be used to endorse or promote", |
| "Original SSLeay License", |
| "OpenSSL License")); |
| |
| /** Python Software Foundation */ |
| public static final Rule PSF = owner(ImmutableList.of("Python Software Foundation")); |
| |
| /** Python Software Foundation License */ |
| public static final Rule PSFL = |
| license( |
| ImmutableList.of( |
| "(?:The )?PSF Licen[cs]e", |
| ".*Python Software Foundation license(?: version \\p{N})?[,.;:]?.*", |
| ".*Permission to use[,;]? copy[,;]? modify[,;]? and distribute this Python software" |
| + " and its associated documentation for any purpose.*")); |
| |
| /** Sun Insdustry Standards Source License */ |
| public static final Rule SISSL = |
| license(ImmutableList.of("\\bSun Industry Standards Source Licen[cs]e")); |
| |
| /** Server Side Public License */ |
| public static final Rule SSPL = |
| license( |
| ImmutableList.of( |
| ".*Server Side Public Licen[cs]e.*", |
| ".*SPDX-License-Identifier: SSPL-1[.]0", |
| "\\p{Pi}?This License\\p{Pf}? refers to (?:the )?Server Side Public License[,;:.]?", |
| "If you make the functionality of the Program (?:or a modified version )?available to" |
| + " third parties as a service,? you must make the Service Source Code available", |
| "\\p{Pi}?Service Source Code\\p{Pf}? means the Corresponding Source for the Program" |
| + "(?: or the modified version),? and the Corresponding Source for all programs" |
| + " that you use to make the Program", |
| "(?:https?://)?(?:www[.])?mongodb[.]com/licensing/server-side-public-license", |
| "SSPL-\\p{N}[.]?\\p{N}?", |
| "This program is free software[,.;:]? you can redistribute it and/or modify it under" |
| + " the terms of the Server Side Public License.*", |
| "You must comply with the Server Side Public License in all respects")); |
| |
| /** Unicode Data Files and Software/Terms of Use */ |
| public static final Rule UNICODE = |
| license( |
| ImmutableList.of( |
| ".*SPDX-License-Identifier: Unicode-DFS-\\p{N}{4}", |
| ".*SPDX-License-Identifier: Unicode-TOU", |
| "https?://(?:www[.])?unicode[.]org/copyright[.]html", |
| "UNICODE,? INC[.]? LICENSE AGREEMENT(?: -)? DATA FILES AND SOFTWARE", |
| "Permission is hereby granted,? free of charge,? to any person obtaining a copy of" |
| + " the Unicode data files and any associated documentation", |
| "Certain documents and files on this website contain a legend indicating that" |
| + " \\p{Pi}?Modification is permitted[,;:.]?\\p{Pf}?", |
| "the particular set of data files known as the \\p{Pi}?Unicode Character" |
| + " Database\\p{Pf}? can be found in", |
| "Each version of the Unicode Standard has further specifications of rights and" |
| + " restrictions of use[,;:.]?", |
| "Unicode License Agreement(?: -)? Data Files and Software(?: [(]?\\p{N}{4}[)]?)?", |
| "Unicode Terms of Use")); |
| |
| /** Unlicense (public domain) */ |
| public static final Rule UNLICENSE = |
| license( |
| ImmutableList.of( |
| ".*SPDX-License-Identifier: Unlicen[cs]e", |
| "<license> <name> ?Unlicen[cs]e ?</name>.*", |
| "This is free and unencumbered software released into the public domain[,;:.]?", |
| "the author (?:or authors )?of this software dedicate any and all copyright interest" |
| + " in the software to the public domain[,;:.]?", |
| "(?:https?://)?(?:www[.])?unlicen[cs]e[.]org(?:/UNLICEN[CS]E)?")); |
| |
| /** Universal Permissive License */ |
| public static final Rule UPL = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?UPL(?:-1[.]0)? ?</name>.*", |
| ".*SPDX-License-Identifier: UPL-1[.]0", |
| "Universal Permissive License v1[.]0", |
| "The above copyright notice and either this complete permission notice or at a" |
| + " minimum a reference to the UPL must be included in all copies", |
| "The Universal Permissive License(?: [(]?UPL[)]?)?,?(?: Version 1[.]0)?")); |
| |
| /** W3C Software Notice and License */ |
| public static final Rule W3C = |
| new Rule( |
| ImmutableList.of( |
| "World Wide Web Consortium[,.;:]?", |
| "Massachusetts Institute of Technology,? European Research Consortium for Informatics" |
| + " and Mathematics, Keio University"), |
| ImmutableList.of( |
| ".*SPDX-License-Identifier: W3C(?:-(?:19980720|20021231|20150513))?", |
| "<license> <name> ? W3C(?:-(?:19980720|20021231|20150513))? ?</name>.*", |
| "https?://(?:www[.])?opensource[.]org/licenses/W3C", |
| "https?://(?:www[.])?w3[.]org/Consortium/Legal/copyright-software-19980720[.]html", |
| "https?://(?:www[.])?w3[.]org/Consortium/Legal/2002" |
| + "/copyright-software-20021231[.]html", |
| "https?://(?:www[.])?w3[.]org/Consortium/Legal/2015/copyright-software-and-document", |
| "If none exist,? a short notice of the following form", |
| "If none exist,? the W3C Software Short Notice should be included", |
| "If none exist,? the W3C Software and Document Short Notice should be included[.]?", |
| "W3C(?:®|[(]R[)])? SOFTWARE (?:NOTICE AND )?LICEN[CS]E" |
| + "(?: [(]?(?:1998-07-20|2002-12-31|2015-05-13)[)]?)?")); |
| |
| /** Watcom-1.0 license */ |
| public static final Rule WATCOM = |
| license( |
| ImmutableList.of( |
| ".*SPDX-License-Identifier: Watcom-1[.]0", |
| ".*Sybase Open Watcom Public License.*", |
| ".*automatically without notice if You[,;]? at any time during the term of this" |
| + " Licen[cs]e[,;]? commence an action for patent infringement [(]?including as a" |
| + " cross claim or counterclaim[)]?.*")); |
| |
| /** Do What The Fuck You Want To Public License */ |
| public static final Rule WTFPL = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?WTFPL ?</name>.*", |
| ".*SPDX-License-Identifier: WTFPL", |
| "\\bDo What The F.ck You Want To Public Licen[cs]e")); |
| |
| /** X.Net License */ |
| public static final Rule XNET = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?X[.]Net(?: Licen[cs]e)? ?</name>.*", |
| "<license> <name> ?Xnet ?</name>.*", |
| ".*SPDX-License-Identifier: Xnet", |
| "https?://(?:www[.])?opensource[.]org/licenses/Xnet", |
| "X.Net Licen[cs]e")); |
| |
| /** Zend Engine License version 2.00 */ |
| public static final Rule ZEND = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?Zend(?: Engine)? License(?: (?:v|version )2[.]00?)? ?</name>.*", |
| "<license> <name> ?Zend(?:-2[.]00?)? ?</name>.*", |
| ".*SPDX-License-Identifier: Zend-2[.]0", |
| "https?://(?:www[.])?zend[.]com/license/2_00[.]txt", |
| "Zend (?:Engine )?License,? v2[.]00?", |
| "The Zend Engine License,? version 2[.]00?")); |
| |
| /** Zlib/libpng License */ |
| public static final Rule ZLIB = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?zlib Licen[cs]e ?</name>.*", |
| "<license> <name> ?zlib/libpng Licen[cs]e(?: with Acknowledgement)? ?</name>.*", |
| ".*SPDX-License-Identifier: Zlib", |
| ".*SPDX-License-Identifier: zlib-acknowledgement", |
| "https?://(?:www[.])?opensource[.]org/licenses/zlib-license[.]php", |
| "https?://(?:www[.])?zlib[.]net/zlib_license[.]html", |
| "https?://(?:www[.])?opensource[.]org/licenses/Zlib", |
| "https?://(?:www[.])?fedoraproject[.]org/wiki/Licensing/ZlibWithAcknowledgement", |
| "Permission is granted to anyone to use this software for any purpose,? including" |
| + " commercial applications,? and to alter it and redistribute it freely,?" |
| + " subject to the following restrictions[,.;:]?", |
| "(?:The )?zlib/libpng License(?: with Acknowledgement)?", |
| "(?:The )?zlib/libpng License [(]Zlib[)]", |
| "zlib licen[cs]e")); |
| |
| /** Zope Public License */ |
| public static final Rule ZPL = |
| license( |
| ImmutableList.of( |
| "<license> <name> ?Zope Public License,?(?: version \\p{N}[.]?\\p{N}?)? ?</name>.*", |
| "<license> <name> ?ZPL-\\p{N}[.]?\\p{N}? ?</name>.*", |
| ".*SPDX-License-Identifier: ZPL-\\p{N}[.]?\\p{N}?", |
| "https?://(?:www[.])?opensource[.]org/licenses/ZPL-\\p{N}[.]?\\p{N}?", |
| "This product includes software developed by Zope Corporation", |
| "Names associated with Zope or Zope Corporation must not be used", |
| "The name Zope Corporation ?[(]tm[)] must not be used", |
| "Names of the copyright holders must not be used to endorse or promote products" |
| + " derived from this software without prior written permission from the" |
| + " copyright holders[,;:.]?", |
| "Zope Public License(?: [(]?ZPL[)]?)?(?: Version)?(?: \\p{N}[.]?\\p{N}?)?")); |
| |
| @VisibleForTesting |
| static ImmutableMap<String, Rule> lookup = |
| ImmutableMap.<String, Rule>builder() |
| .put("AFL2.1", AFL2_1) |
| .put("AFL3.0", AFL3_0) |
| .put("AGPL", AGPL) |
| .put("ANDROID", ANDROID) |
| .put("APACHE1.1", APACHE1_1) |
| .put("APACHE2", APACHE2) |
| .put("ARTISTIC_LICENSE", ARTISTIC_LICENSE) |
| .put("BEER_WARE", BEER_WARE) |
| .put("BOOST", BSL1_0) |
| .put("BSD", BSD) |
| .put("BSL1.0", BSL1_0) |
| .put("CC0", CC0) |
| .put("CC_BY_C", CC_BY_C) |
| .put("CC_BY_NC", CC_BY_NC) |
| .put("CLANG_LLVM", CLANG_LLVM) |
| .put("COMMONS_CLAUSE", COMMONS_CLAUSE) |
| .put("CPAL", CPAL) |
| .put("EDL", EDL) |
| .put("EPL", EPL) |
| .put("EUPL", EUPL) |
| .put("EXAMPLES", EXAMPLES) |
| .put("FTL", FTL) |
| .put("GOOGLE", GOOGLE) |
| .put("GPL", GPL) |
| .put("GPL2", GPL2) |
| .put("GPL3", GPL3) |
| .put("JSON", JSON) |
| .put("LGPL", LGPL) |
| .put("LIBTIFF", LIBTIFF) |
| .put("LPL1.02", LPL1_02) |
| .put("MIT", MIT) |
| .put("MS-PL", MSPL) |
| .put("NCSA", NCSA) |
| .put("NON_COMMERCIAL", NON_COMMERCIAL) |
| .put("NOT_A_CONTRIBUTION", NOT_A_CONTRIBUTION) |
| .put("OPENSSL", OPENSSL) |
| .put("PSF", PSF) |
| .put("PSFL", PSFL) |
| .put("SISSL", SISSL) |
| .put("SSPL", SSPL) |
| .put("UNLICENSE", UNLICENSE) |
| .put("UNICODE", UNICODE) |
| .put("UPL", UPL) |
| .put("W3C", W3C) |
| .put("WATCOM", WATCOM) |
| .put("WTFPL", WTFPL) |
| .put("XNET", XNET) |
| .put("ZEND", ZEND) |
| .put("ZLIB", ZLIB) |
| .put("ZPL", ZPL) |
| .build(); |
| |
| /** Immutable set of copyright rules described as lists of regular expression strings. */ |
| public static class RuleSet { |
| public final ImmutableList<String> firstPartyLicenses; |
| public final ImmutableList<String> thirdPartyLicenses; |
| public final ImmutableList<String> forbiddenLicenses; |
| public final ImmutableList<String> firstPartyOwners; |
| public final ImmutableList<String> thirdPartyOwners; |
| public final ImmutableList<String> forbiddenOwners; |
| public final ImmutableList<String> excludePatterns; |
| |
| /** Returns a Builder object for the RuleSet class. */ |
| public static Builder builder() { |
| return new Builder(); |
| } |
| |
| public String signature() { |
| StringBuilder sb = new StringBuilder(); |
| sb.append("1pl:\n"); |
| sb.append(Joiner.on("\n").join(firstPartyLicenses)); |
| sb.append("\n1po:\n"); |
| sb.append(Joiner.on("\n").join(firstPartyOwners)); |
| sb.append("\n3pl:\n"); |
| sb.append(Joiner.on("\n").join(thirdPartyLicenses)); |
| sb.append("\n3po:\n"); |
| sb.append(Joiner.on("\n").join(thirdPartyOwners)); |
| sb.append("\n!!l:\n"); |
| sb.append(Joiner.on("\n").join(forbiddenLicenses)); |
| sb.append("\n!!o:\n"); |
| sb.append(Joiner.on("\n").join(forbiddenOwners)); |
| sb.append("\nxx:\n"); |
| sb.append(Joiner.on("\n").join(excludePatterns)); |
| return Hashing.farmHashFingerprint64().hashBytes(sb.toString().getBytes(UTF_8)).toString(); |
| } |
| |
| /** Implements the Builder pattern for CopyrightPatterns.RuleSet. */ |
| public static class Builder { |
| private final ImmutableList.Builder<String> firstPartyLicenses = |
| ImmutableList.<String>builder(); |
| private final ImmutableList.Builder<String> thirdPartyLicenses = |
| ImmutableList.<String>builder(); |
| private final ImmutableList.Builder<String> forbiddenLicenses = |
| ImmutableList.<String>builder(); |
| private final ImmutableList.Builder<String> firstPartyOwners = |
| ImmutableList.<String>builder(); |
| private final ImmutableList.Builder<String> thirdPartyOwners = |
| ImmutableList.<String>builder(); |
| private final ImmutableList.Builder<String> forbiddenOwners = ImmutableList.<String>builder(); |
| private final ImmutableList.Builder<String> excludePatterns = ImmutableList.<String>builder(); |
| |
| private Builder() {} |
| |
| /** Create a RuleSet reflecting the current state of this Builder. */ |
| public RuleSet build() { |
| return new RuleSet( |
| firstPartyLicenses.build(), |
| thirdPartyLicenses.build(), |
| forbiddenLicenses.build(), |
| firstPartyOwners.build(), |
| thirdPartyOwners.build(), |
| forbiddenOwners.build(), |
| excludePatterns.build()); |
| } |
| |
| /** Look up `ruleName` and add it as a 1p rule type. */ |
| public Builder addFirstParty(String ruleName) { |
| Rule pattern = lookup.get(ruleName); |
| if (pattern == null) { |
| throw unknownPatternName(ruleName); |
| } |
| if (pattern.licenses != null) { |
| firstPartyLicenses.addAll(pattern.licenses); |
| } |
| if (pattern.owners != null) { |
| firstPartyOwners.addAll(pattern.owners); |
| } |
| if (pattern.exclusions != null) { |
| excludePatterns.addAll(pattern.exclusions); |
| } |
| return this; |
| } |
| |
| /** Add the regular expression `pattern` as a 1p owner. */ |
| public Builder addFirstPartyOwner(String pattern) { |
| firstPartyOwners.add(pattern); |
| return this; |
| } |
| |
| /** Add the regular expression `pattern` as a 1p license */ |
| public Builder addFirstPartyLicense(String pattern) { |
| firstPartyLicenses.add(pattern); |
| return this; |
| } |
| |
| /** Look up `ruleName` and add it as a 3p rule type. */ |
| public Builder addThirdParty(String ruleName) { |
| Rule pattern = lookup.get(ruleName); |
| if (pattern == null) { |
| throw unknownPatternName(ruleName); |
| } |
| if (pattern.licenses != null) { |
| thirdPartyLicenses.addAll(pattern.licenses); |
| } |
| if (pattern.owners != null) { |
| thirdPartyOwners.addAll(pattern.owners); |
| } |
| if (pattern.exclusions != null) { |
| excludePatterns.addAll(pattern.exclusions); |
| } |
| return this; |
| } |
| |
| /** Add the regular expression `pattern` as a 3p owner. */ |
| public Builder addThirdPartyOwner(String pattern) { |
| thirdPartyOwners.add(pattern); |
| return this; |
| } |
| |
| /** Add the regular expression `pattern` as a 3p license. */ |
| public Builder addThirdPartyLicense(String pattern) { |
| thirdPartyLicenses.add(pattern); |
| return this; |
| } |
| |
| /** Look up `ruleName` and add it as a forbidden rule type. */ |
| public Builder addForbidden(String ruleName) { |
| Rule pattern = lookup.get(ruleName); |
| if (pattern == null) { |
| throw unknownPatternName(ruleName); |
| } |
| if (pattern.licenses != null) { |
| forbiddenLicenses.addAll(pattern.licenses); |
| } |
| if (pattern.owners != null) { |
| forbiddenOwners.addAll(pattern.owners); |
| } |
| if (pattern.exclusions != null) { |
| excludePatterns.addAll(pattern.exclusions); |
| } |
| return this; |
| } |
| |
| /** Add the regular expression `pattern` as a forbidden owner. */ |
| public Builder addForbiddenOwner(String pattern) { |
| forbiddenOwners.add(pattern); |
| return this; |
| } |
| |
| /** Add the regular expression `pattern` as a forbidden license. */ |
| public Builder addForbiddenLicense(String pattern) { |
| forbiddenLicenses.add(pattern); |
| return this; |
| } |
| |
| /** Look up `ruleName` and add it as a rule type to ignore completely. */ |
| public Builder exclude(String ruleName) { |
| Rule pattern = lookup.get(ruleName); |
| if (pattern == null) { |
| throw unknownPatternName(ruleName); |
| } |
| if (pattern.licenses != null) { |
| excludePatterns.addAll(pattern.licenses); |
| } |
| if (pattern.owners != null) { |
| excludePatterns.addAll(pattern.owners); |
| } |
| if (pattern.exclusions != null) { |
| excludePatterns.addAll(pattern.exclusions); |
| } |
| return this; |
| } |
| |
| /** Add the regular expression `pattern` to the list of patterns to ignore when found. */ |
| public Builder excludePattern(String pattern) { |
| excludePatterns.add(pattern); |
| return this; |
| } |
| } |
| |
| private RuleSet( |
| ImmutableList<String> firstPartyLicenses, |
| ImmutableList<String> thirdPartyLicenses, |
| ImmutableList<String> forbiddenLicenses, |
| ImmutableList<String> firstPartyOwners, |
| ImmutableList<String> thirdPartyOwners, |
| ImmutableList<String> forbiddenOwners, |
| ImmutableList<String> excludePatterns) { |
| this.firstPartyLicenses = firstPartyLicenses; |
| this.thirdPartyLicenses = thirdPartyLicenses; |
| this.forbiddenLicenses = forbiddenLicenses; |
| this.firstPartyOwners = firstPartyOwners; |
| this.thirdPartyOwners = thirdPartyOwners; |
| this.forbiddenOwners = forbiddenOwners; |
| this.excludePatterns = excludePatterns; |
| } |
| |
| private static UnknownPatternName unknownPatternName(String ruleName) { |
| int minDist = -1; |
| for (String key : lookup.keySet()) { |
| int dist = StringUtils.getLevenshteinDistance(key, ruleName); |
| if (minDist < 0 || dist < minDist) { |
| minDist = dist; |
| } |
| } |
| ImmutableList.Builder<String> closeMatches = ImmutableList.builder(); |
| int numClose = 0; |
| if (minDist < 3) { |
| for (String key : lookup.keySet()) { |
| int dist = StringUtils.getLevenshteinDistance(key, ruleName); |
| if (dist == minDist) { |
| closeMatches.add(key); |
| numClose++; |
| } |
| } |
| } |
| String matches = Joiner.on(", ").join(numClose > 0 ? closeMatches.build() : lookup.keySet()); |
| int lastIndex = matches.lastIndexOf(", "); |
| if (lastIndex > 0) { |
| matches = matches.substring(0, lastIndex + 2) + "or " + matches.substring(lastIndex + 2); |
| } |
| String message = |
| "Unknown license or copyright owner name: " |
| + ruleName |
| + "\n\n" |
| + (numClose > 0 |
| ? "Did you mean " + matches + "?" |
| : "Known names are: " + matches + "."); |
| |
| return new UnknownPatternName(message); |
| } |
| } |
| |
| /** Initialize a pattern consisting of only a list of owner patterns. */ |
| private static Rule owner(ImmutableList<String> owners) { |
| return new Rule(owners, null, null); |
| } |
| |
| /** Initialize a pattern consisting of only a list of license patterns. */ |
| private static Rule license(ImmutableList<String> licenses) { |
| return new Rule(null, licenses, null); |
| } |
| |
| /** Initialize a pattern consisting of lists of license and exclusion patterns. */ |
| private static Rule license(ImmutableList<String> licenses, ImmutableList<String> exclusions) { |
| return new Rule(null, licenses, exclusions); |
| } |
| |
| /** |
| * A matching rule described by lists of regular expressions matching relevant licenses and |
| * owners, and a list of regular expressions matching hits to ignore when found. |
| * |
| * <p>e.g. The text "not a contribution" is important for Apache2 licensed code because it |
| * disclaims the terms of the otherwise described Apache2 license. However, this very text exists |
| * inside the Apache2 license to allow such disclaimers. An effective rule for /not a |
| * contribution/ will have to match /not a contribution/ but ignore /owner as "not a |
| * contribution"/ like it appears in the license itself. |
| */ |
| @VisibleForTesting |
| static class Rule { |
| public final ImmutableList<String> exclusions; |
| public final ImmutableList<String> owners; |
| public final ImmutableList<String> licenses; |
| |
| private Rule(ImmutableList<String> owners, ImmutableList<String> licenses) { |
| this(owners, licenses, null); |
| } |
| |
| private Rule( |
| ImmutableList<String> owners, |
| ImmutableList<String> licenses, |
| ImmutableList<String> exclusions) { |
| this.owners = owners; |
| this.licenses = licenses; |
| this.exclusions = exclusions; |
| } |
| } |
| |
| /** Thrown when requesting a pattern by a name that does not appear among the known patterns. */ |
| public static class UnknownPatternName extends NoSuchElementException { |
| UnknownPatternName(String message) { |
| super(message); |
| } |
| } |
| } |
