private def genPositiveInt: Gen[Int] = Gen.chooseNum()

in ratatool-scalacheck/src/main/scala/com/spotify/ratatool/scalacheck/ProtoBufGenerator.scala [158:205]
42 lines of code
23 McCabe index (conditional complexity)

  private def genPositiveInt: Gen[Int] = Gen.chooseNum(0, Int.MaxValue)
  private def genPositiveLong: Gen[Long] = Gen.chooseNum(0L, Long.MaxValue)

  private def genField(field: FieldDescriptor): Gen[PartialWriter] = {
    val id = field.getNumber
    def genV: Gen[PartialWriter] = field.getType match {
      case Type.DOUBLE   => Arbitrary.arbDouble.arbitrary.map(v => DoubleWriter(id, v))
      case Type.FLOAT    => Arbitrary.arbFloat.arbitrary.map(v => FloatWriter(id, v))
      case Type.INT32    => Arbitrary.arbInt.arbitrary.map(v => Int32Writer(id, v))
      case Type.INT64    => Arbitrary.arbLong.arbitrary.map(v => Int64Writer(id, v))
      case Type.UINT32   => genPositiveInt.map(v => UInt32Writer(id, v))
      case Type.UINT64   => genPositiveLong.map(v => UInt64Writer(id, v))
      case Type.SINT32   => genPositiveInt.map(v => SInt32Writer(id, v))
      case Type.SINT64   => genPositiveLong.map(v => SInt64Writer(id, v))
      case Type.FIXED32  => genPositiveInt.map(v => Fixed32Writer(id, v))
      case Type.FIXED64  => genPositiveLong.map(v => Fixed64Writer(id, v))
      case Type.SFIXED32 => genPositiveInt.map(v => SFixed32Writer(id, v))
      case Type.SFIXED64 => genPositiveLong.map(v => SFixed64Writer(id, v))
      case Type.BOOL     => Arbitrary.arbBool.arbitrary.map(v => BoolWriter(id, v))
      case Type.STRING   => Arbitrary.arbString.arbitrary.map(v => StringWriter(id, v))

      case Type.ENUM =>
        Gen
          .oneOf(field.getEnumType.getValues.asScala)
          .map(e => EnumWriter(id, e))

      case Type.BYTES =>
        Gen
          .choose(1, 40)
          .flatMap(Gen.listOfN(_, Arbitrary.arbByte.arbitrary))
          .map(l => BytesWriter(id, l.toArray))

      case Type.MESSAGE =>
        generate(field.getMessageType)
          .map(b => BytesWriter(id, b))

      case t => throw new RuntimeException(s"Unsupported field type $t")
    }

    field.toProto.getLabel match {
      case Label.LABEL_OPTIONAL =>
        Arbitrary.arbBool.arbitrary.flatMap { e =>
          if (e) genV else NullWriter() _
        }
      case Label.LABEL_REQUIRED => genV
      case Label.LABEL_REPEATED => Gen.listOf(genV).map(l => RepeatedWriter(l))
    }
  }