Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* sbt IO
* Copyright Scala Center, Lightbend, and Mark Harrah
*
* Licensed under Apache License 2.0
* SPDX-License-Identifier: Apache-2.0
*
* See the NOTICE file distributed with this work for
* additional information regarding copyright ownership.
*/
package sbt.internal.nio
import java.nio.file.Path
import sbt.io._
import sbt.nio.file.Glob.FullFileGlob
import sbt.nio.file.RelativeGlob.{ Matcher, NoPath }
import sbt.nio.file.{ AnyPath, Glob, RecursiveGlob, RelativeGlob }
private[sbt] object Globs {
private[sbt] def apply(base: Path, recursive: Boolean, fileFilter: FileFilter): Glob = {
fileFilterToRelativeGlob(fileFilter) match {
case Some(relativeGlob) =>
Glob(base, if (recursive) RecursiveGlob / relativeGlob else relativeGlob)
case None =>
FullFileGlob(base, recursive, fileFilter)
}
}
private[sbt] def fileFilterToRelativeGlob(fileFilter: FileFilter): Option[RelativeGlob] =
fileFilter match {
case nameFilter: NameFilter => nameFilterToRelativeGlob(nameFilter)
case af: AndFilter =>
if (af.left == NothingFilter || af.right == NothingFilter) Some(NoPath)
else if (af.left == AllPassFilter) fileFilterToRelativeGlob(af.right)
else if (af.right == AllPassFilter) fileFilterToRelativeGlob(af.left)
else {
(fileFilterToRelativeGlob(af.left), fileFilterToRelativeGlob(af.right)) match {
case (no @ Some(NoPath), _) => no
case (_, no @ Some(NoPath)) => no
case (Some(AnyPath), right) => right
case (left, Some(AnyPath)) => left
case (Some(left: Matcher), Some(right: Matcher)) => Some(Matcher.and(left, right))
case _ => None
}
}
case nf: NotFilter =>
nf.fileFilter match {
case NothingFilter => Some(AnyPath)
case AllPassFilter => Some(NoPath)
case f =>
fileFilterToRelativeGlob(f).collect { case m: Matcher =>
Matcher.not(m)
}
}
case of: OrFilter =>
if (of.left == AllPassFilter || of.right == AllPassFilter) Some(AnyPath)
else if (of.left == NothingFilter) fileFilterToRelativeGlob(of.right)
else if (of.right == NothingFilter) fileFilterToRelativeGlob(of.left)
else {
(fileFilterToRelativeGlob(of.left), fileFilterToRelativeGlob(of.right)) match {
case (Some(NoPath), right) => right
case (left, Some(NoPath)) => left
case (any @ Some(AnyPath), _) => any
case (_, any @ Some(AnyPath)) => any
case (Some(left: Matcher), Some(right: Matcher)) => Some(Matcher.or(left, right))
case _ => None
}
}
case AllPassFilter => Some(AnyPath)
case NothingFilter => Some(NoPath)
case _ => None
}
private[sbt] def nameFilterToRelativeGlob(nameFilter: NameFilter): Option[Matcher] =
nameFilter match {
case AllPassFilter => Some(AnyPath)
case af: AndNameFilter =>
if (af.left == NothingFilter || af.right == NothingFilter) Some(NoPath)
else if (af.left == AllPassFilter) nameFilterToRelativeGlob(af.right)
else if (af.right == AllPassFilter) nameFilterToRelativeGlob(af.left)
else
(nameFilterToRelativeGlob(af.left), nameFilterToRelativeGlob(af.right)) match {
case (Some(AnyPath), right) => right
case (left, Some(AnyPath)) => left
case (no @ Some(NoPath), _) => no
case (_, no @ Some(NoPath)) => no
case (Some(l), Some(r)) => Some(Matcher.and(l, r))
case _ => None
}
case ef: ExactFilter => Some(Matcher(ef.matchName))
case ef: ExtensionFilter =>
ef.extensions match {
case extensions if extensions.length == 1 => Some(Matcher(s"*.${extensions.head}"))
case extensions => Some(Matcher(s"*.${extensions.mkString("{", ",", "}")}"))
}
case NothingFilter => Some(NoPath)
case nf: NotNameFilter =>
if (nf.fileFilter == NothingFilter) Some(AnyPath)
else nameFilterToRelativeGlob(nf.fileFilter).map(Matcher.not)
case of: OrNameFilter =>
if (of.left == AllPassFilter || of.right == AllPassFilter) Some(AnyPath)
else if (of.left == NothingFilter) nameFilterToRelativeGlob(of.right)
else if (of.right == NothingFilter) nameFilterToRelativeGlob(of.left)
else
(nameFilterToRelativeGlob(of.left), nameFilterToRelativeGlob(of.right)) match {
case (any @ Some(AnyPath), _) => any
case (_, any @ Some(AnyPath)) => any
case (Some(NoPath), right) => right
case (left, Some(NoPath)) => left
case (Some(l), Some(r)) => Some(Matcher.or(l, r))
case _ => None
}
case pf: PatternFilter => Some(Matcher(s"${pf.parts.mkString("*")}"))
case pf: PrefixFilter => Some(Matcher(s"${pf.prefix}*"))
case sf: SimpleFilter => Some(Matcher(sf.acceptFunction))
case sf: SuffixFilter => Some(Matcher(s"*${sf.suffix}"))
case _ => None
}
}
