scalafix.conf

# Copyright: 2018 Sam Halliday
# License: https://www.apache.org/licenses/LICENSE-2.0

# This file enforces the scalazzi safe subset of scala.
#
# For further information, see https://github.com/scalaz/scalazzi

rules = [
  Disable
  DisableSyntax
  ExplicitResultTypes
  LeakingImplicitClassVal
  MissingFinal
  NoAutoTupling
  NoValInForComprehension
  ProcedureSyntax
  RemoveUnused
]

Disable.symbols = [
  {
    regex = "^\\Qscala/collection/mutable\\E.*$"
    message = "Java collections have better performance, which is what I assume you were trying to do"
  }
  {
    regex = "^\\Qscala/collection/parallel\\E.*$"
    message = "parallel collections are low performance and block the thread, prefer scalaz.ApplyN"
  }
  {
    regex = "^\\Qscala/math/Big\\E.*$"
    message = "scala arbitrary precision numbers are broken: https://github.com/scala/bug/issues/9670"
  }
  {
    regex = {
      includes = [
        "^\\Qjava/io\\E.*$"
        "^\\Qscala/io/Source\\E.*$"
      ]
    }
    message = "legacy blocking API, prefer java.nio"
  }
  {
    regex = "^\\Qjava/net/URL#\\E.*$"
    message = "URL talks to the network for equality, prefer URI"
  }
  {
    regex = {
      includes = [
        # overrides not fully implemented: https://github.com/scalacenter/scalafix/pull/634
        "^.*\\Q#equals().\\E$"
        "^.*\\Q#hashCode().\\E$"
        "^.*\\Q#toString().\\E$" # doesn't catch string interpolators...
        # more to add here...
      ]
    }
    message = "prefer scalaz.{Equal, Show, Liskov, etc}"
  }

  {
    symbol = "scala/Enumeration"
    message = "prefer a sealed abstract class"
  }

  {
    regex = {
      includes = [
        "^\\Qscala/util/Either.LeftProjection#get().\\E$"
        "^\\Qscala/util/Either.RightProjection#get().\\E$"
        "^\\Qscala/util/Try#get().\\E$"
        "^\\Qscala/Option#get().\\E$"
        "^\\Qscala/collection/IterableLike#head().\\E$"
      ]
    }
    message = "not a total function"
  }
]

Disable.ifSynthetic = [
   "java/io/Serializable"
   "scala/Any"
   "scala/Product"

   # local type inference + covariant types fires this
   # "scala/Nothing"

   # when upstream broke noImplicitConversion and we don't agree that their
   # implicits are worth the mental burden.
   "scala/Option.option2Iterable"
   "scala/Predef.any2stringadd"

  # I don't understand why these are synthetic
  # https://github.com/scalacenter/scalafix/issues/703
  {
    regex = {
      includes = [
        "^\\Qscala/collection/MapLike#apply().\\E$"
        "^\\Qscala/collection/LinearSeqOptimized#apply().\\E$"
      ]
    }
    message = "not a total function"
  }
]

Disable.unlessInside = [
  {
    safeBlocks = [
      "fommil/std/IO"
      "scalaz/ioeffect/IO"
      "scalaz/ioeffect/Task"
      "scalaz/ApplicativeError.handleError"
      "scalaz/ApplicativeError.raiseError"
      "scalaz/syntax/ApplicativeErrorOps.handleError"
      "scalaz/syntax/ApplicativeErrorOps.recover"
      "scalaz/syntax/MonadErrorOps.emap"
      "scalaz/zio/IO"
      "scalaz/zio/Task"
      "scalaz/zio/UIO"
      "scalaz/zio/ZIO"
      "scalaz/zio/ZIO_E_Throwable.effect"
      "scalaz/zio/ZIOFunctions.effectAsync"
      "scalaz/zio/ZIOFunctions.effectTotal"
      "scalaz/zio/ZIOFunctions.effectTotalWith"
      "scalaz/zio/ZIOFunctions.fail"
      "scalaz/zio/ZIOFunctions.halt"
    ]
    symbols = [
      {
        # This takes the approach of banning everything and then blessing things
        # we trust. It would be entirely feasible to do it the other way and
        # list the explicit list of things that we need to go through IO, but it
        # is less safe. We can have another rule if something in an "excludes"
        # glob catches unsafe things.
        #
        # If something is referentially transparent but not total, instead of
        # adding to this excludes list, add it to the includes list of the
        # scalaz.Maybe.attempt safeBlock. If it can return `null`, add it to a
        # scalaz.Maybe.fromNullable safeBlock.
        regex = {
          includes = [
            "^\\Qjava/\\E.*$"
            #"^.*$"
          ]
          excludes = [
            "^fommil.*$"
            "^scalaz.*$"
            "^\\Qjava/lang/String#\\E.*$"
            "^\\Qjava/time/Instant#\\E.*$"
            "^\\Qjava/time/ZonedDateTime#\\E.*$"
            "^\\Qjava/time/temporal/ChronoUnit#\\E.*$"
            "^\\Qjava/net/URI#\\E.*$"
            "^\\Qjava/net/URLEncoder#\\E.*$"
            "^\\Qjava/net/URLDecoder#\\E.*$"
            # primitives are not supported: https://github.com/scalameta/scalameta/issues/1488

            # WORKAROUND https://github.com/scalacenter/scalafix/issues/715
            "^\\Qjava/\\E$"
            "^\\Qjava/lang/\\E$"
            "^\\Qjava/time/\\E$"
            "^\\Qjava/net\\E$"
          ]
        }
        message = "Untrusted third party library must be called from IO, or blessed in scalafix.conf"
      }
    ]
  }
  {
    safeBlocks = [
      "scalaz/`\/`.fromTryCatchNonFatal",
      "scalaz/`\/`.fromTryCatchThrowable",
      "scalaz/Maybe.attempt",
      "scalaz/Maybe.fromTryCatchNonFatal",
      "scalaz/Maybe.fromTryCatchThrowable"
    ]
    symbols = [
      {
        regex = {
          includes = [
            # should live in a common file so we don't need to duplicate
            "^\\Qjava/net/URLEncoder#\\E.*$"
            "^\\Qjava/net/URLDecoder#\\E.*$"
          ]
          excludes = [
          ]
        }
        message = "Deterministic method is not total, must be called via Maybe.attempt, \/.fromTryCatchNonFatal, etc."
      }
    ]
  }
]

DisableSyntax {
  noAsInstanceOf = true
  noContravariantTypes = true
  noCovariantTypes = true
  noDefaultArgs = true
  noFinalVal = true
  noFinalize = true
  noImplicitConversion = true
  noImplicitObject = true
  noIsInstanceOf = true
  noNulls = true
  noReturns = true
  noSemicolons = true
  noTabs = true
  noThrows = true
  noUniversalEquality = true
  noValInAbstract = true
  noValPatterns = true
  noVars = true
  noWhileLoops = true
  noXml = true
}

ExplicitResultTypes {
  unsafeShortenNames = true

  fatalWarnings = true

  # these apply to non-implicits
  memberKind = [Def, Val]
  memberVisibility = [Public, Protected]

  # turn to the max...
  skipSimpleDefinitions = false
  skipLocalImplicits = false
}