content
stringlengths 0
13M
| path
stringlengths 4
263
| contentHash
stringlengths 1
10
|
|---|---|---|
fun test() {
foo@ for (n in 1..10) {
if (n == 5) continue@foo
if (n > 8) break@/*rename*/foo
}
} | plugins/kotlin/idea/tests/testData/refactoring/rename/labeledLoopByLabelRefInBreak2/before/test.kt | 1109975852 |
// "Create class 'A'" "true"
// ERROR: Unresolved reference: A
import J.A
class X {
} | plugins/kotlin/idea/tests/testData/quickfix/createFromUsage/createClass/importDirective/classWithJavaQualifier.after.kt | 3400554559 |
package com.haishinkit.flv
object FlvAacPacketType {
const val SEQ: Byte = 0x00
const val RAW: Byte = 0x01
}
| haishinkit/src/main/java/com/haishinkit/flv/FlvAacPacketType.kt | 1388734098 |
// "Create actual class for module testModule_JS (JS)" "true"
expect sealed class Sealed
expect object Obj : Sealed
expect class <caret>Klass(x: Int) : Sealed
| plugins/kotlin/idea/tests/testData/multiModuleQuickFix/createActual/sealedSubclass/header/header.kt | 3244678626 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.idea.intentions
import com.intellij.codeInsight.intention.LowPriorityAction
import com.intellij.openapi.editor.Editor
import org.jetbrains.kotlin.idea.base.resources.KotlinBundle
import org.jetbrains.kotlin.idea.codeinsight.api.classic.intentions.SelfTargetingIntention
import org.jetbrains.kotlin.idea.core.implicitModality
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.psi.KtCallableDeclaration
import org.jetbrains.kotlin.psi.KtNamedFunction
import org.jetbrains.kotlin.psi.KtProperty
import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
class AddOpenModifierIntention : SelfTargetingIntention<KtCallableDeclaration>(
KtCallableDeclaration::class.java, KotlinBundle.lazyMessage("make.open")
), LowPriorityAction {
override fun isApplicableTo(element: KtCallableDeclaration, caretOffset: Int): Boolean {
if (element !is KtProperty && element !is KtNamedFunction) return false
if (element.hasModifier(KtTokens.OPEN_KEYWORD)
|| element.hasModifier(KtTokens.ABSTRACT_KEYWORD)
|| element.hasModifier(KtTokens.PRIVATE_KEYWORD)
) return false
val implicitModality = element.implicitModality()
if (implicitModality == KtTokens.OPEN_KEYWORD || implicitModality == KtTokens.ABSTRACT_KEYWORD) return false
val ktClassOrObject = element.containingClassOrObject ?: return false
return ktClassOrObject.hasModifier(KtTokens.ENUM_KEYWORD)
|| ktClassOrObject.hasModifier(KtTokens.OPEN_KEYWORD)
|| ktClassOrObject.hasModifier(KtTokens.ABSTRACT_KEYWORD)
|| ktClassOrObject.hasModifier(KtTokens.SEALED_KEYWORD)
}
override fun applyTo(element: KtCallableDeclaration, editor: Editor?) {
element.addModifier(KtTokens.OPEN_KEYWORD)
}
} | plugins/kotlin/idea/src/org/jetbrains/kotlin/idea/intentions/AddOpenModifierIntention.kt | 3427602587 |
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.testFramework.assertions
import com.intellij.openapi.util.text.StringUtilRt
import com.intellij.rt.execution.junit.FileComparisonFailure
import com.intellij.util.io.readText
import org.assertj.core.api.ListAssert
import org.yaml.snakeyaml.DumperOptions
import org.yaml.snakeyaml.Yaml
import org.yaml.snakeyaml.nodes.Node
import org.yaml.snakeyaml.nodes.Tag
import org.yaml.snakeyaml.representer.Represent
import org.yaml.snakeyaml.representer.Representer
import java.nio.file.Path
import java.util.regex.Pattern
class ListAssertEx<ELEMENT>(actual: List<ELEMENT>) : ListAssert<ELEMENT>(actual) {
fun toMatchSnapshot(snapshotFile: Path) {
isNotNull
compareFileContent(actual, snapshotFile)
}
}
fun dumpData(data: Any): String {
val dumperOptions = DumperOptions()
dumperOptions.isAllowReadOnlyProperties = true
dumperOptions.lineBreak = DumperOptions.LineBreak.UNIX
val yaml = Yaml(DumpRepresenter(), dumperOptions)
return yaml.dump(data)
}
private class DumpRepresenter : Representer() {
init {
representers.put(Pattern::class.java, RepresentDump())
}
private inner class RepresentDump : Represent {
override fun representData(data: Any): Node = representScalar(Tag.STR, data.toString())
}
}
@Throws(FileComparisonFailure::class)
fun compareFileContent(actual: Any, snapshotFile: Path) {
val expectedContent = StringUtilRt.convertLineSeparators(snapshotFile.readText())
val actualContent = if (actual is String) actual else dumpData(actual)
if (actualContent != expectedContent) {
throw FileComparisonFailure(null, expectedContent, actualContent, snapshotFile.toString())
}
} | platform/testFramework/extensions/src/com/intellij/testFramework/assertions/snapshot.kt | 1998422618 |
package org.thoughtcrime.securesms.components.settings.app.notifications.profiles
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
import io.reactivex.rxjava3.core.Single
import org.thoughtcrime.securesms.notifications.profiles.NotificationProfile
import org.thoughtcrime.securesms.recipients.RecipientId
class SelectRecipientsViewModel(
private val profileId: Long,
currentSelection: Set<RecipientId>,
private val repository: NotificationProfilesRepository
) : ViewModel() {
val recipients: MutableSet<RecipientId> = currentSelection.toMutableSet()
fun select(recipientId: RecipientId) {
recipients += recipientId
}
fun deselect(recipientId: RecipientId) {
recipients.remove(recipientId)
}
fun updateAllowedMembers(): Single<NotificationProfile> {
return repository.updateAllowedMembers(profileId, recipients)
.observeOn(AndroidSchedulers.mainThread())
}
class Factory(private val profileId: Long, val currentSelection: Set<RecipientId>) : ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>): T {
return modelClass.cast(SelectRecipientsViewModel(profileId, currentSelection, NotificationProfilesRepository()))!!
}
}
}
| app/src/main/java/org/thoughtcrime/securesms/components/settings/app/notifications/profiles/SelectRecipientsViewModel.kt | 951778612 |
package org.kethereum.bloomfilter
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Test
class BloomFilterTest {
@Test
fun mightContain() {
val bloomFilter = BloomFilter(100)
bloomFilter.add("hello".toByteArray())
bloomFilter.add("bloom filter".toByteArray())
assertTrue(bloomFilter.mightContain("hello".toByteArray()))
assertTrue(bloomFilter.mightContain("bloom filter".toByteArray()))
assertFalse(bloomFilter.mightContain("xxx".toByteArray()))
}
}
| bloomfilter/src/test/kotlin/org/kethereum/bloomfilter/BloomFilterTest.kt | 1567654510 |
// Copyright (c) 2016, Miquel Martí <[email protected]>
// See LICENSE for licensing information
package cat.mvmike.minimalcalendarwidget.application.system
import cat.mvmike.minimalcalendarwidget.BaseTest
import cat.mvmike.minimalcalendarwidget.domain.intent.AutoUpdate
import io.mockk.justRun
import io.mockk.mockkObject
import io.mockk.verify
import org.junit.jupiter.api.Test
internal class EnableWidgetUseCaseTest : BaseTest() {
@Test
fun shouldSetAutoUpdate() {
mockkObject(AutoUpdate)
justRun { AutoUpdate.set(context, INTERVAL_MILLIS) }
EnableWidgetUseCase.execute(context)
verify { AutoUpdate.set(context, INTERVAL_MILLIS) }
}
}
| app/src/test/kotlin/cat/mvmike/minimalcalendarwidget/application/system/EnableWidgetUseCaseTest.kt | 2290168641 |
/*
* Copyright 2014-2021 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
*/
package io.ktor.server.testing.internal
import kotlinx.coroutines.*
internal actual val Dispatchers.IOBridge: CoroutineDispatcher get() = Dispatchers.Default
| ktor-server/ktor-server-test-host/nix/src/io/ktor/server/testing/internal/CoroutineUtilsNix.kt | 775200914 |
import io.ktor.client.*
import io.ktor.client.engine.darwin.*
import io.ktor.client.engine.darwin.internal.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.client.tests.utils.*
import io.ktor.http.*
import kotlinx.coroutines.*
import platform.Foundation.*
import platform.Foundation.NSHTTPCookieStorage.Companion.sharedHTTPCookieStorage
import kotlin.test.*
/*
* Copyright 2014-2022 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
*/
class DarwinLegacyEngineTest {
@Test
fun testRequestInRunBlocking() = runBlocking {
val client = HttpClient(DarwinLegacy)
try {
withTimeout(1000) {
val response = client.get(TEST_SERVER)
assertEquals("Hello, world!", response.bodyAsText())
}
} finally {
client.close()
}
}
@Test
fun testQueryWithCyrillic() = runBlocking {
val client = HttpClient(DarwinLegacy)
try {
withTimeout(1000) {
val response = client.get("$TEST_SERVER/echo_query?привет")
assertEquals("привет=[]", response.bodyAsText())
}
} finally {
client.close()
}
}
@Test
fun testQueryWithMultipleParams() = runBlocking {
val client = HttpClient(DarwinLegacy)
try {
withTimeout(1000) {
val response = client.get("$TEST_SERVER/echo_query?asd=qwe&asd=123&qwe&zxc=vbn")
assertEquals("asd=[qwe, 123], qwe=[], zxc=[vbn]", response.bodyAsText())
}
} finally {
client.close()
}
}
@Test
fun testNSUrlSanitize() {
assertEquals(
"http://127.0.0.1/echo_query?%D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82",
stringToNSUrlString("http://127.0.0.1/echo_query?привет")
)
assertEquals(
"http://%D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82.%D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82/",
stringToNSUrlString("http://привет.привет/")
)
}
@Test
fun testCookieIsNotPersistedByDefault() = runBlocking {
val client = HttpClient(DarwinLegacy)
try {
client.get("$TEST_SERVER/cookies")
val result = client.get("$TEST_SERVER/cookies/dump")
.bodyAsText()
assertEquals("Cookies: ", result)
} finally {
client.close()
}
}
@Test
fun testCookiePersistedWithSessionStore() = runBlocking {
val client = HttpClient(DarwinLegacy) {
engine {
configureSession {
setHTTPCookieStorage(sharedHTTPCookieStorage)
}
}
}
try {
client.get("$TEST_SERVER/cookies")
val result = client.get("$TEST_SERVER/cookies/dump")
.bodyAsText()
assertEquals("Cookies: hello-cookie=my%2Dawesome%2Dvalue", result)
} finally {
client.close()
}
}
@Test
fun testOverrideDefaultSession(): Unit = runBlocking {
val client = HttpClient(DarwinLegacy) {
val delegate = KtorLegacyNSURLSessionDelegate()
val session = NSURLSession.sessionWithConfiguration(
NSURLSessionConfiguration.defaultSessionConfiguration(),
delegate,
delegateQueue = NSOperationQueue()
)
engine {
usePreconfiguredSession(session, delegate)
}
}
try {
val response = client.get(TEST_SERVER)
assertEquals("Hello, world!", response.bodyAsText())
} finally {
client.close()
}
}
@Test
fun testConfigureRequest(): Unit = runBlocking {
val client = HttpClient(DarwinLegacy) {
engine {
configureRequest {
setValue("my header value", forHTTPHeaderField = "XCustomHeader")
}
}
}
val response = client.get("$TEST_SERVER/headers/echo?headerName=XCustomHeader")
assertEquals(HttpStatusCode.OK, response.status)
assertEquals("my header value", response.bodyAsText())
}
private fun stringToNSUrlString(value: String): String {
return Url(value).toNSUrl().absoluteString!!
}
}
| ktor-client/ktor-client-darwin-legacy/darwin/test/DarwinLegacyEngineTest.kt | 160725462 |
/*
* Ad Free
* Copyright (c) 2017 by abertschi, www.abertschi.ch
* See the file "LICENSE" for the full license governing this code.
*/
package ch.abertschi.adfree.model
import com.github.kittinunf.fuel.httpGet
import io.reactivex.Observable
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.schedulers.Schedulers
/**
* Created by abertschi on 26.04.17.
*/
class YamlRemoteConfigFactory<MODEL>(val downloadUrl: String,
val modelType: Class<MODEL>,
val preferences: PreferencesFactory) {
private val SETTING_PERSISTENCE_LOCAL_KEY: String = "YAML_CONFIG_FACTORY_PERSISTENCE_"
init {
SETTING_PERSISTENCE_LOCAL_KEY + modelType.canonicalName
}
fun downloadObservable(): io.reactivex.Observable<Pair<MODEL, String>>
= Observable.create<Pair<MODEL, String>> { source ->
downloadUrl.httpGet().responseString { _, _, result ->
val (data, error) = result
if (error == null) {
try {
val yaml = createYamlInstance()
val model = yaml.loadAs(data, modelType)
source.onNext(Pair<MODEL, String>(model, data ?: ""))
} catch (exception: Exception) {
source.onError(exception)
}
} else {
source.onError(error)
}
source.onComplete()
}
}.observeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
fun loadFromLocalStore(defaultReturn: MODEL? = null): MODEL? {
val yaml = createYamlInstance()
val content = preferences.getPreferences().getString(SETTING_PERSISTENCE_LOCAL_KEY, null)
if (content == null) {
return defaultReturn
} else {
return yaml.loadAs(content, modelType)
}
}
fun storeToLocalStore(model: MODEL) {
val yaml = createYamlInstance()
preferences.getPreferences()
.edit().putString(SETTING_PERSISTENCE_LOCAL_KEY, yaml.dump(model)).commit()
}
private fun createYamlInstance(): org.yaml.snakeyaml.Yaml {
val representer = org.yaml.snakeyaml.representer.Representer()
representer.propertyUtils.setSkipMissingProperties(true)
return org.yaml.snakeyaml.Yaml(representer)
}
} | app/src/main/java/ch/abertschi/adfree/model/YamlRemoteConfigFactory.kt | 3399460873 |
/*
* Copyright © 2013 dvbviewer-controller 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 org.dvbviewer.controller.data.entities
import android.os.Parcelable
import java.util.*
/**
* Interface for EPG entries.
*
* @author RayBa
*/
interface IEPG : Parcelable {
/**
* Gets the id.
*
* @return the id
*/
/**
* Sets the id.
*
* @param id the id to set
*/
var id: Long
/**
* Gets the channel.
*
* @return the channel
*/
/**
* Sets the channel.
*
* @param channel the channel to set
*/
var channel: String
/**
* Gets the channel logo.
*
* @return the channel logo
*/
/**
* Sets the channel logo.
*
* @param channelLogo the new channel logo
*/
var channelLogo: String
/**
* Gets the epg id.
*
* @return the epgID
*/
/**
* Sets the epg id.
*
* @param epgID the epgID to set
*/
var epgID: Long
/**
* Gets the start.
*
* @return the start
*/
/**
* Sets the start.
*
* @param start the start to set
*/
var start: Date
/**
* Gets the end.
*
* @return the end
*/
/**
* Sets the end.
*
* @param end the end to set
*/
var end: Date
/**
* Gets the title.
*
* @return the title
*/
/**
* Sets the title.
*
* @param title the title to set
*/
var title: String
/**
* Gets the subtitle.
*
* @return the subtitle
*/
/**
* Sets the subtitle.
*
* @param subTitle the subtitle to set
*/
var subTitle: String
/**
* Gets the description.
*
* @return the description
*/
/**
* Sets the description.
*
* @param description the description to set
*/
var description: String
} | dvbViewerController/src/main/java/org/dvbviewer/controller/data/entities/IEPG.kt | 3317374571 |
package com.example.santaev.domain.usecase
import com.example.santaev.domain.api.IApiService
import com.example.santaev.domain.api.TranslateRequestDto
import com.example.santaev.domain.dto.LanguageDto
import com.example.santaev.domain.dto.TranslationDto
import com.example.santaev.domain.repository.ITranslationRepository
import io.reactivex.Single
class TranslateUseCase(
private val sourceLanguage: LanguageDto,
private val targetLanguage: LanguageDto,
private val text: String,
private var apiService: IApiService,
private var translationRepository: ITranslationRepository
) {
fun execute(): Single<out Response> {
return apiService.translate(
TranslateRequestDto(
text,
sourceLanguage,
targetLanguage
)
)
.map { response ->
val targetText = response.text.firstOrNull() ?: ""
translationRepository.insert(
TranslationDto(
id = 0,
sourceLangCode = sourceLanguage.code,
targetLangCode = targetLanguage.code,
sourceText = text,
targetText = targetText
)
).subscribe()
Response.Success(
sourceText = text,
targetText = targetText
) as Response
}
.onErrorResumeNext { Single.just(Response.Error()) }
}
sealed class Response {
class Error : Response()
data class Success(
val sourceText: String,
val targetText: String
) : Response()
}
} | domain/src/main/java/com/example/santaev/domain/usecase/TranslateUseCase.kt | 306171998 |
package rustyice.game.actors
import com.badlogic.gdx.graphics.g2d.Batch
import com.badlogic.gdx.graphics.g2d.Sprite
import com.badlogic.gdx.physics.box2d.FixtureDef
import rustyengine.RustyEngine
import rustyice.game.Actor
import rustyice.game.physics.SBPhysicsComponent
import rustyice.graphics.Camera
import rustyice.graphics.RenderLayer
import rustyice.physics.LARGE
import rustyice.physics.WALL
/**
* @author gabek
*/
class TestActor() : Actor() {
@Transient private var testSprite: Sprite? = null
val sbPhysicsComponent: SBPhysicsComponent
override fun update(delta: Float) {
super.update(delta)
}
override fun render(batch: Batch, camera: Camera, layer: RenderLayer) {
val testSprite = testSprite
if(testSprite != null){
testSprite.x = x - width / 2
testSprite.y = y - height / 2
testSprite.rotation = rotation
testSprite.draw(batch)
}
}
override fun init() {
super.init()
val fixtureDef = FixtureDef()
fixtureDef.density = 1f
fixtureDef.filter.categoryBits = LARGE.toShort()
fixtureDef.filter.maskBits = (LARGE or
WALL).toShort()
sbPhysicsComponent.addRectangle(width, height, fixtureDef)
val testSprite = Sprite(RustyEngine.resorces.box)
this.testSprite = testSprite
testSprite.setSize(width, height)
testSprite.setOrigin(width/2, height/2)
}
init {
sbPhysicsComponent = SBPhysicsComponent()
physicsComponent = sbPhysicsComponent
width = 1.9f
height = 1.9f
}
}
| core/src/rustyice/game/actors/TestActor.kt | 2956314099 |
package com.darrenatherton.droidcommunity.features.main
import org.junit.After
import org.junit.Before
import org.junit.Test
import org.mockito.Mock
import org.mockito.Mockito.verify
import org.mockito.Mockito.verifyNoMoreInteractions
import org.mockito.MockitoAnnotations
class MainPresenterTest {
@Mock private lateinit var view: MainPresenter.View
private lateinit var presenter: MainPresenter
@Before
fun setUp() {
MockitoAnnotations.initMocks(this)
presenter = MainPresenter()
}
@Test
fun viewUpdatedWhenFeedTabSelected() {
// given that the view is attached
presenter.viewAttached(view)
// when the feed tab is selected in the view
presenter.onTabSelected(presenter.FEED_TAB)
// then the view title is set for the feed and the subscriptions menu is enabled
verify(view).setTitleForFeed()
verify(view).enableSubscriptionsMenuSwipe()
verifyNoMoreInteractions(view)
}
@Test
fun viewUpdatedWhenChatTabSelected() {
// given that the view is attached
presenter.viewAttached(view)
// when the chat tab is selected in the view
presenter.onTabSelected(presenter.CHAT_TAB)
// then the view title is set for chat and the subscriptions menu is disabled
verify(view).setTitleForChat()
verify(view).disableSubscriptionsMenuSwipe()
verifyNoMoreInteractions(view)
}
@Test
fun viewUpdatedWhenEventsTabSelected() {
// given that the view is attached
presenter.viewAttached(view)
// when the feed tab is selected in the view
presenter.onTabSelected(presenter.EVENTS_TAB)
// then the view title is set for events and the subscriptions menu is disabled
verify(view).setTitleForEvents()
verify(view).disableSubscriptionsMenuSwipe()
verifyNoMoreInteractions(view)
}
@Test
fun viewNotUpdatedWhenViewNotAttached() {
// given that the view is not attached
// when the feed tab is selected in the view
presenter.onTabSelected(presenter.FEED_TAB)
// then the view title is set for the feed and subscription menu is not modified
verifyNoMoreInteractions(view)
}
@Test
fun doNothingIfInvalidTabSelected() {
// given that the view is attached
presenter.viewAttached(view)
// when the presenter tabSelected is called with an unknown tab
presenter.onTabSelected(999)
// then the presenter does not update the view
verifyNoMoreInteractions(view)
}
@After
fun tearDown() {}
} | app/src/test/kotlin/com/darrenatherton/droidcommunity/features/main/MainPresenterTest.kt | 1646932952 |
package org.fedorahosted.freeotp.ui
import android.content.Context
import android.util.AttributeSet
import android.widget.RelativeLayout
class SquareRelativeLayout @JvmOverloads constructor(
context: Context, attrs: AttributeSet? = null
) : RelativeLayout(context, attrs) {
override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
super.onMeasure(widthMeasureSpec, widthMeasureSpec)
}
} | app/src/main/java/org/fedorahosted/freeotp/ui/SquareRelativeLayout.kt | 360747052 |
package blue.aodev.animeultimetv.presentation.screen.animedetails
import android.content.Context
import android.content.Intent
import android.os.Bundle
import blue.aodev.animeultimetv.R
import blue.aodev.animeultimetv.domain.model.AnimeSummary
import blue.aodev.animeultimetv.presentation.screen.LeanbackActivity
class AnimeDetailsActivity : LeanbackActivity() {
companion object {
private val EXTRA_ANIME_SUMMARY = "extraAnimeSummary"
fun getIntent(context: Context, animeSummary: AnimeSummary): Intent {
val intent = Intent(context, AnimeDetailsActivity::class.java)
intent.putExtra(EXTRA_ANIME_SUMMARY, animeSummary)
return intent
}
}
val animeSummary: AnimeSummary by lazy {
intent.getParcelableExtra<AnimeSummary>(EXTRA_ANIME_SUMMARY)
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_anime_details)
}
} | app/src/main/java/blue/aodev/animeultimetv/presentation/screen/animedetails/AnimeDetailsActivity.kt | 2749034317 |
/*
* Copyright 2017-2021 the original author or authors.
*
* 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
*
* https://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 info.novatec.testit.logrecorder.log4j.junit5
import info.novatec.testit.logrecorder.api.LogRecord
import info.novatec.testit.logrecorder.log4j.Log4jLogRecord
import info.novatec.testit.logrecorder.log4j.Log4jLogRecorder
import org.apache.logging.log4j.LogManager
import org.apache.logging.log4j.Logger
import org.junit.jupiter.api.extension.*
/**
* This extension will record the loggers specified by a [RecordLoggers] annotation and inject the [LogRecord]
* as a parameter into the test method.
*
* Recording a logger will set its log level to [org.apache.logging.log4j.Level.ALL] for the duration of the test. After the
* test was executed, the log level will be restored to whatever it was before.
*
* @see RecordLoggers
* @see LogRecord
* @since 1.1
*/
class Log4jRecorderExtension : BeforeTestExecutionCallback, AfterTestExecutionCallback,
ParameterResolver {
private val namespace = ExtensionContext.Namespace.create(javaClass)
override fun supportsParameter(parameterContext: ParameterContext, extensionContext: ExtensionContext): Boolean {
return LogRecord::class.java == parameterContext.parameter.type
}
override fun resolveParameter(parameterContext: ParameterContext, extensionContext: ExtensionContext): Any {
return extensionContext.logRecord
}
override fun beforeTestExecution(context: ExtensionContext) {
val annotation = context.requiredTestMethod.getAnnotation(RecordLoggers::class.java)
?: error("no @RecordLoggers annotation found on test method!")
val fromClasses = annotation.value.map { LogManager.getLogger(it.java) }
val fromNames = annotation.names.map { LogManager.getLogger(it) }
val logRecord = Log4jLogRecord()
context.logRecord = logRecord
val recorders = (fromClasses + fromNames)
.distinct()
.map { it as Logger }
.map { Log4jLogRecorder(it, logRecord) }
.onEach { it.start() }
context.recorders = recorders
}
override fun afterTestExecution(context: ExtensionContext) {
context.recorders.forEach { it.stop() }
}
@Suppress("UNCHECKED_CAST")
private var ExtensionContext.recorders: List<Log4jLogRecorder>
get() = store.get("log-recorders") as List<Log4jLogRecorder>
set(value) = store.put("log-recorders", value)
private var ExtensionContext.logRecord: Log4jLogRecord
get() = store.get("log-record", Log4jLogRecord::class.java)
set(value) = store.put("log-record", value)
private val ExtensionContext.store: ExtensionContext.Store
get() = getStore(namespace)
}
| logrecorder/logrecorder-log4j/src/main/kotlin/info/novatec/testit/logrecorder/log4j/junit5/Log4jRecorderExtension.kt | 730920271 |
package eu.kanade.tachiyomi.ui.library
import eu.davidea.flexibleadapter.FlexibleAdapter
import eu.kanade.tachiyomi.data.database.models.Manga
/**
* Adapter storing a list of manga in a certain category.
*
* @param view the fragment containing this adapter.
*/
class LibraryCategoryAdapter(view: LibraryCategoryView) :
FlexibleAdapter<LibraryItem>(null, view, true) {
/**
* The list of manga in this category.
*/
private var mangas: List<LibraryItem> = emptyList()
/**
* Sets a list of manga in the adapter.
*
* @param list the list to set.
*/
fun setItems(list: List<LibraryItem>) {
// A copy of manga always unfiltered.
mangas = list.toList()
performFilter()
}
/**
* Returns the position in the adapter for the given manga.
*
* @param manga the manga to find.
*/
fun indexOf(manga: Manga): Int {
return currentItems.indexOfFirst { it.manga.id == manga.id }
}
fun performFilter() {
val s = getFilter(String::class.java) ?: ""
updateDataSet(mangas.filter { it.filter(s) })
}
}
| app/src/main/java/eu/kanade/tachiyomi/ui/library/LibraryCategoryAdapter.kt | 2206746054 |
package net.pureal.tests.traits
import org.jetbrains.spek.api.*
import net.pureal.traits.*
public class ExtensionSpecs : Spek() {init {
given("a [2 3 4] array") {
val a = array(2, 3, 4)
on("testing the replaceElements function") {
it("should be [4 6 8]") {
val b = a.replaceElements { 2 * it }
shouldEqual(4, b[0])
shouldEqual(6, b[1])
shouldEqual(8, b[2])
}
}
}
}
} | tests.traits/src/net/pureal/tests/traits/ExtensionSpecs.kt | 3759730301 |
/*
* Copyright 2022 Google LLC
*
* 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.google.android.fhir.catalog
import android.app.Application
import androidx.annotation.DrawableRes
import androidx.annotation.StringRes
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.SavedStateHandle
class LayoutListViewModel(application: Application, private val state: SavedStateHandle) :
AndroidViewModel(application) {
fun getLayoutList(): List<Layout> {
return Layout.values().toList()
}
enum class Layout(
@DrawableRes val iconId: Int,
@StringRes val textId: Int,
val questionnaireFileName: String,
val workflow: WorkflowType = WorkflowType.PAGINATED
) {
DEFAULT(
R.drawable.ic_defaultlayout,
R.string.layout_name_default_text,
"layout_default.json",
WorkflowType.DEFAULT
),
PAGINATED(
R.drawable.ic_paginatedlayout,
R.string.layout_name_paginated,
"layout_paginated.json"
),
REVIEW(R.drawable.ic_reviewlayout, R.string.layout_name_review, ""),
READ_ONLY(R.drawable.ic_readonlylayout, R.string.layout_name_read_only, ""),
}
}
| catalog/src/main/java/com/google/android/fhir/catalog/LayoutListViewModel.kt | 2568277412 |
package io.zhudy.uia.web
/**
* @author Kevin Zou ([email protected])
*/
class ResponseStatusException : RuntimeException {
val status: Int
var reason: String = ""
/**
*
*/
constructor(status: Int) : super("http status [$status]") {
this.status = status
}
/**
*
*/
constructor(status: Int, reason: String) : super(reason) {
this.status = status
this.reason = reason
}
override fun fillInStackTrace() = this
} | server/src/main/kotlin/io/zhudy/uia/web/ResponseStatusException.kt | 1848776640 |
package com.github.programmerr47.ganalytics.core
import org.junit.Assert
import kotlin.reflect.KClass
interface WrapperTest {
val testProvider: TestEventProvider
}
inline fun <T : Any> WrapperTest.run(wrapper: AnalyticsWrapper, clazz: KClass<T>, block: T.() -> Unit) =
wrapper.create(clazz).run(block)
inline fun WrapperTest.assertEquals(event: Event, interfaceMethod: () -> Unit) {
interfaceMethod()
Assert.assertEquals(event, testProvider.lastEvent)
}
interface StableWrapperTest : WrapperTest {
val wrapper: AnalyticsWrapper
}
inline fun <T : Any> StableWrapperTest.run(clazz: KClass<T>, block: T.() -> Unit) = run(wrapper, clazz, block)
abstract class SingleWrapperTest : StableWrapperTest {
override val testProvider: TestEventProvider = TestEventProvider()
override val wrapper: AnalyticsSingleWrapper = AnalyticsSingleWrapper(testProvider)
}
abstract class GroupWrapperTest : StableWrapperTest {
override val testProvider: TestEventProvider = TestEventProvider()
override val wrapper: AnalyticsGroupWrapper = AnalyticsGroupWrapper(testProvider)
} | ganalytics-core/src/test/java/com/github/programmerr47/ganalytics/core/WrapperTest.kt | 3768092409 |
package testData.failureTest
import org.spekframework.spek2.Spek
import org.spekframework.spek2.style.gherkin.Feature
object FailingGherkinTest : Spek({
Feature("a feature") {
Scenario("scenario") {
Given("failing to setup") {
throw Exception()
}
When("do something") {
println("test")
}
}
}
})
object FailingGherkinWithManyScenariosTest : Spek({
Feature("a feature") {
Scenario("scenario 1") {
Given("failing to setup") {
throw Exception()
}
When("do something") {
println("test")
}
}
Scenario("scenario 2") {
Given("failing to setup") {
throw Exception()
}
When("do something") {
println("test")
}
}
}
})
object FailingGherkinAfterSuccessfulSetup : Spek({
Feature("a feature") {
Scenario("scenario 1") {
Given("failing to setup") {
println("pass")
}
When("do something") {
throw Exception()
}
Then("assertion") {
println("assert")
}
}
}
}) | integration-test/src/jvmTest/kotlin/testData/failureTest/FailingGherkinTest.kt | 1074736651 |
package org.wikipedia.feed.announcement
import android.content.Context
import android.net.Uri
import android.text.method.LinkMovementMethod
import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.core.content.ContextCompat
import org.wikipedia.R
import org.wikipedia.databinding.ViewCardAnnouncementBinding
import org.wikipedia.feed.model.Card
import org.wikipedia.feed.view.DefaultFeedCardView
import org.wikipedia.richtext.RichTextUtil
import org.wikipedia.util.DimenUtil
import org.wikipedia.util.StringUtil
class AnnouncementCardView(context: Context) : DefaultFeedCardView<AnnouncementCard>(context) {
interface Callback {
fun onAnnouncementPositiveAction(card: Card, uri: Uri)
fun onAnnouncementNegativeAction(card: Card)
}
private val binding = ViewCardAnnouncementBinding.inflate(LayoutInflater.from(context), this, true)
var localCallback: Callback? = null
init {
binding.viewAnnouncementText.movementMethod = LinkMovementMethod.getInstance()
binding.viewAnnouncementFooterText.movementMethod = LinkMovementMethod.getInstance()
binding.viewAnnouncementActionPositive.setOnClickListener { onPositiveActionClick() }
binding.viewAnnouncementDialogActionPositive.setOnClickListener { onPositiveActionClick() }
binding.viewAnnouncementActionNegative.setOnClickListener { onNegativeActionClick() }
binding.viewAnnouncementDialogActionNegative.setOnClickListener { onNegativeActionClick() }
}
override var card: AnnouncementCard? = null
set(value) {
field = value
value?.let {
if (!it.extract().isNullOrEmpty()) {
binding.viewAnnouncementText.text = StringUtil.fromHtml(it.extract())
}
if (!it.hasAction()) {
binding.viewAnnouncementCardButtonsContainer.visibility = GONE
} else {
binding.viewAnnouncementCardButtonsContainer.visibility = VISIBLE
binding.viewAnnouncementActionPositive.text = it.actionTitle()
binding.viewAnnouncementDialogActionPositive.text = it.actionTitle()
}
if (!it.negativeText().isNullOrEmpty()) {
binding.viewAnnouncementActionNegative.text = it.negativeText()
binding.viewAnnouncementDialogActionNegative.text = it.negativeText()
} else {
binding.viewAnnouncementActionNegative.visibility = GONE
binding.viewAnnouncementDialogActionNegative.visibility = GONE
}
if (it.hasImage()) {
binding.viewAnnouncementHeaderImage.visibility = VISIBLE
binding.viewAnnouncementHeaderImage.loadImage(it.image())
} else {
binding.viewAnnouncementHeaderImage.visibility = GONE
}
if (it.imageHeight() > 0) {
val params = binding.viewAnnouncementHeaderImage.layoutParams as MarginLayoutParams
params.height = DimenUtil.roundedDpToPx(it.imageHeight().toFloat())
binding.viewAnnouncementHeaderImage.layoutParams = params
}
if (it.hasFooterCaption()) {
binding.viewAnnouncementFooterText.text = StringUtil.fromHtml(it.footerCaption())
RichTextUtil.removeUnderlinesFromLinks(binding.viewAnnouncementFooterText)
} else {
binding.viewAnnouncementFooterText.visibility = GONE
binding.viewAnnouncementFooterBorder.visibility = GONE
}
if (it.hasBorder()) {
binding.viewAnnouncementContainer.strokeColor = ContextCompat.getColor(context, R.color.red30)
binding.viewAnnouncementContainer.strokeWidth = 10
} else {
binding.viewAnnouncementContainer.setDefaultBorder()
}
if (it.isArticlePlacement) {
binding.viewAnnouncementCardButtonsContainer.visibility = GONE
binding.viewAnnouncementCardDialogButtonsContainer.visibility = VISIBLE
binding.viewAnnouncementContainer.layoutParams = LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT
)
binding.viewAnnouncementContainer.radius = 0f
}
}
}
private fun onPositiveActionClick() {
card?.let {
callback?.onAnnouncementPositiveAction(it, it.actionUri())
localCallback?.onAnnouncementPositiveAction(it, it.actionUri())
}
}
private fun onNegativeActionClick() {
card?.let {
callback?.onAnnouncementNegativeAction(it)
localCallback?.onAnnouncementNegativeAction(it)
}
}
}
| app/src/main/java/org/wikipedia/feed/announcement/AnnouncementCardView.kt | 413553566 |
package me.serce.solidity.ide.run
import com.google.common.base.Strings
import com.intellij.execution.actions.ConfigurationContext
import com.intellij.execution.actions.LazyRunConfigurationProducer
import com.intellij.execution.configurations.ConfigurationFactory
import com.intellij.execution.lineMarker.ExecutorAction
import com.intellij.execution.lineMarker.RunLineMarkerContributor
import com.intellij.icons.AllIcons
import com.intellij.openapi.actionSystem.AnAction
import com.intellij.openapi.util.Ref
import com.intellij.openapi.util.text.StringUtil
import com.intellij.psi.PsiElement
import com.intellij.util.containers.ContainerUtil
import me.serce.solidity.lang.core.SolElementType
import me.serce.solidity.lang.psi.SolFunctionDefinition
import me.serce.solidity.lang.psi.elementType
class SolidityRunConfigProducer : LazyRunConfigurationProducer<SolidityRunConfigBase>() {
override fun getConfigurationFactory() =
SolidityConfigurationType.getInstance().configurationFactories[0]
override fun isConfigurationFromContext(configuration: SolidityRunConfigBase, context: ConfigurationContext): Boolean {
return ifSolidityRunConfig(configuration) { config ->
val funcName = config.getPersistentData().functionName ?: return@ifSolidityRunConfig false
val contrName = config.getPersistentData().contractName ?: return@ifSolidityRunConfig false
val psiElement = context.location?.psiElement ?: return@ifSolidityRunConfig false
val func = searchFunction(psiElement) ?: return@ifSolidityRunConfig false
return@ifSolidityRunConfig funcName == func.name && contrName == func.contract?.name
}
}
private fun ifSolidityRunConfig(config: SolidityRunConfigBase?, action: (config: SolidityRunConfig) -> Boolean): Boolean {
if (config != null && config::class.qualifiedName == "me.serce.solidity.ide.run.SolidityRunConfig") {
if (config is SolidityRunConfig) {
return action(config)
}
}
return false
}
override fun setupConfigurationFromContext(configuration: SolidityRunConfigBase, context: ConfigurationContext, sourceElement: Ref<PsiElement>): Boolean {
val solFunctionDefinition = searchFunction(sourceElement.get()) ?: return false
if (!SearchUtils.runnableFilter.invoke(solFunctionDefinition)) {
return false
}
if (Strings.isNullOrEmpty(solFunctionDefinition.name)) {
return false
}
return ifSolidityRunConfig(configuration) { config ->
config.setModule(context.module)
config.getPersistentData().setFunction(solFunctionDefinition)
config.name = solFunctionDefinition.contract?.name + "." + solFunctionDefinition.name
true
}
}
}
private fun searchFunction(sourceElement: PsiElement?): SolFunctionDefinition? {
var get = sourceElement
while (get != null && get !is SolFunctionDefinition) {
get = get.parent
}
return if (get == null || get !is SolFunctionDefinition) null else get
}
class SolidityRunLineMarkerProvider : RunLineMarkerContributor() {
override fun getInfo(e: PsiElement): Info? {
if (!hasJavaSupport) return null
val elementType = e.elementType
if (elementType is SolElementType && elementType.name == "Identifier") {
val searchFunction = e.parent ?: return null
if (searchFunction is SolFunctionDefinition && SearchUtils.runnableFilter.invoke(searchFunction)) {
val actions = ExecutorAction.getActions(0).filter { it.toString().startsWith("Run context configuration") }.toTypedArray()
return Info(AllIcons.RunConfigurations.TestState.Run, { element1: PsiElement ->
StringUtil.join(
ContainerUtil.mapNotNull<AnAction, String>(actions) { action -> getText(action, element1) },
"\n"
)
}, *actions)
}
}
return null
}
}
| src/main/kotlin/me/serce/solidity/ide/run/SolidityRunConfigProducer.kt | 1450901070 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package org.jetbrains.kotlin.idea.inspections
import com.intellij.codeInspection.*
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.TextRange
import com.intellij.psi.PsiElementVisitor
import org.jetbrains.kotlin.idea.KotlinBundle
import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.endOffset
import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
import org.jetbrains.kotlin.psi.psiUtil.startOffset
class RedundantElvisReturnNullInspection : AbstractKotlinInspection(), CleanupLocalInspectionTool {
override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
return returnExpressionVisitor(fun(returnExpression: KtReturnExpression) {
if ((returnExpression.returnedExpression?.deparenthesize() as? KtConstantExpression)?.text != KtTokens.NULL_KEYWORD.value) return
val binaryExpression = returnExpression.getStrictParentOfType<KtBinaryExpression>()?.takeIf {
it == it.getStrictParentOfType<KtReturnExpression>()?.returnedExpression?.deparenthesize()
} ?: return
val right = binaryExpression.right?.deparenthesize()?.takeIf { it == returnExpression } ?: return
if (binaryExpression.operationToken == KtTokens.ELSE_KEYWORD) return
if (binaryExpression.left?.resolveToCall()?.resultingDescriptor?.returnType?.isMarkedNullable != true) return
holder.registerProblem(
binaryExpression,
KotlinBundle.message("inspection.redundant.elvis.return.null.descriptor"),
ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
TextRange(binaryExpression.operationReference.startOffset, right.endOffset).shiftLeft(binaryExpression.startOffset),
RemoveRedundantElvisReturnNull()
)
})
}
private fun KtExpression.deparenthesize() = KtPsiUtil.deparenthesize(this)
private class RemoveRedundantElvisReturnNull : LocalQuickFix {
override fun getName() = KotlinBundle.message("remove.redundant.elvis.return.null.text")
override fun getFamilyName() = name
override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
val binaryExpression = descriptor.psiElement as? KtBinaryExpression ?: return
val left = binaryExpression.left ?: return
binaryExpression.replace(left)
}
}
}
| plugins/kotlin/idea/src/org/jetbrains/kotlin/idea/inspections/RedundantElvisReturnNullInspection.kt | 671629263 |
import javaApi.Anon5
internal class A @Anon5(10)
constructor(private val a: Int, private val b: Int) {
@Deprecated("") // this constructor will not be replaced by default parameter value in primary because of this annotation
constructor(a: Int) : this(a, 1) {
}
}
internal class B @Anon5(11)
constructor()
internal class C @Anon5(12)
private constructor() | plugins/kotlin/j2k/old/tests/testData/fileOrElement/constructors/constructorAnnotations.kt | 3374047759 |
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
@file:JvmName("KotlinVersionUtils")
@file:Suppress("deprecation_error")
package org.jetbrains.kotlin.idea.codeInsight.gradle
import org.jetbrains.kotlin.idea.codeInsight.gradle.GradleKotlinTestUtils.KotlinVersion
import org.jetbrains.kotlin.idea.codeInsight.gradle.MultiplePluginVersionGradleImportingTestCase.KotlinVersionRequirement
import org.jetbrains.kotlin.tooling.core.KotlinToolingVersion
import java.util.*
import kotlin.Comparator
val KotlinVersion.isWildcard: Boolean
get() = this.classifier != null &&
this.classifier == WILDCARD_KOTLIN_VERSION_CLASSIFIER
val KotlinVersion.isSnapshot: Boolean
get() = this.classifier != null && this.classifier.lowercase() == "snapshot"
val KotlinVersion.isDev: Boolean
get() = this.classifier != null && this.classifier.lowercase().matches(Regex("""dev-?\d*"""))
val KotlinVersion.isMilestone: Boolean
get() = this.classifier != null &&
this.classifier.lowercase().matches(Regex("""m\d+(-release)?(-\d*)?"""))
val KotlinVersion.isAlpha: Boolean
get() = this.classifier != null &&
this.classifier.lowercase().matches(Regex("""alpha(\d*)?(-release)?-?\d*"""))
val KotlinVersion.isBeta: Boolean
get() = this.classifier != null &&
this.classifier.lowercase().matches(Regex("""beta(\d*)?(-release)?-?\d*"""))
val KotlinVersion.isRC: Boolean
get() = this.classifier != null &&
this.classifier.lowercase().matches(Regex("""(rc)(\d*)?(-release)?-?\d*"""))
val KotlinVersion.isStable: Boolean
get() = this.classifier == null ||
this.classifier.lowercase().matches(Regex("""(release-)?\d+"""))
val KotlinVersion.isPreRelease: Boolean get() = !isStable
enum class KotlinVersionMaturity {
WILDCARD,
SNAPSHOT,
DEV,
MILESTONE,
ALPHA,
BETA,
RC,
STABLE
}
operator fun KotlinVersion.compareTo(other: KotlinVersion): Int {
if (this == other) return 0
(this.major - other.major).takeIf { it != 0 }?.let { return it }
(this.minor - other.minor).takeIf { it != 0 }?.let { return it }
(this.patch - other.patch).takeIf { it != 0 }?.let { return it }
(this.maturity.ordinal - other.maturity.ordinal).takeIf { it != 0 }?.let { return it }
if (this.classifier == null && other.classifier != null) {
/* eg. 1.6.20 > 1.6.20-200 */
return 1
}
if (this.classifier != null && other.classifier == null) {
/* e.g. 1.6.20-200 < 1.6.20 */
return -1
}
val thisClassifierNumber = this.classifierNumber
val otherClassifierNumber = other.classifierNumber
if (thisClassifierNumber != null && otherClassifierNumber != null) {
(thisClassifierNumber - otherClassifierNumber).takeIf { it != 0 }?.let { return it }
}
if (thisClassifierNumber != null && otherClassifierNumber == null) {
/* e.g. 1.6.20-rc1 > 1.6.20-rc */
return 1
}
if (thisClassifierNumber == null && otherClassifierNumber != null) {
/* e.g. 1.6.20-rc < 1.6.20-rc1 */
return -1
}
val thisBuildNumber = this.buildNumber
val otherBuildNumber = other.buildNumber
if (thisBuildNumber != null && otherBuildNumber != null) {
(thisBuildNumber - otherBuildNumber).takeIf { it != 0 }?.let { return it }
}
if (thisBuildNumber == null && otherBuildNumber != null) {
/* e.g. 1.6.20-M1 > 1.6.20-M1-200 */
return 1
}
if (thisBuildNumber != null && otherBuildNumber == null) {
/* e.g. 1.6.20-M1-200 < 1.6.20-M1 */
return -1
}
return 0
}
val KotlinVersion.buildNumber: Int?
get() {
if (classifier == null) return null
/*
Handle classifiers that only consist of version + build number. This is used for stable releases
like:
1.6.20-1
1.6.20-22
1.6.
*/
val buildNumberOnlyClassifierRegex = Regex("\\d+")
if (buildNumberOnlyClassifierRegex.matches(classifier)) {
return classifier.toIntOrNull()
}
val classifierRegex = Regex("""(.+?)(\d*)?-?(\d*)?""")
val classifierMatch = classifierRegex.matchEntire(classifier) ?: return null
return classifierMatch.groupValues.getOrNull(3)?.toIntOrNull()
}
val KotlinVersion.classifierNumber: Int?
get() {
if (classifier == null) return null
/*
Classifiers with only a buildNumber assigned
*/
val buildNumberOnlyClassifierRegex = Regex("\\d+")
if (buildNumberOnlyClassifierRegex.matches(classifier)) {
return null
}
val classifierRegex = Regex("""(.+?)(\d*)?-?(\d*)?""")
val classifierMatch = classifierRegex.matchEntire(classifier) ?: return null
return classifierMatch.groupValues.getOrNull(2)?.toIntOrNull()
}
fun KotlinVersionRequirement.matches(kotlinVersionString: String): Boolean {
return matches(KotlinToolingVersion(kotlinVersionString))
}
fun KotlinVersionRequirement.matches(version: KotlinToolingVersion): Boolean {
return when (this) {
is KotlinVersionRequirement.Exact -> matches(version)
is KotlinVersionRequirement.Range -> matches(version)
}
}
fun KotlinVersionRequirement.Exact.matches(version: KotlinToolingVersion): Boolean {
return this.version.compareTo(version) == 0
}
fun KotlinVersionRequirement.Range.matches(version: KotlinToolingVersion): Boolean {
if (lowestIncludedVersion != null && version < lowestIncludedVersion) return false
if (highestIncludedVersion != null && version > highestIncludedVersion) return false
return true
}
fun parseKotlinVersionRequirement(value: String): KotlinVersionRequirement {
if (value.endsWith("+")) {
return KotlinVersionRequirement.Range(
lowestIncludedVersion = KotlinToolingVersion(value.removeSuffix("+")),
highestIncludedVersion = null
)
}
if (value.contains("<=>")) {
val split = value.split(Regex("""\s*<=>\s*"""))
require(split.size == 2) { "Illegal Kotlin version requirement: $value. Example: '1.4.0 <=> 1.5.0'" }
return KotlinVersionRequirement.Range(
lowestIncludedVersion = KotlinToolingVersion(split[0]),
highestIncludedVersion = KotlinToolingVersion(split[1])
)
}
return KotlinVersionRequirement.Exact(KotlinToolingVersion(value))
}
fun parseKotlinVersion(value: String): KotlinVersion {
fun throwInvalid(): Nothing {
throw IllegalArgumentException("Invalid Kotlin version: $value")
}
val baseVersion = value.split("-", limit = 2)[0]
val classifier = value.split("-", limit = 2).getOrNull(1)
val baseVersionSplit = baseVersion.split(".")
if (!(baseVersionSplit.size == 2 || baseVersionSplit.size == 3)) throwInvalid()
return KotlinVersion(
major = baseVersionSplit[0].toIntOrNull() ?: throwInvalid(),
minor = baseVersionSplit[1].toIntOrNull() ?: throwInvalid(),
patch = baseVersionSplit.getOrNull(2)?.let { it.toIntOrNull() ?: throwInvalid() } ?: 0,
classifier = classifier
)
}
private const val WILDCARD_KOTLIN_VERSION_CLASSIFIER = "*"
fun KotlinVersion.toWildcard(): KotlinVersion {
return KotlinVersion(
major, minor, patch,
classifier = WILDCARD_KOTLIN_VERSION_CLASSIFIER
)
}
val KotlinToolingVersion.isHmppEnabledByDefault get() = this >= KotlinToolingVersion("1.6.20-dev-6442")
| plugins/kotlin/gradle/gradle-java/tests/test/org/jetbrains/kotlin/idea/codeInsight/gradle/KotlinVersionUtils.kt | 608856356 |
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.idea.refactoring.move.moveMethod
import com.intellij.openapi.actionSystem.CommonDataKeys
import com.intellij.openapi.actionSystem.DataContext
import com.intellij.openapi.editor.Editor
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.registry.Registry
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiReference
import com.intellij.refactoring.move.MoveCallback
import com.intellij.refactoring.move.MoveHandlerDelegate
import com.intellij.refactoring.util.CommonRefactoringUtil
import org.jetbrains.annotations.Nls
import org.jetbrains.kotlin.idea.KotlinBundle
import org.jetbrains.kotlin.idea.references.mainReference
import org.jetbrains.kotlin.idea.util.application.isUnitTestMode
import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.collectDescendantsOfType
import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
import org.jetbrains.kotlin.psi.psiUtil.isObjectLiteral
private const val optionName = "kotlin.enable.move.method.refactoring"
private val refactoringIsDisabled: Boolean
get() = !Registry.`is`(optionName) && !isUnitTestMode()
class MoveKotlinMethodHandler : MoveHandlerDelegate() {
private fun showErrorHint(project: Project, dataContext: DataContext?, @Nls message: String) {
val editor = dataContext?.let { CommonDataKeys.EDITOR.getData(it) }
CommonRefactoringUtil.showErrorHint(project, editor, message, KotlinBundle.message("title.move.method"), null)
}
private fun invokeMoveMethodRefactoring(
project: Project,
method: KtNamedFunction,
targetContainer: KtClassOrObject?,
dataContext: DataContext?
) {
if (method.containingClassOrObject == null) return
val errorMessageKey = when {
!method.manager.isInProject(method) ->
"text.move.method.is.not.supported.for.non.project.methods"
method.mentionsTypeParameters() ->
"text.move.method.is.not.supported.for.generic.classes"
method.hasModifier(KtTokens.OVERRIDE_KEYWORD) || method.hasModifier(KtTokens.OPEN_KEYWORD) ->
"text.move.method.is.not.supported.when.method.is.a.part.of.inheritance.hierarchy"
else -> null
}
if (errorMessageKey != null) {
showErrorHint(project, dataContext, KotlinBundle.message(errorMessageKey))
return
}
MoveKotlinMethodDialog(
method,
collectSuitableVariables(method),
targetContainer
).show()
}
private fun collectSuitableVariables(method: KtNamedFunction): Map<KtNamedDeclaration, KtClass> {
val sourceClassOrObject = method.containingClassOrObject ?: return emptyMap()
val allVariables = mutableListOf<KtNamedDeclaration>()
allVariables.addAll(method.valueParameters)
allVariables.addAll(sourceClassOrObject.declarations.filterIsInstance<KtProperty>())
allVariables.addAll(sourceClassOrObject.primaryConstructorParameters.filter { parameter -> parameter.hasValOrVar() })
val variableToClassMap = LinkedHashMap<KtNamedDeclaration, KtClass>()
for (variable in allVariables) {
variable.type()?.let { type ->
if (type.arguments.isEmpty()) {
val ktClass = type.constructor.declarationDescriptor?.findPsi() as? KtClass
if (ktClass != null && method.manager.isInProject(ktClass)) {
variableToClassMap[variable] = ktClass
}
}
}
}
return variableToClassMap
}
override fun canMove(elements: Array<PsiElement?>, targetContainer: PsiElement?, reference: PsiReference?): Boolean {
if (refactoringIsDisabled) return false
if (elements.size != 1) return false
val method = elements[0] as? KtNamedFunction ?: return false
val sourceContainer = method.containingClassOrObject
return (targetContainer == null || super.canMove(elements, targetContainer, reference))
&& sourceContainer != null && !sourceContainer.isObjectLiteral()
}
override fun isValidTarget(psiElement: PsiElement?, sources: Array<out PsiElement>): Boolean {
if (refactoringIsDisabled) return false
return psiElement is KtClassOrObject && !psiElement.hasModifier(KtTokens.ANNOTATION_KEYWORD)
}
override fun doMove(project: Project, elements: Array<out PsiElement>, targetContainer: PsiElement?, callback: MoveCallback?) {
if (refactoringIsDisabled) return
if (elements.size != 1) return
val method = elements[0] as? KtNamedFunction ?: return
val sourceContainer = method.containingClassOrObject
if (sourceContainer == null || sourceContainer.isObjectLiteral()) return
invokeMoveMethodRefactoring(project, elements[0] as KtNamedFunction, targetContainer as? KtClassOrObject, null)
}
override fun tryToMove(
element: PsiElement, project: Project, dataContext: DataContext?, reference: PsiReference?, editor: Editor?
): Boolean {
if (refactoringIsDisabled) return false
if (element is KtNamedFunction) {
element.containingClassOrObject?.let { sourceContainer ->
if (!sourceContainer.isObjectLiteral()) {
invokeMoveMethodRefactoring(project, element, null, dataContext)
return true
}
}
}
return false
}
private fun KtNamedFunction.mentionsTypeParameters(): Boolean {
var ktClassOrObject = containingClassOrObject
val typeParameters = mutableListOf<KtTypeParameter>()
while (ktClassOrObject != null) {
typeParameters.addAll(ktClassOrObject.typeParameters)
ktClassOrObject = if (ktClassOrObject.hasModifier(KtTokens.INNER_KEYWORD)) ktClassOrObject.containingClassOrObject else null
}
return collectDescendantsOfType<KtUserType>().any { userType -> userType.referenceExpression?.mainReference?.resolve() in typeParameters }
}
override fun getActionName(elements: Array<out PsiElement>): String = KotlinBundle.message("action.move.method")
}
| plugins/kotlin/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveMethod/MoveKotlinMethodHandler.kt | 2275319067 |
// "Replace with safe (?.) call" "false"
// ACTION: Add non-null asserted (!!) call
// ACTION: Replace with safe (this?.) call
// ERROR: Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type A?
class A {
fun foo() {
}
}
fun A?.bar() {
<caret>foo()
}
| plugins/kotlin/idea/tests/testData/quickfix/replaceWithSafeCall/noReplaceWithSafeCallForImplicitReceiver.kt | 2416135938 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package org.jetbrains.kotlin.idea.imports
import com.intellij.lang.ImportOptimizer
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.progress.ProgressIndicator
import com.intellij.openapi.progress.ProgressIndicatorProvider
import com.intellij.psi.PsiDocumentManager
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiFile
import org.jetbrains.kotlin.references.fe10.Fe10SyntheticPropertyAccessorReference
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.idea.KotlinBundle
import org.jetbrains.kotlin.idea.base.projectStructure.languageVersionSettings
import org.jetbrains.kotlin.idea.base.projectStructure.moduleInfoOrNull
import org.jetbrains.kotlin.idea.base.scripting.projectStructure.ScriptModuleInfo
import org.jetbrains.kotlin.idea.base.projectStructure.moduleInfo.ModuleSourceInfo
import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
import org.jetbrains.kotlin.idea.formatter.kotlinCustomSettings
import org.jetbrains.kotlin.idea.references.*
import org.jetbrains.kotlin.idea.caches.resolve.safeAnalyzeNonSourceRootCode
import org.jetbrains.kotlin.idea.util.getResolutionScope
import org.jetbrains.kotlin.incremental.components.NoLookupLocation
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.ImportPath
import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
import org.jetbrains.kotlin.resolve.descriptorUtil.getImportableDescriptor
import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
import org.jetbrains.kotlin.resolve.scopes.HierarchicalScope
import org.jetbrains.kotlin.resolve.scopes.utils.*
import org.jetbrains.kotlin.types.error.ErrorFunctionDescriptor
class KotlinImportOptimizer : ImportOptimizer {
override fun supports(file: PsiFile) = file is KtFile
override fun processFile(file: PsiFile): ImportOptimizer.CollectingInfoRunnable {
val ktFile = (file as? KtFile) ?: return DO_NOTHING
val (add, remove, imports) = prepareImports(ktFile) ?: return DO_NOTHING
return object : ImportOptimizer.CollectingInfoRunnable {
override fun getUserNotificationInfo(): String = if (remove == 0)
KotlinBundle.message("import.optimizer.text.zero")
else
KotlinBundle.message(
"import.optimizer.text.non.zero",
remove,
KotlinBundle.message("import.optimizer.text.import", remove),
add,
KotlinBundle.message("import.optimizer.text.import", add)
)
override fun run() = replaceImports(ktFile, imports)
}
}
// The same as com.intellij.pom.core.impl.PomModelImpl.isDocumentUncommitted
// Which is checked in com.intellij.pom.core.impl.PomModelImpl.startTransaction
private val KtFile.isDocumentUncommitted: Boolean
get() {
val documentManager = PsiDocumentManager.getInstance(project)
val cachedDocument = documentManager.getCachedDocument(this)
return cachedDocument != null && documentManager.isUncommited(cachedDocument)
}
private fun prepareImports(file: KtFile): OptimizeInformation? {
ApplicationManager.getApplication().assertReadAccessAllowed()
// Optimize imports may be called after command
// And document can be uncommitted after running that command
// In that case we will get ISE: Attempt to modify PSI for non-committed Document!
if (file.isDocumentUncommitted) return null
val moduleInfo = file.moduleInfoOrNull
if (moduleInfo !is ModuleSourceInfo && moduleInfo !is ScriptModuleInfo) return null
val oldImports = file.importDirectives
if (oldImports.isEmpty()) return null
//TODO: keep existing imports? at least aliases (comments)
val descriptorsToImport = collectDescriptorsToImport(file, true)
val imports = prepareOptimizedImports(file, descriptorsToImport) ?: return null
val intersect = imports.intersect(oldImports.map { it.importPath })
return OptimizeInformation(
add = imports.size - intersect.size,
remove = oldImports.size - intersect.size,
imports = imports
)
}
private data class OptimizeInformation(val add: Int, val remove: Int, val imports: List<ImportPath>)
private class CollectUsedDescriptorsVisitor(file: KtFile, val progressIndicator: ProgressIndicator? = null) : KtVisitorVoid() {
//private val elementsSize: Int = if (progressIndicator != null) {
// var size = 0
// file.accept(object : KtVisitorVoid() {
// override fun visitElement(element: PsiElement) {
// size += 1
// element.acceptChildren(this)
// }
// })
//
// size
//} else {
// 0
//}
private var elementProgress: Int = 0
private val currentPackageName = file.packageFqName
private val aliases: Map<FqName, List<Name>> = file.importDirectives
.asSequence()
.filter { !it.isAllUnder && it.alias != null }
.mapNotNull { it.importPath }
.groupBy(keySelector = { it.fqName }, valueTransform = { it.importedName as Name })
private val descriptorsToImport = hashSetOf<OptimizedImportsBuilder.ImportableDescriptor>()
private val namesToImport = hashMapOf<FqName, MutableSet<Name>>()
private val abstractRefs = ArrayList<OptimizedImportsBuilder.AbstractReference>()
private val unresolvedNames = hashSetOf<Name>()
val data: OptimizedImportsBuilder.InputData
get() = OptimizedImportsBuilder.InputData(
descriptorsToImport,
namesToImport,
abstractRefs,
unresolvedNames,
)
override fun visitElement(element: PsiElement) {
ProgressIndicatorProvider.checkCanceled()
elementProgress += 1
//progressIndicator?.apply {
// if (elementsSize != 0) {
// fraction = elementProgress / elementsSize.toDouble()
// }
//}
element.acceptChildren(this)
}
override fun visitImportList(importList: KtImportList) {
}
override fun visitPackageDirective(directive: KtPackageDirective) {
}
override fun visitKtElement(element: KtElement) {
super.visitKtElement(element)
if (element is KtLabelReferenceExpression) return
val references = element.references.ifEmpty { return }
val bindingContext = element.safeAnalyzeNonSourceRootCode(BodyResolveMode.PARTIAL)
val isResolved = hasResolvedDescriptor(element, bindingContext)
for (reference in references) {
if (reference !is KtReference) continue
ProgressIndicatorProvider.checkCanceled()
abstractRefs.add(AbstractReferenceImpl(reference))
val names = reference.resolvesByNames
if (!isResolved) {
unresolvedNames += names
}
for (target in reference.targets(bindingContext)) {
val importableDescriptor = target.getImportableDescriptor()
val importableFqName = target.importableFqName ?: continue
val parentFqName = importableFqName.parent()
if (target is PackageViewDescriptor && parentFqName == FqName.ROOT) continue // no need to import top-level packages
if (target !is PackageViewDescriptor && parentFqName == currentPackageName && (importableFqName !in aliases)) continue
if (!reference.canBeResolvedViaImport(target, bindingContext)) continue
if (importableDescriptor.name in names && isAccessibleAsMember(importableDescriptor, element, bindingContext)) {
continue
}
val descriptorNames = (aliases[importableFqName].orEmpty() + importableFqName.shortName()).intersect(names)
namesToImport.getOrPut(importableFqName) { hashSetOf() } += descriptorNames
descriptorsToImport += OptimizedImportsBuilder.ImportableDescriptor(importableDescriptor, importableFqName)
}
}
}
private fun isAccessibleAsMember(target: DeclarationDescriptor, place: KtElement, bindingContext: BindingContext): Boolean {
if (target.containingDeclaration !is ClassDescriptor) return false
fun isInScope(scope: HierarchicalScope): Boolean {
return when (target) {
is FunctionDescriptor ->
scope.findFunction(target.name, NoLookupLocation.FROM_IDE) { it == target } != null
&& bindingContext[BindingContext.DEPRECATED_SHORT_NAME_ACCESS, place] != true
is PropertyDescriptor ->
scope.findVariable(target.name, NoLookupLocation.FROM_IDE) { it == target } != null
&& bindingContext[BindingContext.DEPRECATED_SHORT_NAME_ACCESS, place] != true
is ClassDescriptor ->
scope.findClassifier(target.name, NoLookupLocation.FROM_IDE) == target
&& bindingContext[BindingContext.DEPRECATED_SHORT_NAME_ACCESS, place] != true
else -> false
}
}
val resolutionScope = place.getResolutionScope(bindingContext, place.getResolutionFacade())
val noImportsScope = resolutionScope.replaceImportingScopes(null)
if (isInScope(noImportsScope)) return true
// classes not accessible through receivers, only their constructors
return if (target is ClassDescriptor) false
else resolutionScope.getImplicitReceiversHierarchy().any { isInScope(it.type.memberScope.memberScopeAsImportingScope()) }
}
private class AbstractReferenceImpl(private val reference: KtReference) : OptimizedImportsBuilder.AbstractReference {
override val element: KtElement
get() = reference.element
override val dependsOnNames: Collection<Name>
get() {
val resolvesByNames = reference.resolvesByNames
if (reference is KtInvokeFunctionReference) {
val additionalNames =
(reference.element.calleeExpression as? KtNameReferenceExpression)?.mainReference?.resolvesByNames
if (additionalNames != null) {
return resolvesByNames + additionalNames
}
}
return resolvesByNames
}
override fun resolve(bindingContext: BindingContext) = reference.resolveToDescriptors(bindingContext)
override fun toString() = when (reference) {
is Fe10SyntheticPropertyAccessorReference -> {
reference.toString().replace(
"Fe10SyntheticPropertyAccessorReference",
if (reference.getter) "Getter" else "Setter"
)
}
else -> reference.toString().replace("Fe10", "")
}
}
}
companion object {
fun collectDescriptorsToImport(file: KtFile, inProgressBar: Boolean = false): OptimizedImportsBuilder.InputData {
val progressIndicator = if (inProgressBar) ProgressIndicatorProvider.getInstance().progressIndicator else null
progressIndicator?.text = KotlinBundle.message("import.optimizer.progress.indicator.text.collect.imports.for", file.name)
progressIndicator?.isIndeterminate = false
val visitor = CollectUsedDescriptorsVisitor(file, progressIndicator)
file.accept(visitor)
return visitor.data
}
fun prepareOptimizedImports(file: KtFile, data: OptimizedImportsBuilder.InputData): List<ImportPath>? {
val settings = file.kotlinCustomSettings
val options = OptimizedImportsBuilder.Options(
settings.NAME_COUNT_TO_USE_STAR_IMPORT,
settings.NAME_COUNT_TO_USE_STAR_IMPORT_FOR_MEMBERS,
isInPackagesToUseStarImport = { fqName -> fqName.asString() in settings.PACKAGES_TO_USE_STAR_IMPORTS }
)
return OptimizedImportsBuilder(file, data, options, file.languageVersionSettings.apiVersion).buildOptimizedImports()
}
fun replaceImports(file: KtFile, imports: List<ImportPath>) {
val manager = PsiDocumentManager.getInstance(file.project)
manager.getDocument(file)?.let { manager.commitDocument(it) }
val importList = file.importList ?: return
val oldImports = importList.imports
val psiFactory = KtPsiFactory(file.project)
for (importPath in imports) {
importList.addBefore(
psiFactory.createImportDirective(importPath),
oldImports.lastOrNull()
) // insert into the middle to keep collapsed state
}
// remove old imports after adding new ones to keep imports folding state
for (import in oldImports) {
import.delete()
}
}
private fun KtReference.targets(bindingContext: BindingContext): Collection<DeclarationDescriptor> {
//class qualifiers that refer to companion objects should be considered (containing) class references
return bindingContext[BindingContext.SHORT_REFERENCE_TO_COMPANION_OBJECT, element as? KtReferenceExpression]?.let { listOf(it) }
?: resolveToDescriptors(bindingContext)
}
private val DO_NOTHING = object : ImportOptimizer.CollectingInfoRunnable {
override fun run() = Unit
override fun getUserNotificationInfo() = KotlinBundle.message("import.optimizer.notification.text.unused.imports.not.found")
}
}
}
private fun hasResolvedDescriptor(element: KtElement, bindingContext: BindingContext): Boolean =
if (element is KtCallElement)
element.getResolvedCall(bindingContext) != null
else
element.mainReference?.resolveToDescriptors(bindingContext)?.let { descriptors ->
descriptors.isNotEmpty() && descriptors.none { it is ErrorFunctionDescriptor }
} == true
| plugins/kotlin/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt | 283449421 |
internal class A {
internal enum class E {
A,
B,
C
}
} | plugins/kotlin/j2k/old/tests/testData/fileOrElement/class/innerEnum.kt | 2974928297 |
// snippet-sourcedescription:[CreateAlias.kt demonstrates how to create an AWS Key Management Service (AWS KMS) alias.]
// snippet-keyword:[AWS SDK for Kotlin]
// snippet-service:[AWS Key Management Service]
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.kotlin.kms
// snippet-start:[kms.kotlin_create_alias.import]
import aws.sdk.kotlin.services.kms.KmsClient
import aws.sdk.kotlin.services.kms.model.CreateAliasRequest
import kotlin.system.exitProcess
// snippet-end:[kms.kotlin_create_alias.import]
/**
Before running this Kotlin code example, set up your development environment,
including your credentials.
For more information, see the following documentation topic:
https://docs.aws.amazon.com/sdk-for-kotlin/latest/developer-guide/setup.html
*/
suspend fun main(args: Array<String>) {
val usage = """
Usage:
<targetKeyId> <aliasName>
Where:
targetKeyId - The key ID or the Amazon Resource Name (ARN) of the KMS key.
aliasName - An alias name to create (for example, alias/myAlias).
"""
if (args.size != 2) {
println(usage)
exitProcess(0)
}
val targetKeyId = args[0]
val aliasName = args[1]
createCustomAlias(targetKeyId, aliasName)
}
// snippet-start:[kms.kotlin_create_alias.main]
suspend fun createCustomAlias(targetKeyIdVal: String?, aliasNameVal: String?) {
val request = CreateAliasRequest {
aliasName = aliasNameVal
targetKeyId = targetKeyIdVal
}
KmsClient { region = "us-west-2" }.use { kmsClient ->
kmsClient.createAlias(request)
println("$aliasNameVal was successfully created")
}
}
// snippet-end:[kms.kotlin_create_alias.main]
| kotlin/services/kms/src/main/kotlin/com/kotlin/kms/CreateAlias.kt | 1305349140 |
// snippet-sourcedescription:[ListStateMachines.kt demonstrates how to list existing state machines for AWS Step Functions.]
// snippet-keyword:[AWS SDK for Kotlin]
// snippet-service:[AWS Step Functions]
/*
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package com.kotlin.stepfunctions
// snippet-start:[stepfunctions.kotlin.list_machines.import]
import aws.sdk.kotlin.services.sfn.SfnClient
import aws.sdk.kotlin.services.sfn.model.ListStateMachinesRequest
// snippet-end:[stepfunctions.kotlin.list_machines.import]
/**
Before running this Kotlin code example, set up your development environment,
including your credentials.
For more information, see the following documentation topic:
https://docs.aws.amazon.com/sdk-for-kotlin/latest/developer-guide/setup.html
*/
suspend fun main() {
listMachines()
}
// snippet-start:[stepfunctions.kotlin.list_machines.main]
suspend fun listMachines() {
SfnClient { region = "us-east-1" }.use { sfnClient ->
val response = sfnClient.listStateMachines(ListStateMachinesRequest {})
response.stateMachines?.forEach { machine ->
println("The name of the state machine is ${machine.name}")
println("The ARN value is ${machine.stateMachineArn}")
}
}
}
// snippet-end:[stepfunctions.kotlin.list_machines.main]
| kotlin/services/stepfunctions/src/main/kotlin/com/kotlin/stepfunctions/ListStateMachines.kt | 1929208481 |
/*
* ******************************************************************************
* Copyright 2016-2017 Spectra Logic Corporation. All Rights Reserved.
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use
* this file except in compliance with the License. A copy of the License is located at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* or in the "license" file accompanying this file.
* This file 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.spectralogic.dsbrowser.gui.components.physicalplacement
data class ReplicationEntry(
val dataPathEndPoint: String,
val dataPathPort: Int,
val authId: String,
val id: String,
val name: String,
val accessControlReplication: String,
val state: String,
val permitGoingOutOfSync: Boolean,
val quiesced: String
)
| dsb-gui/src/main/java/com/spectralogic/dsbrowser/gui/components/physicalplacement/ReplicationEntry.kt | 3359328690 |
/*
* Copyright (C) 2018 Florian Dreier
*
* This file is part of MyTargets.
*
* MyTargets is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation.
*
* MyTargets is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
package de.dreier.mytargets.test.utils.matchers
import android.content.res.Resources
import androidx.test.espresso.Espresso.onView
import androidx.test.espresso.ViewInteraction
import androidx.test.espresso.assertion.ViewAssertions
import androidx.test.espresso.matcher.BoundedMatcher
import androidx.test.espresso.matcher.ViewMatchers.isAssignableFrom
import androidx.appcompat.widget.Toolbar
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import org.hamcrest.CoreMatchers.`is`
import org.hamcrest.Description
import org.hamcrest.Matcher
object MatcherUtils {
fun getParentViewById(view: View, parentViewId: Int): View? {
if (view.id == parentViewId) {
return view
} else if (view.parent != null && view.parent is ViewGroup) {
return getParentViewById(view.parent as View, parentViewId)
}
return null
}
fun isInViewHierarchy(view: View, viewToFind: View): Boolean {
if (view === viewToFind) {
return true
} else if (view.parent != null && view.parent is ViewGroup) {
return isInViewHierarchy(view.parent as View, viewToFind)
}
return false
}
fun matchToolbarTitle(title: CharSequence): ViewInteraction {
return onView(isAssignableFrom(Toolbar::class.java))
.check(ViewAssertions.matches(withToolbarTitle(`is`(title))))
}
fun withToolbarTitle(
textMatcher: Matcher<CharSequence>): Matcher<Any> {
return object : BoundedMatcher<Any, Toolbar>(Toolbar::class.java) {
public override fun matchesSafely(toolbar: Toolbar): Boolean {
return textMatcher.matches(toolbar.title)
}
override fun describeTo(description: Description) {
description.appendText("with toolbar title: ")
textMatcher.describeTo(description)
}
}
}
fun getMatchingParent(view: View?, matcher: Matcher<View>): View? {
if (view == null) {
return null
}
if (matcher.matches(view)) {
return view
} else if (view.parent != null && view.parent is ViewGroup) {
return getMatchingParent(view.parent as View, matcher)
}
return null
}
/**
* Returns a matcher that matches a descendant of [TextView] that is displaying the string
* associated with the given resource id.
*
* @param resourceId the string resource the text view is expected to hold.
*/
fun containsStringRes(resourceId: Int): Matcher<View> {
return object : BoundedMatcher<View, TextView>(TextView::class.java) {
private var resourceName: String? = null
private var expectedText: String? = null
override fun describeTo(description: Description) {
description.appendText("contains string from resource id: ")
description.appendValue(resourceId)
if (resourceName != null) {
description.appendText("[")
description.appendText(resourceName)
description.appendText("]")
}
if (expectedText != null) {
description.appendText(" value: ")
description.appendText(expectedText)
}
}
public override fun matchesSafely(textView: TextView): Boolean {
if (expectedText == null) {
try {
expectedText = textView.resources.getString(resourceId)
resourceName = textView.resources.getResourceEntryName(resourceId)
} catch (ignored: Resources.NotFoundException) {
/* view could be from a context unaware of the resource id. */
}
}
val actualText = textView.text
// FYI: actualText may not be string ... its just a char sequence convert to string.
return expectedText != null && actualText != null &&
actualText.toString().contains(expectedText!!)
}
}
}
}
| app/src/androidTest/java/de/dreier/mytargets/test/utils/matchers/MatcherUtils.kt | 2922342337 |
/*
* Copyright (C) 2018 Florian Dreier
*
* This file is part of MyTargets.
*
* MyTargets is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation.
*
* MyTargets is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
package de.dreier.mytargets.features.training.environment
import android.content.Intent
import androidx.databinding.DataBindingUtil
import android.os.Bundle
import androidx.appcompat.widget.SwitchCompat
import android.view.*
import android.view.View.GONE
import android.view.View.VISIBLE
import com.evernote.android.state.State
import de.dreier.mytargets.R
import de.dreier.mytargets.base.fragments.FragmentBase
import de.dreier.mytargets.base.navigation.NavigationController.Companion.ITEM
import de.dreier.mytargets.databinding.FragmentEnvironmentBinding
import de.dreier.mytargets.features.settings.SettingsManager
import de.dreier.mytargets.shared.models.EWeather
import de.dreier.mytargets.shared.models.Environment
import de.dreier.mytargets.utils.ToolbarUtils
class EnvironmentFragment : FragmentBase() {
@State
var environment: Environment? = null
private lateinit var binding: FragmentEnvironmentBinding
private var switchView: SwitchCompat? = null
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
binding = DataBindingUtil
.inflate(inflater, R.layout.fragment_environment, container, false)
ToolbarUtils.setSupportActionBar(this, binding.toolbar)
ToolbarUtils.showHomeAsUp(this)
setHasOptionsMenu(true)
// Weather
binding.sunny.setOnClickListener { setWeather(EWeather.SUNNY) }
binding.partlyCloudy.setOnClickListener { setWeather(EWeather.PARTLY_CLOUDY) }
binding.cloudy.setOnClickListener { setWeather(EWeather.CLOUDY) }
binding.lightRain.setOnClickListener { setWeather(EWeather.LIGHT_RAIN) }
binding.rain.setOnClickListener { setWeather(EWeather.RAIN) }
if (savedInstanceState == null) {
environment = arguments!!.getParcelable(ITEM)
}
setWeather(environment!!.weather)
binding.windSpeed.setItemId(environment!!.windSpeed.toLong())
binding.windDirection.setItemId(environment!!.windDirection.toLong())
binding.location.setText(environment!!.location)
binding.windDirection.setOnClickListener { selectedItem, _ ->
navigationController.navigateToWindDirection(selectedItem!!)
}
binding.windSpeed.setOnClickListener { selectedItem, _ ->
navigationController.navigateToWindSpeed(selectedItem!!)
}
return binding.root
}
private fun setWeather(weather: EWeather) {
environment!!.weather = weather
binding.sunny.setImageResource(EWeather.SUNNY.getDrawable(weather))
binding.partlyCloudy.setImageResource(EWeather.PARTLY_CLOUDY.getDrawable(weather))
binding.cloudy.setImageResource(EWeather.CLOUDY.getDrawable(weather))
binding.lightRain.setImageResource(EWeather.LIGHT_RAIN.getDrawable(weather))
binding.rain.setImageResource(EWeather.RAIN.getDrawable(weather))
}
override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
inflater.inflate(R.menu.environment_switch, menu)
val item = menu.findItem(R.id.action_switch)
switchView = item.actionView.findViewById(R.id.action_switch_control)
switchView!!.setOnCheckedChangeListener { _, checked -> setOutdoor(checked) }
setOutdoor(!environment!!.indoor)
switchView!!.isChecked = !environment!!.indoor
}
private fun setOutdoor(checked: Boolean) {
switchView!!.setText(if (checked) R.string.outdoor else R.string.indoor)
binding.indoorPlaceholder.visibility = if (checked) GONE else VISIBLE
binding.weatherLayout.visibility = if (checked) VISIBLE else GONE
}
override fun onSaveInstanceState(outState: Bundle) {
environment = saveItem()
super.onSaveInstanceState(outState)
}
fun onSave() {
val e = saveItem()
SettingsManager.indoor = e.indoor
navigationController.setResultSuccess(e)
navigationController.finish()
}
private fun saveItem(): Environment {
val e = Environment()
e.indoor = !switchView!!.isChecked
e.weather = environment!!.weather
e.windSpeed = binding.windSpeed.selectedItem!!.id.toInt()
e.windDirection = binding.windDirection.selectedItem!!.id.toInt()
e.location = binding.location.text.toString()
return e
}
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
binding.windSpeed.onActivityResult(requestCode, resultCode, data)
binding.windDirection.onActivityResult(requestCode, resultCode, data)
}
}
| app/src/main/java/de/dreier/mytargets/features/training/environment/EnvironmentFragment.kt | 4113584046 |
package net.nemerosa.ontrack.boot.resources
import com.fasterxml.jackson.core.JsonProcessingException
import com.fasterxml.jackson.databind.JsonNode
import net.nemerosa.ontrack.json.JsonUtils
import net.nemerosa.ontrack.model.security.*
import net.nemerosa.ontrack.model.structure.*
import net.nemerosa.ontrack.ui.controller.MockURIBuilder
import net.nemerosa.ontrack.ui.resource.*
import org.junit.Before
import org.junit.Test
import java.io.IOException
import java.net.URI
import java.time.LocalDateTime
import java.util.Arrays
import net.nemerosa.ontrack.json.JsonUtils.array
import net.nemerosa.ontrack.json.JsonUtils.`object`
import net.nemerosa.ontrack.model.structure.TestFixtures.SIGNATURE
import net.nemerosa.ontrack.model.structure.TestFixtures.SIGNATURE_OBJECT
import org.junit.Assert.assertEquals
import org.mockito.Mockito.mock
import org.mockito.Mockito.`when`
class CoreResourceModuleTest {
private var mapper: ResourceObjectMapper? = null
private var securityService: SecurityService? = null
private var structureService: StructureService? = null
private var projectFavouriteService: ProjectFavouriteService? = null
private var branchFavouriteService: BranchFavouriteService? = null
@Before
fun before() {
securityService = mock(SecurityService::class.java)
structureService = mock(StructureService::class.java)
val resourceDecorationContributorService = mock(ResourceDecorationContributorService::class.java)
projectFavouriteService = mock(ProjectFavouriteService::class.java)
branchFavouriteService = mock(BranchFavouriteService::class.java)
mapper = ResourceObjectMapperFactory().resourceObjectMapper(
listOf<ResourceModule>(DefaultResourceModule(
listOf(
ConnectedAccountResourceDecorator(),
ProjectResourceDecorator(resourceDecorationContributorService, projectFavouriteService),
BranchResourceDecorator(resourceDecorationContributorService, structureService, branchFavouriteService),
PromotionLevelResourceDecorator(),
ValidationStampResourceDecorator(),
BuildResourceDecorator(resourceDecorationContributorService),
PromotionRunResourceDecorator(),
ValidationRunResourceDecorator(),
BuildFilterResourceDecorator(),
AccountResourceDecorator(),
AccountGroupResourceDecorator(),
GlobalPermissionResourceDecorator(),
ProjectPermissionResourceDecorator(),
JobStatusResourceDecorator(),
PredefinedValidationStampResourceDecorator()
)
)),
DefaultResourceContext(MockURIBuilder(), securityService)
)
}
@Test
@Throws(JsonProcessingException::class)
fun project_granted_for_update() {
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1)).withSignature(SIGNATURE)
`when`(securityService!!.isProjectFunctionGranted(1, ProjectEdit::class.java)).thenReturn(true)
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_update", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#saveProject:1,")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_disable", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#disableProject:1")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end(),
p
)
}
@Test
@Throws(JsonProcessingException::class)
fun project_not_favourite() {
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1))
.withSignature(SIGNATURE)
`when`(securityService!!.isLogged).thenReturn(true)
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_favourite", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#favouriteProject:1")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end(),
p
)
}
@Test
@Throws(JsonProcessingException::class)
fun project_no_favourite_link_if_not_logged() {
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1))
.withSignature(SIGNATURE)
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end(),
p
)
}
@Test
@Throws(JsonProcessingException::class)
fun project_favourite() {
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1))
.withSignature(SIGNATURE)
`when`(securityService!!.isLogged).thenReturn(true)
`when`(projectFavouriteService!!.isProjectFavourite(p)).thenReturn(true)
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_unfavourite", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#unfavouriteProject:1")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end(),
p
)
}
@Test
@Throws(JsonProcessingException::class)
fun project_granted_for_update_and_disabled() {
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1)).withDisabled(true)
.withSignature(SIGNATURE)
`when`(securityService!!.isProjectFunctionGranted(1, ProjectEdit::class.java)).thenReturn(true)
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", true)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_update", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#saveProject:1,")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_enable", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#enableProject:1")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end(),
p
)
}
@Test
@Throws(JsonProcessingException::class)
fun branch_no_build_granted_for_template_definition() {
// Objects
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1))
.withSignature(SIGNATURE)
val b = Branch.of(p, NameDescription("B", "Branch")).withId(ID.of(1))
.withSignature(SIGNATURE)
`when`(securityService!!.isProjectFunctionGranted(1, BranchTemplateMgt::class.java)).thenReturn(true)
// Serialization
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "B")
.with("description", "Branch")
.with("disabled", false)
.with("type", "CLASSIC")
.with("project", `object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end()
)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:1")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_promotionLevels", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelListForBranch:1")
.with("_validationStamps", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampListForBranch:1")
.with("_validationStampViews", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampViewListForBranch:1")
.with("_allValidationStampFilters", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampFilterController#getAllBranchValidationStampFilters:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:BRANCH,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:BRANCH,1")
.with("_status", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchStatusView:1")
.with("_view", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#buildView:1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:BRANCH,1")
.with("_buildFilterResources", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilters:1")
.with("_buildFilterForms", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilterForms:1")
.with("_buildFilterSave", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#createFilter:1,")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:BRANCH,1,0,10")
.with("_templateDefinition", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getTemplateDefinition:1")
.with("_templateInstanceConnect", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#connectTemplateInstance:1")
.with("_page", "urn:test:#:entity:BRANCH:1")
.end(),
b
)
}
@Test
@Throws(JsonProcessingException::class)
fun branch_instance_for_template_definition() {
// Objects
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1)).withSignature(SIGNATURE)
val b = Branch.of(p, NameDescription("B", "Branch")).withId(ID.of(1))
.withType(BranchType.TEMPLATE_INSTANCE)
.withSignature(SIGNATURE)
`when`(securityService!!.isProjectFunctionGranted(1, BranchTemplateMgt::class.java)).thenReturn(true)
// Serialization
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "B")
.with("description", "Branch")
.with("disabled", false)
.with("type", "TEMPLATE_INSTANCE")
.with("project", `object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end()
)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:1")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_promotionLevels", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelListForBranch:1")
.with("_validationStamps", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampListForBranch:1")
.with("_validationStampViews", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampViewListForBranch:1")
.with("_allValidationStampFilters", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampFilterController#getAllBranchValidationStampFilters:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:BRANCH,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:BRANCH,1")
.with("_status", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchStatusView:1")
.with("_view", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#buildView:1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:BRANCH,1")
.with("_buildFilterResources", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilters:1")
.with("_buildFilterForms", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilterForms:1")
.with("_buildFilterSave", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#createFilter:1,")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:BRANCH,1,0,10")
.with("_templateInstance", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getTemplateInstance:1")
.with("_templateInstanceDisconnect", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#disconnectTemplateInstance:1")
.with("_templateInstanceSync", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#syncTemplateInstance:1")
.with("_page", "urn:test:#:entity:BRANCH:1")
.end(),
b
)
}
@Test
@Throws(JsonProcessingException::class)
fun branch_with_builds_for_template_definition() {
// Objects
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1))
.withSignature(SIGNATURE)
val b = Branch.of(p, NameDescription("B", "Branch")).withId(ID.of(1))
.withSignature(SIGNATURE)
`when`(structureService!!.getBuildCount(b)).thenReturn(1)
`when`(securityService!!.isProjectFunctionGranted(1, BranchTemplateMgt::class.java)).thenReturn(true)
// Serialization
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "B")
.with("description", "Branch")
.with("disabled", false)
.with("type", "CLASSIC")
.with("project", `object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end()
)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:1")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_promotionLevels", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelListForBranch:1")
.with("_validationStamps", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampListForBranch:1")
.with("_validationStampViews", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampViewListForBranch:1")
.with("_allValidationStampFilters", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampFilterController#getAllBranchValidationStampFilters:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:BRANCH,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:BRANCH,1")
.with("_status", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchStatusView:1")
.with("_view", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#buildView:1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:BRANCH,1")
.with("_buildFilterResources", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilters:1")
.with("_buildFilterForms", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilterForms:1")
.with("_buildFilterSave", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#createFilter:1,")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:BRANCH,1,0,10")
.with("_templateInstanceConnect", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#connectTemplateInstance:1")
.with("_page", "urn:test:#:entity:BRANCH:1")
.end(),
b
)
}
@Test
@Throws(JsonProcessingException::class)
fun branch_definition_granted() {
// Objects
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1))
.withSignature(SIGNATURE)
val b = Branch.of(p, NameDescription("B", "Branch")).withId(ID.of(1))
.withType(BranchType.TEMPLATE_DEFINITION)
.withSignature(SIGNATURE)
`when`(securityService!!.isProjectFunctionGranted(1, BranchTemplateMgt::class.java)).thenReturn(true)
// Serialization
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "B")
.with("description", "Branch")
.with("disabled", false)
.with("type", "TEMPLATE_DEFINITION")
.with("project", `object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end()
)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:1")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_promotionLevels", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelListForBranch:1")
.with("_validationStamps", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampListForBranch:1")
.with("_validationStampViews", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampViewListForBranch:1")
.with("_allValidationStampFilters", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampFilterController#getAllBranchValidationStampFilters:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:BRANCH,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:BRANCH,1")
.with("_status", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchStatusView:1")
.with("_view", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#buildView:1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:BRANCH,1")
.with("_buildFilterResources", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilters:1")
.with("_buildFilterForms", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilterForms:1")
.with("_buildFilterSave", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#createFilter:1,")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:BRANCH,1,0,10")
.with("_templateDefinition", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getTemplateDefinition:1")
.with("_templateSync", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#syncTemplateDefinition:1")
.with("_templateInstanceCreate", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#singleTemplateInstanceForm:1")
.with("_page", "urn:test:#:entity:BRANCH:1")
.end(),
b
)
}
@Test
@Throws(JsonProcessingException::class)
fun branch_sync_granted_for_controller() {
// Objects
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1))
.withSignature(SIGNATURE)
val b = Branch.of(p, NameDescription("B", "Branch")).withId(ID.of(1))
.withType(BranchType.TEMPLATE_DEFINITION)
.withSignature(SIGNATURE)
`when`(securityService!!.isProjectFunctionGranted(1, BranchTemplateSync::class.java)).thenReturn(true)
// Serialization
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "B")
.with("description", "Branch")
.with("disabled", false)
.with("type", "TEMPLATE_DEFINITION")
.with("project", `object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end()
)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:1")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_promotionLevels", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelListForBranch:1")
.with("_validationStamps", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampListForBranch:1")
.with("_validationStampViews", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampViewListForBranch:1")
.with("_allValidationStampFilters", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampFilterController#getAllBranchValidationStampFilters:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:BRANCH,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:BRANCH,1")
.with("_status", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchStatusView:1")
.with("_view", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#buildView:1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:BRANCH,1")
.with("_buildFilterResources", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilters:1")
.with("_buildFilterForms", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilterForms:1")
.with("_buildFilterSave", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#createFilter:1,")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:BRANCH,1,0,10")
.with("_templateSync", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#syncTemplateDefinition:1")
.with("_templateInstanceCreate", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#singleTemplateInstanceForm:1")
.with("_page", "urn:test:#:entity:BRANCH:1")
.end(),
b
)
}
@Test
@Throws(JsonProcessingException::class)
fun branch_definition_not_granted() {
// Objects
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1))
.withSignature(SIGNATURE)
val b = Branch.of(p, NameDescription("B", "Branch")).withId(ID.of(1))
.withType(BranchType.TEMPLATE_DEFINITION)
.withSignature(SIGNATURE)
`when`(securityService!!.isProjectFunctionGranted(1, BranchTemplateMgt::class.java)).thenReturn(false)
// Serialization
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "B")
.with("description", "Branch")
.with("disabled", false)
.with("type", "TEMPLATE_DEFINITION")
.with("project", `object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end()
)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:1")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_promotionLevels", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelListForBranch:1")
.with("_validationStamps", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampListForBranch:1")
.with("_validationStampViews", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampViewListForBranch:1")
.with("_allValidationStampFilters", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampFilterController#getAllBranchValidationStampFilters:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:BRANCH,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:BRANCH,1")
.with("_status", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchStatusView:1")
.with("_view", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#buildView:1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:BRANCH,1")
.with("_buildFilterResources", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilters:1")
.with("_buildFilterForms", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilterForms:1")
.with("_buildFilterSave", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#createFilter:1,")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:BRANCH,1,0,10")
.with("_page", "urn:test:#:entity:BRANCH:1")
.end(),
b
)
}
@Test
@Throws(JsonProcessingException::class)
fun branch_no_grant() {
// Objects
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1)).withSignature(SIGNATURE)
val b = Branch.of(p, NameDescription("B", "Branch")).withId(ID.of(1)).withSignature(SIGNATURE)
// Serialization
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "B")
.with("description", "Branch")
.with("disabled", false)
.with("type", "CLASSIC")
.with("project", `object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end()
)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:1")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_promotionLevels", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelListForBranch:1")
.with("_validationStamps", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampListForBranch:1")
.with("_validationStampViews", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampViewListForBranch:1")
.with("_allValidationStampFilters", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampFilterController#getAllBranchValidationStampFilters:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:BRANCH,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:BRANCH,1")
.with("_status", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchStatusView:1")
.with("_view", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#buildView:1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:BRANCH,1")
.with("_buildFilterResources", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilters:1")
.with("_buildFilterForms", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilterForms:1")
.with("_buildFilterSave", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#createFilter:1,")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:BRANCH,1,0,10")
.with("_page", "urn:test:#:entity:BRANCH:1")
.end(),
b
)
}
@Test
@Throws(JsonProcessingException::class)
fun build_view() {
// Objects
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1)).withSignature(SIGNATURE)
val b = Branch.of(p, NameDescription("B", "Branch")).withId(ID.of(1)).withSignature(SIGNATURE)
val signatureTime = LocalDateTime.of(2015, 6, 17, 11, 41)
val build = Build.of(b, NameDescription.nd("1", "Build 1"), Signature.of(signatureTime, "test")).withId(ID.of(1))
// Serialization
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "1")
.with("description", "Build 1")
.with("signature", `object`()
.with("time", "2015-06-17T11:41:00Z")
.with("user", `object`().with("name", "test").end())
.end()
)
.with("branch", `object`()
.with("id", 1)
.with("name", "B")
.with("description", "Branch")
.with("disabled", false)
.with("type", "CLASSIC")
.with("project", `object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end()
)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:1")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_promotionLevels", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelListForBranch:1")
.with("_validationStamps", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampListForBranch:1")
.with("_validationStampViews", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampViewListForBranch:1")
.with("_allValidationStampFilters", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampFilterController#getAllBranchValidationStampFilters:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:BRANCH,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:BRANCH,1")
.with("_status", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchStatusView:1")
.with("_view", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#buildView:1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:BRANCH,1")
.with("_buildFilterResources", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilters:1")
.with("_buildFilterForms", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilterForms:1")
.with("_buildFilterSave", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#createFilter:1,")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:BRANCH,1,0,10")
.with("_page", "urn:test:#:entity:BRANCH:1")
.end()
)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#getBuild:1")
.with("_lastPromotionRuns", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionRunController#getLastPromotionRuns:1")
.with("_promotionRuns", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionRunController#getPromotionRuns:1")
.with("_validationRuns", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationRunController#getValidationRuns:1")
.with("_validationStampRunViews", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationRunController#getValidationStampRunViews:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:BUILD,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:BUILD,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:BUILD,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:BUILD,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:BUILD,1,0,10")
.with("_previous", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#getPreviousBuild:1")
.with("_next", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#getNextBuild:1")
.with("_buildLinksFrom", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#getBuildLinksFrom:1")
.with("_buildLinksTo", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#getBuildLinksTo:1")
.with("_runInfo", "urn:test:net.nemerosa.ontrack.boot.ui.RunInfoController#getRunInfo:build,1")
.with("_page", "urn:test:#:entity:BUILD:1")
.end(),
build
)
}
@Test
@Throws(JsonProcessingException::class)
fun project_not_granted_for_update() {
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1))
.withSignature(SIGNATURE)
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end(),
p
)
}
@Test
@Throws(JsonProcessingException::class)
fun promotion_level_image_link_and_ignored_branch() {
// Objects
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1)).withSignature(SIGNATURE)
val b = Branch.of(p, NameDescription("B", "Branch")).withId(ID.of(1)).withSignature(SIGNATURE)
val pl = PromotionLevel.of(b, NameDescription("PL", "Promotion level")).withId(ID.of(1)).withSignature(SIGNATURE)
// Serialization
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "PL")
.with("description", "Promotion level")
.with("image", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevel:1")
.with("_branch", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:1")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_image", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelImage_:,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROMOTION_LEVEL,1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROMOTION_LEVEL,1")
.with("_runs", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionRunView:1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROMOTION_LEVEL,1,0,10")
.with("_page", "urn:test:#:entity:PROMOTION_LEVEL:1")
.end(),
pl,
Branch::class.java
)
}
@Test
@Throws(JsonProcessingException::class)
fun promotion_level_image_link_and_include_branch() {
// Objects
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1)).withSignature(SIGNATURE)
val b = Branch.of(p, NameDescription("B", "Branch")).withId(ID.of(1)).withSignature(SIGNATURE)
val pl = PromotionLevel.of(b, NameDescription("PL", "Promotion level"))
.withId(ID.of(1))
.withSignature(SIGNATURE)
// Serialization
assertResourceJson(
mapper!!,
`object`()
.with("id", 1)
.with("name", "PL")
.with("description", "Promotion level")
.with("branch", `object`()
.with("id", 1)
.with("name", "B")
.with("description", "Branch")
.with("disabled", false)
.with("type", "CLASSIC")
.with("project", `object`()
.with("id", 1)
.with("name", "P")
.with("description", "Project")
.with("disabled", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_branchStatusViews", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getBranchStatusViews:1")
.with("_buildSearch", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildSearchForm:1")
.with("_buildDiffActions", "urn:test:net.nemerosa.ontrack.boot.ui.BuildController#buildDiffActions:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROJECT,1")
.with("_extra", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getInformation:PROJECT,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:PROJECT,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROJECT,1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROJECT,1,0,10")
.with("_page", "urn:test:#:entity:PROJECT:1")
.end())
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:1")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_promotionLevels", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelListForBranch:1")
.with("_validationStamps", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampListForBranch:1")
.with("_validationStampViews", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampViewListForBranch:1")
.with("_allValidationStampFilters", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampFilterController#getAllBranchValidationStampFilters:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:BRANCH,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:BRANCH,1")
.with("_status", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchStatusView:1")
.with("_view", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#buildView:1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:BRANCH,1")
.with("_buildFilterResources", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilters:1")
.with("_buildFilterForms", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilterForms:1")
.with("_buildFilterSave", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#createFilter:1,")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:BRANCH,1,0,10")
.with("_page", "urn:test:#:entity:BRANCH:1")
.end())
.with("image", false)
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevel:1")
.with("_branch", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:1")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_image", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelImage_:,1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:PROMOTION_LEVEL,1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:PROMOTION_LEVEL,1")
.with("_runs", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionRunView:1")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:PROMOTION_LEVEL,1,0,10")
.with("_page", "urn:test:#:entity:PROMOTION_LEVEL:1")
.end(),
pl
)
}
@Test
@Throws(JsonProcessingException::class)
fun resource_collection_with_filtering() {
val project = Project.of(NameDescription("PRJ", "Project")).withId(ID.of(1))
val branches = Arrays.asList(
Branch.of(project, NameDescription("B1", "Branch 1")).withId(ID.of(1)).withSignature(SIGNATURE),
Branch.of(project, NameDescription("B2", "Branch 2")).withId(ID.of(2)).withSignature(SIGNATURE)
)
val resourceCollection = Resources.of(
branches,
URI.create("urn:branch")
)
assertResourceJson(
mapper!!,
`object`()
.with("_self", "urn:branch")
.with("resources", array()
.with(`object`()
.with("id", 1)
.with("name", "B1")
.with("description", "Branch 1")
.with("disabled", false)
.with("type", "CLASSIC")
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:1")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_promotionLevels", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelListForBranch:1")
.with("_validationStamps", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampListForBranch:1")
.with("_validationStampViews", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampViewListForBranch:1")
.with("_allValidationStampFilters", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampFilterController#getAllBranchValidationStampFilters:1")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:BRANCH,1")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:BRANCH,1")
.with("_status", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchStatusView:1")
.with("_view", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#buildView:1")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:BRANCH,1")
.with("_buildFilterResources", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilters:1")
.with("_buildFilterForms", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilterForms:1")
.with("_buildFilterSave", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#createFilter:1,")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:BRANCH,1,0,10")
.with("_page", "urn:test:#:entity:BRANCH:1")
.end())
.with(`object`()
.with("id", 2)
.with("name", "B2")
.with("description", "Branch 2")
.with("disabled", false)
.with("type", "CLASSIC")
.with("signature", SIGNATURE_OBJECT)
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranch:2")
.with("_project", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectController#getProject:1")
.with("_promotionLevels", "urn:test:net.nemerosa.ontrack.boot.ui.PromotionLevelController#getPromotionLevelListForBranch:2")
.with("_validationStamps", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampListForBranch:2")
.with("_validationStampViews", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampController#getValidationStampViewListForBranch:2")
.with("_allValidationStampFilters", "urn:test:net.nemerosa.ontrack.boot.ui.ValidationStampFilterController#getAllBranchValidationStampFilters:2")
.with("_branches", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchListForProject:1")
.with("_properties", "urn:test:net.nemerosa.ontrack.boot.ui.PropertyController#getProperties:BRANCH,2")
.with("_actions", "urn:test:net.nemerosa.ontrack.boot.ui.ProjectEntityExtensionController#getActions:BRANCH,2")
.with("_status", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#getBranchStatusView:2")
.with("_view", "urn:test:net.nemerosa.ontrack.boot.ui.BranchController#buildView:2")
.with("_decorations", "urn:test:net.nemerosa.ontrack.boot.ui.DecorationsController#getDecorations:BRANCH,2")
.with("_buildFilterResources", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilters:2")
.with("_buildFilterForms", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#buildFilterForms:2")
.with("_buildFilterSave", "urn:test:net.nemerosa.ontrack.boot.ui.BuildFilterController#createFilter:2,")
.with("_events", "urn:test:net.nemerosa.ontrack.boot.ui.EventController#getEvents:BRANCH,2,0,10")
.with("_page", "urn:test:#:entity:BRANCH:2")
.end())
.end())
.end(),
resourceCollection
)
}
@Test
@Throws(JsonProcessingException::class)
fun account_group_links() {
assertResourceJson(
mapper!!,
`object`()
.with("id", 0)
.with("name", "Admins")
.with("description", "Administrators")
.with("_self", "urn:test:net.nemerosa.ontrack.boot.ui.AccountController#getGroup:0")
.with("_update", "urn:test:net.nemerosa.ontrack.boot.ui.AccountController#getGroupUpdateForm:0")
.with("_delete", "urn:test:net.nemerosa.ontrack.boot.ui.AccountController#deleteGroup:0")
.end(),
AccountGroup.of("Admins", "Administrators")
)
}
@Test
@Throws(IOException::class)
fun promotion_run_delete_granted() {
// Objects
val p = Project.of(NameDescription("P", "Project")).withId(ID.of(1))
val b = Branch.of(p, NameDescription("B", "Branch")).withId(ID.of(1)).withType(BranchType.TEMPLATE_DEFINITION)
val pl = PromotionLevel.of(b, NameDescription.nd("PL", "Promotion Level")).withId(ID.of(1))
val build = Build.of(b, NameDescription.nd("1", "Build 1"), Signature.of("test")).withId(ID.of(1))
val run = PromotionRun.of(build, pl, Signature.of("test"), "Run").withId(ID.of(1))
// Security
`when`(securityService!!.isProjectFunctionGranted(1, PromotionRunDelete::class.java)).thenReturn(true)
// Serialization
val node = mapper!!.objectMapper.readTree(mapper!!.write(run))
// Checks the _delete link is present
val delete = JsonUtils.get(node, "_delete")
assertEquals("urn:test:net.nemerosa.ontrack.boot.ui.PromotionRunController#deletePromotionRun:1", delete)
}
companion object {
@Throws(JsonProcessingException::class)
fun assertResourceJson(mapper: ResourceObjectMapper, expectedJson: JsonNode, o: Any) {
assertEquals(
mapper.objectMapper.writeValueAsString(expectedJson),
mapper.write(o)
)
}
@Throws(JsonProcessingException::class)
fun assertResourceJson(mapper: ResourceObjectMapper, expectedJson: JsonNode, o: Any, view: Class<*>) {
assertEquals(
mapper.objectMapper.writeValueAsString(expectedJson),
mapper.write(o, view)
)
}
}
}
| ontrack-ui/src/test/java/net/nemerosa/ontrack/boot/resources/CoreResourceModuleTest.kt | 4225035074 |
/*
* Copyright 2000-2017 JetBrains s.r.o.
*
* 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.intellij.stats.completion
import com.intellij.codeInsight.lookup.impl.LookupImpl
import com.intellij.openapi.components.ServiceManager
abstract class CompletionLoggerProvider {
abstract fun newCompletionLogger(): CompletionLogger
open fun dispose(): Unit = Unit
companion object {
fun getInstance(): CompletionLoggerProvider = ServiceManager.getService(CompletionLoggerProvider::class.java)
}
}
abstract class CompletionLogger {
abstract fun completionStarted(lookup: LookupImpl, isExperimentPerformed: Boolean, experimentVersion: Int,
timestamp: Long, mlTimeContribution: Long)
abstract fun afterCharTyped(c: Char, lookup: LookupImpl, timestamp: Long)
abstract fun afterBackspacePressed(lookup: LookupImpl, timestamp: Long)
abstract fun downPressed(lookup: LookupImpl, timestamp: Long)
abstract fun upPressed(lookup: LookupImpl, timestamp: Long)
abstract fun itemSelectedCompletionFinished(lookup: LookupImpl, timestamp: Long)
abstract fun completionCancelled(timestamp: Long)
abstract fun itemSelectedByTyping(lookup: LookupImpl, timestamp: Long)
abstract fun customMessage(message: String, timestamp: Long)
abstract fun performanceMessage(description: String, value: Long, timestamp: Long)
} | plugins/stats-collector/src/com/intellij/stats/completion/CompletionLogger.kt | 3381859086 |
package com.akhbulatov.wordkeeper.data.global.local.database.word
import androidx.room.Dao
import androidx.room.Delete
import androidx.room.Insert
import androidx.room.Query
import androidx.room.Update
import kotlinx.coroutines.flow.Flow
@Dao
interface WordDao {
@Query("SELECT * FROM words ORDER BY name")
fun getAllWordsSortedByName(): Flow<List<WordDbModel>>
@Query("SELECT * FROM words ORDER BY datetime DESC")
fun getAllWordsSortedByDescDatetime(): Flow<List<WordDbModel>>
@Query("SELECT * FROM words WHERE category = :category")
fun getWordsByCategory(category: String): Flow<List<WordDbModel>>
@Insert
suspend fun insetWord(word: WordDbModel)
@Update
suspend fun updateWord(word: WordDbModel)
@Delete
suspend fun deleteWords(words: List<WordDbModel>)
}
| app/src/main/java/com/akhbulatov/wordkeeper/data/global/local/database/word/WordDao.kt | 1773924713 |
/*
* Copyright 2000-2017 JetBrains s.r.o.
*
* 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.jetbrains.completion.feature.impl
import com.jetbrains.completion.feature.Feature
import com.jetbrains.completion.feature.Transformer
/**
* @author Vitaliy.Bibaev
*/
class FeatureTransformer(private val features: Map<String, Feature>,
arraySize: Int)
: Transformer {
private val array = DoubleArray(arraySize)
override fun featureArray(relevanceMap: Map<String, Any>, userFactors: Map<String, Any?>): DoubleArray {
for ((name, feature) in features) {
val value = relevanceMap[name]
if (value == null) {
feature.setDefaults(array)
} else {
feature.process(value, array)
}
}
return array
}
} | plugins/stats-collector/features/src/com/jetbrains/completion/feature/impl/FeatureTransformer.kt | 1127172256 |
/*
* Copyright 2017 Pronghorn Technology LLC
*
* 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 tech.pronghorn.server.bufferpools
import tech.pronghorn.plugins.internalQueue.InternalQueuePlugin
import java.nio.ByteBuffer
class ReusableBufferPoolManager(private val bufferSize: Int,
private val direct: Boolean = false) {
fun getBuffer(): ReusableByteBuffer = pool.poll() ?: ReusableByteBuffer(
this,
if (direct) ByteBuffer.allocateDirect(bufferSize) else ByteBuffer.allocate(bufferSize)
)
fun release(buffer: ReusableByteBuffer) {
pool.offer(buffer)
}
private val pool = InternalQueuePlugin.get<ReusableByteBuffer>(1024)
}
| src/main/kotlin/tech/pronghorn/server/bufferpools/ReusableBufferPoolManager.kt | 3509063091 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.openapi.application.impl
import com.intellij.openapi.application.*
import com.intellij.openapi.application.ReadAction.CannotReadException
import com.intellij.openapi.progress.*
import com.intellij.openapi.util.Disposer
import com.intellij.testFramework.LeakHunter
import com.intellij.util.concurrency.Semaphore
import kotlinx.coroutines.*
import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.RepeatedTest
import org.junit.jupiter.api.assertThrows
import java.util.concurrent.atomic.AtomicInteger
import kotlin.coroutines.Continuation
import kotlinx.coroutines.sync.Semaphore as KSemaphore
private const val repetitions: Int = 100
abstract class SuspendingReadActionTest : CancellableReadActionTests() {
@RepeatedTest(repetitions)
fun context(): Unit = timeoutRunBlocking {
val application = ApplicationManager.getApplication()
fun assertEmptyContext() {
assertNull(Cancellation.currentJob())
assertNull(ProgressManager.getGlobalProgressIndicator())
application.assertReadAccessNotAllowed()
}
fun assertReadActionWithCurrentJob() {
assertNotNull(Cancellation.currentJob())
assertNull(ProgressManager.getGlobalProgressIndicator())
application.assertReadAccessAllowed()
}
fun assertReadActionWithoutCurrentJob() {
assertNull(Cancellation.currentJob())
assertNull(ProgressManager.getGlobalProgressIndicator())
application.assertReadAccessAllowed()
}
assertEmptyContext()
val result = cra {
assertReadActionWithCurrentJob()
runBlockingCancellable {
assertReadActionWithoutCurrentJob() // TODO consider explicitly turning off RA inside runBlockingCancellable
withContext(Dispatchers.Default) {
assertEmptyContext()
}
assertReadActionWithoutCurrentJob()
}
assertReadActionWithCurrentJob()
42
}
assertEquals(42, result)
assertEmptyContext()
}
@RepeatedTest(repetitions)
fun cancellation(): Unit = timeoutRunBlocking {
launch {
assertThrows<CancellationException> {
cra {
testNoExceptions()
[email protected]()
testExceptions()
}
}
}
}
@RepeatedTest(repetitions)
fun rethrow(): Unit = timeoutRunBlocking {
testRethrow(object : Throwable() {})
testRethrow(CancellationException())
testRethrow(ProcessCanceledException())
testRethrow(CannotReadException())
}
private suspend inline fun <reified T : Throwable> testRethrow(t: T) {
lateinit var readJob: Job
val thrown = assertThrows<T> {
cra {
readJob = requireNotNull(Cancellation.currentJob())
throw t
}
}
val cause = thrown.cause
if (cause != null) {
assertSame(t, cause) // kotlin trace recovery via 'cause'
}
else {
assertSame(t, thrown)
}
assertTrue(readJob.isCompleted)
assertTrue(readJob.isCancelled)
}
/**
* @see NonBlockingReadActionTest.testSyncExecutionHonorsConstraints
*/
@RepeatedTest(repetitions)
fun `read action honors constraints`(): Unit = timeoutRunBlocking {
val scheduled = KSemaphore(1, 1)
lateinit var constraintRunnable: Runnable
var satisfied = false
val constraint = object : ReadConstraint {
override fun toString(): String = "dummy constraint"
override fun isSatisfied(): Boolean = satisfied
override fun schedule(runnable: Runnable) {
constraintRunnable = runnable
scheduled.release()
}
}
launch {
assertFalse(constraint.isSatisfied())
cra(constraint) {
assertTrue(constraint.isSatisfied())
}
}
scheduled.acquire() // constraint was unsatisfied initially
satisfied = true
constraintRunnable.run() // retry with satisfied constraint
}
@RepeatedTest(repetitions)
fun `read action with unsatisfiable constraint is cancellable`(): Unit = timeoutRunBlocking {
val scheduled = KSemaphore(1, 1)
lateinit var constraintRunnable: Runnable
val unsatisfiableConstraint = object : ReadConstraint {
override fun toString(): String = "unsatisfiable constraint"
override fun isSatisfied(): Boolean = false
override fun schedule(runnable: Runnable) {
constraintRunnable = runnable
scheduled.release()
}
}
val job = launch {
cra(unsatisfiableConstraint) {
fail("must not be called")
}
}
scheduled.acquire()
job.cancelAndJoin()
LeakHunter.checkLeak(constraintRunnable, Continuation::class.java)
}
/**
* @see NonBlockingReadActionTest.testSyncExecutionWorksInsideReadAction
*/
@RepeatedTest(repetitions)
fun `read action works if already obtained`(): Unit = timeoutRunBlocking {
cra {
runBlockingCancellable {
assertEquals(42, cra {
42
})
}
}
}
protected abstract suspend fun <T> cra(vararg constraints: ReadConstraint, action: () -> T): T
}
class NonBlocking : SuspendingReadActionTest() {
override suspend fun <T> cra(vararg constraints: ReadConstraint, action: () -> T): T {
return constrainedReadAction(*constraints, action = action)
}
@RepeatedTest(repetitions)
fun `current job`(): Unit = timeoutRunBlocking {
val coroutineJob = coroutineContext.job
readAction {
val readLoopJob = coroutineJob.children.single()
assertCurrentJobIsChildOf(readLoopJob)
}
}
@RepeatedTest(repetitions)
fun `read action is cancelled by write but not restarted because finished`(): Unit = timeoutRunBlocking {
var attempt = false
readAction {
assertFalse(attempt)
attempt = true
waitForPendingWrite().up()
assertThrows<JobCanceledException> { // assert but not throw
ProgressManager.checkCanceled()
}
}
}
@RepeatedTest(repetitions)
fun `read action is cancelled by write and restarted`(): Unit = timeoutRunBlocking {
var attempts = 0
readAction {
when (attempts++) {
0 -> {
waitForPendingWrite().up()
throw assertThrows<JobCanceledException> {
ProgressManager.checkCanceled()
}
}
1 -> {
assertDoesNotThrow {
ProgressManager.checkCanceled()
}
}
else -> {
fail()
}
}
}
}
@RepeatedTest(repetitions)
fun `read action with constraints is cancelled by write and restarted`(): Unit = timeoutRunBlocking {
val constraintScheduled = KSemaphore(1, 1)
lateinit var constraintRunnable: Runnable
val constraint = object : ReadConstraint {
var satisfied: Boolean = true
override fun toString(): String = "dummy constraint"
override fun isSatisfied(): Boolean = satisfied
override fun schedule(runnable: Runnable) {
constraintRunnable = runnable
constraintScheduled.release()
}
}
val application = ApplicationManager.getApplication()
val job = launch {
var attempts = 0
constrainedReadAction(constraint) {
when (attempts++) {
0 -> {
val pendingWrite = beforeWrite()
application.invokeLater {
application.runWriteAction { // cancel attempt 0
constraint.satisfied = false
}
}
pendingWrite.timeoutWaitUp()
throw assertThrows<JobCanceledException> {
ProgressManager.checkCanceled()
}
}
1 -> {
assertDoesNotThrow {
ProgressManager.checkCanceled()
}
}
else -> {
fail()
}
}
}
}
constraintScheduled.acquire()
assertFalse(job.isCompleted)
assertFalse(job.isCancelled)
application.invokeLater {
application.runWriteAction {
constraint.satisfied = true
constraintRunnable.run() // reschedule
}
}
}
/**
* @see NonBlockingReadActionTest.testSyncExecutionIsCancellable
*/
@RepeatedTest(repetitions)
fun `read action with concurrent write actions`(): Unit = timeoutRunBlocking {
val limit = 10
val attempts = AtomicInteger()
launch {
readAction {
if (attempts.getAndIncrement() < limit) {
while (true) {
ProgressManager.checkCanceled() // wait to be cancelled by
}
}
}
assertEquals(limit + 1, attempts.get()) // cancel 10 times, then pass 1 last time
}
launch(Dispatchers.EDT) {
while (attempts.get() <= limit) {
runWriteAction {}
yield()
}
}
}
}
class Blocking : SuspendingReadActionTest() {
override suspend fun <T> cra(vararg constraints: ReadConstraint, action: () -> T): T {
return constrainedReadActionBlocking(*constraints, action = action)
}
@RepeatedTest(repetitions)
fun `current job`(): Unit = timeoutRunBlocking {
val coroutineJob = coroutineContext.job
readActionBlocking {
val readLoopJob = coroutineJob.children.single()
assertSame(readLoopJob, Cancellation.currentJob())
}
}
@RepeatedTest(repetitions)
fun `blocking read action is not cancelled by write`(): Unit = timeoutRunBlocking {
var attempt = false
readActionBlocking {
assertFalse(attempt)
attempt = true
waitForPendingWrite().up()
testNoExceptions()
}
}
}
private fun beforeWrite(): Semaphore {
val beforeWrite = Semaphore(1)
val listenerDisposable = Disposer.newDisposable()
ApplicationManager.getApplication().addApplicationListener(object : ApplicationListener {
override fun beforeWriteActionStart(action: Any) {
beforeWrite.up()
Disposer.dispose(listenerDisposable)
}
}, listenerDisposable)
return beforeWrite
}
| platform/platform-tests/testSrc/com/intellij/openapi/application/impl/SuspendingReadActionTest.kt | 58504933 |
package org.runestar.client.updater.mapper.std.classes
import org.runestar.client.updater.mapper.IdentityMapper
import org.runestar.client.updater.mapper.OrderMapper
import org.runestar.client.updater.mapper.DependsOn
import org.runestar.client.updater.mapper.MethodParameters
import org.runestar.client.updater.mapper.and
import org.runestar.client.updater.mapper.predicateOf
import org.runestar.client.updater.mapper.Class2
import org.runestar.client.updater.mapper.Field2
import org.runestar.client.updater.mapper.Instruction2
import org.runestar.client.updater.mapper.Method2
import org.objectweb.asm.Opcodes.*
import org.objectweb.asm.Type.*
@DependsOn(Node::class)
class DualNode : IdentityMapper.Class() {
override val predicate = predicateOf<Class2> { it.superType == type<Node>() }
.and { it.instanceFields.size >= 2 }
.and { c -> c.instanceFields.count { it.type == c.type } == 2 }
@MethodParameters()
class removeDual : IdentityMapper.InstanceMethod() {
override val predicate = predicateOf<Method2> { it.returnType == VOID_TYPE }
}
@DependsOn(removeDual::class)
class nextDual : OrderMapper.InMethod.Field(removeDual::class, 0) {
override val predicate = predicateOf<Instruction2> { it.opcode == GETFIELD }
}
@DependsOn(nextDual::class)
class previousDual : IdentityMapper.InstanceField() {
override val predicate = predicateOf<Field2> { it.id != field<nextDual>().id }
.and { it.type == type<DualNode>() }
}
class keyDual : IdentityMapper.InstanceField() {
override val predicate = predicateOf<Field2> { it.type == LONG_TYPE }
}
} | updater-mapper/src/main/java/org/runestar/client/updater/mapper/std/classes/DualNode.kt | 3414409639 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder
import com.intellij.codeInsight.daemon.impl.quickfix.CreateFromUsageUtils
import com.intellij.codeInsight.navigation.NavigationUtil
import com.intellij.codeInsight.template.*
import com.intellij.codeInsight.template.impl.TemplateImpl
import com.intellij.codeInsight.template.impl.TemplateManagerImpl
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.editor.Editor
import com.intellij.openapi.editor.ScrollType
import com.intellij.openapi.fileEditor.FileEditorManager
import com.intellij.openapi.fileEditor.OpenFileDescriptor
import com.intellij.openapi.ui.DialogWrapper
import com.intellij.openapi.util.UnfairTextRange
import com.intellij.psi.*
import com.intellij.psi.codeStyle.CodeStyleManager
import com.intellij.psi.codeStyle.JavaCodeStyleManager
import com.intellij.psi.util.PsiTreeUtil
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode
import org.jetbrains.kotlin.cfg.pseudocode.getContainingPseudocode
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.descriptors.annotations.Annotations
import org.jetbrains.kotlin.descriptors.impl.MutablePackageFragmentDescriptor
import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl
import org.jetbrains.kotlin.idea.FrontendInternals
import org.jetbrains.kotlin.idea.base.resources.KotlinBundle
import org.jetbrains.kotlin.idea.core.CollectingNameValidator
import org.jetbrains.kotlin.idea.base.fe10.codeInsight.newDeclaration.Fe10KotlinNameSuggester
import org.jetbrains.kotlin.idea.base.psi.copied
import org.jetbrains.kotlin.idea.base.psi.replaced
import org.jetbrains.kotlin.idea.caches.resolve.analyzeWithAllCompilerChecks
import org.jetbrains.kotlin.idea.caches.resolve.analyzeWithContent
import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
import org.jetbrains.kotlin.idea.caches.resolve.util.getJavaClassDescriptor
import org.jetbrains.kotlin.idea.core.*
import org.jetbrains.kotlin.idea.base.psi.isMultiLine
import org.jetbrains.kotlin.idea.imports.importableFqName
import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.ClassKind
import org.jetbrains.kotlin.idea.refactoring.*
import org.jetbrains.kotlin.idea.resolve.frontendService
import org.jetbrains.kotlin.idea.util.DialogWithEditor
import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
import org.jetbrains.kotlin.idea.util.application.isUnitTestMode
import org.jetbrains.kotlin.idea.util.application.runWriteAction
import org.jetbrains.kotlin.idea.util.application.withPsiAttachment
import org.jetbrains.kotlin.idea.util.getDefaultInitializer
import org.jetbrains.kotlin.incremental.components.NoLookupLocation
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.*
import org.jetbrains.kotlin.psi.typeRefHelpers.setReceiverTypeReference
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
import org.jetbrains.kotlin.resolve.descriptorUtil.getSuperClassOrAny
import org.jetbrains.kotlin.resolve.scopes.HierarchicalScope
import org.jetbrains.kotlin.resolve.scopes.LexicalScopeImpl
import org.jetbrains.kotlin.resolve.scopes.LexicalScopeKind
import org.jetbrains.kotlin.resolve.scopes.utils.findClassifier
import org.jetbrains.kotlin.resolve.scopes.utils.memberScopeAsImportingScope
import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.types.TypeProjectionImpl
import org.jetbrains.kotlin.types.TypeUtils
import org.jetbrains.kotlin.types.Variance
import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
import org.jetbrains.kotlin.types.typeUtil.isAnyOrNullableAny
import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
import org.jetbrains.kotlin.types.typeUtil.isUnit
import org.jetbrains.kotlin.types.typeUtil.makeNullable
import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments
import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
import java.util.*
import kotlin.math.max
/**
* Represents a single choice for a type (e.g. parameter type or return type).
*/
class TypeCandidate(val theType: KotlinType, scope: HierarchicalScope? = null) {
val typeParameters: Array<TypeParameterDescriptor>
var renderedTypes: List<String> = emptyList()
private set
var renderedTypeParameters: List<RenderedTypeParameter>? = null
private set
fun render(typeParameterNameMap: Map<TypeParameterDescriptor, String>, fakeFunction: FunctionDescriptor?) {
renderedTypes = theType.renderShort(typeParameterNameMap)
renderedTypeParameters = typeParameters.map {
RenderedTypeParameter(it, it.containingDeclaration == fakeFunction, typeParameterNameMap.getValue(it))
}
}
init {
val typeParametersInType = theType.getTypeParameters()
if (scope == null) {
typeParameters = typeParametersInType.toTypedArray()
renderedTypes = theType.renderShort(Collections.emptyMap())
} else {
typeParameters = getTypeParameterNamesNotInScope(typeParametersInType, scope).toTypedArray()
}
}
override fun toString() = theType.toString()
}
data class RenderedTypeParameter(
val typeParameter: TypeParameterDescriptor,
val fake: Boolean,
val text: String
)
fun List<TypeCandidate>.getTypeByRenderedType(renderedTypes: List<String>): KotlinType? =
firstOrNull { it.renderedTypes == renderedTypes }?.theType
class CallableBuilderConfiguration(
val callableInfos: List<CallableInfo>,
val originalElement: KtElement,
val currentFile: KtFile = originalElement.containingKtFile,
val currentEditor: Editor? = null,
val isExtension: Boolean = false,
val enableSubstitutions: Boolean = true
)
sealed class CallablePlacement {
class WithReceiver(val receiverTypeCandidate: TypeCandidate) : CallablePlacement()
class NoReceiver(val containingElement: PsiElement) : CallablePlacement()
}
class CallableBuilder(val config: CallableBuilderConfiguration) {
private var finished: Boolean = false
val currentFileContext = config.currentFile.analyzeWithContent()
private lateinit var _currentFileModule: ModuleDescriptor
val currentFileModule: ModuleDescriptor
get() {
if (!_currentFileModule.isValid) {
updateCurrentModule()
}
return _currentFileModule
}
init {
updateCurrentModule()
}
val pseudocode: Pseudocode? by lazy { config.originalElement.getContainingPseudocode(currentFileContext) }
private val typeCandidates = HashMap<TypeInfo, List<TypeCandidate>>()
var placement: CallablePlacement? = null
private val elementsToShorten = ArrayList<KtElement>()
private fun updateCurrentModule() {
_currentFileModule = config.currentFile.analyzeWithAllCompilerChecks().moduleDescriptor
}
fun computeTypeCandidates(typeInfo: TypeInfo): List<TypeCandidate> =
typeCandidates.getOrPut(typeInfo) { typeInfo.getPossibleTypes(this).map { TypeCandidate(it) } }
private fun computeTypeCandidates(
typeInfo: TypeInfo,
substitutions: List<KotlinTypeSubstitution>,
scope: HierarchicalScope
): List<TypeCandidate> {
if (!typeInfo.substitutionsAllowed) return computeTypeCandidates(typeInfo)
return typeCandidates.getOrPut(typeInfo) {
val types = typeInfo.getPossibleTypes(this).asReversed()
// We have to use semantic equality here
data class EqWrapper(val _type: KotlinType) {
override fun equals(other: Any?) = this === other
|| other is EqWrapper && KotlinTypeChecker.DEFAULT.equalTypes(_type, other._type)
override fun hashCode() = 0 // no good way to compute hashCode() that would agree with our equals()
}
val newTypes = LinkedHashSet(types.map(::EqWrapper))
for (substitution in substitutions) {
// each substitution can be applied or not, so we offer all options
val toAdd = newTypes.map { it._type.substitute(substitution, typeInfo.variance) }
// substitution.byType are type arguments, but they cannot already occur in the type before substitution
val toRemove = newTypes.filter { substitution.byType in it._type }
newTypes.addAll(toAdd.map(::EqWrapper))
newTypes.removeAll(toRemove)
}
if (newTypes.isEmpty()) {
newTypes.add(EqWrapper(currentFileModule.builtIns.anyType))
}
newTypes.map { TypeCandidate(it._type, scope) }.asReversed()
}
}
private fun buildNext(iterator: Iterator<CallableInfo>) {
if (iterator.hasNext()) {
val context = Context(iterator.next())
runWriteAction { context.buildAndRunTemplate { buildNext(iterator) } }
ApplicationManager.getApplication().invokeLater { context.showDialogIfNeeded() }
} else {
runWriteAction { ShortenReferences.DEFAULT.process(elementsToShorten) }
}
}
fun build(onFinish: () -> Unit = {}) {
try {
assert(config.currentEditor != null) { "Can't run build() without editor" }
check(!finished) { "Current builder has already finished" }
buildNext(config.callableInfos.iterator())
} finally {
finished = true
onFinish()
}
}
private inner class Context(val callableInfo: CallableInfo) {
val skipReturnType: Boolean
val ktFileToEdit: KtFile
val containingFileEditor: Editor
val containingElement: PsiElement
val dialogWithEditor: DialogWithEditor?
val receiverClassDescriptor: ClassifierDescriptor?
val typeParameterNameMap: Map<TypeParameterDescriptor, String>
val receiverTypeCandidate: TypeCandidate?
val mandatoryTypeParametersAsCandidates: List<TypeCandidate>
val substitutions: List<KotlinTypeSubstitution>
var finished: Boolean = false
init {
// gather relevant information
val placement = placement
var nullableReceiver = false
when (placement) {
is CallablePlacement.NoReceiver -> {
containingElement = placement.containingElement
receiverClassDescriptor = with(placement.containingElement) {
when (this) {
is KtClassOrObject -> currentFileContext[BindingContext.CLASS, this]
is PsiClass -> getJavaClassDescriptor()
else -> null
}
}
}
is CallablePlacement.WithReceiver -> {
val theType = placement.receiverTypeCandidate.theType
nullableReceiver = theType.isMarkedNullable
receiverClassDescriptor = theType.constructor.declarationDescriptor
val classDeclaration = receiverClassDescriptor?.let { DescriptorToSourceUtils.getSourceFromDescriptor(it) }
containingElement = if (!config.isExtension && classDeclaration != null) classDeclaration else config.currentFile
}
else -> throw IllegalArgumentException("Placement wan't initialized")
}
val receiverType = receiverClassDescriptor?.defaultType?.let {
if (nullableReceiver) it.makeNullable() else it
}
val project = config.currentFile.project
if (containingElement.containingFile != config.currentFile) {
NavigationUtil.activateFileWithPsiElement(containingElement)
}
dialogWithEditor = if (containingElement is KtElement) {
ktFileToEdit = containingElement.containingKtFile
containingFileEditor = if (ktFileToEdit != config.currentFile) {
FileEditorManager.getInstance(project).selectedTextEditor!!
} else {
config.currentEditor!!
}
null
} else {
val dialog = object : DialogWithEditor(project, KotlinBundle.message("fix.create.from.usage.dialog.title"), "") {
override fun doOKAction() {
project.executeWriteCommand(KotlinBundle.message("premature.end.of.template")) {
TemplateManagerImpl.getTemplateState(editor)?.gotoEnd(false)
}
super.doOKAction()
}
}
containingFileEditor = dialog.editor
with(containingFileEditor.settings) {
additionalColumnsCount = config.currentEditor!!.settings.getRightMargin(project)
additionalLinesCount = 5
}
ktFileToEdit = PsiDocumentManager.getInstance(project).getPsiFile(containingFileEditor.document) as KtFile
ktFileToEdit.analysisContext = config.currentFile
dialog
}
val scope = getDeclarationScope()
receiverTypeCandidate = receiverType?.let { TypeCandidate(it, scope) }
val fakeFunction: FunctionDescriptor?
// figure out type substitutions for type parameters
val substitutionMap = LinkedHashMap<KotlinType, KotlinType>()
if (config.enableSubstitutions) {
collectSubstitutionsForReceiverTypeParameters(receiverType, substitutionMap)
val typeArgumentsForFakeFunction = callableInfo.typeParameterInfos
.map {
val typeCandidates = computeTypeCandidates(it)
assert(typeCandidates.size == 1) { "Ambiguous type candidates for type parameter $it: $typeCandidates" }
typeCandidates.first().theType
}
.subtract(substitutionMap.keys)
fakeFunction = createFakeFunctionDescriptor(scope, typeArgumentsForFakeFunction.size)
collectSubstitutionsForCallableTypeParameters(fakeFunction, typeArgumentsForFakeFunction, substitutionMap)
mandatoryTypeParametersAsCandidates = listOfNotNull(receiverTypeCandidate) + typeArgumentsForFakeFunction.map {
TypeCandidate(substitutionMap[it]!!, scope)
}
} else {
fakeFunction = null
mandatoryTypeParametersAsCandidates = Collections.emptyList()
}
substitutions = substitutionMap.map { KotlinTypeSubstitution(it.key, it.value) }
callableInfo.parameterInfos.forEach {
computeTypeCandidates(it.typeInfo, substitutions, scope)
}
val returnTypeCandidate = computeTypeCandidates(callableInfo.returnTypeInfo, substitutions, scope).singleOrNull()
skipReturnType = when (callableInfo.kind) {
CallableKind.FUNCTION ->
returnTypeCandidate?.theType?.isUnit() ?: false
CallableKind.CLASS_WITH_PRIMARY_CONSTRUCTOR ->
callableInfo.returnTypeInfo == TypeInfo.Empty || returnTypeCandidate?.theType?.isAnyOrNullableAny() ?: false
CallableKind.CONSTRUCTOR -> true
CallableKind.PROPERTY -> containingElement is KtBlockExpression
}
// figure out type parameter renames to avoid conflicts
typeParameterNameMap = getTypeParameterRenames(scope)
callableInfo.parameterInfos.forEach { renderTypeCandidates(it.typeInfo, typeParameterNameMap, fakeFunction) }
if (!skipReturnType) {
renderTypeCandidates(callableInfo.returnTypeInfo, typeParameterNameMap, fakeFunction)
}
receiverTypeCandidate?.render(typeParameterNameMap, fakeFunction)
mandatoryTypeParametersAsCandidates.forEach { it.render(typeParameterNameMap, fakeFunction) }
}
private fun getDeclarationScope(): HierarchicalScope {
if (config.isExtension || receiverClassDescriptor == null) {
return currentFileModule.getPackage(config.currentFile.packageFqName).memberScope.memberScopeAsImportingScope()
}
if (receiverClassDescriptor is ClassDescriptorWithResolutionScopes) {
return receiverClassDescriptor.scopeForMemberDeclarationResolution
}
assert(receiverClassDescriptor is JavaClassDescriptor) { "Unexpected receiver class: $receiverClassDescriptor" }
val projections = ((receiverClassDescriptor as JavaClassDescriptor).declaredTypeParameters)
.map { TypeProjectionImpl(it.defaultType) }
val memberScope = receiverClassDescriptor.getMemberScope(projections)
return LexicalScopeImpl(
memberScope.memberScopeAsImportingScope(), receiverClassDescriptor, false, null, emptyList(),
LexicalScopeKind.SYNTHETIC
) {
receiverClassDescriptor.typeConstructor.parameters.forEach { addClassifierDescriptor(it) }
}
}
private fun collectSubstitutionsForReceiverTypeParameters(
receiverType: KotlinType?,
result: MutableMap<KotlinType, KotlinType>
) {
if (placement is CallablePlacement.NoReceiver) return
val classTypeParameters = receiverType?.arguments ?: Collections.emptyList()
val ownerTypeArguments = (placement as? CallablePlacement.WithReceiver)?.receiverTypeCandidate?.theType?.arguments
?: Collections.emptyList()
assert(ownerTypeArguments.size == classTypeParameters.size)
ownerTypeArguments.zip(classTypeParameters).forEach { result[it.first.type] = it.second.type }
}
private fun collectSubstitutionsForCallableTypeParameters(
fakeFunction: FunctionDescriptor,
typeArguments: Set<KotlinType>,
result: MutableMap<KotlinType, KotlinType>
) {
for ((typeArgument, typeParameter) in typeArguments.zip(fakeFunction.typeParameters)) {
result[typeArgument] = typeParameter.defaultType
}
}
@OptIn(FrontendInternals::class)
private fun createFakeFunctionDescriptor(scope: HierarchicalScope, typeParameterCount: Int): FunctionDescriptor {
val fakeFunction = SimpleFunctionDescriptorImpl.create(
MutablePackageFragmentDescriptor(currentFileModule, FqName("fake")),
Annotations.EMPTY,
Name.identifier("fake"),
CallableMemberDescriptor.Kind.SYNTHESIZED,
SourceElement.NO_SOURCE
)
val validator = CollectingNameValidator { scope.findClassifier(Name.identifier(it), NoLookupLocation.FROM_IDE) == null }
val parameterNames = Fe10KotlinNameSuggester.suggestNamesForTypeParameters(typeParameterCount, validator)
val typeParameters = (0 until typeParameterCount).map {
TypeParameterDescriptorImpl.createWithDefaultBound(
fakeFunction,
Annotations.EMPTY,
false,
Variance.INVARIANT,
Name.identifier(parameterNames[it]),
it,
ktFileToEdit.getResolutionFacade().frontendService()
)
}
return fakeFunction.initialize(
null, null, emptyList(), typeParameters, Collections.emptyList(), null,
null, DescriptorVisibilities.INTERNAL
)
}
private fun renderTypeCandidates(
typeInfo: TypeInfo,
typeParameterNameMap: Map<TypeParameterDescriptor, String>,
fakeFunction: FunctionDescriptor?
) {
typeCandidates[typeInfo]?.forEach { it.render(typeParameterNameMap, fakeFunction) }
}
private fun isInsideInnerOrLocalClass(): Boolean {
val classOrObject = containingElement.getNonStrictParentOfType<KtClassOrObject>()
return classOrObject is KtClass && (classOrObject.isInner() || classOrObject.isLocal)
}
private fun createDeclarationSkeleton(): KtNamedDeclaration {
with(config) {
val assignmentToReplace =
if (containingElement is KtBlockExpression && (callableInfo as? PropertyInfo)?.writable == true) {
originalElement as KtBinaryExpression
} else null
val pointerOfAssignmentToReplace = assignmentToReplace?.createSmartPointer()
val ownerTypeString = if (isExtension) {
val renderedType = receiverTypeCandidate!!.renderedTypes.first()
val isFunctionType = receiverTypeCandidate.theType.constructor.declarationDescriptor is FunctionClassDescriptor
if (isFunctionType) "($renderedType)." else "$renderedType."
} else ""
val classKind = (callableInfo as? ClassWithPrimaryConstructorInfo)?.classInfo?.kind
fun renderParamList(): String {
val prefix = if (classKind == ClassKind.ANNOTATION_CLASS) "val " else ""
val list = callableInfo.parameterInfos.indices.joinToString(", ") { i -> "${prefix}p$i: Any" }
return if (callableInfo.parameterInfos.isNotEmpty()
|| callableInfo.kind == CallableKind.FUNCTION
|| callableInfo.kind == CallableKind.CONSTRUCTOR
) "($list)" else list
}
val paramList = when (callableInfo.kind) {
CallableKind.FUNCTION, CallableKind.CLASS_WITH_PRIMARY_CONSTRUCTOR, CallableKind.CONSTRUCTOR ->
renderParamList()
CallableKind.PROPERTY -> ""
}
val returnTypeString = if (skipReturnType || assignmentToReplace != null) "" else ": Any"
val header = "$ownerTypeString${callableInfo.name.quoteIfNeeded()}$paramList$returnTypeString"
val psiFactory = KtPsiFactory(currentFile)
val modifiers = buildString {
val modifierList = callableInfo.modifierList?.copied() ?: psiFactory.createEmptyModifierList()
val visibilityKeyword = modifierList.visibilityModifierType()
if (visibilityKeyword == null) {
val defaultVisibility =
if (callableInfo.isAbstract) ""
else if (containingElement is KtClassOrObject
&& !(containingElement is KtClass && containingElement.isInterface())
&& containingElement.isAncestor(config.originalElement)
&& callableInfo.kind != CallableKind.CONSTRUCTOR
) "private "
else if (isExtension) "private "
else ""
append(defaultVisibility)
}
// TODO: Get rid of isAbstract
if (callableInfo.isAbstract
&& containingElement is KtClass
&& !containingElement.isInterface()
&& !modifierList.hasModifier(KtTokens.ABSTRACT_KEYWORD)
) {
modifierList.appendModifier(KtTokens.ABSTRACT_KEYWORD)
}
val text = modifierList.normalize().text
if (text.isNotEmpty()) {
append("$text ")
}
}
val isExpectClassMember by lazy {
containingElement is KtClassOrObject && containingElement.resolveToDescriptorIfAny()?.isExpect ?: false
}
val declaration: KtNamedDeclaration = when (callableInfo.kind) {
CallableKind.FUNCTION, CallableKind.CONSTRUCTOR -> {
val body = when {
callableInfo is ConstructorInfo -> if (callableInfo.withBody) "{\n\n}" else ""
callableInfo.isAbstract -> ""
containingElement is KtClass && containingElement.hasModifier(KtTokens.EXTERNAL_KEYWORD) -> ""
containingElement is KtObjectDeclaration && containingElement.hasModifier(KtTokens.EXTERNAL_KEYWORD) -> ""
containingElement is KtObjectDeclaration && containingElement.isCompanion()
&& containingElement.parent.parent is KtClass
&& (containingElement.parent.parent as KtClass).hasModifier(KtTokens.EXTERNAL_KEYWORD) -> ""
isExpectClassMember -> ""
else -> "{\n\n}"
}
@Suppress("USELESS_CAST") // KT-10755
when {
callableInfo is FunctionInfo -> psiFactory.createFunction("${modifiers}fun<> $header $body") as KtNamedDeclaration
(callableInfo as ConstructorInfo).isPrimary -> {
val constructorText = if (modifiers.isNotEmpty()) "${modifiers}constructor$paramList" else paramList
psiFactory.createPrimaryConstructor(constructorText) as KtNamedDeclaration
}
else -> psiFactory.createSecondaryConstructor("${modifiers}constructor$paramList $body") as KtNamedDeclaration
}
}
CallableKind.CLASS_WITH_PRIMARY_CONSTRUCTOR -> {
val classWithPrimaryConstructorInfo = callableInfo as ClassWithPrimaryConstructorInfo
with(classWithPrimaryConstructorInfo.classInfo) {
val classBody = when (kind) {
ClassKind.ANNOTATION_CLASS, ClassKind.ENUM_ENTRY -> ""
else -> "{\n\n}"
}
val safeName = name.quoteIfNeeded()
when (kind) {
ClassKind.ENUM_ENTRY -> {
val targetParent = applicableParents.singleOrNull()
if (!(targetParent is KtClass && targetParent.isEnum())) {
throw KotlinExceptionWithAttachments("Enum class expected: ${targetParent?.let { it::class.java }}")
.withPsiAttachment("targetParent", targetParent)
}
val hasParameters = targetParent.primaryConstructorParameters.isNotEmpty()
psiFactory.createEnumEntry("$safeName${if (hasParameters) "()" else " "}")
}
else -> {
val openMod = if (open && kind != ClassKind.INTERFACE) "open " else ""
val innerMod = if (inner || isInsideInnerOrLocalClass()) "inner " else ""
val typeParamList = when (kind) {
ClassKind.PLAIN_CLASS, ClassKind.INTERFACE -> "<>"
else -> ""
}
val ctor =
classWithPrimaryConstructorInfo.primaryConstructorVisibility?.name?.let { " $it constructor" } ?: ""
psiFactory.createDeclaration<KtClassOrObject>(
"$openMod$innerMod${kind.keyword} $safeName$typeParamList$ctor$paramList$returnTypeString $classBody"
)
}
}
}
}
CallableKind.PROPERTY -> {
val isVar = (callableInfo as PropertyInfo).writable
val const = if (callableInfo.isConst) "const " else ""
val valVar = if (isVar) "var" else "val"
val accessors = if (isExtension && !isExpectClassMember) {
buildString {
append("\nget() {}")
if (isVar) {
append("\nset() {}")
}
}
} else ""
psiFactory.createProperty("$modifiers$const$valVar<> $header$accessors")
}
}
if (callableInfo is PropertyInfo) {
callableInfo.annotations.forEach { declaration.addAnnotationEntry(it) }
}
val newInitializer = pointerOfAssignmentToReplace?.element
if (newInitializer != null) {
(declaration as KtProperty).initializer = newInitializer.right
return newInitializer.replace(declaration) as KtCallableDeclaration
}
val container = if (containingElement is KtClass && callableInfo.isForCompanion) {
containingElement.getOrCreateCompanionObject()
} else containingElement
val declarationInPlace = placeDeclarationInContainer(declaration, container, config.originalElement, ktFileToEdit)
if (declarationInPlace is KtSecondaryConstructor) {
val containingClass = declarationInPlace.containingClassOrObject!!
val primaryConstructorParameters = containingClass.primaryConstructorParameters
if (primaryConstructorParameters.isNotEmpty()) {
declarationInPlace.replaceImplicitDelegationCallWithExplicit(true)
} else if ((receiverClassDescriptor as ClassDescriptor).getSuperClassOrAny().constructors
.all { it.valueParameters.isNotEmpty() }
) {
declarationInPlace.replaceImplicitDelegationCallWithExplicit(false)
}
if (declarationInPlace.valueParameters.size > primaryConstructorParameters.size) {
val hasCompatibleTypes = primaryConstructorParameters.zip(callableInfo.parameterInfos).all { (primary, secondary) ->
val primaryType = currentFileContext[BindingContext.TYPE, primary.typeReference] ?: return@all false
val secondaryType = computeTypeCandidates(secondary.typeInfo).firstOrNull()?.theType ?: return@all false
secondaryType.isSubtypeOf(primaryType)
}
if (hasCompatibleTypes) {
val delegationCallArgumentList = declarationInPlace.getDelegationCall().valueArgumentList
primaryConstructorParameters.forEach {
val name = it.name
if (name != null) delegationCallArgumentList?.addArgument(psiFactory.createArgument(name))
}
}
}
}
return declarationInPlace
}
}
private fun getTypeParameterRenames(scope: HierarchicalScope): Map<TypeParameterDescriptor, String> {
val allTypeParametersNotInScope = LinkedHashSet<TypeParameterDescriptor>()
mandatoryTypeParametersAsCandidates.asSequence()
.plus(callableInfo.parameterInfos.asSequence().flatMap { typeCandidates[it.typeInfo]!!.asSequence() })
.flatMap { it.typeParameters.asSequence() }
.toCollection(allTypeParametersNotInScope)
if (!skipReturnType) {
computeTypeCandidates(callableInfo.returnTypeInfo).asSequence().flatMapTo(allTypeParametersNotInScope) {
it.typeParameters.asSequence()
}
}
val validator = CollectingNameValidator { scope.findClassifier(Name.identifier(it), NoLookupLocation.FROM_IDE) == null }
val typeParameterNames = allTypeParametersNotInScope.map {
Fe10KotlinNameSuggester.suggestNameByName(it.name.asString(), validator)
}
return allTypeParametersNotInScope.zip(typeParameterNames).toMap()
}
private fun setupTypeReferencesForShortening(
declaration: KtNamedDeclaration,
parameterTypeExpressions: List<TypeExpression>
) {
if (config.isExtension) {
val receiverTypeText = receiverTypeCandidate!!.theType.renderLong(typeParameterNameMap).first()
val replacingTypeRef = KtPsiFactory(declaration).createType(receiverTypeText)
(declaration as KtCallableDeclaration).setReceiverTypeReference(replacingTypeRef)!!
}
val returnTypeRefs = declaration.getReturnTypeReferences()
if (returnTypeRefs.isNotEmpty()) {
val returnType = typeCandidates[callableInfo.returnTypeInfo]!!.getTypeByRenderedType(
returnTypeRefs.map { it.text }
)
if (returnType != null) {
// user selected a given type
replaceWithLongerName(returnTypeRefs, returnType)
}
}
val valueParameters = declaration.getValueParameters()
val parameterIndicesToShorten = ArrayList<Int>()
assert(valueParameters.size == parameterTypeExpressions.size)
for ((i, parameter) in valueParameters.asSequence().withIndex()) {
val parameterTypeRef = parameter.typeReference
if (parameterTypeRef != null) {
val parameterType = parameterTypeExpressions[i].typeCandidates.getTypeByRenderedType(
listOf(parameterTypeRef.text)
)
if (parameterType != null) {
replaceWithLongerName(listOf(parameterTypeRef), parameterType)
parameterIndicesToShorten.add(i)
}
}
}
}
private fun postprocessDeclaration(declaration: KtNamedDeclaration) {
if (callableInfo is PropertyInfo && callableInfo.isLateinitPreferred) {
if (declaration.containingClassOrObject == null) return
val propertyDescriptor = declaration.resolveToDescriptorIfAny() as? PropertyDescriptor ?: return
val returnType = propertyDescriptor.returnType ?: return
if (TypeUtils.isNullableType(returnType) || KotlinBuiltIns.isPrimitiveType(returnType)) return
declaration.addModifier(KtTokens.LATEINIT_KEYWORD)
}
if (callableInfo.isAbstract) {
val containingClass = declaration.containingClassOrObject
if (containingClass is KtClass && containingClass.isInterface()) {
declaration.removeModifier(KtTokens.ABSTRACT_KEYWORD)
}
}
}
private fun setupDeclarationBody(func: KtDeclarationWithBody) {
if (func !is KtNamedFunction && func !is KtPropertyAccessor) return
if (skipReturnType && callableInfo is FunctionInfo && callableInfo.preferEmptyBody) return
val oldBody = func.bodyExpression ?: return
val bodyText = getFunctionBodyTextFromTemplate(
func.project,
TemplateKind.FUNCTION,
if (callableInfo.name.isNotEmpty()) callableInfo.name else null,
if (skipReturnType) "Unit" else (func as? KtFunction)?.typeReference?.text ?: "",
receiverClassDescriptor?.importableFqName ?: receiverClassDescriptor?.name?.let { FqName.topLevel(it) }
)
oldBody.replace(KtPsiFactory(func).createBlock(bodyText))
}
private fun setupCallTypeArguments(callElement: KtCallElement, typeParameters: List<TypeParameterDescriptor>) {
val oldTypeArgumentList = callElement.typeArgumentList ?: return
val renderedTypeArgs = typeParameters.map { typeParameter ->
val type = substitutions.first { it.byType.constructor.declarationDescriptor == typeParameter }.forType
IdeDescriptorRenderers.SOURCE_CODE.renderType(type)
}
if (renderedTypeArgs.isEmpty()) {
oldTypeArgumentList.delete()
} else {
oldTypeArgumentList.replace(KtPsiFactory(callElement).createTypeArguments(renderedTypeArgs.joinToString(", ", "<", ">")))
elementsToShorten.add(callElement.typeArgumentList!!)
}
}
private fun setupReturnTypeTemplate(builder: TemplateBuilder, declaration: KtNamedDeclaration): TypeExpression? {
val candidates = typeCandidates[callableInfo.returnTypeInfo]!!
if (candidates.isEmpty()) return null
val elementToReplace: KtElement?
val expression: TypeExpression = when (declaration) {
is KtCallableDeclaration -> {
elementToReplace = declaration.typeReference
TypeExpression.ForTypeReference(candidates)
}
is KtClassOrObject -> {
elementToReplace = declaration.superTypeListEntries.firstOrNull()
TypeExpression.ForDelegationSpecifier(candidates)
}
else -> throw KotlinExceptionWithAttachments("Unexpected declaration kind: ${declaration::class.java}")
.withPsiAttachment("declaration", declaration)
}
if (elementToReplace == null) return null
if (candidates.size == 1) {
builder.replaceElement(elementToReplace, (expression.calculateResult(null) as TextResult).text)
return null
}
builder.replaceElement(elementToReplace, expression)
return expression
}
private fun setupValVarTemplate(builder: TemplateBuilder, property: KtProperty) {
if (!(callableInfo as PropertyInfo).writable) {
builder.replaceElement(property.valOrVarKeyword, ValVarExpression)
}
}
private fun setupTypeParameterListTemplate(
builder: TemplateBuilderImpl,
declaration: KtNamedDeclaration
): TypeParameterListExpression? {
when (declaration) {
is KtObjectDeclaration -> return null
!is KtTypeParameterListOwner -> {
throw KotlinExceptionWithAttachments("Unexpected declaration kind: ${declaration::class.java}")
.withPsiAttachment("declaration", declaration)
}
}
val typeParameterList = (declaration as KtTypeParameterListOwner).typeParameterList ?: return null
val typeParameterMap = HashMap<String, List<RenderedTypeParameter>>()
val mandatoryTypeParameters = ArrayList<RenderedTypeParameter>()
//receiverTypeCandidate?.let { mandatoryTypeParameters.addAll(it.renderedTypeParameters!!) }
mandatoryTypeParametersAsCandidates.asSequence().flatMapTo(mandatoryTypeParameters) { it.renderedTypeParameters!!.asSequence() }
callableInfo.parameterInfos.asSequence()
.flatMap { typeCandidates[it.typeInfo]!!.asSequence() }
.forEach { typeParameterMap[it.renderedTypes.first()] = it.renderedTypeParameters!! }
if (declaration.getReturnTypeReference() != null) {
typeCandidates[callableInfo.returnTypeInfo]!!.forEach {
typeParameterMap[it.renderedTypes.first()] = it.renderedTypeParameters!!
}
}
val expression = TypeParameterListExpression(
mandatoryTypeParameters,
typeParameterMap,
callableInfo.kind != CallableKind.CLASS_WITH_PRIMARY_CONSTRUCTOR
)
val leftSpace = typeParameterList.prevSibling as? PsiWhiteSpace
val rangeStart = leftSpace?.startOffset ?: typeParameterList.startOffset
val offset = typeParameterList.startOffset
val range = UnfairTextRange(rangeStart - offset, typeParameterList.endOffset - offset)
builder.replaceElement(typeParameterList, range, "TYPE_PARAMETER_LIST", expression, false)
return expression
}
private fun setupParameterTypeTemplates(builder: TemplateBuilder, parameterList: List<KtParameter>): List<TypeExpression> {
assert(parameterList.size == callableInfo.parameterInfos.size)
val typeParameters = ArrayList<TypeExpression>()
for ((parameter, ktParameter) in callableInfo.parameterInfos.zip(parameterList)) {
val parameterTypeExpression = TypeExpression.ForTypeReference(typeCandidates[parameter.typeInfo]!!)
val parameterTypeRef = ktParameter.typeReference!!
builder.replaceElement(parameterTypeRef, parameterTypeExpression)
// add parameter name to the template
val possibleNamesFromExpression = parameter.typeInfo.getPossibleNamesFromExpression(currentFileContext)
val possibleNames = arrayOf(*parameter.nameSuggestions.toTypedArray(), *possibleNamesFromExpression)
// figure out suggested names for each type option
val parameterTypeToNamesMap = HashMap<String, Array<String>>()
typeCandidates[parameter.typeInfo]!!.forEach { typeCandidate ->
val suggestedNames = Fe10KotlinNameSuggester.suggestNamesByType(typeCandidate.theType, { true })
parameterTypeToNamesMap[typeCandidate.renderedTypes.first()] = suggestedNames.toTypedArray()
}
// add expression to builder
val parameterNameExpression = ParameterNameExpression(possibleNames, parameterTypeToNamesMap)
val parameterNameIdentifier = ktParameter.nameIdentifier!!
builder.replaceElement(parameterNameIdentifier, parameterNameExpression)
typeParameters.add(parameterTypeExpression)
}
return typeParameters
}
private fun replaceWithLongerName(typeRefs: List<KtTypeReference>, theType: KotlinType) {
val psiFactory = KtPsiFactory(ktFileToEdit.project)
val fullyQualifiedReceiverTypeRefs = theType.renderLong(typeParameterNameMap).map { psiFactory.createType(it) }
(typeRefs zip fullyQualifiedReceiverTypeRefs).forEach { (shortRef, longRef) -> shortRef.replace(longRef) }
}
private fun transformToJavaMemberIfApplicable(declaration: KtNamedDeclaration): Boolean {
fun convertToJava(targetClass: PsiClass): PsiMember? {
val psiFactory = KtPsiFactory(declaration)
psiFactory.createPackageDirectiveIfNeeded(config.currentFile.packageFqName)?.let {
declaration.containingFile.addBefore(it, null)
}
val adjustedDeclaration = when (declaration) {
is KtNamedFunction, is KtProperty -> {
val klass = psiFactory.createClass("class Foo {}")
klass.body!!.add(declaration)
(declaration.replace(klass) as KtClass).body!!.declarations.first()
}
else -> declaration
}
return when (adjustedDeclaration) {
is KtNamedFunction, is KtSecondaryConstructor -> {
createJavaMethod(adjustedDeclaration as KtFunction, targetClass)
}
is KtProperty -> {
createJavaField(adjustedDeclaration, targetClass)
}
is KtClass -> {
createJavaClass(adjustedDeclaration, targetClass)
}
else -> null
}
}
if (config.isExtension || receiverClassDescriptor !is JavaClassDescriptor) return false
val targetClass = DescriptorToSourceUtils.getSourceFromDescriptor(receiverClassDescriptor) as? PsiClass
if (targetClass == null || !targetClass.canRefactor()) return false
val project = declaration.project
val newJavaMember = convertToJava(targetClass) ?: return false
val modifierList = newJavaMember.modifierList!!
if (newJavaMember is PsiMethod || newJavaMember is PsiClass) {
modifierList.setModifierProperty(PsiModifier.FINAL, false)
}
val needStatic = when (callableInfo) {
is ClassWithPrimaryConstructorInfo -> with(callableInfo.classInfo) {
!inner && kind != ClassKind.ENUM_ENTRY && kind != ClassKind.ENUM_CLASS
}
else -> callableInfo.receiverTypeInfo.staticContextRequired
}
modifierList.setModifierProperty(PsiModifier.STATIC, needStatic)
JavaCodeStyleManager.getInstance(project).shortenClassReferences(newJavaMember)
val descriptor = OpenFileDescriptor(project, targetClass.containingFile.virtualFile)
val targetEditor = FileEditorManager.getInstance(project).openTextEditor(descriptor, true)!!
targetEditor.selectionModel.removeSelection()
when (newJavaMember) {
is PsiMethod -> CreateFromUsageUtils.setupEditor(newJavaMember, targetEditor)
is PsiField -> targetEditor.caretModel.moveToOffset(newJavaMember.endOffset - 1)
is PsiClass -> {
val constructor = newJavaMember.constructors.firstOrNull()
val superStatement = constructor?.body?.statements?.firstOrNull() as? PsiExpressionStatement
val superCall = superStatement?.expression as? PsiMethodCallExpression
if (superCall != null) {
val lParen = superCall.argumentList.firstChild
targetEditor.caretModel.moveToOffset(lParen.endOffset)
} else {
targetEditor.caretModel.moveToOffset(newJavaMember.nameIdentifier?.startOffset ?: newJavaMember.startOffset)
}
}
}
targetEditor.scrollingModel.scrollToCaret(ScrollType.RELATIVE)
return true
}
private fun setupEditor(declaration: KtNamedDeclaration) {
if (declaration is KtProperty && !declaration.hasInitializer() && containingElement is KtBlockExpression) {
val defaultValueType = typeCandidates[callableInfo.returnTypeInfo]!!.firstOrNull()?.theType
val defaultValue = defaultValueType?.let { it.getDefaultInitializer() } ?: "null"
val initializer = declaration.setInitializer(KtPsiFactory(declaration).createExpression(defaultValue))!!
val range = initializer.textRange
containingFileEditor.selectionModel.setSelection(range.startOffset, range.endOffset)
containingFileEditor.caretModel.moveToOffset(range.endOffset)
return
}
if (declaration is KtSecondaryConstructor && !declaration.hasImplicitDelegationCall()) {
containingFileEditor.caretModel.moveToOffset(declaration.getDelegationCall().valueArgumentList!!.startOffset + 1)
return
}
setupEditorSelection(containingFileEditor, declaration)
}
// build templates
fun buildAndRunTemplate(onFinish: () -> Unit) {
val declarationSkeleton = createDeclarationSkeleton()
val project = declarationSkeleton.project
val declarationPointer = SmartPointerManager.getInstance(project).createSmartPsiElementPointer(declarationSkeleton)
// build templates
val documentManager = PsiDocumentManager.getInstance(project)
val document = containingFileEditor.document
documentManager.commitDocument(document)
documentManager.doPostponedOperationsAndUnblockDocument(document)
val caretModel = containingFileEditor.caretModel
caretModel.moveToOffset(ktFileToEdit.node.startOffset)
val declaration = declarationPointer.element ?: return
val declarationMarker = document.createRangeMarker(declaration.textRange)
val builder = TemplateBuilderImpl(ktFileToEdit)
if (declaration is KtProperty) {
setupValVarTemplate(builder, declaration)
}
if (!skipReturnType) {
setupReturnTypeTemplate(builder, declaration)
}
val parameterTypeExpressions = setupParameterTypeTemplates(builder, declaration.getValueParameters())
// add a segment for the parameter list
// Note: because TemplateBuilderImpl does not have a replaceElement overload that takes in both a TextRange and alwaysStopAt, we
// need to create the segment first and then hack the Expression into the template later. We use this template to update the type
// parameter list as the user makes selections in the parameter types, and we need alwaysStopAt to be false so the user can't tab to
// it.
val expression = setupTypeParameterListTemplate(builder, declaration)
documentManager.doPostponedOperationsAndUnblockDocument(document)
// the template built by TemplateBuilderImpl is ordered by element position, but we want types to be first, so hack it
val templateImpl = builder.buildInlineTemplate() as TemplateImpl
val variables = templateImpl.variables!!
if (variables.isNotEmpty()) {
val typeParametersVar = if (expression != null) variables.removeAt(0) else null
for (i in callableInfo.parameterInfos.indices) {
Collections.swap(variables, i * 2, i * 2 + 1)
}
typeParametersVar?.let { variables.add(it) }
}
// TODO: Disabled shortening names because it causes some tests fail. Refactor code to use automatic reference shortening
templateImpl.isToShortenLongNames = false
// run the template
TemplateManager.getInstance(project).startTemplate(containingFileEditor, templateImpl, object : TemplateEditingAdapter() {
private fun finishTemplate(brokenOff: Boolean) {
try {
documentManager.commitDocument(document)
dialogWithEditor?.close(DialogWrapper.OK_EXIT_CODE)
if (brokenOff && !isUnitTestMode()) return
// file templates
val newDeclaration = PsiTreeUtil.findElementOfClassAtOffset(
ktFileToEdit,
declarationMarker.startOffset,
declaration::class.java,
false
) ?: return
runWriteAction {
postprocessDeclaration(newDeclaration)
// file templates
if (newDeclaration is KtNamedFunction || newDeclaration is KtSecondaryConstructor) {
setupDeclarationBody(newDeclaration as KtFunction)
}
if (newDeclaration is KtProperty) {
newDeclaration.getter?.let { setupDeclarationBody(it) }
if (callableInfo is PropertyInfo && callableInfo.initializer != null) {
newDeclaration.initializer = callableInfo.initializer
}
}
val callElement = config.originalElement as? KtCallElement
if (callElement != null) {
setupCallTypeArguments(callElement, expression?.currentTypeParameters ?: Collections.emptyList())
}
CodeStyleManager.getInstance(project).reformat(newDeclaration)
// change short type names to fully qualified ones (to be shortened below)
if (newDeclaration.getValueParameters().size == parameterTypeExpressions.size) {
setupTypeReferencesForShortening(newDeclaration, parameterTypeExpressions)
}
if (!transformToJavaMemberIfApplicable(newDeclaration)) {
elementsToShorten.add(newDeclaration)
setupEditor(newDeclaration)
}
}
} finally {
declarationMarker.dispose()
finished = true
onFinish()
}
}
override fun templateCancelled(template: Template?) {
finishTemplate(true)
}
override fun templateFinished(template: Template, brokenOff: Boolean) {
finishTemplate(brokenOff)
}
})
}
fun showDialogIfNeeded() {
if (!isUnitTestMode() && dialogWithEditor != null && !finished) {
dialogWithEditor.show()
}
}
}
}
// TODO: Simplify and use formatter as much as possible
@Suppress("UNCHECKED_CAST")
internal fun <D : KtNamedDeclaration> placeDeclarationInContainer(
declaration: D,
container: PsiElement,
anchor: PsiElement,
fileToEdit: KtFile = container.containingFile as KtFile
): D {
val psiFactory = KtPsiFactory(container)
val newLine = psiFactory.createNewLine()
fun calcNecessaryEmptyLines(decl: KtDeclaration, after: Boolean): Int {
var lineBreaksPresent = 0
var neighbor: PsiElement? = null
siblingsLoop@
for (sibling in decl.siblings(forward = after, withItself = false)) {
when (sibling) {
is PsiWhiteSpace -> lineBreaksPresent += (sibling.text ?: "").count { it == '\n' }
else -> {
neighbor = sibling
break@siblingsLoop
}
}
}
val neighborType = neighbor?.node?.elementType
val lineBreaksNeeded = when {
neighborType == KtTokens.LBRACE || neighborType == KtTokens.RBRACE -> 1
neighbor is KtDeclaration && (neighbor !is KtProperty || decl !is KtProperty) -> 2
else -> 1
}
return max(lineBreaksNeeded - lineBreaksPresent, 0)
}
val actualContainer = (container as? KtClassOrObject)?.getOrCreateBody() ?: container
fun addDeclarationToClassOrObject(
classOrObject: KtClassOrObject,
declaration: KtNamedDeclaration
): KtNamedDeclaration {
val classBody = classOrObject.getOrCreateBody()
return if (declaration is KtNamedFunction) {
val neighbor = PsiTreeUtil.skipSiblingsBackward(
classBody.rBrace ?: classBody.lastChild!!,
PsiWhiteSpace::class.java
)
classBody.addAfter(declaration, neighbor) as KtNamedDeclaration
} else classBody.addAfter(declaration, classBody.lBrace!!) as KtNamedDeclaration
}
fun addNextToOriginalElementContainer(addBefore: Boolean): D {
val sibling = anchor.parentsWithSelf.first { it.parent == actualContainer }
return if (addBefore || PsiTreeUtil.hasErrorElements(sibling)) {
actualContainer.addBefore(declaration, sibling)
} else {
actualContainer.addAfter(declaration, sibling)
} as D
}
val declarationInPlace = when {
declaration is KtPrimaryConstructor -> {
(container as KtClass).createPrimaryConstructorIfAbsent().replaced(declaration)
}
declaration is KtProperty && container !is KtBlockExpression -> {
val sibling = actualContainer.getChildOfType<KtProperty>() ?: when (actualContainer) {
is KtClassBody -> actualContainer.declarations.firstOrNull() ?: actualContainer.rBrace
is KtFile -> actualContainer.declarations.first()
else -> null
}
sibling?.let { actualContainer.addBefore(declaration, it) as D } ?: fileToEdit.add(declaration) as D
}
actualContainer.isAncestor(anchor, true) -> {
val insertToBlock = container is KtBlockExpression
if (insertToBlock) {
val parent = container.parent
if (parent is KtFunctionLiteral) {
if (!parent.isMultiLine()) {
parent.addBefore(newLine, container)
parent.addAfter(newLine, container)
}
}
}
addNextToOriginalElementContainer(insertToBlock || declaration is KtTypeAlias)
}
container is KtFile -> container.add(declaration) as D
container is PsiClass -> {
if (declaration is KtSecondaryConstructor) {
val wrappingClass = psiFactory.createClass("class ${container.name} {\n}")
addDeclarationToClassOrObject(wrappingClass, declaration)
(fileToEdit.add(wrappingClass) as KtClass).declarations.first() as D
} else {
fileToEdit.add(declaration) as D
}
}
container is KtClassOrObject -> {
var sibling: PsiElement? = container.declarations.lastOrNull { it::class == declaration::class }
if (sibling == null && declaration is KtProperty) {
sibling = container.body?.lBrace
}
insertMembersAfterAndReformat(null, container, declaration, sibling)
}
else -> throw KotlinExceptionWithAttachments("Invalid containing element: ${container::class.java}")
.withPsiAttachment("container", container)
}
when (declaration) {
is KtEnumEntry -> {
val prevEnumEntry = declarationInPlace.siblings(forward = false, withItself = false).firstIsInstanceOrNull<KtEnumEntry>()
if (prevEnumEntry != null) {
if ((prevEnumEntry.prevSibling as? PsiWhiteSpace)?.text?.contains('\n') == true) {
declarationInPlace.parent.addBefore(psiFactory.createNewLine(), declarationInPlace)
}
val comma = psiFactory.createComma()
if (prevEnumEntry.allChildren.any { it.node.elementType == KtTokens.COMMA }) {
declarationInPlace.add(comma)
} else {
prevEnumEntry.add(comma)
}
val semicolon = prevEnumEntry.allChildren.firstOrNull { it.node?.elementType == KtTokens.SEMICOLON }
if (semicolon != null) {
(semicolon.prevSibling as? PsiWhiteSpace)?.text?.let {
declarationInPlace.add(psiFactory.createWhiteSpace(it))
}
declarationInPlace.add(psiFactory.createSemicolon())
semicolon.delete()
}
}
}
!is KtPrimaryConstructor -> {
val parent = declarationInPlace.parent
calcNecessaryEmptyLines(declarationInPlace, false).let {
if (it > 0) parent.addBefore(psiFactory.createNewLine(it), declarationInPlace)
}
calcNecessaryEmptyLines(declarationInPlace, true).let {
if (it > 0) parent.addAfter(psiFactory.createNewLine(it), declarationInPlace)
}
}
}
return declarationInPlace
}
fun KtNamedDeclaration.getReturnTypeReference() = getReturnTypeReferences().singleOrNull()
internal fun KtNamedDeclaration.getReturnTypeReferences(): List<KtTypeReference> {
return when (this) {
is KtCallableDeclaration -> listOfNotNull(typeReference)
is KtClassOrObject -> superTypeListEntries.mapNotNull { it.typeReference }
else -> throw AssertionError("Unexpected declaration kind: $text")
}
}
fun CallableBuilderConfiguration.createBuilder(): CallableBuilder = CallableBuilder(this)
| plugins/kotlin/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt | 2407631214 |
package org.jetbrains.cabal.psi
import com.intellij.lang.ASTNode
import org.jetbrains.cabal.parser.CabalTokelTypes
import org.jetbrains.cabal.psi.SingleValueField
class TestModuleField(node: ASTNode) : SingleValueField(node)
| plugin/src/org/jetbrains/cabal/psi/TestModuleField.kt | 3681476150 |
package com.nibado.projects.advent.y2017
import com.nibado.projects.advent.*
import com.nibado.projects.advent.Point
object Day14 : Day {
private val rows = (0..127).map { "amgozmfv-$it" }
private val square : List<String> by lazy { rows.map { hash(it) }.map { toBinary(it) } }
override fun part1() = square.sumBy { it.count { it == '1' } }.toString()
override fun part2(): String {
val points = (0 .. 127).flatMap { x -> (0 .. 127 ).map { y -> Point(x, y) } }.toMutableSet()
val visited = points.filter { square[it.y][it.x] == '0'}.toMutableSet()
points.removeAll(visited)
var count = 0
while(!points.isEmpty()) {
count++
fill(visited, points, points.first())
}
return count.toString()
}
private fun fill(visited: MutableSet<Point>, points: MutableSet<Point>, current: Point) {
visited += current
points -= current
current.neighborsHv().filter { points.contains(it) }.forEach { fill(visited, points, it) }
}
private fun hash(input: String): String {
val chars = input.toCharArray().map { it.toInt() } + listOf(17, 31, 73, 47, 23)
return (0..15).map { Day10.knot(chars, 64).subList(it * 16, it * 16 + 16) }.map { xor(it) }.toHex()
}
} | src/main/kotlin/com/nibado/projects/advent/y2017/Day14.kt | 219840795 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
@file:Suppress("ReplaceGetOrSet")
package org.jetbrains.intellij.build.impl.compilation
import com.github.luben.zstd.Zstd
import com.github.luben.zstd.ZstdDirectBufferCompressingStreamNoFinalizer
import com.intellij.diagnostic.telemetry.forkJoinTask
import com.intellij.diagnostic.telemetry.use
import io.opentelemetry.api.common.AttributeKey
import io.opentelemetry.api.common.Attributes
import io.opentelemetry.api.trace.Span
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.decodeFromStream
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import okio.*
import org.jetbrains.intellij.build.TraceManager.spanBuilder
import java.nio.ByteBuffer
import java.nio.channels.FileChannel
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.StandardOpenOption
import java.util.*
import java.util.concurrent.*
import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.atomic.AtomicLong
private val MEDIA_TYPE_JSON = "application/json".toMediaType()
internal val READ_OPERATION = EnumSet.of(StandardOpenOption.READ)
internal const val MAX_BUFFER_SIZE = 4_000_000
internal fun uploadArchives(reportStatisticValue: (key: String, value: String) -> Unit,
config: CompilationCacheUploadConfiguration,
metadataJson: String,
httpClient: OkHttpClient,
items: List<PackAndUploadItem>,
bufferPool: DirectFixedSizeByteBufferPool) {
val uploadedCount = AtomicInteger()
val uploadedBytes = AtomicLong()
val reusedCount = AtomicInteger()
val reusedBytes = AtomicLong()
var fallbackToHeads = false
val alreadyUploaded: Set<String> = try {
if (config.checkFiles) {
spanBuilder("fetch info about already uploaded files").use {
HashSet(getFoundAndMissingFiles(metadataJson, config.serverUrl, httpClient).found)
}
}
else {
emptySet()
}
}
catch (e: Throwable) {
Span.current().recordException(e, Attributes.of(
AttributeKey.stringKey("message"), "failed to fetch info about already uploaded files, will fallback to HEAD requests"
))
fallbackToHeads = true
emptySet()
}
ForkJoinTask.invokeAll(items.mapNotNull { item ->
if (alreadyUploaded.contains(item.name)) {
reusedCount.getAndIncrement()
reusedBytes.getAndAdd(Files.size(item.archive))
return@mapNotNull null
}
forkJoinTask(spanBuilder("upload archive").setAttribute("name", item.name).setAttribute("hash", item.hash!!)) {
val isUploaded = uploadFile(url = "${config.serverUrl}/$uploadPrefix/${item.name}/${item.hash!!}.jar",
file = item.archive,
useHead = fallbackToHeads,
span = Span.current(),
httpClient = httpClient,
bufferPool = bufferPool)
val size = Files.size(item.archive)
if (isUploaded) {
uploadedCount.getAndIncrement()
uploadedBytes.getAndAdd(size)
}
else {
reusedCount.getAndIncrement()
reusedBytes.getAndAdd(size)
}
}
})
Span.current().addEvent("upload complete", Attributes.of(
AttributeKey.longKey("reusedParts"), reusedCount.get().toLong(),
AttributeKey.longKey("uploadedParts"), uploadedCount.get().toLong(),
AttributeKey.longKey("reusedBytes"), reusedBytes.get(),
AttributeKey.longKey("uploadedBytes"), uploadedBytes.get(),
AttributeKey.longKey("totalBytes"), reusedBytes.get() + uploadedBytes.get(),
AttributeKey.longKey("totalCount"), (reusedCount.get() + uploadedCount.get()).toLong(),
))
reportStatisticValue("compile-parts:reused:bytes", reusedBytes.get().toString())
reportStatisticValue("compile-parts:reused:count", reusedCount.get().toString())
reportStatisticValue("compile-parts:uploaded:bytes", uploadedBytes.get().toString())
reportStatisticValue("compile-parts:uploaded:count", uploadedCount.get().toString())
reportStatisticValue("compile-parts:total:bytes", (reusedBytes.get() + uploadedBytes.get()).toString())
reportStatisticValue("compile-parts:total:count", (reusedCount.get() + uploadedCount.get()).toString())
}
private fun getFoundAndMissingFiles(metadataJson: String, serverUrl: String, client: OkHttpClient): CheckFilesResponse {
client.newCall(Request.Builder()
.url("$serverUrl/check-files")
.post(metadataJson.toRequestBody(MEDIA_TYPE_JSON))
.build()).execute().useSuccessful {
return Json.decodeFromStream(it.body.byteStream())
}
}
// Using ZSTD dictionary doesn't make the difference, even slightly worse (default compression level 3).
// That's because in our case we compress a relatively large archive of class files.
private fun uploadFile(url: String,
file: Path,
useHead: Boolean,
span: Span,
httpClient: OkHttpClient,
bufferPool: DirectFixedSizeByteBufferPool): Boolean {
if (useHead) {
val request = Request.Builder().url(url).head().build()
val code = httpClient.newCall(request).execute().use {
it.code
}
when {
code == 200 -> {
span.addEvent("already exist on server, nothing to upload", Attributes.of(
AttributeKey.stringKey("url"), url,
))
return false
}
code != 404 -> {
span.addEvent("responded with unexpected", Attributes.of(
AttributeKey.longKey("code"), code.toLong(),
AttributeKey.stringKey("url"), url,
))
}
}
}
val fileSize = Files.size(file)
if (Zstd.compressBound(fileSize) <= MAX_BUFFER_SIZE) {
compressSmallFile(file = file, fileSize = fileSize, bufferPool = bufferPool, url = url)
}
else {
val request = Request.Builder()
.url(url)
.put(object : RequestBody() {
override fun contentType() = MEDIA_TYPE_BINARY
override fun writeTo(sink: BufferedSink) {
compressFile(file = file, output = sink, bufferPool = bufferPool)
}
})
.build()
httpClient.newCall(request).execute().useSuccessful { }
}
return true
}
private fun compressSmallFile(file: Path, fileSize: Long, bufferPool: DirectFixedSizeByteBufferPool, url: String) {
val targetBuffer = bufferPool.allocate()
try {
var readOffset = 0L
val sourceBuffer = bufferPool.allocate()
var isSourceBufferReleased = false
try {
FileChannel.open(file, READ_OPERATION).use { input ->
do {
readOffset += input.read(sourceBuffer, readOffset)
}
while (readOffset < fileSize)
}
sourceBuffer.flip()
Zstd.compress(targetBuffer, sourceBuffer, 3, false)
targetBuffer.flip()
bufferPool.release(sourceBuffer)
isSourceBufferReleased = true
}
finally {
if (!isSourceBufferReleased) {
bufferPool.release(sourceBuffer)
}
}
val compressedSize = targetBuffer.remaining()
val request = Request.Builder()
.url(url)
.put(object : RequestBody() {
override fun contentLength() = compressedSize.toLong()
override fun contentType() = MEDIA_TYPE_BINARY
override fun writeTo(sink: BufferedSink) {
targetBuffer.mark()
sink.write(targetBuffer)
targetBuffer.reset()
}
})
.build()
httpClient.newCall(request).execute().useSuccessful { }
}
finally {
bufferPool.release(targetBuffer)
}
}
private fun compressFile(file: Path, output: BufferedSink, bufferPool: DirectFixedSizeByteBufferPool) {
val targetBuffer = bufferPool.allocate()
object : ZstdDirectBufferCompressingStreamNoFinalizer(targetBuffer, 3) {
override fun flushBuffer(toFlush: ByteBuffer): ByteBuffer {
toFlush.flip()
while (toFlush.hasRemaining()) {
output.write(toFlush)
}
toFlush.clear()
return toFlush
}
override fun close() {
try {
super.close()
}
finally {
bufferPool.release(targetBuffer)
}
}
}.use { compressor ->
val sourceBuffer = bufferPool.allocate()
try {
var offset = 0L
FileChannel.open(file, READ_OPERATION).use { input ->
val fileSize = input.size()
while (offset < fileSize) {
val actualBlockSize = (fileSize - offset).toInt()
if (sourceBuffer.remaining() > actualBlockSize) {
sourceBuffer.limit(sourceBuffer.position() + actualBlockSize)
}
var readOffset = offset
do {
readOffset += input.read(sourceBuffer, readOffset)
}
while (sourceBuffer.hasRemaining())
sourceBuffer.flip()
compressor.compress(sourceBuffer)
sourceBuffer.clear()
offset = readOffset
}
}
}
finally {
bufferPool.release(sourceBuffer)
}
}
}
@Serializable
private data class CheckFilesResponse(
val found: List<String> = emptyList(),
val missing: List<String> = emptyList(),
) | platform/build-scripts/src/org/jetbrains/intellij/build/impl/compilation/upload.kt | 4193149694 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.ide.util
import com.intellij.navigation.TargetPresentation
import com.intellij.openapi.application.EDT
import com.intellij.openapi.application.readAction
import com.intellij.openapi.ui.popup.util.PopupUtil
import com.intellij.openapi.util.Key
import com.intellij.psi.PsiElement
import com.intellij.ui.AnimatedIcon.ANIMATION_IN_RENDERER_ALLOWED
import com.intellij.ui.ScreenUtil
import com.intellij.ui.popup.AbstractPopup
import com.intellij.util.concurrency.annotations.RequiresEdt
import com.intellij.util.ui.UIUtil
import com.intellij.util.ui.UIUtil.runWhenChanged
import com.intellij.util.ui.UIUtil.runWhenHidden
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.channels.SendChannel
import java.awt.Dimension
import java.awt.Point
import java.awt.Rectangle
import javax.swing.AbstractListModel
import javax.swing.JList
import javax.swing.event.ListDataEvent
internal fun getComputer(list: JList<*>): PsiElementBackgroundPresentationComputer {
val existing = UIUtil.getClientProperty(list, computerKey)
if (existing != null) {
return existing
}
val computer = PsiElementBackgroundPresentationComputer(list)
UIUtil.putClientProperty(list, computerKey, computer)
UIUtil.putClientProperty(list, ANIMATION_IN_RENDERER_ALLOWED, true)
fun cleanUp() {
UIUtil.putClientProperty(list, computerKey, null)
UIUtil.putClientProperty(list, ANIMATION_IN_RENDERER_ALLOWED, null)
computer.dispose()
}
runWhenHidden(list, ::cleanUp)
runWhenChanged(list, "cellRenderer", ::cleanUp)
return computer
}
private val computerKey = Key.create<PsiElementBackgroundPresentationComputer>("PsiElementBackgroundPresentationComputer")
private typealias RendererAndElement = Pair<PsiElementListCellRenderer<*>, PsiElement>
internal class PsiElementBackgroundPresentationComputer(list: JList<*>) {
private val myCoroutineScope = CoroutineScope(Job())
private val myRepaintQueue = myCoroutineScope.repaintQueue(list)
private val myPresentationMap: MutableMap<RendererAndElement, Deferred<TargetPresentation>> = HashMap()
fun dispose() {
myCoroutineScope.cancel()
myRepaintQueue.close()
myPresentationMap.clear()
}
@RequiresEdt
fun computePresentationAsync(renderer: PsiElementListCellRenderer<*>, element: PsiElement): Deferred<TargetPresentation> {
return myPresentationMap.computeIfAbsent(RendererAndElement(renderer, element), ::doComputePresentationAsync)
}
private fun doComputePresentationAsync(rendererAndElement: RendererAndElement): Deferred<TargetPresentation> {
val result = myCoroutineScope.async {
//delay((Math.random() * 3000 + 2000).toLong()) // uncomment to add artificial delay to check out how it looks in UI
readAction {
val (renderer, element) = rendererAndElement
renderer.computePresentation(element)
}
}
myCoroutineScope.launch {
result.join()
myRepaintQueue.send(Unit) // repaint _after_ the resulting future is done
}
return result
}
}
private fun CoroutineScope.repaintQueue(list: JList<*>): SendChannel<Unit> {
val repaintQueue = Channel<Unit>(Channel.CONFLATED)
launch(Dispatchers.EDT) {
// A tick happens when an element has finished computing.
// Several elements are also merged into a single tick because the Channel is CONFLATED.
for (tick in repaintQueue) {
notifyModelChanged(list)
redrawListAndContainer(list)
delay(100) // update UI no more often that once in 100ms
}
}
return repaintQueue
}
/**
* This method forces [javax.swing.plaf.basic.BasicListUI.updateLayoutStateNeeded] to become non-zero via the path:
* [JList.getModel]
* -> [AbstractListModel.getListDataListeners]
* -> [javax.swing.event.ListDataListener.contentsChanged]
* -> [javax.swing.plaf.basic.BasicListUI.Handler.contentsChanged]
*
* It's needed so next call of [javax.swing.plaf.basic.BasicListUI.maybeUpdateLayoutState] will recompute list's preferred size.
*/
private fun notifyModelChanged(list: JList<*>) {
val model = list.model
if (model !is AbstractListModel) {
error("Unsupported list model: " + model.javaClass.name)
}
val size = model.size
if (size == 0) {
return
}
val listeners = model.listDataListeners
if (listeners.isEmpty()) {
return
}
val e = ListDataEvent(list, ListDataEvent.CONTENTS_CHANGED, 0, size - 1)
for (listener in listeners) {
listener.contentsChanged(e)
}
}
private fun redrawListAndContainer(list: JList<*>) {
if (!list.isShowing) {
return
}
resizePopup(list)
list.repaint()
}
private fun resizePopup(list: JList<*>) {
val popup = PopupUtil.getPopupContainerFor(list) ?: return
if (popup is AbstractPopup && popup.dimensionServiceKey != null) {
return
}
val popupLocation = popup.locationOnScreen
val rectangle = Rectangle(popupLocation, list.parent.preferredSize)
ScreenUtil.fitToScreen(rectangle)
if (rectangle.width > popup.size.width) { // don't shrink popup
popup.setLocation(Point(rectangle.x, popupLocation.y)) // // don't change popup vertical position on screen
popup.size = Dimension(rectangle.width, popup.size.height) // don't change popup height
}
}
| platform/lang-impl/src/com/intellij/ide/util/PsiElementBackgroundPresentationComputer.kt | 4055076393 |
package com.nibado.projects.advent.collect
class Link<T>(val value: T, var next: Link<T>? = null) : Collection<T> {
fun next() = next ?: this
fun nextOrNull() = next
fun firstLink() = linkSequence().first()
fun lastLink() = linkSequence().last()
fun addNext(value: T) : Link<T> = addNext(Link(value))
fun addNext(link: Link<T>) : Link<T> {
val next = this.next
link.lastLink().next = next
this.next = link
return link
}
fun addAll(iterable: Iterable<T>) {
val firstLink = Link(iterable.first())
val last = iterable.drop(1).fold(firstLink) {
link, e -> link.next = Link(e)
link.next!!
}
last.next = this.next
this.next = firstLink
}
fun remove(amount: Int = 1) : Link<T> {
val toRemove = linkSequence().drop(amount).first()
val removeStart = next()
next = toRemove.next
toRemove.next = null
return removeStart
}
override val size: Int
get() = linkSequence().count()
override fun contains(element: T): Boolean =
linkSequence().any { it.value == element }
override fun containsAll(elements: Collection<T>): Boolean {
return this.toSet().containsAll(elements)
}
override fun isEmpty(): Boolean = false
override fun iterator(): Iterator<T> =
linkSequence().map { it.value }.iterator()
fun linkSequence() : Sequence<Link<T>> {
val start = this
return sequence {
var current : Link<T>? = start
while(current != null) {
yield(current!!)
current = current.next
if(current == start) {
break
}
}
}
}
override fun toString() : String = joinToString(", ", "[", "]")
companion object {
fun <T> of(iterable: Iterable<T>) : Link<T> = Link(iterable.first()).also { it.addAll(iterable.drop(1)) }
fun <T> of(vararg elements: T) = of(elements.toList())
}
} | src/main/kotlin/com/nibado/projects/advent/collect/Link.kt | 319340796 |
// JVM_TARGET: 17
package test
@JvmRecord
data class J(@JvmField val x: Int) {
fun x(): Int {
return if (x < 100) x else 100
}
}
| plugins/kotlin/j2k/new/tests/testData/multiFile/Java17_RecordClassExplicitAccessor/JavaClass.kt | 28684817 |
package io.github.chrislo27.rhre3.editor.picker
import io.github.chrislo27.rhre3.sfxdb.Game
class FavouritesFilter : SimpleFilter(
{ it.isFavourited || it.games.any(Game::isFavourited) },
gameFilter = { it.isFavourited || it.gameGroup.isFavourited }
) | core/src/main/kotlin/io/github/chrislo27/rhre3/editor/picker/FavouritesFilter.kt | 131919739 |
package io.github.chrislo27.rhre3.editor.stage.theme
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.Preferences
import com.badlogic.gdx.graphics.Color
import com.badlogic.gdx.graphics.OrthographicCamera
import com.badlogic.gdx.graphics.Texture
import com.badlogic.gdx.graphics.g2d.TextureRegion
import com.badlogic.gdx.utils.Align
import io.github.chrislo27.rhre3.editor.Editor
import io.github.chrislo27.rhre3.editor.stage.EditorStage
import io.github.chrislo27.rhre3.screen.EditorScreen
import io.github.chrislo27.rhre3.theme.LoadedThemes
import io.github.chrislo27.rhre3.theme.Theme
import io.github.chrislo27.rhre3.theme.Themes
import io.github.chrislo27.toolboks.registry.AssetRegistry
import io.github.chrislo27.toolboks.ui.*
import io.github.chrislo27.toolboks.util.gdxutils.openFileExplorer
class ThemeChooserStage(val editor: Editor, val palette: UIPalette, parent: EditorStage, camera: OrthographicCamera, pixelsWidth: Float, pixelsHeight: Float)
: Stage<EditorScreen>(parent, camera, pixelsWidth, pixelsHeight) {
private val preferences: Preferences
get() = editor.main.preferences
val title: TextLabel<EditorScreen>
private val chooserButtonBar: Stage<EditorScreen>
private val themeList: ThemeListStage<Theme>
val themeEditor: ThemeEditorStage
init {
this.elements += ColourPane(this, this).apply {
this.colour.set(Editor.TRANSLUCENT_BLACK)
this.colour.a = 0.8f
}
themeList = object : ThemeListStage<Theme>(editor, palette, this@ThemeChooserStage, [email protected], 362f, 352f) {
override val itemList: List<Theme> get() = LoadedThemes.themes
override fun getItemName(item: Theme): String = item.name
override fun isItemNameLocalizationKey(item: Theme): Boolean = item.nameIsLocalization
override fun getItemBgColor(item: Theme): Color = item.background
override fun getItemLineColor(item: Theme): Color = item.trackLine
override fun isItemSelected(item: Theme): Boolean = item == LoadedThemes.themes[LoadedThemes.index]
override fun getBlueBarLimit(): Int = Themes.defaultThemes.size
override fun onItemButtonSelected(leftClick: Boolean, realIndex: Int, buttonIndex: Int) {
if (leftClick) {
LoadedThemes.index = realIndex
LoadedThemes.persistIndex(preferences)
editor.theme = LoadedThemes.currentTheme
}
}
}.apply {
location.set(screenX = 0f, screenY = 0f, screenWidth = 0f, screenHeight = 0f,
pixelX = 20f, pixelY = 53f, pixelWidth = 362f, pixelHeight = 352f)
}
this.elements += themeList
title = TextLabel(palette, this, this).apply {
this.location.set(screenX = 0f, screenWidth = 1f, screenY = 0.875f, screenHeight = 0.125f)
this.textAlign = Align.center
this.textWrapping = false
this.isLocalizationKey = true
this.text = "editor.themeChooser.title"
this.location.set(screenWidth = 0.95f, screenX = 0.025f)
}
this.elements += title
themeEditor = ThemeEditorStage(editor, palette, this, this.camera, 362f, 392f).apply {
this.location.set(screenX = 0f, screenY = 0f, screenWidth = 0f, screenHeight = 0f,
pixelX = 20f, pixelY = 13f, pixelWidth = 362f, pixelHeight = 392f)
this.visible = false
}
this.elements += themeEditor
chooserButtonBar = Stage(this, this.camera, 346f, 34f).apply {
location.set(screenX = 0f, screenY = 0f, screenWidth = 0f, screenHeight = 0f,
pixelX = 20f, pixelY = 13f, pixelWidth = 346f, pixelHeight = 34f)
this.elements += Button(palette, this, this.stage).apply {
this.location.set(0f, 0f, 0f, 1f, 0f, 0f, 346f - 34f * 2f - 8f * 2f, 0f)
this.addLabel(TextLabel(palette, this, this.stage).apply {
this.isLocalizationKey = true
this.text = "editor.themeEditor"
this.textWrapping = true
this.fontScaleMultiplier = 0.75f
this.location.set(pixelWidth = -4f, pixelX = 2f)
})
this.leftClickAction = { _, _ ->
themeEditor.state = ThemeEditorStage.State.ChooseTheme
themeEditor.update()
updateVisibility(true)
}
}
this.elements += object : Button<EditorScreen>(palette, this, this.stage) {
override fun onLeftClick(xPercent: Float, yPercent: Float) {
super.onLeftClick(xPercent, yPercent)
LoadedThemes.reloadThemes(preferences, false)
LoadedThemes.persistIndex(preferences)
editor.theme = LoadedThemes.currentTheme
themeList.apply {
buttonScroll = 0
resetButtons()
}
}
}.apply {
this.location.set(0f, 0f, 0f, 1f, 346f - 34f * 2f - 8f, 0f, 34f, 0f)
this.tooltipTextIsLocalizationKey = true
this.tooltipText = "editor.themeChooser.reset"
this.addLabel(ImageLabel(palette, this, this.stage).apply {
this.image = TextureRegion(AssetRegistry.get<Texture>("ui_icon_updatesfx"))
})
}
this.elements += Button(palette, this, this.stage).apply {
this.location.set(0f, 0f, 0f, 1f, 346f - 34f, 0f, 34f, 0f)
this.addLabel(ImageLabel(palette, this, this.stage).apply {
this.renderType = ImageLabel.ImageRendering.ASPECT_RATIO
this.image = TextureRegion(AssetRegistry.get<Texture>("ui_icon_folder"))
})
this.leftClickAction = { _, _ ->
Gdx.net.openFileExplorer(LoadedThemes.THEMES_FOLDER)
}
this.tooltipTextIsLocalizationKey = true
this.tooltipText = "editor.themeEditor.openContainingFolder"
}
}
this.elements += chooserButtonBar
}
fun updateVisibility(inThemeEditor: Boolean) {
themeEditor.visible = inThemeEditor
chooserButtonBar.visible = !inThemeEditor
themeList.visible = !inThemeEditor
}
fun resetEverything() {
updateVisibility(false)
themeList.resetButtons()
title.text = "editor.themeChooser.title"
}
} | core/src/main/kotlin/io/github/chrislo27/rhre3/editor/stage/theme/ThemeChooserStage.kt | 4228133031 |
package org.stepik.android.presentation.wishlist.reducer
import org.stepik.android.presentation.wishlist.WishlistFeature.State
import org.stepik.android.presentation.wishlist.WishlistFeature.Message
import org.stepik.android.presentation.wishlist.WishlistFeature.Action
import org.stepik.android.presentation.wishlist.model.WishlistAction
import ru.nobird.app.core.model.mutate
import ru.nobird.app.presentation.redux.reducer.StateReducer
import javax.inject.Inject
class WishlistReducer
@Inject
constructor() : StateReducer<State, Message, Action> {
override fun reduce(state: State, message: Message): Pair<State, Set<Action>> =
when (message) {
is Message.InitMessage -> {
if (state is State.Idle || state is State.Error && message.forceUpdate) {
State.Loading to setOf(Action.FetchWishList)
} else {
null
}
}
is Message.FetchWishlistSuccess -> {
if (state is State.Loading) {
val newState =
if (message.wishlistedCourses.isNullOrEmpty()) {
State.Empty
} else {
State.Content(message.wishlistedCourses)
}
newState to emptySet()
} else {
null
}
}
is Message.FetchWishListError -> {
if (state is State.Loading) {
State.Error to emptySet()
} else {
null
}
}
is Message.WishlistOperationUpdate -> {
val resultingState =
when (state) {
is State.Content -> {
val resultingList =
if (message.wishlistOperationData.wishlistAction == WishlistAction.ADD) {
state.wishListCourses.mutate { add(0, message.wishlistOperationData.courseId) }
} else {
state.wishListCourses.mutate { remove(message.wishlistOperationData.courseId) }
}
if (resultingList.isEmpty()) {
State.Empty
} else {
State.Content(wishListCourses = resultingList)
}
}
is State.Empty -> {
if (message.wishlistOperationData.wishlistAction == WishlistAction.ADD) {
State.Content(listOf(message.wishlistOperationData.courseId))
} else {
state
}
}
else ->
state
}
resultingState to emptySet()
}
} ?: state to emptySet()
} | app/src/main/java/org/stepik/android/presentation/wishlist/reducer/WishlistReducer.kt | 2712711664 |
package org.stepik.android.view.injection.video_player
import dagger.Binds
import dagger.Module
import org.stepik.android.cache.video_player.VideoTimestampCacheDataSourceImpl
import org.stepik.android.data.video_player.repository.VideoTimestampRepositoryImpl
import org.stepik.android.data.video_player.source.VideoTimestampCacheDataSource
import org.stepik.android.domain.video_player.repository.VideoTimestampRepository
@Module
abstract class VideoTimestampDataModule {
@Binds
internal abstract fun bindVideoTimestampRepository(
videoTimestampRepositoryImpl: VideoTimestampRepositoryImpl
): VideoTimestampRepository
@Binds
internal abstract fun bindVideoTimestampCacheDataSource(
videoTimestampCacheDataSourceImpl: VideoTimestampCacheDataSourceImpl
): VideoTimestampCacheDataSource
} | app/src/main/java/org/stepik/android/view/injection/video_player/VideoTimestampDataModule.kt | 3668434108 |
package com.nononsenseapps.feeder.ui.compose.theme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Typography
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextDecoration
// Set of Material typography styles to start with
val Typography = Typography(
// TODO REMOVE
// h1 = TextStyle(
// fontWeight = FontWeight.Light,
// fontSize = 34.sp,
// letterSpacing = (-1.5).sp
// ),
// h2 = TextStyle(
// fontWeight = FontWeight.Light,
// fontSize = 30.sp,
// letterSpacing = (-0.5).sp
// ),
// h3 = TextStyle(
// fontWeight = FontWeight.Normal,
// fontSize = 28.sp,
// letterSpacing = 0.sp
// ),
// h4 = TextStyle(
// fontWeight = FontWeight.Normal,
// fontSize = 26.sp,
// letterSpacing = 0.25.sp
// ),
// h5 = TextStyle(
// fontWeight = FontWeight.Normal,
// fontSize = 24.sp,
// letterSpacing = 0.sp
// ),
// h6 = TextStyle(
// fontWeight = FontWeight.Medium,
// fontSize = 20.sp,
// letterSpacing = 0.15.sp
// ),
)
@Composable
fun LinkTextStyle(): TextStyle =
TextStyle(
color = MaterialTheme.colorScheme.primary,
textDecoration = TextDecoration.Underline
)
fun titleFontWeight(unread: Boolean) =
if (unread) {
FontWeight.Bold
} else {
FontWeight.Normal
}
@Composable
fun FeedListItemTitleStyle(): SpanStyle =
FeedListItemTitleTextStyle().toSpanStyle()
@Composable
fun FeedListItemTitleTextStyle(): TextStyle =
MaterialTheme.typography.titleMedium
@Composable
fun FeedListItemStyle(): TextStyle =
MaterialTheme.typography.bodyLarge
@Composable
fun FeedListItemFeedTitleStyle(): TextStyle =
FeedListItemDateStyle()
@Composable
fun FeedListItemDateStyle(): TextStyle =
MaterialTheme.typography.labelMedium
@Composable
fun TTSPlayerStyle(): TextStyle =
MaterialTheme.typography.titleMedium
@Composable
fun CodeInlineStyle(): SpanStyle =
SpanStyle(
background = CodeBlockBackground(),
fontFamily = FontFamily.Monospace
)
/**
* Has no background because it is meant to be put over a Surface which has the proper background.
*/
@Composable
fun CodeBlockStyle(): TextStyle =
MaterialTheme.typography.bodyMedium.merge(
SpanStyle(
fontFamily = FontFamily.Monospace
)
)
@Composable
fun CodeBlockBackground(): Color =
MaterialTheme.colorScheme.surfaceVariant
@Composable
fun BlockQuoteStyle(): SpanStyle =
MaterialTheme.typography.bodyLarge.toSpanStyle().merge(
SpanStyle(
fontWeight = FontWeight.Light
)
)
| app/src/main/java/com/nononsenseapps/feeder/ui/compose/theme/Typography.kt | 1000214440 |
// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.idea.maven.navigator.actions
import com.intellij.execution.Executor
import com.intellij.openapi.actionSystem.*
import com.intellij.openapi.project.DumbAware
import org.jetbrains.idea.maven.project.actions.RunBuildAction
import org.jetbrains.idea.maven.statistics.MavenActionsUsagesCollector
class MavenBuildMenu : DefaultActionGroup(), DumbAware {
private val actionManager = ActionManager.getInstance()
override fun update(e: AnActionEvent) {
val project = AnAction.getEventProject(e) ?: return
childActionsOrStubs
.filter { it is MyDelegatingAction || it is RunBuildAction }
.forEach { remove(it) }
Executor.EXECUTOR_EXTENSION_NAME.extensionList
.filter { it.isApplicable(project) }
.reversed()
.forEach {
val contextAction = actionManager.getAction(it.contextActionId)
if (contextAction != null) {
add(wrap(contextAction, it), Constraints.FIRST)
}
}
ActionManager.getInstance().getAction("Maven.RunBuild")?.let {
add(it, Constraints.FIRST)
}
}
private interface MyDelegatingAction
private class DelegatingActionGroup internal constructor(action: ActionGroup, private val executor: Executor) :
EmptyAction.MyDelegatingActionGroup(action), MyDelegatingAction {
override fun getChildren(e: AnActionEvent?): Array<AnAction> {
val children = super.getChildren(e)
return children.map { wrap(it, executor) }.toTypedArray()
}
override fun actionPerformed(e: AnActionEvent) {
reportUsage(e, executor)
super.actionPerformed(e)
}
}
private class DelegatingAction internal constructor(action: AnAction, private val executor: Executor) :
EmptyAction.MyDelegatingAction(action), MyDelegatingAction {
override fun actionPerformed(e: AnActionEvent) {
reportUsage(e, executor)
super.actionPerformed(e)
}
}
companion object {
private fun wrap(action: AnAction, executor: Executor): AnAction = if (action is ActionGroup) DelegatingActionGroup(action, executor)
else DelegatingAction(action, executor)
private fun reportUsage(e: AnActionEvent, executor: Executor) {
MavenActionsUsagesCollector.trigger(e.project, MavenActionsUsagesCollector.ActionID.RunBuildAction, e, executor)
}
}
} | plugins/maven/src/main/java/org/jetbrains/idea/maven/navigator/actions/MavenBuildMenu.kt | 649061131 |
package io.github.ranolp.kubo.telegram.general
enum class MessageParseMode {
MARKDOWN, HTML;
} | Kubo-Telegram/src/main/kotlin/io/github/ranolp/kubo/telegram/general/MessageParseMode.kt | 744990022 |
package com.aemtools.codeinsight.htl.annotator
import com.aemtools.common.intention.BaseHtlIntentionAction
import com.aemtools.common.util.psiDocumentManager
import com.aemtools.lang.htl.psi.mixin.HtlStringLiteralMixin
import com.intellij.openapi.editor.Editor
import com.intellij.openapi.project.Project
import com.intellij.psi.PsiFile
import com.intellij.psi.SmartPsiElementPointer
/**
* Inverts [HtlStringLiteralMixin] quotes.
*
* @author Dmytro Troynikov
*/
class HtlWrongQuotesLiteralFixIntentionAction(
private val pointer: SmartPsiElementPointer<HtlStringLiteralMixin>
) : BaseHtlIntentionAction(
text = { "Invert HTL Literal quotes" }
) {
override fun invoke(project: Project, editor: Editor, file: PsiFile) {
val element = pointer.element ?: return
val document = project.psiDocumentManager().getDocument(file)
?: return
val newValue = element.swapQuotes()
val (start, end) = element.textRange.startOffset to element.textRange.endOffset
document.replaceString(start, end, newValue)
project.psiDocumentManager().commitDocument(document)
}
}
| aem-intellij-core/src/main/kotlin/com/aemtools/codeinsight/htl/annotator/HtlWrongQuotesLiteralFixIntentionAction.kt | 3129156116 |
package io.fluidsonic.json
public object IntArrayJsonCodec : AbstractJsonEncoderCodec<IntArray, JsonCodingContext>() {
override fun JsonEncoder<JsonCodingContext>.encode(value: IntArray): Unit =
writeList(value)
}
| coding/sources-jvm/codecs/basic/IntArrayJsonCodec.kt | 2553631942 |
package com.farmerbb.taskbar.helper
import org.junit.Assert
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
@RunWith(RobolectricTestRunner::class)
class DashboardHelperTest {
private val helper = DashboardHelper.getInstance()
@Test
fun testGetInstance() {
Assert.assertNotNull(helper)
for (i in 1..20) {
Assert.assertEquals(helper, DashboardHelper.getInstance())
}
}
@Test
fun testSetDashboardOpen() {
Assert.assertFalse(helper.isDashboardOpen)
helper.isDashboardOpen = true
Assert.assertTrue(helper.isDashboardOpen)
helper.isDashboardOpen = false
}
}
| app/src/test/java/com/farmerbb/taskbar/helper/DashboardHelperTest.kt | 1809649178 |
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.plugins.terminal
import com.intellij.internal.statistic.collectors.fus.TerminalFusAwareHandler
import com.intellij.internal.statistic.collectors.fus.os.OsVersionUsageCollector
import com.intellij.internal.statistic.eventLog.FeatureUsageData
import com.intellij.internal.statistic.service.fus.collectors.FUCounterUsageLogger
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.SystemInfo
import com.intellij.terminal.TerminalShellCommandHandler
import com.intellij.util.PathUtil
import java.util.*
class TerminalUsageTriggerCollector {
companion object {
@JvmStatic
fun triggerSshShellStarted(project: Project) {
FUCounterUsageLogger.getInstance().logEvent(project, GROUP_ID, "ssh.exec")
}
@JvmStatic
fun triggerCommandExecuted(project: Project) {
FUCounterUsageLogger.getInstance().logEvent(project, GROUP_ID, "terminal.command.executed")
}
@JvmStatic
fun triggerSmartCommand(project: Project,
workingDirectory: String?,
localSession: Boolean,
command: String,
handler: TerminalShellCommandHandler,
executed: Boolean) {
val data = FeatureUsageData().addData("terminalCommandHandler", handler::class.java.name)
if (handler is TerminalFusAwareHandler) {
handler.fillData(project, workingDirectory, localSession, command, data)
}
val eventId = if (executed) {
"terminal.smart.command.executed"
}
else {
"terminal.smart.command.not.executed"
}
FUCounterUsageLogger.getInstance().logEvent(project, GROUP_ID, eventId, data)
}
@JvmStatic
fun triggerLocalShellStarted(project: Project, shellCommand: Array<String>) {
val osVersion = OsVersionUsageCollector.parse(SystemInfo.OS_VERSION)
FUCounterUsageLogger.getInstance().logEvent(project, GROUP_ID, "local.exec", FeatureUsageData()
.addData("os-version", if (osVersion == null) "unknown" else osVersion.toCompactString())
.addData("shell", getShellNameForStat(shellCommand.firstOrNull()))
)
}
@JvmStatic
private fun getShellNameForStat(shellName: String?): String {
if (shellName == null) return "unspecified"
var name = shellName.trimStart()
val ind = name.indexOf(" ")
name = if (ind < 0) name else name.substring(0, ind)
if (SystemInfo.isFileSystemCaseSensitive) {
name = name.toLowerCase(Locale.ENGLISH)
}
name = PathUtil.getFileName(name)
name = trimKnownExt(name)
return if (KNOWN_SHELLS.contains(name)) name else "other"
}
private fun trimKnownExt(name: String): String {
val ext = PathUtil.getFileExtension(name)
return if (ext != null && KNOWN_EXTENSIONS.contains(ext)) name.substring(0, name.length - ext.length - 1) else name
}
}
}
private const val GROUP_ID = "terminalShell"
private val KNOWN_SHELLS = setOf("activate",
"anaconda3",
"bash",
"cexec",
"cmd",
"cmder",
"cmder_shell",
"cygwin",
"fish",
"git",
"git-bash",
"git-cmd",
"init",
"miniconda3",
"msys2_shell",
"powershell",
"pwsh",
"sh",
"tcsh",
"ubuntu",
"ubuntu1804",
"wsl",
"zsh")
private val KNOWN_EXTENSIONS = setOf("exe", "bat", "cmd") | plugins/terminal/src/org/jetbrains/plugins/terminal/TerminalUsageCollector.kt | 2692630060 |
// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.ide.navigationToolbar.experimental
import com.intellij.openapi.actionSystem.DefaultActionGroup
class RightToolbarGroup: DefaultActionGroup() {
} | platform/lang-impl/src/com/intellij/ide/navigationToolbar/experimental/RightToolbarGroup.kt | 45053079 |
package json.codecVisibility
import codecProvider.CustomCodingContext
import io.fluidsonic.json.AbstractJsonCodec
import io.fluidsonic.json.JsonCodingType
import io.fluidsonic.json.JsonDecoder
import io.fluidsonic.json.JsonEncoder
import io.fluidsonic.json.missingPropertyError
import io.fluidsonic.json.readBooleanOrNull
import io.fluidsonic.json.readByteOrNull
import io.fluidsonic.json.readCharOrNull
import io.fluidsonic.json.readDoubleOrNull
import io.fluidsonic.json.readFloatOrNull
import io.fluidsonic.json.readFromMapByElementValue
import io.fluidsonic.json.readIntOrNull
import io.fluidsonic.json.readLongOrNull
import io.fluidsonic.json.readShortOrNull
import io.fluidsonic.json.readStringOrNull
import io.fluidsonic.json.readValueOfType
import io.fluidsonic.json.readValueOfTypeOrNull
import io.fluidsonic.json.writeBooleanOrNull
import io.fluidsonic.json.writeByteOrNull
import io.fluidsonic.json.writeCharOrNull
import io.fluidsonic.json.writeDoubleOrNull
import io.fluidsonic.json.writeFloatOrNull
import io.fluidsonic.json.writeIntOrNull
import io.fluidsonic.json.writeIntoMap
import io.fluidsonic.json.writeLongOrNull
import io.fluidsonic.json.writeMapElement
import io.fluidsonic.json.writeShortOrNull
import io.fluidsonic.json.writeStringOrNull
import io.fluidsonic.json.writeValueOrNull
import kotlin.String
import kotlin.Unit
public object PublicJsonCodec : AbstractJsonCodec<Public, CustomCodingContext>() {
public override fun JsonDecoder<CustomCodingContext>.decode(valueType: JsonCodingType<Public>):
Public {
var _value: String? = null
readFromMapByElementValue { key ->
when (key) {
"value" -> _value = readString()
else -> skipValue()
}
}
return Public(
`value` = _value ?: missingPropertyError("value")
)
}
public override fun JsonEncoder<CustomCodingContext>.encode(`value`: Public): Unit {
writeIntoMap {
writeMapElement("value", string = value.`value`)
}
}
}
| annotation-processor/test-cases/1/output-expected/json/codecVisibility/PublicJsonCodec.kt | 1747770015 |
// Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.ide.ui.laf.darcula.ui
import com.intellij.ui.JBColor
import com.intellij.ui.paint.LinePainter2D
import com.intellij.util.ui.JBUI
import java.awt.*
import java.awt.geom.GeneralPath
import javax.swing.JComponent
import javax.swing.JSlider
import javax.swing.LookAndFeel
import javax.swing.SwingConstants
import javax.swing.plaf.basic.BasicSliderUI
public open class DarculaSliderUI(b: JComponent? = null) : BasicSliderUI(b as JSlider) {
companion object {
@Suppress("UNUSED_PARAMETER")
@JvmStatic
fun createUI(c: JComponent): DarculaSliderUI = DarculaSliderUI(c)
}
private val theme = DarculaSliderUIThemes()
override fun paintThumb(g: Graphics) {
val g2d = g.create() as Graphics2D
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON)
try {
val path = if (slider.orientation == SwingConstants.HORIZONTAL) {
val x1 = thumbRect.x + theme.focusBorderThickness
val x2 = x1 + thumbRect.width - (theme.focusBorderThickness * 2)
val x3 = theme.thumbHalfWidth + 1 + x1
val y1 = thumbRect.y + theme.focusBorderThickness
val y2 = y1 + theme.thumbOverhang
val y3 = y1 + thumbRect.height - (theme.focusBorderThickness * 2)
getHPath(x1, y1, x2, y2, x3, y3)
}
else {
val x1 = thumbRect.x + theme.focusBorderThickness
val x2 = x1 + theme.thumbOverhang
val x3 = x1 + thumbRect.width - (theme.focusBorderThickness * 2)
val y1 = thumbRect.y + theme.focusBorderThickness
val y2 = y1 + theme.thumbHalfWidth + 1
val y3 = y1 + thumbRect.height - (theme.focusBorderThickness * 2)
getVPath(x1, y1, x2, x3, y2, y3)
}
if (slider.hasFocus()) {
g2d.stroke = BasicStroke((theme.focusBorderThickness + theme.borderThickness).toFloat())
g2d.paint = theme.focusedOuterColor
g2d.draw(path)
}
g2d.paint = if (slider.isEnabled) theme.buttonColor else theme.disabledButtonColor
g2d.fill(path)
g2d.paint = if (slider.hasFocus()) {
theme.focusedBorderColor
}
else if (slider.isEnabled) {
theme.buttonBorderColor
}
else {
theme.disabledButtonBorderColor
}
g2d.stroke = BasicStroke(theme.borderThickness.toFloat())
g2d.draw(path)
}
finally {
g2d.dispose()
}
}
private fun getHPath(x1: Int,
y1: Int,
x2: Int,
y2: Int,
x3: Int,
y3: Int): GeneralPath {
val path = GeneralPath()
path.moveTo((x1 + theme.arc).toDouble(), y1.toDouble())
path.lineTo((x2 - theme.arc).toDouble(), y1.toDouble())
path.lineTo(x2.toDouble(), (y1 + theme.arc).toDouble())
// path.quadTo(path.currentPoint.x, path.currentPoint.y, x2.toDouble(), (y1 + arc).toDouble())
path.lineTo(x2.toDouble(), y2.toDouble())
path.lineTo(x3.toDouble(), y3.toDouble())
path.lineTo(x1.toDouble(), y2.toDouble())
path.lineTo(x1.toDouble(), (y1 + theme.arc).toDouble())
path.lineTo(x1 + theme.arc.toDouble(), y1.toDouble())
// path.quadTo(path.currentPoint.x, path.currentPoint.y, x1 + arc.toDouble(), y1.toDouble())
path.closePath()
return path
}
private fun getVPath(x1: Int,
y1: Int,
x2: Int,
x3: Int,
y2: Int,
y3: Int): GeneralPath {
val path = GeneralPath()
path.moveTo((x1 + theme.arc).toDouble(), y1.toDouble())
path.lineTo(x2.toDouble(), y1.toDouble())
path.lineTo(x3.toDouble(), y2.toDouble())
path.lineTo(x2.toDouble(), y3.toDouble())
path.lineTo((x1 + theme.arc).toDouble(), y3.toDouble())
path.lineTo(x1.toDouble(), (y3 - theme.arc).toDouble())
// path.quadTo(path.currentPoint.x, path.currentPoint.y, x1.toDouble(), (y3 - arc).toDouble())
path.lineTo(x1.toDouble(), (y1 + theme.arc).toDouble())
path.lineTo((x1 + theme.arc).toDouble(), y1.toDouble())
//path.quadTo(path.currentPoint.x, path.currentPoint.y, (x1 + arc).toDouble(), y1.toDouble())
path.closePath()
return path
}
override fun calculateThumbLocation() {
super.calculateThumbLocation()
if (slider.orientation == JSlider.HORIZONTAL) {
val valuePosition = xPositionForValue(slider.value)
thumbRect.x = valuePosition - theme.focusedThumbHalfWidth
thumbRect.y = trackRect.y
}
else {
val valuePosition = yPositionForValue(slider.value)
thumbRect.x = trackRect.x
thumbRect.y = valuePosition - theme.focusedThumbHalfWidth
}
}
override fun setThumbLocation(x: Int, y: Int) {
super.setThumbLocation(x, y)
slider.repaint()
}
override fun getBaseline(c: JComponent?, width: Int, height: Int): Int {
if (slider.orientation == SwingConstants.HORIZONTAL) {
return theme.thumbOverhang + (2 * theme.focusBorderThickness) + slider.insets.top + theme.borderThickness
}
else {
return super.getBaseline(c, width, height)
}
}
override fun paintTrack(g: Graphics) {
val g2d = g.create() as Graphics2D
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON)
g2d.paint = if (slider.isEnabled) theme.trackColor else theme.disabledTrackColor
try {
if (slider.orientation == SwingConstants.HORIZONTAL) {
val y = thumbRect.y + theme.focusBorderThickness + theme.thumbOverhang - theme.trackThickness
LinePainter2D.paint(g2d, trackRect.getX(), y.toDouble(), trackRect.maxX, y.toDouble(),
LinePainter2D.StrokeType.INSIDE,
theme.trackThickness.toDouble())
}
else {
val x = thumbRect.x + theme.focusBorderThickness + theme.thumbOverhang - theme.trackThickness
LinePainter2D.paint(g2d, x.toDouble(), trackRect.y.toDouble(), x.toDouble(), trackRect.maxY, LinePainter2D.StrokeType.INSIDE,
theme.trackThickness.toDouble())
}
}
finally {
g2d.dispose()
}
}
override fun paintFocus(g: Graphics) {
paintThumb(g)
}
override fun getThumbSize(): Dimension {
val width = (theme.focusedThumbHalfWidth * 2) + 1
return if (slider.orientation == SwingConstants.HORIZONTAL) Dimension(width, theme.thumbHeight)
else Dimension(theme.thumbHeight, width)
}
override fun calculateTrackBuffer() {
if (slider.paintLabels && slider.labelTable != null) {
val highLabel = highestValueLabel
val lowLabel = lowestValueLabel
if (slider.orientation == JSlider.HORIZONTAL) {
if (highLabel != null && lowLabel != null) {
trackBuffer = highLabel.bounds.width.coerceAtLeast(lowLabel.bounds.width) / 2
}
trackBuffer = trackBuffer.coerceAtLeast(theme.focusedThumbHalfWidth)
}
else {
if (highLabel != null && lowLabel != null) {
trackBuffer = highLabel.bounds.height.coerceAtLeast(lowLabel.bounds.height) / 2
}
trackBuffer = trackBuffer.coerceAtLeast(theme.focusedThumbHalfWidth) + 1
}
}
else {
trackBuffer = theme.focusedThumbHalfWidth + 1
}
}
override fun calculateLabelRect() {
super.calculateLabelRect()
if (slider.orientation == JSlider.HORIZONTAL) {
labelRect.y += theme.tickBottom
}
else {
labelRect.x += theme.tickBottom
}
}
override fun calculateTickRect() {
if (slider.orientation == JSlider.HORIZONTAL) {
tickRect.x = trackRect.x
tickRect.y = trackRect.y + theme.focusBorderThickness + theme.thumbOverhang + theme.tickTop
tickRect.width = trackRect.width
tickRect.height = if (slider.paintTicks) tickLength else 0
}
else {
tickRect.width = if (slider.paintTicks) tickLength else 0
if (slider.componentOrientation.isLeftToRight) {
tickRect.x = trackRect.x + theme.focusBorderThickness + theme.thumbOverhang + theme.tickTop
}
else {
tickRect.x = trackRect.x - (theme.focusBorderThickness + theme.thumbOverhang + theme.tickTop)
}
tickRect.y = trackRect.y
tickRect.height = trackRect.height
}
}
override fun getTickLength(): Int {
return theme.majorTickHeight
}
override fun installDefaults(slider: JSlider?) {
LookAndFeel.installColorsAndFont(slider, "Slider.background",
"Slider.foreground", "Slider.font")
focusInsets = JBUI.emptyInsets()
}
override fun paintMinorTickForHorizSlider(g: Graphics, tickBounds: Rectangle, x_: Int) {
g as Graphics2D
g.color = if (slider.isEnabled) theme.tickColor else theme.disabledTickColor
val x = x_ + 1
g.stroke = BasicStroke(theme.borderThickness.toFloat())
g.drawLine(x, 0, x, theme.minorTickHeight)
}
override fun paintMajorTickForHorizSlider(g: Graphics, tickBounds: Rectangle, x_: Int) {
g as Graphics2D
g.color = if (slider.isEnabled) theme.tickColor else theme.disabledTickColor
val x = x_ + 1
g.stroke = BasicStroke(theme.borderThickness.toFloat())
g.drawLine(x, 0, x, theme.majorTickHeight)
}
override fun paintMinorTickForVertSlider(g: Graphics, tickBounds: Rectangle, y_: Int) {
g as Graphics2D
g.color = if (slider.isEnabled) theme.tickColor else theme.disabledTickColor
val y = y_ + 1
g.stroke = BasicStroke(theme.borderThickness.toFloat())
g.drawLine(0, y, theme.minorTickHeight, y)
}
override fun paintMajorTickForVertSlider(g: Graphics, tickBounds: Rectangle, y_: Int) {
g as Graphics2D
g.color = if (slider.isEnabled) theme.tickColor else theme.disabledTickColor
val y = y_ + 1
g.stroke = BasicStroke(theme.borderThickness.toFloat())
g.drawLine(0, y, theme.majorTickHeight, y)
}
}
public class DarculaSliderUIThemes {
val thumbHalfWidth = JBUI.scale(7)
val thumbHeight = JBUI.scale(24)
val focusedThumbHalfWidth = thumbHalfWidth + focusBorderThickness
val arc: Int
get() = JBUI.scale(1)
val trackThickness: Int
get() = JBUI.scale(3)
val focusBorderThickness: Int
get() = JBUI.scale(3)
val focusedBorderColor: Color
get() = JBUI.CurrentTheme.Focus.focusColor()
val borderThickness: Int
get() = JBUI.scale(1)
val thumbOverhang: Int
get() = JBUI.scale(10)
val buttonColor: Color
get() = JBColor.namedColor("Slider.buttonColor", JBColor(0xFFFFFF, 0x9B9E9E))
val buttonBorderColor: Color
get() = JBColor.namedColor("Slider.buttonBorderColor", JBColor(0xA6A6A6, 0x393D3F))
val trackColor: Color
get() = JBColor.namedColor("Slider.trackColor", JBColor(0xC7C7C7, 0x666666))
val tickColor: Color
get() = JBColor.namedColor("Slider.tickColor", JBColor(0x999999, 0x808080))
val focusedOuterColor: Color
get() = JBUI.CurrentTheme.Component.FOCUSED_BORDER_COLOR
val disabledButtonColor: Color
get() = JBColor.PanelBackground
val disabledButtonBorderColor: Color
get() = JBColor.namedColor("Component.disabledBorderColor", 0x87AFDA)
val disabledTrackColor: Color
get() = disabledButtonBorderColor
val disabledTickColor: Color
get() = disabledButtonBorderColor
val tickTop: Int
get() = JBUI.scale(6)
val tickBottom: Int
get() = JBUI.scale(2)
val minorTickHeight: Int
get() = JBUI.scale(4)
val majorTickHeight: Int
get() = JBUI.scale(7)
} | platform/platform-impl/src/com/intellij/ide/ui/laf/darcula/ui/DarculaSliderUI.kt | 1522785200 |
package com.thedeadpixelsociety.ld34.components
import com.badlogic.ashley.core.Component
import com.badlogic.gdx.math.Rectangle
data class BoundsComponent(val rect: Rectangle = Rectangle(0f, 0f, 1f, 1f)) : Component
| core/src/com/thedeadpixelsociety/ld34/components/BoundsComponent.kt | 676531937 |
/*
* (C) Copyright 2018 Lukas Morawietz (https://github.com/F43nd1r)
*
* 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.faendir.acra.model
import com.faendir.acra.util.equalsBy
import com.fasterxml.jackson.annotation.JsonIgnore
import org.hibernate.annotations.OnDelete
import org.hibernate.annotations.OnDeleteAction
import javax.persistence.Access
import javax.persistence.AccessType
import javax.persistence.CascadeType
import javax.persistence.CollectionTable
import javax.persistence.Column
import javax.persistence.ElementCollection
import javax.persistence.Embeddable
import javax.persistence.Entity
import javax.persistence.FetchType
import javax.persistence.GeneratedValue
import javax.persistence.GenerationType
import javax.persistence.Id
import javax.persistence.OneToOne
/**
* @author Lukas
* @since 08.12.2017
*/
@Entity
class App(
val name: String,
@JsonIgnore
@OneToOne(cascade = [CascadeType.ALL], optional = false, orphanRemoval = true, fetch = FetchType.LAZY)
@OnDelete(action = OnDeleteAction.CASCADE)
var reporter: User
) {
var configuration: Configuration = Configuration()
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
val id = 0
override fun equals(other: Any?) = equalsBy(other, App::id)
override fun hashCode() = id
@Embeddable
class Configuration(
var minScore: Int = 95,
@ElementCollection(fetch = FetchType.EAGER)
@CollectionTable(name = "app_report_columns")
@Column(name = "path")
var customReportColumns: MutableList<String> = mutableListOf()
)
} | acrarium/src/main/kotlin/com/faendir/acra/model/App.kt | 952338849 |
// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.idea.maven.project
import com.intellij.openapi.Disposable
import com.intellij.openapi.externalSystem.autoimport.changes.AsyncFilesChangesListener.Companion.subscribeOnVirtualFilesChanges
import com.intellij.openapi.externalSystem.autoimport.changes.FilesChangesListener
import com.intellij.openapi.externalSystem.autoimport.settings.ReadAsyncSupplier
import com.intellij.openapi.util.io.FileUtil
import org.jetbrains.idea.maven.server.MavenDistributionsCache
import java.util.concurrent.ExecutorService
class MavenGeneralSettingsWatcher private constructor(
private val manager: MavenProjectsManager,
private val watcher: MavenProjectsManagerWatcher,
backgroundExecutor: ExecutorService,
parentDisposable: Disposable
) {
private val generalSettings get() = manager.generalSettings
private val embeddersManager get() = manager.embeddersManager
private val settingsFiles: Set<String>
get() = collectSettingsFiles().map { FileUtil.toCanonicalPath(it) }.toSet()
private fun collectSettingsFiles() = sequence {
generalSettings.effectiveUserSettingsIoFile?.path?.let { yield(it) }
generalSettings.effectiveGlobalSettingsIoFile?.path?.let { yield(it) }
}
private fun fireSettingsChange() {
embeddersManager.reset()
MavenDistributionsCache.getInstance(manager.project).cleanCaches();
watcher.scheduleUpdateAll(true, true)
}
private fun fireSettingsXmlChange() {
generalSettings.changed()
// fireSettingsChange() will be called indirectly by pathsChanged listener on GeneralSettings object
}
init {
generalSettings.addListener(::fireSettingsChange, parentDisposable)
val filesProvider = ReadAsyncSupplier.readAction(::settingsFiles, backgroundExecutor, this)
subscribeOnVirtualFilesChanges(false, filesProvider, object : FilesChangesListener {
override fun apply() = fireSettingsXmlChange()
}, parentDisposable)
}
companion object {
@JvmStatic
fun registerGeneralSettingsWatcher(
manager: MavenProjectsManager,
watcher: MavenProjectsManagerWatcher,
backgroundExecutor: ExecutorService,
parentDisposable: Disposable
) {
MavenGeneralSettingsWatcher(manager, watcher, backgroundExecutor, parentDisposable)
}
}
}
| plugins/maven/src/main/java/org/jetbrains/idea/maven/project/MavenGeneralSettingsWatcher.kt | 2066897348 |
// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.testFramework
import com.intellij.openapi.util.io.FileUtilRt
import com.intellij.openapi.vfs.LocalFileSystem
import com.intellij.openapi.vfs.VfsUtil
import com.intellij.openapi.vfs.VirtualFile
import com.intellij.openapi.vfs.refreshVfs
import com.intellij.util.SmartList
import com.intellij.util.io.*
import com.intellij.util.lang.CompoundRuntimeException
import org.junit.rules.ExternalResource
import org.junit.runner.Description
import org.junit.runners.model.Statement
import java.io.IOException
import java.nio.file.Path
import java.nio.file.Paths
import kotlin.properties.Delegates
class TemporaryDirectory : ExternalResource() {
companion object {
@JvmStatic
fun generateTemporaryPath(fileName: String): Path {
val tempDirectory = Paths.get(FileUtilRt.getTempDirectory())
var path = tempDirectory.resolve(fileName)
if (!path.exists()) {
return path
}
var i = 0
var ext = FileUtilRt.getExtension(fileName)
if (ext.isNotEmpty()) {
ext = ".$ext"
}
val name = FileUtilRt.getNameWithoutExtension(fileName)
do {
path = tempDirectory.resolve("${name}_$i$ext")
i++
}
while (path.exists() && i < 9)
if (path.exists()) {
throw IOException("Cannot generate unique random path with '$name' prefix under '$path'")
}
return path
}
}
private val paths = SmartList<Path>()
private var sanitizedName: String by Delegates.notNull()
override fun apply(base: Statement, description: Description): Statement {
sanitizedName = sanitizeFileName(description.methodName)
return super.apply(base, description)
}
override fun after() {
val errors = SmartList<Throwable>()
for (path in paths) {
try {
path.delete()
}
catch (e: Throwable) {
errors.add(e)
}
}
CompoundRuntimeException.throwIfNotEmpty(errors)
paths.clear()
}
fun newPath(directoryName: String? = null, refreshVfs: Boolean = false): Path {
val path = generatePath(directoryName)
if (refreshVfs) {
path.refreshVfs()
}
return path
}
private fun generatePath(suffix: String?): Path {
var fileName = sanitizedName
if (suffix != null) {
fileName += "_$suffix"
}
val path = generateTemporaryPath(fileName)
paths.add(path)
return path
}
fun newVirtualDirectory(directoryName: String? = null): VirtualFile {
val path = generatePath(directoryName)
path.createDirectories()
val virtualFile = LocalFileSystem.getInstance().refreshAndFindFileByPath(path.systemIndependentPath)
VfsUtil.markDirtyAndRefresh(false, true, true, virtualFile)
return virtualFile!!
}
}
fun VirtualFile.writeChild(relativePath: String, data: String) = VfsTestUtil.createFile(this, relativePath, data)
fun VirtualFile.writeChild(relativePath: String, data: ByteArray) = VfsTestUtil.createFile(this, relativePath, data) | platform/testFramework/src/com/intellij/testFramework/TemporaryDirectory.kt | 3779671372 |
/*
* WiFiAnalyzer
* Copyright (C) 2015 - 2022 VREM Software Development <[email protected]>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package com.vrem.wifianalyzer.navigation.availability
import com.vrem.wifianalyzer.MainContext
import com.vrem.wifianalyzer.R
internal val navigationOptionScannerSwitchOff: NavigationOption = {
it.optionMenu.menu?.let { menu ->
menu.findItem(R.id.action_scanner).isVisible = false
}
}
internal val navigationOptionScannerSwitchOn: NavigationOption = {
it.optionMenu.menu?.let { menu ->
val menuItem = menu.findItem(R.id.action_scanner)
menuItem.isVisible = true
if (MainContext.INSTANCE.scannerService.running()) {
menuItem.setTitle(R.string.scanner_pause)
menuItem.setIcon(R.drawable.ic_pause)
} else {
menuItem.setTitle(R.string.scanner_play)
menuItem.setIcon(R.drawable.ic_play_arrow)
}
}
}
| app/src/main/kotlin/com/vrem/wifianalyzer/navigation/availability/ScannerSwitch.kt | 1367313893 |
// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.util
import com.intellij.openapi.progress.ProgressManager
import com.intellij.util.containers.ContainerUtil
import org.jetbrains.annotations.ApiStatus
/**
* A Processor + Flow, or the Poor man's Flow: a reactive-stream-like wrapper around [Processor].
*
* Instead of creating the [Processor] manually - create a [Plow] and work with the Processor inside a lambda.
* If your method accepts the processor it is the good idea to return a [Plow] instead to avoid the "return value in parameter" semantic
*
* Itself [Plow] is stateless and ["Cold"](https://projectreactor.io/docs/core/3.3.9.RELEASE/reference/index.html#reactor.hotCold),
* meaning that the same instance of [Plow] could be reused several times (by reevaluating the sources),
* but depending on the idempotence of the [producingFunction] this contract could be violated,
* so to be careful, and it is better to obtain the new [Plow] instance each time.
*/
@ApiStatus.Experimental
class Plow<T> private constructor(private val producingFunction: (Processor<T>) -> Boolean) {
@Suppress("UNCHECKED_CAST")
fun processWith(processor: Processor<in T>): Boolean = producingFunction(processor as Processor<T>)
fun <P : Processor<T>> processTo(processor: P): P = processor.apply { producingFunction(this) }
fun findAny(): T? = processTo(CommonProcessors.FindFirstProcessor()).foundValue
fun find(test: (T) -> Boolean): T? = processTo(object : CommonProcessors.FindFirstProcessor<T>() {
override fun accept(t: T): Boolean = test(t)
}).foundValue
fun <C : MutableCollection<T>> collectTo(coll: C): C = coll.apply { processTo(CommonProcessors.CollectProcessor(this)) }
fun toList(): List<T> = ContainerUtil.unmodifiableOrEmptyList(collectTo(SmartList()))
fun toSet(): Set<T> = ContainerUtil.unmodifiableOrEmptySet(collectTo(HashSet()))
fun toArray(array: Array<T>): Array<T> = processTo(CommonProcessors.CollectProcessor()).toArray(array)
fun <R> transform(transformation: (Processor<R>) -> (Processor<T>)): Plow<R> =
Plow { pr -> producingFunction(transformation(pr)) }
fun <R> map(mapping: (T) -> R): Plow<R> = transform { pr -> Processor { v -> pr.process(mapping(v)) } }
fun <R> mapNotNull(mapping: (T) -> R?): Plow<R> = transform { pr -> Processor { v -> mapping(v)?.let { pr.process(it) } ?: true } }
fun filter(test: (T) -> Boolean): Plow<T> = transform { pr -> Processor { v -> !test(v) || pr.process(v) } }
fun <R> mapToProcessor(mapping: (T, Processor<R>) -> Boolean): Plow<R> =
Plow { rProcessor -> producingFunction(Processor { t -> mapping(t, rProcessor) }) }
fun <R> flatMap(mapping: (T) -> Plow<R>): Plow<R> = mapToProcessor { t, processor -> mapping(t).processWith(processor) }
fun cancellable(): Plow<T> = transform { pr -> Processor { v -> ProgressManager.checkCanceled();pr.process(v) } }
companion object {
@JvmStatic
fun <T> empty(): Plow<T> = of { true }
@JvmStatic
fun <T> of(processorCall: (Processor<T>) -> Boolean): Plow<T> = Plow(processorCall)
@JvmStatic
@JvmName("ofArray")
fun <T> Array<T>.toPlow(): Plow<T> = Plow { pr -> all { pr.process(it) } }
@JvmStatic
@JvmName("ofIterable")
fun <T> Iterable<T>.toPlow(): Plow<T> = Plow { pr -> all { pr.process(it) } }
@JvmStatic
fun <T> concat(vararg plows: Plow<T>): Plow<T> = of { pr -> plows.all { it.processWith(pr) } }
}
} | platform/util-ex/src/com/intellij/util/Plow.kt | 1686866196 |
// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.plugins.groovy.lang.resolve.references
import com.intellij.psi.JavaPsiFacade
import com.intellij.psi.PsiClass
import com.intellij.psi.PsiClassType
import com.intellij.psi.PsiElement
import org.jetbrains.plugins.groovy.lang.psi.api.GroovyResolveResult
import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.GrListOrMap
import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentLabel
import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList
import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrConstructorCall
import org.jetbrains.plugins.groovy.lang.resolve.api.*
class GrMapConstructorPropertyReference(element: GrArgumentLabel) : GroovyPropertyWriteReferenceBase<GrArgumentLabel>(element) {
override val receiverArgument: Argument?
get() {
val label: GrArgumentLabel = element
val namedArgument: GrNamedArgument = label.parent as GrNamedArgument // hard cast because reference must be checked before
val constructorReference: GroovyConstructorReference = requireNotNull(getConstructorReference(namedArgument))
val resolveResult: GroovyResolveResult = constructorReference.resolveClass() ?: return null
val clazz: PsiClass = resolveResult.element as? PsiClass ?: return null
val type: PsiClassType = JavaPsiFacade.getElementFactory(label.project).createType(clazz, resolveResult.substitutor)
return JustTypeArgument(type)
}
override val propertyName: String get() = requireNotNull(element.name)
override val argument: Argument? get() = (element.parent as GrNamedArgument).expression?.let(::ExpressionArgument)
companion object {
@JvmStatic
fun getConstructorReference(argument: GrNamedArgument): GroovyConstructorReference? {
val parent: PsiElement? = argument.parent
if (parent is GrListOrMap) {
return parent.constructorReference ?: getReferenceFromDirectInvocation(parent.parent)
}
return getReferenceFromDirectInvocation(parent)
}
private fun getReferenceFromDirectInvocation(element: PsiElement?) : GroovyConstructorReference? {
if (element is GrArgumentList) {
val parent: PsiElement? = element.getParent()
if (parent is GrConstructorCall) {
return parent.constructorReference
}
}
return null
}
}
}
| plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/resolve/references/GrMapConstructorPropertyReference.kt | 219632986 |
// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.workspaceModel.ide.legacyBridge
import com.intellij.facet.ModifiableFacetModel
interface ModifiableFacetModelBridge: ModifiableFacetModel {
fun prepareForCommit()
}
| platform/lang-impl/src/com/intellij/workspaceModel/ide/legacyBridge/ModifiableFacetModelBridge.kt | 3650026349 |
// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.openapi.editor.colors
import com.intellij.configurationStore.schemeManager.SchemeManagerFactoryBase
import com.intellij.ide.ui.UISettings
import com.intellij.openapi.editor.colors.impl.AbstractColorsScheme
import com.intellij.openapi.editor.colors.impl.AdditionalTextAttributesEP
import com.intellij.openapi.editor.colors.impl.EditorColorsManagerImpl
import com.intellij.testFramework.DisposableRule
import com.intellij.testFramework.ProjectRule
import com.intellij.testFramework.assertions.Assertions.assertThat
import com.intellij.testFramework.rules.InMemoryFsRule
import com.intellij.util.io.readText
import com.intellij.util.io.write
import org.junit.ClassRule
import org.junit.Rule
import org.junit.Test
class EditorColorSchemeTest {
companion object {
@JvmField
@ClassRule
val projectRule = ProjectRule()
}
@JvmField
@Rule
val disposableRule = DisposableRule()
@JvmField
@Rule
val fsRule = InMemoryFsRule()
@Test
fun loadSchemes() {
val schemeFile = fsRule.fs.getPath("colors/Foo.icls")
val schemeData = """
<scheme name="Foo" version="142" parent_scheme="Default">
<option name="EDITOR_FONT_SIZE" value="12" />
<option name="EDITOR_FONT_NAME" value="Menlo" />
<option name="JAVA_NUMBER" baseAttributes="DEFAULT_NUMBER" />
</scheme>""".trimIndent()
schemeFile.write(schemeData)
val schemeManagerFactory = SchemeManagerFactoryBase.TestSchemeManagerFactory(fsRule.fs.getPath(""))
val manager = EditorColorsManagerImpl(schemeManagerFactory)
val scheme = manager.getScheme("Foo")
assertThat(scheme.name).isEqualTo("Foo")
(scheme as AbstractColorsScheme).setSaveNeeded(true)
schemeManagerFactory.save()
// JAVA_NUMBER is removed - see isParentOverwritingInheritance
assertThat(removeSchemeMetaInfo(schemeFile.readText())).isEqualTo("""
<scheme name="Foo" version="142" parent_scheme="Default">
<option name="FONT_SCALE" value="${UISettings.defFontScale}" />
<option name="LINE_SPACING" value="1.2" />
<option name="EDITOR_FONT_SIZE" value="12" />
<option name="EDITOR_FONT_NAME" value="${scheme.editorFontName}" />
</scheme>""".trimIndent())
assertThat(schemeFile.parent).hasChildren("Foo.icls")
// test reload
val schemeNamesBeforeReload = manager.schemeManager.allSchemes.map { it.name }
schemeManagerFactory.process {
it.reload()
}
assertThat(manager.schemeManager.allSchemes
.map { it.name })
.isEqualTo(schemeNamesBeforeReload)
}
@Test
fun optimizeBundledSchemes() {
val schemeFile = fsRule.fs.getPath("colors/Foo.icls")
val schemeData = """
<scheme name="Foo" version="142" parent_scheme="Darcula">
<metaInfo>
<property name="forceOptimize">true</property>
</metaInfo>
<attributes>
<option baseAttributes="DEFAULT_CLASS_NAME" name="GO_BUILTIN_TYPE_REFERENCE" />
</attributes>
</scheme>""".trimIndent()
schemeFile.write(schemeData)
val schemeManagerFactory = SchemeManagerFactoryBase.TestSchemeManagerFactory(fsRule.fs.getPath(""))
val manager = EditorColorsManagerImpl(schemeManagerFactory)
val scheme = manager.getScheme("Foo")
assertThat(scheme.name).isEqualTo("Foo")
(scheme as AbstractColorsScheme).setSaveNeeded(true)
schemeManagerFactory.save()
// GO_BUILTIN_TYPE_REFERENCE should be removed as it's the same as defined in parent scheme
assertThat(removeSchemeMetaInfo(schemeFile.readText())).isEqualTo("""
<scheme name="Foo" version="142" parent_scheme="Darcula">
</scheme>""".trimIndent())
}
@Test
fun loadAdditionalAttributesBeforeOptimization() {
val ep = AdditionalTextAttributesEP()
ep.scheme = "Darcula"
ep.file = "com/intellij/openapi/editor/colors/foregroundForGoBuiltinTypeReference.xml"
AdditionalTextAttributesEP.EP_NAME.getPoint(null).registerExtension(ep, disposableRule.disposable)
val schemeFile = fsRule.fs.getPath("colors/Foo.icls")
val schemeData = """
<scheme name="Foo" version="142" parent_scheme="Darcula">
<metaInfo>
<property name="forceOptimize">true</property>
</metaInfo>
<attributes>
<option baseAttributes="DEFAULT_CLASS_NAME" name="GO_BUILTIN_TYPE_REFERENCE" />
</attributes>
</scheme>""".trimIndent()
schemeFile.write(schemeData)
val schemeManagerFactory = SchemeManagerFactoryBase.TestSchemeManagerFactory(fsRule.fs.getPath(""))
val manager = EditorColorsManagerImpl(schemeManagerFactory)
val scheme = manager.getScheme("Foo")
assertThat(scheme.name).isEqualTo("Foo")
(scheme as AbstractColorsScheme).setSaveNeeded(true)
schemeManagerFactory.save()
// GO_BUILTIN_TYPE_REFERENCE should not be removed as it's not the same as defined in foregroundForGoBuiltinTypeReference
assertThat(removeSchemeMetaInfo(schemeFile.readText())).isEqualTo("""
<scheme name="Foo" version="142" parent_scheme="Darcula">
<attributes>
<option name="GO_BUILTIN_TYPE_REFERENCE" baseAttributes="" />
</attributes>
</scheme>""".trimIndent())
}
}
| platform/platform-tests/testSrc/com/intellij/openapi/editor/colors/EditorColorSchemeTest.kt | 2248707792 |
package vkm.vkm.utils
import android.content.Context
import android.media.MediaPlayer
import android.util.Log
import android.widget.Toast
import com.github.kittinunf.fuel.android.core.Json
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import org.json.JSONArray
import org.json.JSONObject
import vkm.vkm.DownloadManager
import java.io.File
import java.nio.charset.Charset
import java.nio.charset.StandardCharsets
import java.security.MessageDigest
import kotlin.coroutines.resume
import kotlin.coroutines.suspendCoroutine
import kotlin.reflect.KMutableProperty
import kotlin.reflect.full.memberProperties
import kotlin.reflect.jvm.javaType
fun ByteArray?.toHexString(): String {
if (this == null || isEmpty()) { return "" }
val ret = StringBuilder()
forEach { ret.append(String.format("%02x", it)) }
return ret.toString()
}
fun ByteArray?.md5(): String {
if (this == null) { return ""}
return MessageDigest.getInstance("MD5").digest(this).toHexString()
}
fun String.md5(charset: Charset = StandardCharsets.UTF_8): String {
return toByteArray(charset).md5()
}
fun String?.beginning(length: Int): String {
if (this == null) { return "" }
return filterIndexed { index, _ -> index < length }
}
fun String?.log() {
this?.takeIf { isNotEmpty() }?.let {
Log.v("vkmLog", this)
}
}
fun String?.logE(e: Throwable? = null) {
this?.takeIf { isNotEmpty() }?.let {
Log.e("vkmLog", this, e)
}
}
fun String.toComposition(): Composition {
val composition = Composition()
val properties = split("|VKM|")
val map = mutableMapOf<String, String>()
properties.forEach { serializedProperty ->
val pair = serializedProperty.split("=VKM=")
if (pair.size > 1) {
map[pair[0]] = pair[1]
}
}
composition::class.memberProperties.forEach {
val kMutableProperty = it as KMutableProperty<*>
map[it.name]?.let { propertyValue ->
when (kMutableProperty.returnType.javaType) {
Int::class.javaPrimitiveType,
Int::class.javaObjectType -> kMutableProperty.setter.call(composition, propertyValue.toInt())
Long::class.javaPrimitiveType,
Long::class.javaObjectType -> kMutableProperty.setter.call(composition, propertyValue.toLong())
String::class.java -> kMutableProperty.setter.call(composition, propertyValue)
}
}
}
return composition
}
fun String?.toast(context: Context?, length: Int = Toast.LENGTH_SHORT): String? {
if (this == null) { return this }
val me = this
context?.let {
GlobalScope.launch(Dispatchers.Main) { Toast.makeText(context, me, length).show() }
}
return this
}
fun String?.normalize() : String? {
if (this == null) { return null }
return this.trim().toLowerCase().replace(" ", "")
}
fun Composition.serialize(): String {
return Composition::class.memberProperties.joinToString(separator = "|VKM|") { "${it.name}=VKM=${it.get(this)}" }
}
fun Composition.matches(string: String): Boolean {
return name.contains(string) || artist.contains(string)
}
fun Composition.fileName(): String {
val artistNormalized = artist.trim().beginning(32).replace(' ', '_').replace('/', '_')
val nameNormalized = name.trim().beginning(32).replace(' ', '_').replace('/', '_')
return "$artistNormalized-$nameNormalized.mp3"
}
fun Composition.localFile(): File? {
val file = DownloadManager.getDownloadDir().resolve(fileName())
return if (file.exists()) file else null
}
fun Composition?.equalsTo(other: Composition?): Boolean {
return this?.name.normalize() == other?.name.normalize() && this?.artist.normalize() == other?.artist.normalize()
}
suspend fun MediaPlayer.loadAsync() {
suspendCoroutine<Unit> { continuation ->
this.setOnPreparedListener { continuation.resume(Unit) }
this.prepareAsync()
}
}
fun JSONObject.gets(name: String): String {
return try {
this.get(name).toString()
} catch (e: Exception) {
""
}
}
fun JSONObject.geta(name: String): JSONArray {
return try {
this.getJSONArray(name)
} catch (e: Exception) {
JSONArray("[]")
}
}
fun JSONObject.geto(name: String): JSONObject {
return try {
this.getJSONObject(name)
} catch (e: Exception) {
JSONObject("{}")
}
}
fun JSONObject.getl(name: String): Long {
return try {
this.getLong(name)
} catch (e: Exception) {
0L
}
}
fun <R> JSONArray.map(action: (obj: JSONObject) -> R): MutableList<R> {
return (0 until this.length()).map {
action(this.get(it) as JSONObject)
}.toMutableList()
}
fun <R> JSONArray.mapArr(action: (obj: JSONArray) -> R): MutableList<R> {
return (0 until this.length()).map {
action(this.get(it) as JSONArray)
}.toMutableList()
}
fun Json?.safeObj(): JSONObject {
return try {
this?.obj() ?: JSONObject()
} catch (e: Exception) {
JSONObject()
}
}
fun Json?.safeArr(): JSONArray {
return try {
this?.array() ?: JSONArray()
} catch (e: Exception) {
JSONArray()
}
} | app/src/main/java/vkm/vkm/utils/Extensions.kt | 1805954557 |
package com.aerodeko.pfm.model
import java.util.*
/**
* Created by rm on 28/12/2016.
*/
// TODO: amount should be Long
data class Budget(val name: String, val amount: Double, val startDate: Date, val endDate: Date) {
// val daysInBudget: Long {
// val
// }
}
| app/src/main/java/com/aerodeko/pfm/model/Budget.kt | 3794800501 |
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
import kotlin.text.*
import kotlin.test.*
fun assertTrue(msg: String, value: Boolean) = assertTrue(value, msg)
fun assertFalse(msg: String, value: Boolean) = assertFalse(value, msg)
internal var testPatterns = arrayOf("(a|b)*abb", "(1*2*3*4*)*567", "(a|b|c|d)*aab", "(1|2|3|4|5|6|7|8|9|0)(1|2|3|4|5|6|7|8|9|0)*", "(abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ)*", "(a|b)*(a|b)*A(a|b)*lice.*", "(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)(a|b|c|d|e|f|g|h|" + "i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)*(1|2|3|4|5|6|7|8|9|0)*|while|for|struct|if|do")
internal var groupPatterns = arrayOf("(a|b)*aabb", "((a)|b)*aabb", "((a|b)*)a(abb)", "(((a)|(b))*)aabb", "(((a)|(b))*)aa(b)b", "(((a)|(b))*)a(a(b)b)")
fun testReplaceAll() {
val input = "aabfooaabfooabfoob"
val pattern = "a*b"
val regex = Regex(pattern)
assertEquals("-foo-foo-foo-", regex.replace(input, "-"))
}
fun testReplaceFirst() {
val input = "zzzdogzzzdogzzz"
val pattern = "dog"
val regex = Regex(pattern)
assertEquals("zzzcatzzzdogzzz", regex.replaceFirst(input, "cat"))
}
/*
* Class under test for String group(int)
*/
fun testGroupint() {
val positiveTestString = "ababababbaaabb"
// test IndexOutOfBoundsException
// //
for (i in groupPatterns.indices) {
val regex = Regex(groupPatterns[i])
val result = regex.matchEntire(positiveTestString)!!
try {
// groupPattern <index + 1> equals to number of groups
// of the specified pattern
// //
result.groups[i + 2]
fail("IndexOutBoundsException expected")
result.groups[i + 100]
fail("IndexOutBoundsException expected")
result.groups[-1]
fail("IndexOutBoundsException expected")
result.groups[-100]
fail("IndexOutBoundsException expected")
} catch (e: IndexOutOfBoundsException) {
}
}
val groupResults = arrayOf(
arrayOf("a"),
arrayOf("a", "a"),
arrayOf("ababababba", "a", "abb"),
arrayOf("ababababba", "a", "a", "b"),
arrayOf("ababababba", "a", "a", "b", "b"),
arrayOf("ababababba", "a", "a", "b", "abb", "b")
)
for (i in groupPatterns.indices) {
val regex = Regex(groupPatterns[i])
val result = regex.matchEntire(positiveTestString)!!
for (j in 0..groupResults[i].size - 1) {
assertEquals(groupResults[i][j], result.groupValues[j + 1], "i: $i j: $j")
}
}
}
fun testGroup() {
val positiveTestString = "ababababbaaabb"
val negativeTestString = "gjhfgdsjfhgcbv"
for (element in groupPatterns) {
val regex = Regex(element)
val result = regex.matchEntire(positiveTestString)!!
assertEquals(positiveTestString, result.groupValues[0])
assertEquals(positiveTestString, result.groups[0]!!.value)
assertEquals(0 until positiveTestString.length, result.groups[0]!!.range)
}
for (element in groupPatterns) {
val regex = Regex(element)
val result = regex.matchEntire(negativeTestString)
assertEquals(result, null)
}
}
fun testGroupPossessive() {
val regex = Regex("((a)|(b))++c")
assertEquals("a", regex.matchEntire("aac")!!.groupValues[1])
}
fun testMatchesMisc() {
val posSeq = arrayOf(
arrayOf("abb", "ababb", "abababbababb", "abababbababbabababbbbbabb"),
arrayOf("213567", "12324567", "1234567", "213213567", "21312312312567", "444444567"),
arrayOf("abcdaab", "aab", "abaab", "cdaab", "acbdadcbaab"),
arrayOf("213234567", "3458", "0987654", "7689546432", "0398576", "98432", "5"),
arrayOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"),
arrayOf("ababbaAabababblice", "ababbaAliceababab", "ababbAabliceaaa", "abbbAbbbliceaaa", "Alice"),
arrayOf("a123", "bnxnvgds156", "for", "while", "if", "struct"))
for (i in testPatterns.indices) {
val regex = Regex(testPatterns[i])
for (j in 0..posSeq[i].size - 1) {
assertTrue("Incorrect match: " + testPatterns[i] + " vs " + posSeq[i][j], regex.matches(posSeq[i][j]))
}
}
}
fun testMatchesQuantifiers() {
val testPatternsSingles = arrayOf("a{5}", "a{2,4}", "a{3,}")
val testPatternsMultiple = arrayOf("((a)|(b)){1,2}abb", "((a)|(b)){2,4}", "((a)|(b)){3,}")
val stringSingles = arrayOf(
arrayOf("aaaaa", "aaa"),
arrayOf("aa", "a", "aaa", "aaaaaa", "aaaa", "aaaaa"),
arrayOf("aaa", "a", "aaaa", "aa")
)
val stringMultiples = arrayOf(
arrayOf("ababb", "aba"),
arrayOf("ab", "b", "bab", "ababa", "abba", "abababbb"),
arrayOf("aba", "b", "abaa", "ba")
)
for (i in testPatternsSingles.indices) {
val regex = Regex(testPatternsSingles[i])
for (j in 0..stringSingles.size / 2 - 1) {
assertTrue("Match expected, but failed: " + regex.pattern + " : " + stringSingles[i][j],
regex.matches(stringSingles[i][j * 2])
)
assertFalse("Match failure expected, but match succeed: " + regex.pattern + " : " + stringSingles[i][j * 2 + 1],
regex.matches(stringSingles[i][j * 2 + 1])
)
}
}
for (i in testPatternsMultiple.indices) {
val regex = Regex(testPatternsMultiple[i])
for (j in 0..stringMultiples.size / 2 - 1) {
assertTrue("Match expected, but failed: " + regex.pattern + " : " + stringMultiples[i][j],
regex.matches(stringMultiples[i][j * 2])
)
assertFalse("Match failure expected, but match succeed: " + regex.pattern + " : " + stringMultiples[i][j * 2 + 1],
regex.matches(stringMultiples[i][j * 2 + 1])
)
}
}
// Test for the optimized '.+' quantifier node.
assertFalse(Regex(".+abc").matches("abc"))
assertFalse(Regex(".+\nabc", RegexOption.DOT_MATCHES_ALL).matches("\nabc"))
assertFalse(Regex(".+").matches(""))
assertFalse(Regex(".+\n", RegexOption.DOT_MATCHES_ALL).matches("\n"))
assertFalse(Regex(".+abc").containsMatchIn("abc"))
assertFalse(Regex(".+\nabc", RegexOption.DOT_MATCHES_ALL).containsMatchIn("\nabc"))
assertFalse(Regex(".+").containsMatchIn(""))
assertFalse(Regex(".+\n", RegexOption.DOT_MATCHES_ALL).containsMatchIn("\n"))
assertTrue(Regex(".+abc").matches("aabc"))
assertTrue(Regex(".+\nabc", RegexOption.DOT_MATCHES_ALL).matches("a\nabc"))
assertTrue(Regex(".+").matches("a"))
assertTrue(Regex(".+\n", RegexOption.DOT_MATCHES_ALL).matches("a\n"))
assertTrue(Regex(".+abc").containsMatchIn("aabc"))
assertTrue(Regex(".+\nabc", RegexOption.DOT_MATCHES_ALL).containsMatchIn("a\nabc"))
assertTrue(Regex(".+").containsMatchIn("a"))
assertTrue(Regex(".+\n", RegexOption.DOT_MATCHES_ALL).containsMatchIn("a\n"))
}
fun testQuantVsGroup() {
val patternString = "(d{1,3})((a|c)*)(d{1,3})((a|c)*)(d{1,3})"
val testString = "dacaacaacaaddaaacaacaaddd"
val regex = Regex(patternString)
val result = regex.matchEntire(testString)!!
assertEquals("dacaacaacaaddaaacaacaaddd", result.groupValues[0])
assertEquals("d", result.groupValues[1])
assertEquals("acaacaacaa", result.groupValues[2])
assertEquals("dd", result.groupValues[4])
assertEquals("aaacaacaa", result.groupValues[5])
assertEquals("ddd", result.groupValues[7])
}
/*
* Class under test for boolean find()
*/
fun testFind() {
var testPattern = "(abb)"
var testString = "cccabbabbabbabbabb"
val regex = Regex(testPattern)
var result = regex.find(testString)
var start = 3
var end = 6
while (result != null) {
assertEquals(start, result.groups[1]!!.range.start)
assertEquals(end, result.groups[1]!!.range.endInclusive + 1)
start = end
end += 3
result = result.next()
}
testPattern = "(\\d{1,3})"
testString = "aaaa123456789045"
val regex2 = Regex(testPattern)
var result2 = regex2.find(testString)
start = 4
val length = 3
while (result2 != null) {
assertEquals(testString.substring(start, start + length), result2.groupValues[1])
start += length
result2 = result2.next()
}
}
fun testSEOLsymbols() {
val regex = Regex("^a\\(bb\\[$")
assertTrue(regex.matches("a(bb["))
}
fun testGroupCount() {
for (i in groupPatterns.indices) {
val regex = Regex(groupPatterns[i])
val result = regex.matchEntire("ababababbaaabb")!!
assertEquals(i + 1, result.groups.size - 1)
}
}
fun testReluctantQuantifiers() {
val regex = Regex("(ab*)*b")
val result = regex.matchEntire("abbbb")
if (result != null) {
assertEquals("abbb", result.groupValues[1])
} else {
fail("Match expected: (ab*)*b vs abbbb")
}
}
fun testEnhancedFind() {
val input = "foob"
val pattern = "a*b"
val regex = Regex(pattern)
val result = regex.find(input)!!
assertEquals("b", result.groupValues[0])
}
fun testPosCompositeGroup() {
val posExamples = arrayOf("aabbcc", "aacc", "bbaabbcc")
val negExamples = arrayOf("aabb", "bb", "bbaabb")
val posPat = Regex("(aa|bb){1,3}+cc")
val negPat = Regex("(aa|bb){1,3}+bb")
for (element in posExamples) {
assertTrue(posPat.matches(element))
}
for (element in negExamples) {
assertFalse(negPat.matches(element))
}
assertTrue(Regex("(aa|bb){1,3}+bb").matches("aabbaabb"))
}
fun testPosAltGroup() {
val posExamples = arrayOf("aacc", "bbcc", "cc")
val negExamples = arrayOf("bb", "aa")
val posPat = Regex("(aa|bb)?+cc")
val negPat = Regex("(aa|bb)?+bb")
for (element in posExamples) {
assertTrue(posPat.toString() + " vs: " + element, posPat.matches(element))
}
for (element in negExamples) {
assertFalse(negPat.matches(element))
}
assertTrue(Regex("(aa|bb)?+bb").matches("aabb"))
}
fun testRelCompGroup() {
var res = ""
for (i in 0..3) {
val regex = Regex("((aa|bb){$i,3}?).*cc")
val result = regex.matchEntire("aaaaaacc")
assertTrue(regex.toString() + " vs: " + "aaaaaacc", result != null)
assertEquals(res, result!!.groupValues[1])
res += "aa"
}
}
fun testRelAltGroup() {
var regex = Regex("((aa|bb)??).*cc")
var result = regex.matchEntire("aacc")
assertTrue(regex.toString() + " vs: " + "aacc", result != null)
assertEquals("", result!!.groupValues[1])
regex = Regex("((aa|bb)??)cc")
result = regex.matchEntire("aacc")
assertTrue(regex.toString() + " vs: " + "aacc", result != null)
assertEquals("aa", result!!.groupValues[1])
}
fun testIgnoreCase() {
var regex = Regex("(aa|bb)*", RegexOption.IGNORE_CASE)
assertTrue(regex.matches("aAbb"))
regex = Regex("(a|b|c|d|e)*", RegexOption.IGNORE_CASE)
assertTrue(regex.matches("aAebbAEaEdebbedEccEdebbedEaedaebEbdCCdbBDcdcdADa"))
regex = Regex("[a-e]*", RegexOption.IGNORE_CASE)
assertTrue(regex.matches("aAebbAEaEdebbedEccEdebbedEaedaebEbdCCdbBDcdcdADa"))
}
fun testQuoteReplacement() {
assertEquals("\\\\aaCC\\$1", Regex.escapeReplacement("\\aaCC$1"))
}
fun testOverFlow() {
var regex = Regex("(a*)*")
var result = regex.matchEntire("aaa")
assertTrue(result != null)
assertEquals("", result!!.groupValues[1])
assertTrue(Regex("(1+)\\1+").matches("11"))
assertTrue(Regex("(1+)(2*)\\2+").matches("11"))
regex = Regex("(1+)\\1*")
result = regex.matchEntire("11")
assertTrue(result != null)
assertEquals("11", result!!.groupValues[1])
regex = Regex("((1+)|(2+))(\\2+)")
result = regex.matchEntire("11")
assertTrue(result != null)
assertEquals("1", result!!.groupValues[2])
assertEquals("1", result.groupValues[1])
assertEquals("1", result.groupValues[4])
assertEquals("", result.groupValues[3])
}
fun testUnicode() {
assertTrue(Regex("\\x61a").matches("aa"))
assertTrue(Regex("\\u0061a").matches("aa"))
assertTrue(Regex("\\0141a").matches("aa"))
assertTrue(Regex("\\0777").matches("?7"))
}
fun testUnicodeCategory() {
assertTrue(Regex("\\p{Ll}").matches("k")) // Unicode lower case
assertTrue(Regex("\\P{Ll}").matches("K")) // Unicode non-lower
// case
assertTrue(Regex("\\p{Lu}").matches("K")) // Unicode upper case
assertTrue(Regex("\\P{Lu}").matches("k")) // Unicode non-upper
// case combinations
assertTrue(Regex("[\\p{L}&&[^\\p{Lu}]]").matches("k"))
assertTrue(Regex("[\\p{L}&&[^\\p{Ll}]]").matches("K"))
assertFalse(Regex("[\\p{L}&&[^\\p{Lu}]]").matches("K"))
assertFalse(Regex("[\\p{L}&&[^\\p{Ll}]]").matches("k"))
// category/character combinations
assertFalse(Regex("[\\p{L}&&[^a-z]]").matches("k"))
assertTrue(Regex("[\\p{L}&&[^a-z]]").matches("K"))
assertTrue(Regex("[\\p{Lu}a-z]").matches("k"))
assertTrue(Regex("[a-z\\p{Lu}]").matches("k"))
assertFalse(Regex("[\\p{Lu}a-d]").matches("k"))
assertTrue(Regex("[a-d\\p{Lu}]").matches("K"))
assertFalse(Regex("[\\p{L}&&[^\\p{Lu}&&[^G]]]").matches("K"))
}
fun testSplitEmpty() {
val regex = Regex("")
val s = regex.split("", 0)
assertEquals(1, s.size)
assertEquals("", s[0])
}
fun testFindDollar() {
val regex = Regex("a$")
val result = regex.find("a\n")
assertTrue(result != null)
assertEquals("a", result!!.groupValues[0])
}
/*
* Regression test for HARMONY-674
*/
fun testPatternMatcher() {
assertTrue(Regex("(?:\\d+)(?:pt)").matches("14pt"))
}
/**
* Inspired by HARMONY-3360
*/
fun test3360() {
val str = "!\"#%&'(),-./"
val regex = Regex("\\s")
assertFalse(regex.containsMatchIn(str))
}
/**
* Regression test for HARMONY-3360
*/
fun testGeneralPunctuationCategory() {
val s = arrayOf(",", "!", "\"", "#", "%", "&", "'", "(", ")", "-", ".", "/")
val regexp = "\\p{P}"
for (i in s.indices) {
val regex = Regex(regexp)
assertTrue(regex.containsMatchIn(s[i]))
}
}
fun box() {
testReplaceAll()
testReplaceFirst()
testGroupint()
testGroup()
testGroupPossessive()
testMatchesMisc()
testMatchesQuantifiers()
testQuantVsGroup()
testFind()
testSEOLsymbols()
testGroupCount()
testReluctantQuantifiers()
testEnhancedFind()
testPosCompositeGroup()
testPosAltGroup()
testRelCompGroup()
testRelAltGroup()
testIgnoreCase()
testQuoteReplacement()
testOverFlow()
testUnicode()
testUnicodeCategory()
testSplitEmpty()
testFindDollar()
testPatternMatcher()
test3360()
testGeneralPunctuationCategory()
} | backend.native/tests/external/stdlib/text/RegexTest/harmony/MatchResultTest.kt | 894997346 |
// TODO: muted automatically, investigate should it be ran for JS or not
// IGNORE_BACKEND: JS, NATIVE
data class A(val s: String) : Cloneable {
fun externalClone(): A = clone() as A
}
fun box(): String {
val a = A("OK")
val b = a.externalClone()
if (a != b) return "Fail equals"
if (a === b) return "Fail identity"
return b.s
}
| backend.native/tests/external/codegen/box/javaInterop/objectMethods/cloneableClassWithoutClone.kt | 4046163373 |
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue
import kotlin.test.*
fun box() {
assertEquals(listOf(3, 2, 1), listOf(1, 2, 3).asReversed())
assertEquals(listOf(3, 2, 1), listOf(1, 2, 3).asReversed().toList())
}
| backend.native/tests/external/stdlib/collections/ReversedViewsTest/testSimple.kt | 273742694 |
//inspired by kt3492
interface Base {
val foo: String
fun bar(): String
}
abstract class KWithOverride : Base {
override val foo = bar()
}
abstract class K : KWithOverride() {
}
class A : K() {
override val foo = "A.foo"
override fun bar() = "A.bar"
inner class B : K() {
override val foo = "B.foo"
override fun bar() = "B.bar"
fun test1() = super<K>@A.foo
fun test2() = super<K>@B.foo
fun test3() = super<K>.foo
fun test4() = [email protected]
fun test5() = [email protected]
fun test6() = super.foo
}
}
fun box(): String {
val b = A().B()
if (b.test1() != "A.bar") return "test1 ${b.test1()}"
if (b.test2() != "B.bar") return "test2 ${b.test2()}"
if (b.test3() != "B.bar") return "test3 ${b.test3()}"
if (b.test4() != "A.bar") return "test4 ${b.test4()}"
if (b.test5() != "B.bar") return "test5 ${b.test5()}"
if (b.test6() != "B.bar") return "test6 ${b.test6()}"
return "OK"
}
| backend.native/tests/external/codegen/box/super/innerClassLabeledSuperProperty2.kt | 3637318942 |
fun box(): String {
val l = ArrayList<Int>()
l.add(2)
val sb = StringBuilder()
for (i in l[0]..3) {
sb.append(i)
}
if (sb.toString() != "23") return "Fail: $sb}"
return "OK"
} | backend.native/tests/external/codegen/box/platformTypes/primitives/rangeTo.kt | 2628252469 |
open class Father(val param: String) {
abstract inner class InClass {
fun work(): String {
return param
}
}
inner class Child(p: String) : Father(p) {
fun test(): InClass {
class Local : Father.InClass() {
}
return Local()
}
}
}
fun box(): String {
return Father("fail").Child("OK").test().work()
} | backend.native/tests/external/codegen/box/innerNested/superConstructorCall/localExtendsInner.kt | 2832551675 |
// See also KT-6299
public open class Outer private constructor(val s: String) {
inner class Inner: Outer("O") {
fun foo(): String {
return this.s + [email protected]
}
}
class Nested: Outer("K")
fun bar() = Inner()
}
fun box(): String {
val inner = Outer.Nested().bar()
return inner.foo()
} | backend.native/tests/external/codegen/box/privateConstructors/inner.kt | 835209387 |
@file:JvmName("InvalidParameterUtils")
package com.vimeo.networking2
import com.squareup.moshi.Json
import com.squareup.moshi.JsonClass
import com.vimeo.networking2.enums.ErrorCodeType
import com.vimeo.networking2.enums.asEnum
/**
* Similar to [ApiError] object, this holds error codes/error messages relevant to a specific invalid field.
*
* @param field Name of the invalid field.
* @param errorCode Error code for the invalid field. See [ApiError.errorCodeType].
* @param error The user readable error message detailing why the request was invalid.
* @param developerMessage Detailed description of why the field is invalid.
*/
@JsonClass(generateAdapter = true)
data class InvalidParameter(
@Json(name = "field")
val field: String? = null,
@Json(name = "error_code")
val errorCode: String? = null,
@Json(name = "error")
val error: String? = null,
@Json(name = "developer_message")
val developerMessage: String? = null
)
/**
* @see InvalidParameter.errorCode
* @see ErrorCodeType
*/
val InvalidParameter.errorCodeType: ErrorCodeType
get() = errorCode.asEnum(ErrorCodeType.DEFAULT)
| models/src/main/java/com/vimeo/networking2/InvalidParameter.kt | 2015122653 |
// Copyright 2015-present 650 Industries. All rights reserved.
package abi42_0_0.expo.modules.permissions
import android.Manifest
import android.content.Context
import android.os.Bundle
import abi42_0_0.expo.modules.interfaces.permissions.Permissions
import abi42_0_0.expo.modules.interfaces.permissions.PermissionsResponse
import abi42_0_0.expo.modules.interfaces.permissions.PermissionsResponseListener
import abi42_0_0.expo.modules.permissions.requesters.BackgroundLocationRequester
import abi42_0_0.expo.modules.permissions.requesters.ForegroundLocationRequester
import abi42_0_0.expo.modules.permissions.requesters.LegacyLocationRequester
import abi42_0_0.expo.modules.permissions.requesters.NotificationRequester
import abi42_0_0.expo.modules.permissions.requesters.PermissionRequester
import abi42_0_0.expo.modules.permissions.requesters.RemindersRequester
import abi42_0_0.expo.modules.permissions.requesters.SimpleRequester
import abi42_0_0.org.unimodules.core.ExportedModule
import abi42_0_0.org.unimodules.core.ModuleRegistry
import abi42_0_0.org.unimodules.core.Promise
import abi42_0_0.org.unimodules.core.interfaces.ExpoMethod
internal const val ERROR_TAG = "ERR_PERMISSIONS"
class PermissionsModule(context: Context) : ExportedModule(context) {
private lateinit var mPermissions: Permissions
private lateinit var mRequesters: Map<String, PermissionRequester>
@Throws(IllegalStateException::class)
override fun onCreate(moduleRegistry: ModuleRegistry) {
mPermissions = moduleRegistry.getModule(Permissions::class.java)
?: throw IllegalStateException("Couldn't find implementation for Permissions interface.")
val notificationRequester = NotificationRequester(context)
val contactsRequester = if (mPermissions.isPermissionPresentInManifest(Manifest.permission.WRITE_CONTACTS)) {
SimpleRequester(Manifest.permission.WRITE_CONTACTS, Manifest.permission.READ_CONTACTS)
} else {
SimpleRequester(Manifest.permission.READ_CONTACTS)
}
mRequesters = mapOf(
// Legacy requester
PermissionsTypes.LOCATION.type to LegacyLocationRequester(
if (android.os.Build.VERSION.SDK_INT == android.os.Build.VERSION_CODES.Q) {
mPermissions.isPermissionPresentInManifest(Manifest.permission.ACCESS_BACKGROUND_LOCATION)
} else {
false
}
),
PermissionsTypes.LOCATION_FOREGROUND.type to ForegroundLocationRequester(),
PermissionsTypes.LOCATION_BACKGROUND.type to BackgroundLocationRequester(),
PermissionsTypes.CAMERA.type to SimpleRequester(Manifest.permission.CAMERA),
PermissionsTypes.CONTACTS.type to contactsRequester,
PermissionsTypes.AUDIO_RECORDING.type to SimpleRequester(Manifest.permission.RECORD_AUDIO),
PermissionsTypes.MEDIA_LIBRARY_WRITE_ONLY.type to SimpleRequester(Manifest.permission.WRITE_EXTERNAL_STORAGE),
PermissionsTypes.MEDIA_LIBRARY.type to SimpleRequester(Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE),
PermissionsTypes.CALENDAR.type to SimpleRequester(Manifest.permission.READ_CALENDAR, Manifest.permission.WRITE_CALENDAR),
PermissionsTypes.SMS.type to SimpleRequester(Manifest.permission.READ_SMS),
PermissionsTypes.NOTIFICATIONS.type to notificationRequester,
PermissionsTypes.USER_FACING_NOTIFICATIONS.type to notificationRequester,
PermissionsTypes.SYSTEM_BRIGHTNESS.type to SimpleRequester(Manifest.permission.WRITE_SETTINGS),
PermissionsTypes.REMINDERS.type to RemindersRequester()
)
}
@Throws(IllegalStateException::class)
private fun getRequester(permissionType: String): PermissionRequester {
return mRequesters[permissionType]
?: throw IllegalStateException("Unrecognized permission type: $permissionType")
}
override fun getName(): String = "ExpoPermissions"
@ExpoMethod
fun getAsync(requestedPermissionsTypes: ArrayList<String>, promise: Promise) {
try {
delegateToPermissionsServiceIfNeeded(requestedPermissionsTypes, mPermissions::getPermissions, promise)
} catch (e: IllegalStateException) {
promise.reject(ERROR_TAG + "_UNKNOWN", "Failed to get permissions", e)
}
}
@ExpoMethod
fun askAsync(requestedPermissionsTypes: ArrayList<String>, promise: Promise) {
try {
delegateToPermissionsServiceIfNeeded(requestedPermissionsTypes, mPermissions::askForPermissions, promise)
} catch (e: IllegalStateException) {
promise.reject(ERROR_TAG + "_UNKNOWN", "Failed to get permissions", e)
}
}
private fun createPermissionsResponseListener(requestedPermissionsTypes: ArrayList<String>, promise: Promise) =
PermissionsResponseListener { permissionsNativeStatus ->
promise.resolve(parsePermissionsResponse(requestedPermissionsTypes, permissionsNativeStatus))
}
private fun delegateToPermissionsServiceIfNeeded(permissionTypes: ArrayList<String>, permissionsServiceDelegate: (PermissionsResponseListener, Array<out String>) -> Unit, promise: Promise) {
val androidPermissions = getAndroidPermissionsFromList(permissionTypes)
// Some permissions like `NOTIFICATIONS` or `USER_FACING_NOTIFICATIONS` aren't supported by the android.
// So, if the user asks/gets those permissions, we can return status immediately.
if (androidPermissions.isEmpty()) {
// We pass an empty map here cause those permissions don't depend on the system result.
promise.resolve(parsePermissionsResponse(permissionTypes, emptyMap()))
return
}
permissionsServiceDelegate(createPermissionsResponseListener(permissionTypes, promise), androidPermissions)
}
@Throws(IllegalStateException::class)
private fun parsePermissionsResponse(requestedPermissionsTypes: List<String>, permissionMap: Map<String, PermissionsResponse>): Bundle {
return Bundle().apply {
requestedPermissionsTypes.forEach {
putBundle(it, getRequester(it).parseAndroidPermissions(permissionMap))
}
}
}
@Throws(IllegalStateException::class)
private fun getAndroidPermissionsFromList(requestedPermissionsTypes: List<String>): Array<String> {
return requestedPermissionsTypes
.map { getRequester(it).getAndroidPermissions() }
.reduce { acc, list -> acc + list }
.toTypedArray()
}
}
| android/versioned-abis/expoview-abi42_0_0/src/main/java/abi42_0_0/expo/modules/permissions/PermissionsModule.kt | 3722197917 |
// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.plugins.groovy.lang.psi.patterns
import com.intellij.patterns.ElementPattern
import com.intellij.patterns.PatternCondition
import com.intellij.psi.PsiMethod
import com.intellij.util.ProcessingContext
import org.jetbrains.plugins.groovy.lang.psi.api.GroovyMethodResult
import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList
import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrCall
class GroovyClosurePattern : GroovyExpressionPattern<GrClosableBlock, GroovyClosurePattern>(GrClosableBlock::class.java) {
fun inMethod(methodPattern: ElementPattern<out PsiMethod>): GroovyClosurePattern {
return with(object : PatternCondition<GrClosableBlock>("closureInMethod") {
override fun accepts(closure: GrClosableBlock, context: ProcessingContext?): Boolean {
val call = getCall(closure) ?: return false
context?.put(closureCallKey, call)
val method = call.resolveMethod() ?: return false
return methodPattern.accepts(method)
}
})
}
fun inMethodResult(condition: PatternCondition<in GroovyMethodResult>): GroovyClosurePattern {
return with(object : PatternCondition<GrClosableBlock>("closureInMethodResult") {
override fun accepts(closure: GrClosableBlock, context: ProcessingContext?): Boolean {
val call = getCall(closure) ?: return false
context?.put(closureCallKey, call)
val result = call.advancedResolve() as? GroovyMethodResult ?: return false
return condition.accepts(result, context)
}
})
}
companion object {
private fun getCall(closure: GrClosableBlock): GrCall? {
val parent = closure.parent
when (parent) {
is GrCall -> {
return if (closure in parent.closureArguments) parent else null
}
is GrArgumentList -> {
val grandParent = parent.parent as? GrCall ?: return null
if (grandParent.closureArguments.isNotEmpty()) return null
if (grandParent.expressionArguments.lastOrNull() != closure) return null
return grandParent
}
else -> return null
}
}
}
} | plugins/groovy/groovy-psi/src/org/jetbrains/plugins/groovy/lang/psi/patterns/GroovyClosurePattern.kt | 2664803863 |
// FIR_COMPARISON
/// KT-1187 Wrong unnecessary completion
fun anyfun() {
a.b.c.d.e.f.<caret>
}
// INVOCATION_COUNT: 2
// NUMBER: 0 | plugins/kotlin/completion/tests/testData/basic/common/noCompletion/DoNotCompleteForErrorReceiversForce.kt | 1929518167 |
fun foo() {
if
(true) {
}
while
(true) {
}
for
(i in 0..42) {
}
}
// SET_FALSE: KEEP_LINE_BREAKS
| plugins/kotlin/idea/tests/testData/formatter/KeepLineBreak.after.inv.kt | 2228947654 |
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.scripting.ide_services.compiler.impl
import com.intellij.psi.PsiElement
import com.intellij.psi.tree.TokenSet
import org.jetbrains.kotlin.builtins.isFunctionType
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor
import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl
import org.jetbrains.kotlin.idea.codeInsight.ReferenceVariantsHelper
import org.jetbrains.kotlin.idea.util.CallTypeAndReceiver
import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
import org.jetbrains.kotlin.idea.util.getResolutionScope
import org.jetbrains.kotlin.lexer.KtKeywordToken
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.endOffset
import org.jetbrains.kotlin.psi.psiUtil.quoteIfNeeded
import org.jetbrains.kotlin.psi.psiUtil.startOffset
import org.jetbrains.kotlin.renderer.ClassifierNamePolicy
import org.jetbrains.kotlin.renderer.ParameterNameRenderingPolicy
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.DescriptorUtils
import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
import org.jetbrains.kotlin.resolve.scopes.LexicalScope
import org.jetbrains.kotlin.resolve.scopes.MemberScope.Companion.ALL_NAME_FILTER
import org.jetbrains.kotlin.scripting.ide_services.compiler.completion
import org.jetbrains.kotlin.scripting.ide_services.compiler.filterOutShadowedDescriptors
import org.jetbrains.kotlin.scripting.ide_services.compiler.nameFilter
import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.types.asFlexibleType
import org.jetbrains.kotlin.types.isFlexible
import java.io.File
import java.util.*
import kotlin.script.experimental.api.ScriptCompilationConfiguration
import kotlin.script.experimental.api.SourceCodeCompletionVariant
fun getKJvmCompletion(
ktScript: KtFile,
bindingContext: BindingContext,
resolutionFacade: KotlinResolutionFacadeForRepl,
moduleDescriptor: ModuleDescriptor,
cursor: Int,
configuration: ScriptCompilationConfiguration
) = KJvmReplCompleter(
ktScript,
bindingContext,
resolutionFacade,
moduleDescriptor,
cursor,
configuration
).getCompletion()
// Insert a constant string right after a cursor position to make this identifiable as a simple reference
// For example, code line
// import java.
// ^
// is converted to
// import java.ABCDEF
// and it makes token after dot (for which reference variants are looked) discoverable in PSI
fun prepareCodeForCompletion(code: String, cursor: Int) =
code.substring(0, cursor) + KJvmReplCompleter.INSERTED_STRING + code.substring(cursor)
private class KJvmReplCompleter(
private val ktScript: KtFile,
private val bindingContext: BindingContext,
private val resolutionFacade: KotlinResolutionFacadeForRepl,
private val moduleDescriptor: ModuleDescriptor,
private val cursor: Int,
private val configuration: ScriptCompilationConfiguration
) {
private fun getElementAt(cursorPos: Int): PsiElement? {
var element: PsiElement? = ktScript.findElementAt(cursorPos)
while (element !is KtExpression && element != null) {
element = element.parent
}
return element
}
fun getCompletion() = sequence<SourceCodeCompletionVariant> gen@{
val filterOutShadowedDescriptors = configuration[ScriptCompilationConfiguration.completion.filterOutShadowedDescriptors]!!
val nameFilter = configuration[ScriptCompilationConfiguration.completion.nameFilter]!!
val element = getElementAt(cursor)
var descriptors: Collection<DeclarationDescriptor>? = null
var isTipsManagerCompletion = true
var isSortNeeded = true
if (element == null)
return@gen
val simpleExpression = when {
element is KtSimpleNameExpression -> element
element.parent is KtSimpleNameExpression -> element.parent as KtSimpleNameExpression
else -> null
}
if (simpleExpression != null) {
val inDescriptor: DeclarationDescriptor = simpleExpression.getResolutionScope(bindingContext, resolutionFacade).ownerDescriptor
val prefix = element.text.substring(0, cursor - element.startOffset)
val elementParent = element.parent
if (prefix.isEmpty() && elementParent is KtBinaryExpression) {
val parentChildren = elementParent.children
if (parentChildren.size == 3 &&
parentChildren[1] is KtOperationReferenceExpression &&
parentChildren[1].text == INSERTED_STRING
) return@gen
}
isSortNeeded = false
descriptors = ReferenceVariantsHelper(
bindingContext,
resolutionFacade,
moduleDescriptor,
VisibilityFilter(inDescriptor)
).getReferenceVariants(
simpleExpression,
DescriptorKindFilter.ALL,
{ name: Name -> !name.isSpecial && nameFilter(name.identifier, prefix) },
filterOutJavaGettersAndSetters = true,
filterOutShadowed = filterOutShadowedDescriptors, // setting to true makes it slower up to 4 times
excludeNonInitializedVariable = true,
useReceiverType = null
)
} else if (element is KtStringTemplateExpression) {
if (element.hasInterpolation()) {
return@gen
}
val stringVal = element.entries.joinToString("") {
val t = it.text
if (it.startOffset <= cursor && cursor <= it.endOffset) {
val s = cursor - it.startOffset
val e = s + INSERTED_STRING.length
t.substring(0, s) + t.substring(e)
} else t
}
val separatorIndex = stringVal.lastIndexOfAny(charArrayOf('/', '\\'))
val dir = if (separatorIndex != -1) {
stringVal.substring(0, separatorIndex + 1)
} else {
"."
}
val namePrefix = stringVal.substring(separatorIndex + 1)
val file = File(dir)
file.listFiles { p, f -> p == file && f.startsWith(namePrefix, true) }?.forEach {
yield(SourceCodeCompletionVariant(it.name, it.name, "file", "file"))
}
return@gen
} else {
isTipsManagerCompletion = false
val resolutionScope: LexicalScope?
val parent = element.parent
val qualifiedExpression = when {
element is KtQualifiedExpression -> {
isTipsManagerCompletion = true
element
}
parent is KtQualifiedExpression -> parent
else -> null
}
if (qualifiedExpression != null) {
val receiverExpression = qualifiedExpression.receiverExpression
val expressionType = bindingContext.get(
BindingContext.EXPRESSION_TYPE_INFO,
receiverExpression
)?.type
if (expressionType != null) {
isSortNeeded = false
descriptors = ReferenceVariantsHelper(
bindingContext,
resolutionFacade,
moduleDescriptor,
{ true }
).getReferenceVariants(
receiverExpression,
CallTypeAndReceiver.DOT(receiverExpression),
DescriptorKindFilter.ALL,
ALL_NAME_FILTER,
filterOutShadowed = filterOutShadowedDescriptors,
)
}
} else {
resolutionScope = bindingContext.get(
BindingContext.LEXICAL_SCOPE,
element as KtExpression?
)
descriptors = (resolutionScope?.getContributedDescriptors(
DescriptorKindFilter.ALL,
ALL_NAME_FILTER
)
?: return@gen)
}
}
if (descriptors != null) {
val targetElement = if (isTipsManagerCompletion) element else element.parent
val prefixEnd = cursor - targetElement.startOffset
var prefix = targetElement.text.substring(0, prefixEnd)
val cursorWithinElement = cursor - element.startOffset
val dotIndex = prefix.lastIndexOf('.', cursorWithinElement)
prefix = if (dotIndex >= 0) {
prefix.substring(dotIndex + 1, cursorWithinElement)
} else {
prefix.substring(0, cursorWithinElement)
}
if (descriptors !is ArrayList<*>) {
descriptors = ArrayList(descriptors)
}
(descriptors as ArrayList<DeclarationDescriptor>)
.map {
val presentation =
getPresentation(
it
)
Triple(it, presentation, (presentation.presentableText + presentation.tailText).toLowerCase())
}
.let {
if (isSortNeeded) it.sortedBy { descTriple -> descTriple.third } else it
}
.forEach {
val descriptor = it.first
val (rawName, presentableText, tailText, completionText) = it.second
if (nameFilter(rawName, prefix)) {
val fullName: String =
formatName(
presentableText
)
yield(
SourceCodeCompletionVariant(
completionText,
fullName,
tailText,
getIconFromDescriptor(
descriptor
)
)
)
}
}
yieldAll(
keywordsCompletionVariants(
KtTokens.KEYWORDS,
prefix
)
)
yieldAll(
keywordsCompletionVariants(
KtTokens.SOFT_KEYWORDS,
prefix
)
)
}
}
private class VisibilityFilter(
private val inDescriptor: DeclarationDescriptor
) : (DeclarationDescriptor) -> Boolean {
override fun invoke(descriptor: DeclarationDescriptor): Boolean {
if (descriptor is TypeParameterDescriptor && !isTypeParameterVisible(descriptor)) return false
if (descriptor is DeclarationDescriptorWithVisibility) {
return try {
descriptor.visibility.isVisible(null, descriptor, inDescriptor)
} catch (e: IllegalStateException) {
true
}
}
return true
}
private fun isTypeParameterVisible(typeParameter: TypeParameterDescriptor): Boolean {
val owner = typeParameter.containingDeclaration
var parent: DeclarationDescriptor? = inDescriptor
while (parent != null) {
if (parent == owner) return true
if (parent is ClassDescriptor && !parent.isInner) return false
parent = parent.containingDeclaration
}
return true
}
}
companion object {
const val INSERTED_STRING = "ABCDEF"
private const val NUMBER_OF_CHAR_IN_COMPLETION_NAME = 40
private fun keywordsCompletionVariants(
keywords: TokenSet,
prefix: String
) = sequence {
keywords.types.forEach {
val token = (it as KtKeywordToken).value
if (token.startsWith(prefix)) yield(
SourceCodeCompletionVariant(
token,
token,
"keyword",
"keyword"
)
)
}
}
private val RENDERER =
IdeDescriptorRenderers.SOURCE_CODE.withOptions {
this.classifierNamePolicy =
ClassifierNamePolicy.SHORT
this.typeNormalizer =
IdeDescriptorRenderers.APPROXIMATE_FLEXIBLE_TYPES
this.parameterNameRenderingPolicy =
ParameterNameRenderingPolicy.NONE
this.renderDefaultAnnotationArguments = false
this.typeNormalizer = lambda@{ kotlinType: KotlinType ->
if (kotlinType.isFlexible()) {
return@lambda kotlinType.asFlexibleType().upperBound
}
kotlinType
}
}
private fun getIconFromDescriptor(descriptor: DeclarationDescriptor): String = when (descriptor) {
is FunctionDescriptor -> "method"
is PropertyDescriptor -> "property"
is LocalVariableDescriptor -> "property"
is ClassDescriptor -> "class"
is PackageFragmentDescriptor -> "package"
is PackageViewDescriptor -> "package"
is ValueParameterDescriptor -> "genericValue"
is TypeParameterDescriptorImpl -> "class"
else -> ""
}
private fun formatName(builder: String, symbols: Int = NUMBER_OF_CHAR_IN_COMPLETION_NAME): String {
return if (builder.length > symbols) {
builder.substring(0, symbols) + "..."
} else builder
}
data class DescriptorPresentation(
val rawName: String,
val presentableText: String,
val tailText: String,
val completionText: String
)
fun getPresentation(descriptor: DeclarationDescriptor): DescriptorPresentation {
val rawDescriptorName = descriptor.name.asString()
val descriptorName = rawDescriptorName.quoteIfNeeded()
var presentableText = descriptorName
var typeText = ""
var tailText = ""
var completionText = ""
if (descriptor is FunctionDescriptor) {
val returnType = descriptor.returnType
typeText =
if (returnType != null) RENDERER.renderType(returnType) else ""
presentableText += RENDERER.renderFunctionParameters(
descriptor
)
val parameters = descriptor.valueParameters
if (parameters.size == 1 && parameters.first().type.isFunctionType)
completionText = "$descriptorName { "
val extensionFunction = descriptor.extensionReceiverParameter != null
val containingDeclaration = descriptor.containingDeclaration
if (extensionFunction) {
tailText += " for " + RENDERER.renderType(
descriptor.extensionReceiverParameter!!.type
)
tailText += " in " + DescriptorUtils.getFqName(containingDeclaration)
}
} else if (descriptor is VariableDescriptor) {
val outType =
descriptor.type
typeText = RENDERER.renderType(outType)
} else if (descriptor is ClassDescriptor) {
val declaredIn = descriptor.containingDeclaration
tailText = " (" + DescriptorUtils.getFqName(declaredIn) + ")"
} else {
typeText = RENDERER.render(descriptor)
}
tailText = if (typeText.isEmpty()) tailText else typeText
if (completionText.isEmpty()) {
completionText = presentableText
var position = completionText.indexOf('(')
if (position != -1) { //If this is a string with a package after
if (completionText[position - 1] == ' ') {
position -= 2
}
//if this is a method without args
if (completionText[position + 1] == ')') {
position++
}
completionText = completionText.substring(0, position + 1)
}
position = completionText.indexOf(":")
if (position != -1) {
completionText = completionText.substring(0, position - 1)
}
}
return DescriptorPresentation(
rawDescriptorName,
presentableText,
tailText,
completionText
)
}
}
}
| plugins/kotlin/compiler-plugins/scripting-ide-services/src/org/jetbrains/kotlin/scripting/ide_services/compiler/impl/KJvmReplCompleter.kt | 1812664873 |
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.idea.scratch.compile
import org.jetbrains.kotlin.diagnostics.rendering.Renderers
import org.jetbrains.kotlin.diagnostics.rendering.RenderingContext
import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
import org.jetbrains.kotlin.idea.scratch.ScratchExpression
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.resolve.calls.util.isSingleUnderscore
class KtScratchSourceFileProcessor {
companion object {
const val GENERATED_OUTPUT_PREFIX = "##scratch##generated##"
const val LINES_INFO_MARKER = "end##"
const val END_OUTPUT_MARKER = "end##!@#%^&*"
const val OBJECT_NAME = "ScratchFileRunnerGenerated"
const val INSTANCE_NAME = "instanceScratchFileRunner"
const val PACKAGE_NAME = "org.jetbrains.kotlin.idea.scratch.generated"
const val GET_RES_FUN_NAME_PREFIX = "generated_get_instance_res"
}
fun process(expressions: List<ScratchExpression>): Result {
val sourceProcessor = KtSourceProcessor()
expressions.forEach {
sourceProcessor.process(it)
}
val codeResult =
"""
package $PACKAGE_NAME
${sourceProcessor.imports.joinToString("\n") { it.text }}
object $OBJECT_NAME {
class $OBJECT_NAME {
${sourceProcessor.classBuilder}
}
@JvmStatic fun main(args: Array<String>) {
val $INSTANCE_NAME = $OBJECT_NAME()
${sourceProcessor.objectBuilder}
println("$END_OUTPUT_MARKER")
}
}
"""
return Result.OK("$PACKAGE_NAME.$OBJECT_NAME", codeResult)
}
class KtSourceProcessor {
val classBuilder = StringBuilder()
val objectBuilder = StringBuilder()
val imports = arrayListOf<KtImportDirective>()
private var resCount = 0
fun process(expression: ScratchExpression) {
val psiElement = expression.element
when (psiElement) {
is KtDestructuringDeclaration -> processDestructuringDeclaration(expression, psiElement)
is KtVariableDeclaration -> processDeclaration(expression, psiElement)
is KtFunction -> processDeclaration(expression, psiElement)
is KtClassOrObject -> processDeclaration(expression, psiElement)
is KtImportDirective -> imports.add(psiElement)
is KtExpression -> processExpression(expression, psiElement)
}
}
private fun processDeclaration(e: ScratchExpression, c: KtDeclaration) {
classBuilder.append(c.text).newLine()
val descriptor = c.resolveToDescriptorIfAny() ?: return
val context = RenderingContext.of(descriptor)
objectBuilder.println(Renderers.COMPACT.render(descriptor, context))
objectBuilder.appendLineInfo(e)
}
private fun processDestructuringDeclaration(e: ScratchExpression, c: KtDestructuringDeclaration) {
val entries = c.entries.mapNotNull { if (it.isSingleUnderscore) null else it.resolveToDescriptorIfAny() }
entries.forEach {
val context = RenderingContext.of(it)
val rendered = Renderers.COMPACT.render(it, context)
classBuilder.append(rendered).newLine()
objectBuilder.println(rendered)
}
objectBuilder.appendLineInfo(e)
classBuilder.append("init {").newLine()
classBuilder.append(c.text).newLine()
entries.forEach {
classBuilder.append("this.${it.name} = ${it.name}").newLine()
}
classBuilder.append("}").newLine()
}
private fun processExpression(e: ScratchExpression, expr: KtExpression) {
val resName = "$GET_RES_FUN_NAME_PREFIX$resCount"
classBuilder.append("fun $resName() = run { ${expr.text} }").newLine()
objectBuilder.printlnObj("$INSTANCE_NAME.$resName()")
objectBuilder.appendLineInfo(e)
resCount += 1
}
private fun StringBuilder.appendLineInfo(e: ScratchExpression) {
println("$LINES_INFO_MARKER${e.lineStart}|${e.lineEnd}")
}
private fun StringBuilder.println(str: String) = append("println(\"$GENERATED_OUTPUT_PREFIX$str\")").newLine()
private fun StringBuilder.printlnObj(str: String) = append("println(\"$GENERATED_OUTPUT_PREFIX\${$str}\")").newLine()
private fun StringBuilder.newLine() = append("\n")
}
sealed class Result {
class Error(val message: String) : Result()
class OK(val mainClassName: String, val code: String) : Result()
}
} | plugins/kotlin/jvm/src/org/jetbrains/kotlin/idea/scratch/compile/KtScratchSourceFileProcessor.kt | 814070072 |
// EXTRACTION_TARGET: property with initializer
class A {
val i: Int
init {
i = 1
}
fun foo(): Int {
return <selection>1 + 2</selection>
}
}
| plugins/kotlin/idea/tests/testData/refactoring/introduceProperty/extractToClassWithNameClashAndAnonymousInitializer.kt | 3287639182 |
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.lang.java.actions
import com.intellij.codeInsight.daemon.QuickFixBundle.message
import com.intellij.lang.jvm.actions.CreateFieldRequest
import com.intellij.lang.jvm.actions.JvmActionGroup
import com.intellij.lang.jvm.actions.JvmGroupIntentionAction
import com.intellij.psi.PsiClass
internal abstract class CreateFieldActionBase(
target: PsiClass,
override val request: CreateFieldRequest
) : CreateMemberAction(target, request), JvmGroupIntentionAction {
override fun getRenderData() = JvmActionGroup.RenderData { request.fieldName }
override fun getFamilyName(): String = message("create.field.from.usage.family")
}
| java/java-impl/src/com/intellij/lang/java/actions/CreateFieldActionBase.kt | 3848549325 |
// WITH_STDLIB
// IS_APPLICABLE: false
fun <T : CharSequence> foo(a: Iterable<T>) {
val b = sequenceOf("a", "b", "c", "e")
val c = a - <caret>b
}
| plugins/kotlin/idea/tests/testData/intentions/convertArgumentToSet/iterableMinusSequenceOfIndirect.kt | 1097764443 |
package at.phatbl.swift
import at.phatbl.swiftpm.Constants.Companion.TASK_SWIFT_VERSION
import org.gradle.testfixtures.ProjectBuilder
import org.jetbrains.spek.api.Spek
import org.jetbrains.spek.api.dsl.describe
import org.jetbrains.spek.api.dsl.it
import kotlin.test.assertNotNull
import kotlin.test.assertTrue
object VersionTaskSpek: Spek({
describe("swift version task") {
val project = ProjectBuilder.builder().build()
val task = project.tasks.create(TASK_SWIFT_VERSION, VersionTask::class.java)
it("can be added to project") {
assertNotNull(task)
assertTrue { task is VersionTask }
}
it("has a tokenized command line") {
val expectedTokens = arrayOf(
"swift",
"--version"
)
expectedTokens.forEach { token ->
assertTrue(task.command.contains(token))
}
}
}
})
| src/test/kotlin/at/phatbl/swift/VersionTaskSpek.kt | 3282917191 |
/*
* Copyright 2019 Louis Cognault Ayeva Derman. Use of this source code is governed by the Apache 2.0 license.
*/
package splitties.views.appcompat
@PublishedApi
internal const val NO_GETTER = "Property does not have a getter"
/**
* Usage example:
* `@Deprecated(NO_GETTER, level = DeprecationLevel.HIDDEN) get() = noGetter`
*/
@PublishedApi
internal inline val noGetter: Nothing
get() = throw UnsupportedOperationException(NO_GETTER)
| modules/views-appcompat/src/androidMain/kotlin/splitties/views/appcompat/noGetter.kt | 580148689 |
package com.kickstarter.mock.factories
import com.kickstarter.mock.factories.MessageFactory.message
import com.kickstarter.mock.factories.MessageThreadFactory.messageThread
import com.kickstarter.mock.factories.UserFactory.user
import com.kickstarter.services.apiresponses.MessageThreadEnvelope
import com.kickstarter.services.apiresponses.MessageThreadEnvelope.Companion.builder
object MessageThreadEnvelopeFactory {
@JvmStatic
fun empty(): MessageThreadEnvelope {
return messageThreadEnvelope()
.toBuilder()
.messages(null)
.build()
}
@JvmStatic
fun messageThreadEnvelope(): MessageThreadEnvelope {
return builder()
.messages(listOf(message()))
.messageThread(messageThread())
.participants(listOf(user()))
.build()
}
}
| app/src/main/java/com/kickstarter/mock/factories/MessageThreadEnvelopeFactory.kt | 2576814821 |
package info.nightscout.androidaps.setupwizard.elements
import android.graphics.Typeface
import android.text.Editable
import android.text.InputType
import android.text.TextWatcher
import android.view.View
import android.widget.EditText
import android.widget.LinearLayout
import android.widget.TextView
import dagger.android.HasAndroidInjector
import info.nightscout.androidaps.R
import info.nightscout.androidaps.setupwizard.SWTextValidator
import info.nightscout.androidaps.utils.CryptoUtil
class SWEditEncryptedPassword(injector: HasAndroidInjector, private val cryptoUtil: CryptoUtil) : SWItem(injector, Type.STRING) {
private var validator: SWTextValidator = SWTextValidator(String::isNotEmpty)
private var updateDelay = 0L
override fun generateDialog(layout: LinearLayout) {
val context = layout.context
val l = TextView(context)
l.id = View.generateViewId()
label?.let { l.setText(it) }
l.setTypeface(l.typeface, Typeface.BOLD)
layout.addView(l)
val c = TextView(context)
c.id = View.generateViewId()
comment?.let { c.setText(it) }
c.setTypeface(c.typeface, Typeface.ITALIC)
layout.addView(c)
val editText = EditText(context)
editText.id = View.generateViewId()
editText.inputType = InputType.TYPE_CLASS_TEXT
editText.maxLines = 1
editText.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD
layout.addView(editText)
val c2 = TextView(context)
c2.id = View.generateViewId()
c2.setText(R.string.confirm)
layout.addView(c2)
val editText2 = EditText(context)
editText2.id = View.generateViewId()
editText2.inputType = InputType.TYPE_CLASS_TEXT
editText2.maxLines = 1
editText2.inputType = InputType.TYPE_CLASS_TEXT or InputType.TYPE_TEXT_VARIATION_PASSWORD
layout.addView(editText2)
super.generateDialog(layout)
val watcher = object : TextWatcher {
override fun beforeTextChanged(s: CharSequence, start: Int, count: Int, after: Int) {}
override fun onTextChanged(s: CharSequence, start: Int, before: Int, count: Int) {
sp.remove(preferenceId)
scheduleChange(updateDelay)
if (validator.isValid(editText.text.toString()) && validator.isValid(editText2.text.toString()) && editText.text.toString() == editText2.text.toString())
save(s.toString(), updateDelay)
}
override fun afterTextChanged(s: Editable) {}
}
editText.addTextChangedListener(watcher)
editText2.addTextChangedListener(watcher)
}
fun preferenceId(preferenceId: Int): SWEditEncryptedPassword {
this.preferenceId = preferenceId
return this
}
fun validator(validator: SWTextValidator): SWEditEncryptedPassword {
this.validator = validator
return this
}
override fun save(value: String, updateDelay: Long) {
sp.putString(preferenceId, cryptoUtil.hashPassword(value))
scheduleChange(updateDelay)
}
} | app/src/main/java/info/nightscout/androidaps/setupwizard/elements/SWEditEncryptedPassword.kt | 971013554 |
package de.fabmax.kool.physics
import de.fabmax.kool.math.Mat4f
import de.fabmax.kool.math.MutableVec3f
import de.fabmax.kool.math.Ray
import de.fabmax.kool.math.Vec3f
import de.fabmax.kool.physics.articulations.Articulation
import de.fabmax.kool.physics.geometry.CollisionGeometry
import de.fabmax.kool.scene.Scene
import de.fabmax.kool.util.logE
import de.fabmax.kool.util.logW
import org.lwjgl.system.MemoryStack
import physx.PxTopLevelFunctions
import physx.common.PxVec3
import physx.extensions.PxDefaultCpuDispatcher
import physx.physics.*
import physx.support.SupportFunctions
import physx.support.TypeHelpers
import physx.support.Vector_PxContactPairPoint
import kotlin.collections.set
actual class PhysicsWorld actual constructor(scene: Scene?, val isContinuousCollisionDetection: Boolean, val numWorkers: Int) : CommonPhysicsWorld(), Releasable {
val pxScene: PxScene
private val cpuDispatcher: PxDefaultCpuDispatcher
private val raycastResult = PxRaycastBuffer10()
private val sweepResult = PxSweepBuffer10()
private val bufPxGravity = Vec3f(0f, -9.81f, 0f).toPxVec3(PxVec3())
private val bufGravity = MutableVec3f()
actual var gravity: Vec3f
get() = pxScene.gravity.toVec3f(bufGravity)
set(value) {
pxScene.gravity = value.toPxVec3(bufPxGravity)
}
private var mutActiveActors = 0
actual val activeActors: Int
get() = mutActiveActors
private val pxActors = mutableMapOf<PxActor, RigidActor>()
init {
Physics.checkIsLoaded()
cpuDispatcher = PxTopLevelFunctions.DefaultCpuDispatcherCreate(numWorkers)
MemoryStack.stackPush().use { mem ->
var flags = PxSceneFlagEnum.eENABLE_ACTIVE_ACTORS
if (isContinuousCollisionDetection) {
flags = flags or PxSceneFlagEnum.eENABLE_CCD
}
val sceneDesc = PxSceneDesc.createAt(mem, MemoryStack::nmalloc, Physics.physics.tolerancesScale)
sceneDesc.gravity = bufPxGravity
sceneDesc.cpuDispatcher = this.cpuDispatcher
sceneDesc.filterShader = PxTopLevelFunctions.DefaultFilterShader()
sceneDesc.simulationEventCallback = SimEventCallback()
sceneDesc.flags.set(flags)
pxScene = Physics.physics.createScene(sceneDesc)
}
scene?.let { registerHandlers(it) }
}
override fun singleStepAsync(timeStep: Float) {
super.singleStepAsync(timeStep)
pxScene.simulate(timeStep)
}
override fun fetchAsyncStepResults() {
pxScene.fetchResults(true)
for (i in actors.indices) {
actors[i].isActive = false
}
val activeActors = SupportFunctions.PxScene_getActiveActors(pxScene)
mutActiveActors = activeActors.size()
for (i in 0 until mutActiveActors) {
pxActors[activeActors.at(i)]?.isActive = true
}
super.fetchAsyncStepResults()
}
fun getActor(pxActor: PxActor): RigidActor? {
return pxActors[pxActor]
}
override fun addActor(actor: RigidActor) {
super.addActor(actor)
pxScene.addActor(actor.pxRigidActor)
pxActors[actor.pxRigidActor] = actor
// set necessary ccd flags in case it is enabled for this scene
val pxActor = actor.pxRigidActor
if (isContinuousCollisionDetection && pxActor is PxRigidBody) {
pxActor.setRigidBodyFlag(PxRigidBodyFlagEnum.eENABLE_CCD, true)
actor.simulationFilterData = FilterData {
set(actor.simulationFilterData)
word2 = PxPairFlagEnum.eDETECT_CCD_CONTACT
}
}
}
override fun removeActor(actor: RigidActor) {
super.removeActor(actor)
pxScene.removeActor(actor.pxRigidActor)
pxActors -= actor.pxRigidActor
}
override fun addArticulation(articulation: Articulation) {
super.addArticulation(articulation)
articulation.links.forEach { pxActors[it.pxLink] = it }
pxScene.addArticulation(articulation.pxArticulation)
}
override fun removeArticulation(articulation: Articulation) {
super.removeArticulation(articulation)
articulation.links.forEach { pxActors -= it.pxLink }
pxScene.removeArticulation(articulation.pxArticulation)
}
override fun release() {
super.release()
pxScene.release()
bufPxGravity.destroy()
raycastResult.destroy()
sweepResult.destroy()
cpuDispatcher.destroy()
}
actual fun raycast(ray: Ray, maxDistance: Float, result: HitResult): Boolean {
result.clear()
MemoryStack.stackPush().use { mem ->
synchronized(raycastResult) {
val ori = ray.origin.toPxVec3(mem.createPxVec3())
val dir = ray.direction.toPxVec3(mem.createPxVec3())
if (pxScene.raycast(ori, dir, maxDistance, raycastResult)) {
var minDist = maxDistance
var nearestHit: PxRaycastHit? = null
var nearestActor: RigidActor? = null
for (i in 0 until raycastResult.nbAnyHits) {
val hit = raycastResult.getAnyHit(i)
val actor = pxActors[hit.actor]
if (actor != null && hit.distance < minDist) {
result.hitActors += actor
minDist = hit.distance
nearestHit = hit
nearestActor = actor
}
}
if (nearestHit != null) {
result.nearestActor = nearestActor
result.hitDistance = minDist
nearestHit.position.toVec3f(result.hitPosition)
nearestHit.normal.toVec3f(result.hitNormal)
}
}
}
}
return result.isHit
}
actual fun sweepTest(testGeometry: CollisionGeometry, geometryPose: Mat4f, testDirection: Vec3f, distance: Float, result: HitResult): Boolean {
result.clear()
MemoryStack.stackPush().use { mem ->
val sweepPose = geometryPose.toPxTransform(mem.createPxTransform())
val sweepDir = testDirection.toPxVec3(mem.createPxVec3())
if (pxScene.sweep(testGeometry.pxGeometry, sweepPose, sweepDir, distance, sweepResult)) {
var minDist = distance
var nearestHit: PxSweepHit? = null
var nearestActor: RigidActor? = null
for (i in 0 until sweepResult.nbAnyHits) {
val hit = sweepResult.getAnyHit(i)
val actor = pxActors[hit.actor]
if (actor != null && hit.distance < minDist) {
result.hitActors += actor
minDist = hit.distance
nearestHit = hit
nearestActor = actor
}
}
if (nearestHit != null) {
result.nearestActor = nearestActor
result.hitDistance = minDist
nearestHit.position.toVec3f(result.hitPosition)
nearestHit.normal.toVec3f(result.hitNormal)
}
}
}
return result.isHit
}
private inner class SimEventCallback : JavaSimulationEventCallback() {
val contacts = Vector_PxContactPairPoint(64)
override fun onTrigger(pairs: PxTriggerPair, count: Int) {
for (i in 0 until count) {
val pair = TypeHelpers.getTriggerPairAt(pairs, i)
val isEnter = pair.status == PxPairFlagEnum.eNOTIFY_TOUCH_FOUND
val trigger = pxActors[pair.triggerActor]
val actor = pxActors[pair.otherActor]
if (trigger != null && actor != null) {
triggerListeners[trigger]?.apply {
var cnt = actorEnterCounts.getOrPut(actor) { 0 }
val shape = actor.shapes.find { it.pxShape == pair.otherShape }
if (shape == null) {
logE { "shape reference not found" }
}
if (isEnter) {
cnt++
if (cnt == 1) {
listeners.forEach { it.onActorEntered(trigger, actor) }
}
shape?.let { s -> listeners.forEach { it.onShapeEntered(trigger, actor, s) } }
} else {
cnt--
shape?.let { s -> listeners.forEach { it.onShapeExited(trigger, actor, s) } }
if (cnt == 0) {
listeners.forEach { it.onActorExited(trigger, actor) }
}
}
actorEnterCounts[actor] = cnt
}
} else {
logE { "actor reference not found" }
}
}
}
override fun onContact(pairHeader: PxContactPairHeader, pairs: PxContactPair, nbPairs: Int) {
val actorA = pxActors[pairHeader.getActors(0)]
val actorB = pxActors[pairHeader.getActors(1)]
if (actorA == null || actorB == null) {
logW { "onContact: actor reference not found" }
return
}
for (i in 0 until nbPairs) {
val pair = TypeHelpers.getContactPairAt(pairs, i)
val evts = pair.events
if (evts.isSet(PxPairFlagEnum.eNOTIFY_TOUCH_FOUND)) {
val contactPoints: MutableList<ContactPoint>?
val pxContactPoints = pair.extractContacts(contacts.data(), 64)
if (pxContactPoints > 0) {
contactPoints = mutableListOf()
for (iPt in 0 until pxContactPoints) {
val contact = contacts.at(iPt)
contactPoints += ContactPoint(contact.position.toVec3f(), contact.normal.toVec3f(), contact.impulse.toVec3f(), contact.separation)
}
} else {
contactPoints = null
}
fireOnTouchFound(actorA, actorB, contactPoints)
} else if (evts.isSet(PxPairFlagEnum.eNOTIFY_TOUCH_LOST)) {
fireOnTouchLost(actorA, actorB)
}
}
}
}
} | kool-physics/src/jvmMain/kotlin/de/fabmax/kool/physics/PhysicsWorld.kt | 256467289 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.