content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package jetbrains.xodus.browser.web.search
import org.junit.Assert.assertEquals
import org.junit.Test
class SmartSearchQueryParserTest {
@Test
fun testSimple() {
val result = "firstName='John' and lastName='McClane' and age!=34".parse()
assertEquals(3, result.size.toLong())
result[0].assertPropertyValueTerm("firstName", "John", true)
result[1].assertPropertyValueTerm("lastName", "McClane", true)
result[2].assertPropertyValueTerm("age", "34", false)
}
@Test
fun testSingleParam() {
val result = "firstName='John'".parse()
assertEquals(1, result.size.toLong())
result[0].assertPropertyValueTerm("firstName", "John", true)
}
@Test
fun testWithoutQuotes() {
val result = "firstName=John and lastName!=McClane and age=43".parse()
assertEquals(3, result.size.toLong())
result[0].assertPropertyValueTerm("firstName", "John", true)
result[1].assertPropertyValueTerm("lastName", "McClane", false)
result[2].assertPropertyValueTerm("age", "43", true)
}
@Test
fun testLike() {
val result = "firstName=John and lastName~McClane".parse()
assertEquals(2, result.size.toLong())
result[0].assertPropertyValueTerm("firstName", "John", true)
result[1].assertPropertyLikeTerm("lastName", "McClane")
}
@Test
fun testSingleParamsWithoutQuotes() {
val result = "firstName=John".parse()
assertEquals(1, result.size.toLong())
result[0].assertPropertyValueTerm("firstName", "John", true)
}
@Test
fun testEscapingQuotes() {
val result = "firstName=John and lastName='Mc''Clane'".parse()
assertEquals(2, result.size.toLong())
result[0].assertPropertyValueTerm("firstName", "John", true)
result[1].assertPropertyValueTerm("lastName", "Mc'Clane", true)
}
@Test
fun testOmitAndIntoQuotes() {
val result = "firstName!='John and Mike' and lastName='McClane'".parse()
assertEquals(2, result.size.toLong())
result[0].assertPropertyValueTerm("firstName", "John and Mike", false)
result[1].assertPropertyValueTerm("lastName", "McClane", true)
}
@Test
fun testEqualsIntoQuotes() {
val result = "firstName='John=Mike' and lastName='McClane'".parse()
assertEquals(2, result.size.toLong())
result[0].assertPropertyValueTerm("firstName", "John=Mike", true)
result[1].assertPropertyValueTerm("lastName", "McClane", true)
}
@Test
fun testSpacesIntoQuotes() {
val result = "firstName='John Mike' and lastName='McClane'".parse()
assertEquals(2, result.size.toLong())
result[0].assertPropertyValueTerm("firstName", "John Mike", true)
result[1].assertPropertyValueTerm("lastName", "McClane", true)
}
@Test
fun testSpecialSymbols() {
val result = "'_!@firstName'='John Mike' and '_!@lastName'='McClane'".parse()
assertEquals(2, result.size.toLong())
result[0].assertPropertyValueTerm("_!@firstName", "John Mike", true)
result[1].assertPropertyValueTerm("_!@lastName", "McClane", true)
}
@Test
fun testRange() {
val result = "firstName!='John Mike' and age=[30,40]".parse()
assertEquals(2, result.size.toLong())
result[0].assertPropertyValueTerm("firstName", "John Mike", false)
result[1].assertPropertyRangeTerm("age", 30, 40)
}
@Test
fun testLink() {
val result = "@linkName!=MyType[3] and firstName~Jo".parse()
assertEquals(2, result.size)
result[0].assertLinkTerm("linkName", "MyType", 3, false)
result[1].assertPropertyLikeTerm("firstName", "Jo")
}
@Test
fun testPropNull() {
val result = "firstName=null and lastName='null'".parse()
assertEquals(2, result.size)
result[0].assertPropertyValueTerm("firstName", null, true)
result[1].assertPropertyValueTerm("lastName", "null", true)
}
@Test
fun testLinkNull() {
val result = "@user!=null and @action=MyAction[4]".parse()
assertEquals(2, result.size)
result[0].assertLinkTerm("user", null, null, false)
result[1].assertLinkTerm("action", "MyAction", 4, true)
}
@Test(expected = jetbrains.xodus.browser.web.search.ParseException::class)
@Throws(jetbrains.xodus.browser.web.search.ParseException::class)
fun testCheckThrowsExceptionOnEmptyMap() {
jetbrains.xodus.browser.web.search.SmartSearchQueryParser.check(emptyList<SearchTerm>(), "")
}
@Test
fun testCaseInsensitive() {
val result = "firstName='John Mike' AND lastName='McClane'".parse()
assertEquals(2, result.size.toLong())
result[0].assertPropertyValueTerm("firstName", "John Mike", true)
result[1].assertPropertyValueTerm("lastName", "McClane", true)
}
private fun SearchTerm.assertPropertyLikeTerm(expectedName: String, expectedValue: String) {
val actual = this as PropertyLikeSearchTerm
assertEquals(expectedName, actual.name)
assertEquals(expectedValue, actual.value)
}
private fun SearchTerm.assertPropertyRangeTerm(expectedName: String, expectedStart: Long, expectedEnd: Long) {
val actual = this as PropertyRangeSearchTerm
assertEquals(expectedName, actual.name)
assertEquals(expectedStart, actual.start)
assertEquals(expectedEnd, actual.end)
}
private fun SearchTerm.assertPropertyValueTerm(expectedName: String, expectedValue: String?, expectedEquals: Boolean) {
val actual = this as PropertyValueSearchTerm
assertEquals(expectedName, actual.name)
assertEquals(expectedValue, actual.value)
assertEquals(expectedEquals, actual.equals)
}
private fun SearchTerm.assertLinkTerm(expectedName: String, expectedTypeName: String?, expectedLocalId: Long?, expectedEquals: Boolean) {
val actual = this as LinkSearchTerm
assertEquals(expectedName, actual.name)
assertEquals(expectedTypeName, actual.oppositeEntityTypeName)
assertEquals(expectedLocalId, actual.oppositeEntityLocalId)
assertEquals(expectedEquals, actual.equals)
}
}
| entity-browser-app/src/test/kotlin/jetbrains/xodus/browser/web/search/SmartSearchQueryParserTest.kt | 409398482 |
@file:Suppress("UNCHECKED_CAST")
package com.siimkinks.sqlitemagic.model.persist
import android.database.sqlite.SQLiteDatabase
import androidx.test.ext.junit.runners.AndroidJUnit4
import com.google.common.truth.Truth.assertThat
import com.siimkinks.sqlitemagic.DefaultConnectionTest
import com.siimkinks.sqlitemagic.Select
import com.siimkinks.sqlitemagic.createVals
import com.siimkinks.sqlitemagic.model.*
import com.siimkinks.sqlitemagic.model.insert.BulkItemsInsertTest
import com.siimkinks.sqlitemagic.model.insert.BulkItemsInsertWithConflictsTest
import com.siimkinks.sqlitemagic.model.insert.assertEarlyUnsubscribeFromInsertRollbackedAllValues
import com.siimkinks.sqlitemagic.model.insert.assertEarlyUnsubscribeFromInsertStoppedAnyFurtherWork
import com.siimkinks.sqlitemagic.model.persist.BulkItemsPersistWithConflictsTest.*
import com.siimkinks.sqlitemagic.model.update.BulkItemsUpdateTest
import com.siimkinks.sqlitemagic.model.update.BulkItemsUpdateWithConflictsTest
import com.siimkinks.sqlitemagic.model.update.assertEarlyUnsubscribeFromUpdateRollbackedAllValues
import org.junit.Test
import org.junit.runner.RunWith
import java.util.*
@RunWith(AndroidJUnit4::class)
class BulkItemsPersistWithConflictsIgnoringNullTest : DefaultConnectionTest {
@Test
fun mutableModelBulkPersistWithInsertAndIgnoreConflictSetsIdsIgnoringNull() {
assertThatDual {
testCase {
BulkItemsInsertTest.MutableModelBulkOperationSetsIds(
forModel = it,
setUp = {
val model = it as TestModelWithNullableColumns
createVals {
var newRandom = it.newRandom()
newRandom = it.setId(newRandom, -1)
model.nullSomeColumns(newRandom)
}
},
operation = BulkPersistForInsertWithIgnoreConflictDualOperation(
ignoreNullValues = true))
}
isSuccessfulFor(
simpleMutableAutoIdTestModel,
complexMutableAutoIdTestModel)
}
}
@Test
fun simpleModelBulkPersistWithInsertAndIgnoreConflictIgnoringNull() {
assertThatDual {
testCase {
BulkItemsInsertWithConflictsTest.SimpleModelBulkOperationWithIgnoreConflict(
forModel = it as TestModelWithUniqueColumn,
setUp = {
val nullableModel = it as NullableColumns<Any>
val testVals = createVals {
val (random) = insertNewRandom(it)
nullableModel.nullSomeColumns(random)
}
for (i in 0..10) {
testVals.add(nullableModel.nullSomeColumns(it.newRandom()))
}
Collections.shuffle(testVals)
testVals
},
operation = BulkPersistForInsertWithIgnoreConflictDualOperation(
ignoreNullValues = true))
}
isSuccessfulFor(*SIMPLE_NULLABLE_FIXED_ID_MODELS)
}
}
@Test
fun simpleModelBulkPersistWithUpdateAndIgnoreConflictIgnoringNull() {
assertThatDual {
testCase {
BulkItemsUpdateWithConflictsTest.SimpleModelBulkOperationWithIgnoreConflict(
forModel = it as TestModelWithUniqueColumn,
setUp = {
val model = it as TestModelWithUniqueColumn
BulkItemsUpdateWithConflictsTest.BulkUpdateWithIgnoreConflictTestVals(
model = model,
nullSomeColumns = true)
},
operation = BulkPersistForUpdateWithIgnoreConflictDualOperation(
ignoreNullValues = true))
}
isSuccessfulFor(*SIMPLE_NULLABLE_FIXED_ID_MODELS)
}
}
@Test
fun complexBulkPersistWithInsertAndIgnoreConflictIgnoringNullWhereParentFails() {
assertThatDual {
testCase {
BulkItemsInsertWithConflictsTest.ComplexModelBulkOperationWithIgnoreConflictWhereParentFails(
forModel = it as ComplexTestModelWithUniqueColumn,
setUp = {
val nullableModel = it as NullableColumns<Any>
val model = it as ComplexTestModelWithUniqueColumn
val testVals = createVals {
val (v1, _) = insertNewRandom(model)
val newRandom = nullableModel.nullSomeColumns(model.newRandom())
model.transferUniqueVal(v1, newRandom)
}
for (i in 0..10) {
testVals.add(nullableModel.nullSomeColumns(model.newRandom()))
}
Collections.shuffle(testVals)
testVals
},
operation = BulkPersistForInsertWithIgnoreConflictDualOperation(
ignoreNullValues = true))
}
isSuccessfulFor(*COMPLEX_NULLABLE_FIXED_ID_MODELS)
}
}
@Test
fun complexBulkPersistWithUpdateAndIgnoreConflictIgnoringNullWhereParentFails() {
assertThatDual {
testCase {
BulkItemsUpdateWithConflictsTest.ComplexModelBulkOperationWithIgnoreConflictWhereParentFails(
forModel = it as ComplexTestModelWithUniqueColumn,
setUp = {
BulkItemsUpdateWithConflictsTest.BulkUpdateWithIgnoreConflictTestVals(
model = it as ComplexTestModelWithUniqueColumn,
nullSomeColumns = true)
},
operation = BulkPersistForUpdateWithIgnoreConflictDualOperation(
ignoreNullValues = true))
}
isSuccessfulFor(*COMPLEX_NULLABLE_FIXED_ID_MODELS)
}
}
@Test
fun complexBulkPersistWithInsertAndIgnoreConflictIgnoringNullWhereChildFails() {
assertThatDual {
testCase {
BulkItemsInsertWithConflictsTest.ComplexModelBulkOperationWithIgnoreConflictWhereChildFails(
forModel = it as ComplexTestModelWithUniqueColumn,
setUp = {
val nullableModel = it as NullableColumns<Any>
val model = it as ComplexTestModelWithUniqueColumn
val testVals = createVals {
val (newRandom, _) = insertNewRandom(model)
val newVal = nullableModel.nullSomeColumns(model.newRandom())
model.transferComplexColumnUniqueVal(newRandom, newVal)
}
for (i in 0..10) {
testVals.add(nullableModel.nullSomeColumns(it.newRandom()))
}
Collections.shuffle(testVals)
testVals
},
operation = BulkPersistForInsertWithIgnoreConflictDualOperation(
ignoreNullValues = true))
}
isSuccessfulFor(*COMPLEX_NULLABLE_FIXED_ID_MODELS)
}
}
@Test
fun complexBulkPersistWithUpdateAndIgnoreConflictIgnoringNullWhereChildFails() {
assertThatDual {
testCase {
BulkItemsUpdateWithConflictsTest.ComplexBulkOperationWithIgnoreConflictWhereChildFails(
forModel = it as ComplexTestModelWithUniqueColumn,
setUp = {
BulkItemsUpdateWithConflictsTest.BulkUpdateWithIgnoreConflictTestVals(
model = it as ComplexTestModelWithUniqueColumn,
nullSomeColumns = true,
transferUniqueVal = { model, src, target ->
(model as ComplexTestModelWithUniqueColumn).transferComplexColumnUniqueVal(src, target)
})
},
operation = BulkPersistForUpdateWithIgnoreConflictDualOperation(
ignoreNullValues = true))
}
isSuccessfulFor(*COMPLEX_NULLABLE_FIXED_ID_MODELS)
}
}
@Test
fun complexModelBulkPersistWithInsertAndIgnoreConflictIgnoringNullWhereAllChildrenFail() {
assertThatDual {
testCase {
BulkItemsInsertWithConflictsTest.ComplexBulkOperationWithIgnoreConflictWhereAllChildrenFail(
forModel = it as ComplexTestModelWithUniqueColumn,
setUp = {
val model = it as ComplexTestModelWithUniqueColumn
val nullableModel = it as NullableColumns<Any>
createVals {
val (newRandom) = insertNewRandom(it)
val newVal = nullableModel.nullSomeColumns(it.newRandom())
model.transferComplexColumnUniqueVal(newRandom, newVal)
}
},
operation = BulkPersistForInsertWithIgnoreConflictWhereAllFailDualOperation(
ignoreNullValues = true))
}
isSuccessfulFor(*COMPLEX_NULLABLE_FIXED_ID_MODELS)
}
}
@Test
fun complexModelBulkPersistWithUpdateAndIgnoreConflictIgnoringNullWhereAllChildrenFail() {
assertThatDual {
testCase {
BulkItemsUpdateWithConflictsTest.ComplexBulkOperationWithIgnoreConflictWhereAllChildrenFail(
forModel = it as ComplexTestModelWithUniqueColumn,
setUp = {
BulkItemsUpdateWithConflictsTest.BulkUpdateWithIgnoreConflictWhereAllFailTestVals(
model = it as ComplexTestModelWithUniqueColumn,
nullSomeColumns = true,
transferUniqueVal = { model, src, target ->
(model as ComplexTestModelWithUniqueColumn).transferComplexColumnUniqueVal(src, target)
})
},
operation = BulkPersistForUpdateWithIgnoreConflictWhereAllFailDualOperation(
ignoreNullValues = true))
}
isSuccessfulFor(*COMPLEX_NULLABLE_FIXED_ID_MODELS)
}
}
@Test
fun bulkPersistWithInsertAndIgnoreConflictIgnoringNullWhereAllFail() {
assertThatDual {
testCase {
BulkItemsInsertWithConflictsTest.BulkOperationWithIgnoreConflictWhereAllFail(
forModel = it,
setUp = {
val model = it as TestModelWithUniqueColumn
val nullableModel = it as NullableColumns<Any>
createVals {
val (v, _) = insertNewRandom(model)
val newRandom = nullableModel.nullSomeColumns(it.newRandom())
model.transferUniqueVal(v, newRandom)
}
},
operation = BulkPersistForInsertWithIgnoreConflictWhereAllFailDualOperation(
ignoreNullValues = true))
}
isSuccessfulFor(*ALL_NULLABLE_FIXED_ID_MODELS)
}
}
@Test
fun bulkPersistWithUpdateAndIgnoreConflictIgnoringNullWhereAllFail() {
assertThatDual {
testCase {
BulkItemsUpdateWithConflictsTest.BulkOperationWithIgnoreConflictWhereAllFail(
forModel = it as TestModelWithUniqueColumn,
setUp = {
BulkItemsUpdateWithConflictsTest.BulkUpdateWithIgnoreConflictWhereAllFailTestVals(
model = it as TestModelWithUniqueColumn,
nullSomeColumns = true)
},
operation = BulkPersistForUpdateWithIgnoreConflictWhereAllFailDualOperation(
ignoreNullValues = true))
}
isSuccessfulFor(*ALL_NULLABLE_FIXED_ID_MODELS)
}
}
@Test
fun earlyUnsubscribeFromSimpleModelPersistWithInsertAndIgnoreConflictIgnoringNull() {
assertThatSingle {
testCase {
BulkItemsInsertWithConflictsTest.EarlyUnsubscribeWithIgnoreConflict(
"Unsubscribing in-flight bulk persist with insert and ignore conflict algorithm " +
"with ignoring null values on simple models rollbacks all values",
forModel = it,
setUp = { createVals(count = 500) { newRandomWithNulledColumns()(it) } },
test = BulkPersistEarlyUnsubscribeWithIgnoreConflict(ignoreNullValues = true),
assertResults = assertEarlyUnsubscribeFromInsertRollbackedAllValues())
}
isSuccessfulFor(*SIMPLE_NULLABLE_AUTO_ID_MODELS)
}
}
@Test
fun earlyUnsubscribeFromSimpleModelPersistWithUpdateAndIgnoreConflictIgnoringNull() {
assertThatSingle {
testCase {
BulkItemsUpdateWithConflictsTest.EarlyUnsubscribeWithIgnoreConflict(
"Unsubscribing in-flight bulk persist with update and ignore conflict algorithm " +
"with ignoring null values on simple models rollbacks all values",
forModel = it,
setUp = { createVals(count = 500) { newUpdatableRandomWithNulledColumns()(it) } },
test = BulkPersistEarlyUnsubscribeWithIgnoreConflict(ignoreNullValues = true),
assertResults = assertEarlyUnsubscribeFromUpdateRollbackedAllValues())
}
isSuccessfulFor(*SIMPLE_NULLABLE_AUTO_ID_MODELS)
}
}
@Test
fun earlyUnsubscribeFromComplexModelPersistWithInsertAndIgnoreConflictIgnoringNull() {
assertThatSingle {
testCase {
BulkItemsInsertWithConflictsTest.EarlyUnsubscribeWithIgnoreConflict(
"Unsubscribing in-flight bulk persist with insert and ignore conflict algorithm " +
"with ignoring null values on complex models stops any further work",
forModel = it,
setUp = { createVals(count = 500) { newRandomWithNulledColumns()(it) } },
test = BulkPersistEarlyUnsubscribeWithIgnoreConflict(ignoreNullValues = true),
assertResults = assertEarlyUnsubscribeFromInsertStoppedAnyFurtherWork())
}
isSuccessfulFor(*COMPLEX_NULLABLE_AUTO_ID_MODELS)
}
}
@Test
fun earlyUnsubscribeFromComplexModelPersistWithUpdateAndIgnoreConflictIgnoringNull() {
assertThatSingle {
testCase {
BulkItemsUpdateWithConflictsTest.EarlyUnsubscribeWithIgnoreConflict(
"Unsubscribing in-flight bulk persist with update and ignore conflict algorithm " +
"with ignoring null values on complex models stops any further work",
forModel = it,
setUp = { createVals(count = 500) { newUpdatableRandomWithNulledColumns()(it) } },
test = BulkPersistEarlyUnsubscribeWithIgnoreConflict(ignoreNullValues = true),
assertResults = { model, testVals, eventsCount ->
val firstDbValue = Select
.from(model.table)
.queryDeep()
.takeFirst()
.execute()!!
val firstTestVal = testVals
.sortedBy { model.getId(it) }
.first()
(model as ComplexNullableColumns<Any>)
.assertAllExceptNulledColumnsAreUpdated(firstDbValue, firstTestVal)
assertThat(eventsCount.get()).isEqualTo(0)
})
}
isSuccessfulFor(*COMPLEX_NULLABLE_AUTO_ID_MODELS)
}
}
@Test
fun streamedBulkPersistWithInsertAndIgnoreConflictIgnoringNull() {
assertThatSingle {
testCase {
BulkItemsInsertTest.StreamedBulkOperation(
forModel = it,
test = BulkItemsPersistTest.StreamedBulkPersistWithInsertOperation(
ignoreConflict = true,
ignoreNullValues = true))
}
isSuccessfulFor(*ALL_AUTO_ID_MODELS)
}
}
@Test
fun streamedBulkPersistWithUpdateAndIgnoreConflictIgnoringNull() {
assertThatSingle {
testCase {
BulkItemsUpdateTest.StreamedBulkOperation(
forModel = it,
test = BulkItemsPersistTest.StreamedBulkPersistWithUpdateOperation(
ignoreConflict = true,
ignoreNullValues = true))
}
isSuccessfulFor(*ALL_AUTO_ID_MODELS)
}
}
@Test
fun bulkPersistWithUpdateByUniqueColumnAndIgnoreConflictIgnoringNull() {
assertThatDual {
testCase {
BulkItemsPersistIgnoringNullTest.BulkOperationByUniqueColumnIgnoringNull(
forModel = it,
operation = BulkPersistDualOperation(ignoreNullValues = true) { model, testVals ->
model.bulkPersistBuilder(testVals)
.conflictAlgorithm(SQLiteDatabase.CONFLICT_IGNORE)
.byColumn((model as TestModelWithUniqueColumn).uniqueColumn)
})
}
isSuccessfulFor(*ALL_FIXED_ID_MODELS)
}
}
@Test
fun bulkPersistWithUpdateByComplexUniqueColumnAndIgnoreConflictIgnoringNull() {
assertThatDual {
testCase {
BulkItemsPersistIgnoringNullTest.BulkOperationByComplexUniqueColumnIgnoringNull(
forModel = it,
operation = BulkPersistDualOperation(ignoreNullValues = true) { model, testVals ->
model.bulkPersistBuilder(testVals)
.conflictAlgorithm(SQLiteDatabase.CONFLICT_IGNORE)
.byColumn((model as ComplexTestModelWithUniqueColumn).complexUniqueColumn)
})
}
isSuccessfulFor(*COMPLEX_FIXED_ID_MODELS)
}
}
@Test
fun bulkPersistWithUpdateByComplexColumnUniqueColumnAndIgnoreConflictIgnoringNull() {
assertThatDual {
testCase {
BulkItemsPersistIgnoringNullTest.BulkOperationByComplexColumnUniqueColumnIgnoringNull(
forModel = it,
operation = BulkPersistDualOperation(ignoreNullValues = true) { model, testVals ->
model.bulkPersistBuilder(testVals)
.conflictAlgorithm(SQLiteDatabase.CONFLICT_IGNORE)
.byColumn((model as ComplexTestModelWithUniqueColumn).complexColumnUniqueColumn)
})
}
isSuccessfulFor(*COMPLEX_FIXED_ID_MODELS)
}
}
} | sqlitemagic-tests/app/src/androidTest/kotlin/com/siimkinks/sqlitemagic/model/persist/BulkItemsPersistWithConflictsIgnoringNullTest.kt | 906705686 |
package eu.kanade.tachiyomi.extension.ko.navercomic
import eu.kanade.tachiyomi.source.Source
import eu.kanade.tachiyomi.source.SourceFactory
class NaverComicFactory : SourceFactory {
override fun createSources(): List<Source> = listOf(
NaverWebtoon(),
NaverBestChallenge(),
NaverChallenge()
)
}
| src/ko/navercomic/src/eu/kanade/tachiyomi/extension/ko/navercomic/NaverComicFactory.kt | 3116631516 |
package y2k.joyreactor
import org.robovm.apple.avfoundation.AVLayerVideoGravity
import org.robovm.apple.avfoundation.AVPlayer
import org.robovm.apple.avfoundation.AVPlayerLayer
import org.robovm.apple.coremedia.CMTime
import org.robovm.apple.foundation.NSObject
import org.robovm.apple.foundation.NSURL
import org.robovm.apple.uikit.UIActivityIndicatorView
import org.robovm.apple.uikit.UIViewController
import org.robovm.objc.annotation.CustomClass
import org.robovm.objc.annotation.IBOutlet
import y2k.joyreactor.common.ServiceLocator
import y2k.joyreactor.common.bindingBuilder
import y2k.joyreactor.viewmodel.VideoViewModel
/**
* Created by y2k on 22/10/15.
*/
@CustomClass("VideoViewController")
class VideoViewController : UIViewController() {
@IBOutlet lateinit var indicatorView: UIActivityIndicatorView
lateinit var player: AVPlayer
var repeatObserver: NSObject? = null
override fun viewDidLoad() {
super.viewDidLoad()
navigationController.setNavigationBarHidden(true, true)
val vm = ServiceLocator.resolve<VideoViewModel>()
bindingBuilder {
action(vm.isBusy) {
navigationItem.setHidesBackButton(it, true)
if (it) indicatorView.startAnimating()
else indicatorView.stopAnimating()
}
action(vm.videoFile) {
if (it == null) return@action
// TODO: вынести в отдельный контрол
player = AVPlayer(NSURL(it))
repeatObserver = player.addBoundaryTimeObserver(
listOf(player.currentItem.asset.duration.subtract(CMTime.create(0.1, 600))),
null) { player.seekToTime(CMTime.Zero()) }
val layer = AVPlayerLayer()
layer.player = player
layer.frame = view.frame
layer.videoGravity = AVLayerVideoGravity.ResizeAspect
view.layer.addSublayer(layer)
player.play()
}
}
}
override fun viewWillAppear(animated: Boolean) {
super.viewWillAppear(animated)
navigationController.setHidesBarsOnTap(true)
}
override fun viewWillDisappear(animated: Boolean) {
super.viewWillDisappear(animated)
navigationController.setHidesBarsOnTap(false)
if (repeatObserver != null) player.removeTimeObserver(repeatObserver)
}
} | ios/src/main/kotlin/y2k/joyreactor/VideoViewController.kt | 2646719753 |
/**
* The MIT License (MIT)
*
* Copyright (c) 2019 vk.com
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
// *********************************************************************
// THIS FILE IS AUTO GENERATED!
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING.
// *********************************************************************
package com.vk.sdk.api.photos.dto
import com.google.gson.annotations.SerializedName
import kotlin.String
enum class PhotosImageType(
val value: String
) {
@SerializedName("s")
S("s"),
@SerializedName("m")
M("m"),
@SerializedName("x")
X("x"),
@SerializedName("l")
L("l"),
@SerializedName("o")
O("o"),
@SerializedName("p")
P("p"),
@SerializedName("q")
Q("q"),
@SerializedName("r")
R("r"),
@SerializedName("y")
Y("y"),
@SerializedName("z")
Z("z"),
@SerializedName("w")
W("w");
}
| api/src/main/java/com/vk/sdk/api/photos/dto/PhotosImageType.kt | 2944157532 |
/*
* Copyright (C) 2019 AniTrend
*
* 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 <https://www.gnu.org/licenses/>.
*/
package com.mxt.anitrend.model.entity.anilist.user.statistics
import com.mxt.anitrend.model.entity.anilist.user.statistics.contract.IUserStatistic
import com.mxt.anitrend.model.entity.base.StudioBase
/** [UserStudioStatistic](https://anilist.github.io/ApiV2-GraphQL-Docs/userstudiostatistic.doc.html)
*
* @param studio studio
*/
data class UserStudioStatistic(
val studio: StudioBase?,
override val chaptersRead: Int,
override val count: Int,
override val meanScore: Float,
override val mediaIds: List<Int>,
override val minutesWatched: Int
) : IUserStatistic
| app/src/main/java/com/mxt/anitrend/model/entity/anilist/user/statistics/UserStudioStatistic.kt | 4126108549 |
package com.vasilich.monitoring
import com.google.common.cache.Cache
import org.apache.commons.lang3.StringUtils
import java.util.Comparator
import java.util.concurrent.TimeUnit
import com.google.common.cache.CacheBuilder
import java.util.TreeSet
fun stringDistanceComparator(criticalDistance: Int) = Comparator<String> { (one: String, another: String): Int ->
val distance = StringUtils.getLevenshteinDistance(one, another)
when {
distance > criticalDistance -> distance
else -> 0
}
}
/**
* Monitoring can be very importunate
* With this trait we can reduce it verbosity
*/
fun throttle<T>(cache: Cache<T, Unit> = CacheBuilder.newBuilder()!!.maximumSize(20)!!
.expireAfterWrite(2, TimeUnit.MINUTES)!!.build()!!,
comparator: Comparator<T>? = null): (Collection<T>) -> Collection<T> =
{ input ->
val keyset = cache.asMap()!!.keySet()
val newInstances = input.filter { when {
comparator == null && !keyset.contains(it) -> true
comparator == null -> false
else -> {
val keyComparableSet = TreeSet(comparator)
keyComparableSet.addAll(keyset)
!keyComparableSet.containsItem(it)
}
}}
newInstances.forEach { cache.put(it, Unit.VALUE) }
newInstances
}
| src/main/kotlin/com/vasilich/monitoring/Throttled.kt | 2079842745 |
package com.mobapptuts.kotlinwebview
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
}
| app/src/test/java/com/mobapptuts/kotlinwebview/ExampleUnitTest.kt | 1661805098 |
package org.jetbrains.kotlinx.jupyter.api
import kotlin.reflect.KClass
import kotlin.reflect.KProperty
import kotlin.reflect.KType
import kotlin.reflect.full.createType
import kotlin.reflect.full.isSubtypeOf
import kotlin.reflect.full.starProjectedType
typealias VariableDeclarationCallback<T> = KotlinKernelHost.(T, KProperty<*>) -> Unit
typealias VariableName = String
typealias VariableUpdateCallback<T> = KotlinKernelHost.(T, KProperty<*>) -> VariableName?
fun interface FieldHandlerExecution<T> {
fun execute(host: KotlinKernelHost, value: T, property: KProperty<*>)
}
interface FieldHandler {
/**
* Returns true if this converter accepts [type], false otherwise
*/
fun acceptsType(type: KType): Boolean
/**
* Execution to handle conversion.
* Should not throw if [acceptsType] returns true
*/
val execution: FieldHandlerExecution<*>
}
class FieldHandlerByClass(
private val kClass: KClass<out Any>,
override val execution: FieldHandlerExecution<*>,
) : FieldHandler {
override fun acceptsType(type: KType) = type.isSubtypeOf(kClass.starProjectedType)
}
data class VariableDeclaration(
val name: VariableName,
val value: Any?,
val type: KType,
val isMutable: Boolean = false,
) {
constructor(
name: VariableName,
value: Any?,
isMutable: Boolean = false
) : this(
name,
value,
value?.let { it::class.starProjectedType } ?: Any::class.createType(nullable = true),
isMutable
)
}
fun KotlinKernelHost.declare(vararg variables: VariableDeclaration) = declare(variables.toList())
fun KotlinKernelHost.declare(vararg variables: Pair<VariableName, Any?>) = declare(variables.map { VariableDeclaration(it.first, it.second) })
| jupyter-lib/api/src/main/kotlin/org/jetbrains/kotlinx/jupyter/api/fieldsHandling.kt | 793623601 |
/*
* StatCraft Plugin
*
* Copyright (c) 2016 Kyle Wood (DemonWav)
* https://www.demonwav.com
*
* MIT License
*/
package com.demonwav.statcraft.commands
abstract class AbstractBaseCommand : BaseCommand {
}
| statcraft-common/src/main/kotlin/com/demonwav/statcraft/commands/AbstractBaseCommand.kt | 2651280133 |
package com.habitrpg.android.habitica.helpers
import android.content.Context
import com.habitrpg.android.habitica.R
import com.habitrpg.common.habitica.helpers.NumberAbbreviator.abbreviate
import io.kotest.core.spec.style.StringSpec
import io.kotest.matchers.shouldBe
import io.mockk.clearMocks
import io.mockk.every
import io.mockk.mockk
import java.util.*
class NumberAbbreviatorTest : StringSpec({
val mockContext = mockk<Context>()
beforeEach {
Locale.setDefault(Locale.US)
every { mockContext.getString(R.string.thousand_abbrev) } returns "k"
every { mockContext.getString(R.string.million_abbrev) } returns "m"
every { mockContext.getString(R.string.billion_abbrev) } returns "b"
every { mockContext.getString(R.string.trillion_abbrev) } returns "t"
}
"doesn't abbreviate small numbers" {
abbreviate(mockContext, 215.0, 2) shouldBe "215"
abbreviate(mockContext, 2.05, 2) shouldBe "2.05"
}
"it abbreviates thousands" {
abbreviate(mockContext, 1550.0, 2) shouldBe "1.55k"
}
"it abbreviates millions" {
abbreviate(mockContext, 9990000.0, 2) shouldBe "9.99m"
}
"it abbreviates billions" {
abbreviate(mockContext, 1990000000.0, 2) shouldBe "1.99b"
}
"it abbreviates trillions" {
abbreviate(mockContext, 1990000000000.0, 2) shouldBe "1.99t"
}
"it abbreviates thousands without additional decimals" {
abbreviate(mockContext, 1000.0, 2) shouldBe "1k"
abbreviate(mockContext, 1500.0, 2) shouldBe "1.5k"
abbreviate(mockContext, 1500.0, 0) shouldBe "1k"
}
"it rounds correctly" {
abbreviate(mockContext, 9999.0, 2) shouldBe "9.99k"
}
afterEach { clearMocks(mockContext) }
})
| Habitica/src/test/java/com/habitrpg/android/habitica/helpers/NumberAbbreviatorTest.kt | 1610415500 |
package lijin.heinika.cn.mygankio.entiy
/**
* Created by heinika on 17-7-26.
*/
/**
* error : false
* results : [{"_id":"5827f41b421aa911d3bb7ecb","createdAt":"2016-11-13T13:03:23.38Z","desc":"独立全端开发的开源小作：简诗 2.0","images":["http://img.gank.io/b6be7a85-4035-437f-9521-65593fdbc48e"],"publishedAt":"2016-11-14T11:36:49.680Z","source":"web","type":"Android","url":"https://www.v2ex.com/t/320154","used":true,"who":"wingjay"},{"_id":"58280022421aa911d3bb7ecc","createdAt":"2016-11-13T13:54:42.240Z","desc":"RxJava源码解读之旅","publishedAt":"2016-11-14T11:36:49.680Z","source":"web","type":"Android","url":"https://zhuanlan.zhihu.com/p/23617414","used":true,"who":"Li Wenjing"},{"_id":"58281b82421aa911cf2e1558","createdAt":"2016-11-13T15:51:30.961Z","desc":"在Android图形处理-Canvas已经有了基本的使用，但是这节介绍几个好玩的属性","images":["http://img.gank.io/0c71383b-d925-4108-91bb-39f3ede15386"],"publishedAt":"2016-11-14T11:36:49.680Z","source":"web","type":"Android","url":"http://www.haotianyi.win/2016/11/android%E5%9B%BE%E5%BD%A2%E5%A4%84%E7%90%86-%E7%99%BE%E5%8F%98paint/","used":true,"who":"HaoTianYi"},{"_id":"57d039ed421aa90d4500446a","createdAt":"2016-09-08T00:01:49.521Z","desc":"一个炫酷的侧边栏效果","images":["http://img.gank.io/34a8195d-dcf5-45bf-a332-54ed9a8f465a"],"publishedAt":"2016-11-11T12:03:10.196Z","source":"web","type":"Android","url":"https://github.com/mzule/FantasySlide","used":true,"who":"Jason Cao"},{"_id":"57e3e32f421aa95bd0501610","createdAt":"2016-09-22T21:57:03.924Z","desc":"副作用小的在线热更新View库，可将View作为一个独立模块进行更新抽换","publishedAt":"2016-11-11T12:03:10.196Z","source":"web","type":"Android","url":"https://github.com/kot32go/dynamic-load-view","used":true,"who":"kot32"},{"_id":"57eb7bb6421aa95ddb9cb556","createdAt":"2016-09-28T16:13:42.307Z","desc":"Android事件分发原理(责任链模式)","publishedAt":"2016-11-11T12:03:10.196Z","source":"web","type":"Android","url":"http://www.gcssloop.com/customview/dispatch-touchevent-theory","used":true,"who":"sloop"},{"_id":"58205525421aa90e6f21b4d4","createdAt":"2016-11-07T18:19:17.462Z","desc":"一个真正的Ripple效果，需要考虑Ripple的圆心变化","publishedAt":"2016-11-11T12:03:10.196Z","source":"web","type":"Android","url":"https://github.com/liuguangqiang/RippleLayout","used":true,"who":"Eric"},{"_id":"582180fc421aa9137697465d","createdAt":"2016-11-08T15:38:36.188Z","desc":"apk 瘦身之去除 R.class","publishedAt":"2016-11-10T11:40:42.4Z","source":"chrome","type":"Android","url":"https://github.com/mogujie/ThinRPlugin","used":true,"who":"蒋朋"},{"_id":"5822a17f421aa90e799ec2a4","createdAt":"2016-11-09T12:09:35.314Z","desc":"通过浏览器管理sqlite数据库","images":["http://img.gank.io/fb674796-3ebb-4684-9a0c-4d18097eb771"],"publishedAt":"2016-11-10T11:40:42.4Z","source":"web","type":"Android","url":"https://github.com/skyhacker2/SQLiteOnWeb-Android","used":true,"who":"pcyan"},{"_id":"58232df6421aa9137697466f","createdAt":"2016-11-09T22:08:54.356Z","desc":"一个支持选词的 TextView，类似与单词 app 中点击单词翻译的效果","images":["http://img.gank.io/cfc82bd9-731f-4ac9-80db-67254f15baa1"],"publishedAt":"2016-11-10T11:40:42.4Z","source":"web","type":"Android","url":"https://github.com/burgessjp/GetWordTextView","used":true,"who":"solid"}]
*/
data class BaseData<T> (
val isError: Boolean,
val results: T?
)
| app/src/main/java/lijin/heinika/cn/mygankio/entiy/BaseData.kt | 3735438686 |
package org.stepik.android.model
import android.os.Parcelable
import com.google.gson.annotations.SerializedName
import kotlinx.android.parcel.Parcelize
@Parcelize
data class ViewRevenue(
@SerializedName("enabled")
val enabled: Boolean
) : Parcelable | model/src/main/java/org/stepik/android/model/ViewRevenue.kt | 3891493388 |
package org.stepic.droid.adaptive.util
import android.content.Context
import org.stepic.droid.R
import org.stepic.droid.di.AppSingleton
import org.stepic.droid.preferences.SharedPreferenceHelper
import javax.inject.Inject
@AppSingleton
class RatingNamesGenerator
@Inject
constructor(
private val context: Context,
private val sharedPreferenceHelper: SharedPreferenceHelper
) {
private val animalsMale by lazy { context.resources.getStringArray(R.array.animals_m) }
private val animalsFemale by lazy { context.resources.getStringArray(R.array.animals_f) }
private val animals by lazy { animalsMale + animalsFemale }
private val adjectives by lazy { context.resources.getStringArray(R.array.adjectives) }
private val adjectivesFemale by lazy { context.resources.getStringArray(R.array.adjectives_female) }
fun getName(user: Long) : String =
if (user == sharedPreferenceHelper.profile?.id) {
context.getString(R.string.adaptive_rating_you_placeholder)
} else {
val hash = hash(user)
val animal = animals[(hash % animals.size).toInt()]
val adjIndex = (hash / animals.size).toInt()
val adj = if (isFemaleNoun(animal)) {
adjectivesFemale[adjIndex]
} else {
adjectives[adjIndex]
}
adj.capitalize() + ' ' + animal
}
private fun isFemaleNoun(noun: String) = animalsFemale.contains(noun)
private fun hash(x: Long): Long {
var h = x
h = h.shr(16).xor(h) * 0x45d9f3b
h = h.shr(16).xor(h) * 0x45d9f3b
h = h.shr(16).xor(h)
return h % (animals.size * adjectives.size)
}
} | app/src/main/java/org/stepic/droid/adaptive/util/RatingNamesGenerator.kt | 769810038 |
package com.vmenon.mpo.auth.framework.di.dagger
import javax.inject.Scope
@Scope
@Retention(AnnotationRetention.RUNTIME)
annotation class AuthScope
| auth_framework/src/main/java/com/vmenon/mpo/auth/framework/di/dagger/AuthScope.kt | 2615735141 |
package com.jayrave.moshi.pristineModels
interface NameFormatter {
/**
* @throws [NameFormatException] whenever a [NameFormatter] finds something wrong with
* the data it has to work with
*/
@Throws(NameFormatException::class)
fun format(input: String): String
class NameFormatException(message: String?) : RuntimeException(message)
} | src/main/kotlin/com/jayrave/moshi/pristineModels/NameFormatter.kt | 2939907975 |
// Copyright 2000-2017 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.jetbrains.python.sdk
import com.intellij.application.options.ReplacePathToMacroMap
import com.intellij.openapi.components.*
import com.intellij.openapi.util.io.FileUtil
import com.intellij.util.PathUtil
import com.intellij.util.SystemProperties
import com.intellij.util.xmlb.XmlSerializerUtil
import com.jetbrains.python.sdk.flavors.VirtualEnvSdkFlavor
import org.jetbrains.annotations.SystemIndependent
import org.jetbrains.jps.model.serialization.PathMacroUtil
/**
* @author vlan
*/
@State(name = "PySdkSettings", storages = arrayOf(Storage(value = "py_sdk_settings.xml", roamingType = RoamingType.DISABLED)))
class PySdkSettings : PersistentStateComponent<PySdkSettings.State> {
companion object {
@JvmStatic
val instance: PySdkSettings = ServiceManager.getService(PySdkSettings::class.java)
private const val VIRTUALENV_ROOT_DIR_MACRO_NAME = "VIRTUALENV_ROOT_DIR"
}
private val state: State = State()
var useNewEnvironmentForNewProject: Boolean
get() = state.USE_NEW_ENVIRONMENT_FOR_NEW_PROJECT
set(value) {
state.USE_NEW_ENVIRONMENT_FOR_NEW_PROJECT = value
}
var preferredEnvironmentType: String?
get() = state.PREFERRED_ENVIRONMENT_TYPE
set(value) {
state.PREFERRED_ENVIRONMENT_TYPE = value
}
var preferredVirtualEnvBaseSdk: String?
get() = state.PREFERRED_VIRTUALENV_BASE_SDK
set(value) {
state.PREFERRED_VIRTUALENV_BASE_SDK = value
}
fun setPreferredVirtualEnvBasePath(value: @SystemIndependent String, projectPath: @SystemIndependent String) {
val pathMap = ReplacePathToMacroMap().apply {
addMacroReplacement(projectPath, PathMacroUtil.PROJECT_DIR_MACRO_NAME)
addMacroReplacement(defaultVirtualEnvRoot, VIRTUALENV_ROOT_DIR_MACRO_NAME)
}
val pathToSave = when {
FileUtil.isAncestor(projectPath, value, true) -> value.trimEnd { !it.isLetter() }
else -> PathUtil.getParentPath(value)
}
state.PREFERRED_VIRTUALENV_BASE_PATH = pathMap.substitute(pathToSave, true)
}
fun getPreferredVirtualEnvBasePath(projectPath: @SystemIndependent String): @SystemIndependent String {
val pathMap = ExpandMacroToPathMap().apply {
addMacroExpand(PathMacroUtil.PROJECT_DIR_MACRO_NAME, projectPath)
addMacroExpand(VIRTUALENV_ROOT_DIR_MACRO_NAME, defaultVirtualEnvRoot)
}
val defaultPath = when {
defaultVirtualEnvRoot != userHome -> defaultVirtualEnvRoot
else -> "$${PathMacroUtil.PROJECT_DIR_MACRO_NAME}$/venv"
}
val rawSavedPath = state.PREFERRED_VIRTUALENV_BASE_PATH ?: defaultPath
val savedPath = pathMap.substitute(rawSavedPath, true)
return when {
FileUtil.isAncestor(projectPath, savedPath, true) -> savedPath
else -> "$savedPath/${PathUtil.getFileName(projectPath)}"
}
}
override fun getState() = state
override fun loadState(state: PySdkSettings.State) {
XmlSerializerUtil.copyBean(state, this.state)
}
@Suppress("PropertyName")
class State {
@JvmField
var USE_NEW_ENVIRONMENT_FOR_NEW_PROJECT: Boolean = false
@JvmField
var PREFERRED_ENVIRONMENT_TYPE: String? = null
@JvmField
var PREFERRED_VIRTUALENV_BASE_PATH: String? = null
@JvmField
var PREFERRED_VIRTUALENV_BASE_SDK: String? = null
}
private val defaultVirtualEnvRoot: @SystemIndependent String
get() = VirtualEnvSdkFlavor.getDefaultLocation()?.path ?: userHome
private val userHome: @SystemIndependent String
get() = FileUtil.toSystemIndependentName(SystemProperties.getUserHome())
} | python/src/com/jetbrains/python/sdk/PySdkSettings.kt | 1266437475 |
package co.garmax.materialflashlight.ui.main
import android.animation.ArgbEvaluator
import android.animation.ValueAnimator
import android.os.Bundle
import android.text.Editable
import android.text.TextWatcher
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.annotation.ColorRes
import androidx.core.content.ContextCompat
import androidx.vectordrawable.graphics.drawable.AnimatedVectorDrawableCompat
import co.garmax.materialflashlight.BuildConfig
import co.garmax.materialflashlight.R
import co.garmax.materialflashlight.databinding.FragmentMainBinding
import co.garmax.materialflashlight.extensions.observeNotNull
import co.garmax.materialflashlight.features.modes.ModeBase.Mode
import co.garmax.materialflashlight.features.modules.ModuleBase.Module
import co.garmax.materialflashlight.service.ForegroundService
import co.garmax.materialflashlight.ui.BaseFragment
import org.koin.androidx.viewmodel.ext.android.viewModel
import timber.log.Timber
class MainFragment : BaseFragment() {
private val viewModel by viewModel<MainViewModel>()
private val binding get() = _binding!!
private var _binding: FragmentMainBinding? = null
private var animatedDrawableDay: AnimatedVectorDrawableCompat? = null
private var animatedDrawableNight: AnimatedVectorDrawableCompat? = null
private var backgroundColorAnimation: ValueAnimator? = null
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
_binding = FragmentMainBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
setupLayout(savedInstanceState)
setupViewModel()
}
private fun setupLayout(savedInstanceState: Bundle?) {
animatedDrawableDay =
AnimatedVectorDrawableCompat.create(requireContext(), R.drawable.avc_appbar_day)
animatedDrawableNight =
AnimatedVectorDrawableCompat.create(requireContext(), R.drawable.avc_appbar_night)
with(binding) {
fab.setOnClickListener {
if (viewModel.isLightTurnedOn) {
ForegroundService.stopService(requireContext())
} else {
ForegroundService.startService(requireContext())
}
}
layoutKeepScreenOn.setOnClickListener { binding.switchKeepScreenOn.toggle() }
layoutAutoTurnOn.setOnClickListener { binding.switchAutoTurnOn.toggle() }
layoutContent.setBackgroundColor(
ContextCompat.getColor(
requireContext(),
if (viewModel.isLightTurnedOn) R.color.green else R.color.colorPrimaryLight
)
)
if (savedInstanceState == null) {
// Set module
when (viewModel.lightModule) {
Module.MODULE_CAMERA_FLASHLIGHT -> radioCameraFlashlight.isChecked = true
Module.MODULE_SCREEN -> radioScreen.isChecked = true
}
when (viewModel.lightMode) {
Mode.MODE_INTERVAL_STROBE -> radioIntervalStrobe.isChecked = true
Mode.MODE_TORCH -> radioTorch.isChecked = true
Mode.MODE_SOUND_STROBE -> radioSoundStrobe.isChecked = true
Mode.MODE_SOS -> radioSos.isChecked = true
}
intervalStrobeOn.setText(viewModel.strobeOnPeriod.toString())
intervalStrobeOff.setText(viewModel.strobeOffPeriod.toString())
} else {
setState(viewModel.isLightTurnedOn, false)
}
intervalStrobeTiming.visibility =
if (radioIntervalStrobe.isChecked) View.VISIBLE
else View.GONE
switchKeepScreenOn.isChecked = viewModel.isKeepScreenOn
fab.keepScreenOn = viewModel.isKeepScreenOn
switchAutoTurnOn.isChecked = viewModel.isAutoTurnedOn
radioSoundStrobe.setOnCheckedChangeListener { _, isChecked ->
if (isChecked) viewModel.setMode(Mode.MODE_SOUND_STROBE)
}
radioIntervalStrobe.setOnCheckedChangeListener { _, isChecked ->
if (isChecked) {
viewModel.setMode(Mode.MODE_INTERVAL_STROBE)
intervalStrobeTiming.visibility = View.VISIBLE
} else {
intervalStrobeTiming.visibility = View.GONE
}
}
radioTorch.setOnCheckedChangeListener { _, isChecked ->
if (isChecked) viewModel.setMode(Mode.MODE_TORCH)
}
radioSos.setOnCheckedChangeListener { _, isChecked ->
if (isChecked) viewModel.setMode(Mode.MODE_SOS)
}
radioCameraFlashlight.setOnCheckedChangeListener { _, isChecked ->
if (isChecked) viewModel.setModule(Module.MODULE_CAMERA_FLASHLIGHT)
}
radioScreen.setOnCheckedChangeListener { _, isChecked ->
if (isChecked) viewModel.setModule(Module.MODULE_SCREEN)
}
switchKeepScreenOn.setOnCheckedChangeListener { _, isChecked ->
viewModel.isKeepScreenOn = isChecked
fab.keepScreenOn = isChecked
}
switchAutoTurnOn.setOnCheckedChangeListener { _, isChecked ->
viewModel.isAutoTurnedOn = isChecked
}
val textWatcherObject = object: TextWatcher {
override fun afterTextChanged(p0: Editable?) {}
override fun beforeTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {}
override fun onTextChanged(p0: CharSequence?, start: Int, before: Int, count: Int) {
val strobeOnString = intervalStrobeOn.text.toString()
val strobeOn = if (strobeOnString == "") 0 else Integer.parseInt(strobeOnString)
val strobeOffString = intervalStrobeOff.text.toString()
val strobeOff = if (strobeOffString == "") 0 else Integer.parseInt(strobeOffString)
viewModel.setStrobePeriod(strobeOn, strobeOff)
}
}
intervalStrobeOn.addTextChangedListener(textWatcherObject)
intervalStrobeOff.addTextChangedListener(textWatcherObject)
textVersion.text = getString(R.string.text_version, BuildConfig.VERSION_NAME)
}
}
private fun setupViewModel() {
// Handle toggle of the light
observeNotNull(viewModel.liveDataLightToggle) { setState(it, true) }
}
private fun setState(isLightOn: Boolean, animated: Boolean) {
Timber.d("Light toggle %s, animated %s", isLightOn, animated)
with(binding) {
if (isLightOn) {
// Fab image
fab.setImageResource(R.drawable.ic_power_on)
// Appbar image
if (animated) {
imageAppbar.setImageDrawable(animatedDrawableDay)
animatedDrawableDay?.start()
animateBackground(R.color.colorPrimaryLight, R.color.green)
} else {
imageAppbar.setImageResource(R.drawable.vc_appbar_day)
layoutContent.setBackgroundResource(R.color.green)
}
} else {
// Fab image
fab.setImageResource(R.drawable.ic_power_off)
// Appbar image
if (animated) {
imageAppbar.setImageDrawable(animatedDrawableNight)
animatedDrawableNight?.start()
animateBackground(R.color.green, R.color.colorPrimaryLight)
} else {
imageAppbar.setImageResource(R.drawable.vc_appbar_night)
layoutContent.setBackgroundResource(R.color.colorPrimaryLight)
}
}
}
}
private fun animateBackground(@ColorRes fromColorResId: Int, @ColorRes toColorResId: Int) {
val colorFrom: Int = ContextCompat.getColor(requireContext(), fromColorResId)
val colorTo: Int = ContextCompat.getColor(requireContext(), toColorResId)
if (backgroundColorAnimation?.isRunning == true) {
backgroundColorAnimation?.cancel()
}
backgroundColorAnimation =
ValueAnimator.ofObject(ArgbEvaluator(), colorFrom, colorTo).apply {
duration = resources.getInteger(R.integer.animation_time).toLong()
addUpdateListener { animator: ValueAnimator ->
binding.layoutContent.setBackgroundColor(
animator.animatedValue as Int
)
}
start()
}
}
} | app/src/main/java/co/garmax/materialflashlight/ui/main/MainFragment.kt | 581361813 |
/*
* Copyright 2017 [email protected]
*
* 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 nomic.hive.adapter
import com.github.mustachejava.DefaultMustacheFactory
import nomic.hive.InvalidHiveQueryException
import java.io.Reader
import java.io.StringReader
import java.io.StringWriter
import java.sql.Connection
import java.sql.DriverManager
/**
* This implementation of [HiveAdapter] use JDBC for connecting to
* HIVE instance. For placeholder replacing is used Mustache as
* template engine
*
* @author [email protected]
*/
class JdbcHiveAdapter(jdbcUrl: String, username: String, password: String) : HiveAdapter {
/// ref to JDBC connections
private val connection: Connection;
/// ref to Mustache template engine
private val mustache: DefaultMustacheFactory;
/**
* initialize and create connection to Hive
*/
init {
Class.forName("org.apache.hive.jdbc.HiveDriver");
connection = DriverManager.getConnection(jdbcUrl, username, password)
mustache = DefaultMustacheFactory()
}
//-------------------------------------------------------------------------------------------------
// implemented functions
//-------------------------------------------------------------------------------------------------
/**
* parse script to queries,replace placeholders with fields, and execute these
* queries.
*/
override fun exec(script: Reader, fields: Map<String, Any>):Boolean {
val replacedScript = replacePlaceholders(script, fields)
return exec(replacedScript)
}
/**
* parse script to queries and execute them
*/
override fun exec(script: Reader):Boolean {
val filteredScript = removeComments(script)
val queries = splitSemiColon(filteredScript.readText());
var allRes = true;
for (query: String in queries) {
var res = exec(query)
if (!res) {
allRes = false;
}
}
return allRes;
}
/**
* parse string to queries,replace placeholders with fields, and execute these
* queries.
*/
override fun exec(query: String, fields: Map<String, Any>):Boolean {
val replacedQuery = replacePlaceholders(StringReader(query), fields).readText()
return exec(replacedQuery)
}
/**
* parse string to queries and execute them
*/
override fun exec(query: String):Boolean {
val trimmed = query.trim()
if (!trimmed.isBlank()) {
try {
val stmt = connection.prepareStatement(trimmed)
return stmt.execute();
} catch (e: Exception) {
throw InvalidHiveQueryException(trimmed, e)
}
}
return true;
}
//-------------------------------------------------------------------------------------------------
// private functions
//-------------------------------------------------------------------------------------------------
private fun replacePlaceholders(script: Reader, fields:Map<String, Any>): Reader {
val sm = "${'$'}{"
val em = "}"
val template = mustache.compile(script, "", sm, em);
val result = StringWriter()
template.execute(result, fields)
return result.toString().reader()
}
/**
* remove lines starting with '--'
*/
private fun removeComments(query: Reader): Reader =
query.readLines()
.filter { line -> !line.startsWith("--") }
.reduce {a, b -> a + " " + b }
.reader()
/**
* "stolen" from HIVE CLI (https://github.com/apache/hive/blob/master/cli/src/java/org/apache/hadoop/hive/cli/CliDriver.java#428)
* but I need exactly this functionality to keep it compatible.
*/
private fun splitSemiColon(line: String): List<String> {
var insideSingleQuote = false
var insideDoubleQuote = false
var escape = false
var beginIndex = 0
val ret:MutableList<String> = mutableListOf()
for (index in 0..line.length - 1) {
if (line[index] == '\'') {
// take a look to see if it is escaped
if (!escape) {
// flip the boolean variable
insideSingleQuote = !insideSingleQuote
}
} else if (line[index] == '\"') {
// take a look to see if it is escaped
if (!escape) {
// flip the boolean variable
insideDoubleQuote = !insideDoubleQuote
}
} else if (line[index] == ';') {
if (insideSingleQuote || insideDoubleQuote) {
// do not split
} else {
// split, do not include ; itself
ret.add(line.substring(beginIndex, index))
beginIndex = index + 1
}
} else {
// nothing to do
}
// set the escape
if (escape) {
escape = false
} else if (line[index] == '\\') {
escape = true
}
}
ret.add(line.substring(beginIndex))
return ret
}
} | nomic-hive/src/main/kotlin/nomic/hive/adapter/JdbcHiveAdapter.kt | 1034359320 |
package info.nightscout.androidaps.plugins.pump.omnipod.dash.driver.pod.definition
enum class ActivationProgress {
NOT_STARTED,
GOT_POD_VERSION,
SET_UNIQUE_ID,
PROGRAMMED_LOW_RESERVOIR_ALERTS,
REPROGRAMMED_LUMP_OF_COAL_ALERT,
PRIMING,
PRIME_COMPLETED,
PHASE_1_COMPLETED,
PROGRAMMED_BASAL,
UPDATED_EXPIRATION_ALERTS,
INSERTING_CANNULA,
CANNULA_INSERTED,
COMPLETED;
fun isBefore(other: ActivationProgress): Boolean = ordinal < other.ordinal
fun isAtLeast(other: ActivationProgress): Boolean = ordinal >= other.ordinal
}
| omnipod-dash/src/main/java/info/nightscout/androidaps/plugins/pump/omnipod/dash/driver/pod/definition/ActivationProgress.kt | 327169521 |
package expo.modules.updates.loader
import androidx.test.internal.runner.junit4.AndroidJUnit4ClassRunner
import org.junit.Assert
import org.junit.Test
import org.junit.runner.RunWith
import java.security.cert.CertificateException
import java.security.cert.CertificateExpiredException
private const val testBody = "{\"id\":\"0754dad0-d200-d634-113c-ef1f26106028\",\"createdAt\":\"2021-11-23T00:57:14.437Z\",\"runtimeVersion\":\"1\",\"assets\":[{\"hash\":\"cb65fafb5ed456fc3ed8a726cf4087d37b875184eba96f33f6d99104e6e2266d\",\"key\":\"489ea2f19fa850b65653ab445637a181.jpg\",\"contentType\":\"image/jpeg\",\"url\":\"http://192.168.64.1:3000/api/assets?asset=updates/1/assets/489ea2f19fa850b65653ab445637a181&runtimeVersion=1&platform=android\",\"fileExtension\":\".jpg\"}],\"launchAsset\":{\"hash\":\"323ddd1968ee76d4ddbb16b04fb2c3f1b6d1ab9b637d819699fecd6fa0ffb1a8\",\"key\":\"696a70cf7035664c20ea86f67dae822b.bundle\",\"contentType\":\"application/javascript\",\"url\":\"http://192.168.64.1:3000/api/assets?asset=updates/1/bundles/android-696a70cf7035664c20ea86f67dae822b.js&runtimeVersion=1&platform=android\",\"fileExtension\":\".bundle\"}}"
private const val testCertificate = "-----BEGIN CERTIFICATE-----\nMIIDfzCCAmegAwIBAgIJLGiqnjmA9JmpMA0GCSqGSIb3DQEBCwUAMGkxFDASBgNV\nBAMTC2V4YW1wbGUub3JnMQswCQYDVQQGEwJVUzERMA8GA1UECBMIVmlyZ2luaWEx\nEzARBgNVBAcTCkJsYWNrc2J1cmcxDTALBgNVBAoTBFRlc3QxDTALBgNVBAsTBFRl\nc3QwHhcNMjExMTIyMTc0NzQzWhcNMjIxMTIyMTc0NzQzWjBpMRQwEgYDVQQDEwtl\neGFtcGxlLm9yZzELMAkGA1UEBhMCVVMxETAPBgNVBAgTCFZpcmdpbmlhMRMwEQYD\nVQQHEwpCbGFja3NidXJnMQ0wCwYDVQQKEwRUZXN0MQ0wCwYDVQQLEwRUZXN0MIIB\nIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAucg/fRwgYLxO4fDG1W/ew4Wu\nkqp2+j9mLyA18sd8noCT0eSJwxMTLJJq4biNx6kJEVSQdodN3e/qSJndz+ZHA7b1\n6Do3Ecg5oRvl3HEwaH4AkM2Lj87VjgfxPUsiSHtPd+RTbxnOy9lGupQa/j71WrAq\nzJpNmhP70vzkY4EVejn52kzRPZB3kTxkjggFrG/f18Bcf4VYxN3aLML32jih+UC0\n6fv57HNZZ3ewGSJrLcUdEgctBWiz1gzwF6YdXtEJ14eQbgHgsLsXaEQeg2ncGGxF\n/3rIhsnlWjeIIya7TS0nvqZHNKznZV9EWpZQBFVoLGGrvOdU3pTmP39qbmY0nwID\nAQABoyowKDAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwMw\nDQYJKoZIhvcNAQELBQADggEBAALcH9Jb3wq64YkNxUIa25T9umhr4uRe94ESHujM\nIRrBbbqu1p3Vs8N3whZNhcL6Djb4ob18m/aGKbF+UQBMvhn23qRCG6KKzIeDY6Os\n8tYyIwush2XeOFA7S5syPqVBI6PrRBDMCLmAJO4qTM2p0f+zyFXFuytCXOv2fA3M\n88aYVmU7NIfBTFdqNIgSt1yj7FKvd5zgoUyu7mTVdzY59xQzkzYTsnobY2XrTcvY\n6wyRqOAQ86wR8OvDjHB5y/YN2Pdg7d9jUFBCX6Ohr7W3GHrjAadKwq+kbH1aP0oB\nQTFLQQfl3gtJ3Dl/5iBQD38sCIkA54FPSsKTRw3mC4DImBQ=\n-----END CERTIFICATE-----"
private const val testSignature = "sig=\"VpuLfRlB0DizR+hRWmedPGHdx/nzNJ8OomMZNGHwqx64zrx1XezriBoItup/icOlXFrqs6FHaul4g5m41JfEWCUbhXC4x+iNk//bxozEYJHmjbcAtC6xhWbMMYQQaUjuYk7rEL987AbOWyUI2lMhrhK7LNzBaT8RGqBcpEyAqIOMuEKcK0faySnWJylc7IzxHmO8jlx5ufzio8301wej8mNW5dZd7PFOX8Dz015tIpF00VGi29ShDNFbpnalch7f92NFs08Z0g9LXndmrGjNL84Wqd4kq5awRGQObrCuDHU4uFdZjtr4ew0JaNlVuyUrrjyDloBdq0aR804vuDXacQ==\""
private const val testCertificateValidityExpired = "-----BEGIN CERTIFICATE-----\nMIIDfzCCAmegAwIBAgIJUMTYibP/SwICMA0GCSqGSIb3DQEBCwUAMGkxFDASBgNV\nBAMTC2V4YW1wbGUub3JnMQswCQYDVQQGEwJVUzERMA8GA1UECBMIVmlyZ2luaWEx\nEzARBgNVBAcTCkJsYWNrc2J1cmcxDTALBgNVBAoTBFRlc3QxDTALBgNVBAsTBFRl\nc3QwHhcNMjIwMTEzMjEyNDA2WhcNMjIwMTEzMjEyNDA2WjBpMRQwEgYDVQQDEwtl\neGFtcGxlLm9yZzELMAkGA1UEBhMCVVMxETAPBgNVBAgTCFZpcmdpbmlhMRMwEQYD\nVQQHEwpCbGFja3NidXJnMQ0wCwYDVQQKEwRUZXN0MQ0wCwYDVQQLEwRUZXN0MIIB\nIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuFzjX8khaNUKLBAnywPK7olI\nkFIYrCHCRMJrsd8h/bES9ieFuhycNw8/4JdTd3fq7j8WFYR9OAUeddmh7Z9dB5DR\nQOg1Iy4raODPPpgtTsjQSLf/bDh47WBmqnCapWTImphp9ABfqrWRT404DrV4rlKP\ntp4a0PF2HDeGDKu9GrCt6Ui+lA95rQzkBosE603ljkT8jJfE2McboGi7RXvyUl8N\nXpx9Pzvdkf5yUChgtWF8LZIHIKU1Ozcx5GfIGIQ44JRZIOpHS4jRPkItrOqDvvuZ\nFRLdrmEDr+QIeHutTKeTOPyhiRxz33L6S+DT7hGvQxtcuFAfri866CoGp3GxawID\nAQABoyowKDAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwMw\nDQYJKoZIhvcNAQELBQADggEBAA2U+1FgCEA96aNeb33Ce37tUWRcVH8sSQdaFRJa\nvEU8jW+d+bXWS9DFfarLdBP5BvOCd1lr63vqkUbB04MgsGtLARmR1fRxBs18XKIl\njiOeDNvsRwkG7zz5Td6/J0Zt6m0Csl5RwSIaN7wM1QAkD9NukMBTQsAghMSfyqry\na1b0zVegz5nR744dcs82QxAnxD6UFQgu2pvV0TklAdbLI1kgnv7v+7V4g+UMOMIa\nEjtx2ikPNziuPxxS6zPkWiFOgmii+jtWkJt55YZRQsrzmKHX8iQL79FguqHchfeM\njfcCAqPuMRzQErPGvS9rmdofsvuXK/3xldt/ujFyLw6TGZ8=\n-----END CERTIFICATE-----"
private const val testCertificateNoKeyUsage = "-----BEGIN CERTIFICATE-----\nMIIDUzCCAjugAwIBAgIJSvGkSo8+4UukMA0GCSqGSIb3DQEBCwUAMGkxFDASBgNV\nBAMTC2V4YW1wbGUub3JnMQswCQYDVQQGEwJVUzERMA8GA1UECBMIVmlyZ2luaWEx\nEzARBgNVBAcTCkJsYWNrc2J1cmcxDTALBgNVBAoTBFRlc3QxDTALBgNVBAsTBFRl\nc3QwHhcNMjIwMTEzMjEyNTAxWhcNMjMwMTEzMjEyNTAxWjBpMRQwEgYDVQQDEwtl\neGFtcGxlLm9yZzELMAkGA1UEBhMCVVMxETAPBgNVBAgTCFZpcmdpbmlhMRMwEQYD\nVQQHEwpCbGFja3NidXJnMQ0wCwYDVQQKEwRUZXN0MQ0wCwYDVQQLEwRUZXN0MIIB\nIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArp9E7jQyOsA2IyGCX5tR9hsR\n/FCUBkSfpqlQejtKMlaX3XUmhDi8RgT0SGsqEztpmXVWHQuXHMJ4//N9kdSkZtK0\n5D2ZxEIrdOq/R+KfVtlLbwiOc1c4ApVIrJofXNntKK7nUR2AwF2pLjqD6wV6Pzsi\nYOtvykwZE4pvUnEluN6K5Sj509gq+vh68nmY2F/i16zZ/jULoRYmQHVhb6Dl2SEW\nuMIJB0hXPa0hC/hV1bmWDeCGOHgv4Ah0lK7KySlah29Z9a6Xxs6doYjGKc4HEOSb\nkEfSkIysqIn69FfzKlkSGj6oKtZezUfXHpgQcBjuTroePHy19QBM1CfSTJ10wQID\nAQABMA0GCSqGSIb3DQEBCwUAA4IBAQCAE35etL3iKVYTMA1nlmPgp9JBJzu33xT9\npY9pIG2Xuco4yXgFKrDC3FBp4/jp2eKcABzAUvlnU5g7WW3HoYwvXuceGR5bt71r\n36fkFU0V1wWg8cro0uJI8obBX2RceZ4KJze7+TPygRAXbZHl+I0MJs0NHkoRdBMb\n5v5N2i1BkCzP+yxkAogQTQ8or0761QMUDxbtcadUJqworNzJCK0Fk4wmX41JLPNh\nv0DjycUkJKikXHDiyE41Mmn7feIPepNOGEM6tmrLFut3iXrQPVar9ZtJyTnVdGSR\nfLIHcXU2vKNav2X36xFGkqAVMO3Y2ut7mfwpd3TcSrsjng54MjZo\n-----END CERTIFICATE-----"
private const val testCertificateNoCodeSigningExtendedKeyUsage = "-----BEGIN CERTIFICATE-----\nMIIDdTCCAl2gAwIBAgIJCJvpeGIP+bCfMA0GCSqGSIb3DQEBCwUAMGkxFDASBgNV\nBAMTC2V4YW1wbGUub3JnMQswCQYDVQQGEwJVUzERMA8GA1UECBMIVmlyZ2luaWEx\nEzARBgNVBAcTCkJsYWNrc2J1cmcxDTALBgNVBAoTBFRlc3QxDTALBgNVBAsTBFRl\nc3QwHhcNMjIwMTEzMjEyOTMwWhcNMjMwMTEzMjEyOTMwWjBpMRQwEgYDVQQDEwtl\neGFtcGxlLm9yZzELMAkGA1UEBhMCVVMxETAPBgNVBAgTCFZpcmdpbmlhMRMwEQYD\nVQQHEwpCbGFja3NidXJnMQ0wCwYDVQQKEwRUZXN0MQ0wCwYDVQQLEwRUZXN0MIIB\nIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA82yZpjIloSl5wQeZl1Sc9RP0\nJ7CYJvG1dVhZ253jeDaItq7iyM4Aplz4wPxGalOlKeg8ozT4/Iz0xA2f1wuOxvXW\nICY4p7S3aJklDhFb89Uilh+JQAdchHIxJJX15rMtcRaJOTnSxN9HOPyQv1L778BU\nwJQMUoOS7g2xH9N7az/g87ynEy/kDl3j/LsBWLVRQjqlZP9EArVeQgObMbinD/FR\naxMKrbdZsxnMsbTxsMmRzl9mWS4w0suHQIxd9/XJXJhU8tvlJUfX+v/GDgaWDRQr\naxo4Al8Sk8Yoo5+MhUXmWXj1qgR1xeLbWjCSAzJu6iBBbCt7/Qe3/IiA7XD/KwID\nAQABoyAwHjAOBgNVHQ8BAf8EBAMCB4AwDAYDVR0lAQH/BAIwADANBgkqhkiG9w0B\nAQsFAAOCAQEAlGgAnpg5+VavyvVk//4mMVbYZNtZqRt3oZvXuNGESHdcZ1teGy+Q\nHmRw85Q4iUkdLvE1pmEmcHzWNiNVisnK3PzC9iB2kfGAiWgxmwq418BHVpPIoVds\nULgFT+25rW6slIhbXPlUt7lTCQXKsPxu0z1TuHYW4iR+iw0Szg1uChJ0piBOa2yU\nbzQySAA/1VWxhEXozN1w1VEn1UUBwWg8/dY1s/p4+fFsjjaUPe+jrVGnqxIP4SCF\nbH1xqdYet4yZas1xAZJemKiIc0YkqKvlydhKlObV0lqssyFPpM32WyRPTsxGhcbP\nie/CX1Di+wxp/yqbXK7lhDzFiFzLLQtfUQ==\n-----END CERTIFICATE-----"
@RunWith(AndroidJUnit4ClassRunner::class)
class CryptoTest {
@Test
fun test_parseSignatureHeader_ParsesCodeSigningInfo() {
val codeSigningInfo = Crypto.parseSignatureHeader("sig=\"12345\", keyid=\"test\", alg=\"rsa-v1_5-sha256\"")
Assert.assertEquals(codeSigningInfo.signature, "12345")
Assert.assertEquals(codeSigningInfo.keyId, "test")
Assert.assertEquals(codeSigningInfo.algorithm, Crypto.CodeSigningAlgorithm.RSA_SHA256)
}
@Test
fun test_parseSignatureHeader_DefaultsKeyIdAndAlg() {
val codeSigningInfo = Crypto.parseSignatureHeader("sig=\"12345\"")
Assert.assertEquals(codeSigningInfo.signature, "12345")
Assert.assertEquals(codeSigningInfo.keyId, "root")
Assert.assertEquals(codeSigningInfo.algorithm, Crypto.CodeSigningAlgorithm.RSA_SHA256)
}
@Test(expected = Exception::class)
@Throws(Exception::class)
fun test_parseSignatureHeader_ThrowsForInvalidAlg() {
Crypto.parseSignatureHeader("sig=\"12345\", alg=\"blah\"")
}
@Test
fun test_createAcceptSignatureHeader_CreatesSignatureHeaderDefaultValues() {
val configuration = Crypto.CodeSigningConfiguration(testCertificate, mapOf())
val signatureHeader = Crypto.createAcceptSignatureHeader(configuration)
Assert.assertEquals(signatureHeader, "sig, keyid=\"root\", alg=\"rsa-v1_5-sha256\"")
}
@Test
fun test_createAcceptSignatureHeader_CreatesSignatureHeaderValuesFromConfig() {
val configuration = Crypto.CodeSigningConfiguration(
testCertificate,
mapOf(
Crypto.CODE_SIGNING_METADATA_ALGORITHM_KEY to "rsa-v1_5-sha256",
Crypto.CODE_SIGNING_METADATA_KEY_ID_KEY to "test"
)
)
val signatureHeader = Crypto.createAcceptSignatureHeader(configuration)
Assert.assertEquals(signatureHeader, "sig, keyid=\"test\", alg=\"rsa-v1_5-sha256\"")
}
@Test
fun test_createAcceptSignatureHeader_CreatesSignatureHeaderEscapedValues() {
val configuration = Crypto.CodeSigningConfiguration(
testCertificate,
mapOf(
Crypto.CODE_SIGNING_METADATA_ALGORITHM_KEY to "rsa-v1_5-sha256",
Crypto.CODE_SIGNING_METADATA_KEY_ID_KEY to """test"hello\"""
)
)
val signatureHeader = Crypto.createAcceptSignatureHeader(configuration)
Assert.assertEquals("""sig, keyid="test\"hello\\", alg="rsa-v1_5-sha256"""", signatureHeader)
}
@Test(expected = Exception::class)
@Throws(Exception::class)
fun test_createAcceptSignatureHeader_ThrowsInvalidAlg() {
val configuration = Crypto.CodeSigningConfiguration(
testCertificate,
mapOf(
Crypto.CODE_SIGNING_METADATA_ALGORITHM_KEY to "fake",
Crypto.CODE_SIGNING_METADATA_KEY_ID_KEY to "test"
)
)
Crypto.createAcceptSignatureHeader(configuration)
}
@Test
fun test_verifyCodeSigning_Verifies() {
val codeSigningConfiguration = Crypto.CodeSigningConfiguration(testCertificate, mapOf())
val codesigningInfo = Crypto.parseSignatureHeader(testSignature)
val isValid = Crypto.isSignatureValid(codeSigningConfiguration, codesigningInfo, testBody.toByteArray())
Assert.assertTrue(isValid)
}
@Test
fun test_verifyCodeSigning_ReturnsFalseWhenSignatureIsInvalid() {
val codeSigningConfiguration = Crypto.CodeSigningConfiguration(testCertificate, mapOf())
val codesigningInfo = Crypto.parseSignatureHeader("sig=\"aGVsbG8=\"")
val isValid = Crypto.isSignatureValid(codeSigningConfiguration, codesigningInfo, testBody.toByteArray())
Assert.assertFalse(isValid)
}
@Test(expected = Exception::class)
@Throws(Exception::class)
fun test_verifyCodeSigning_ThrowsWhenKeyDoesNotMatch() {
val codeSigningConfiguration = Crypto.CodeSigningConfiguration(
testCertificate,
mapOf(
Crypto.CODE_SIGNING_METADATA_KEY_ID_KEY to "test"
)
)
val codesigningInfo = Crypto.parseSignatureHeader("sig=\"aGVsbG8=\", keyid=\"other\"")
Crypto.isSignatureValid(codeSigningConfiguration, codesigningInfo, testBody.toByteArray())
}
@Test(expected = CertificateException::class)
@Throws(CertificateException::class)
fun test_construct_multipleCertsInPEMThrowsError() {
Crypto.CodeSigningConfiguration(
testCertificate + testCertificate,
mapOf(
Crypto.CODE_SIGNING_METADATA_KEY_ID_KEY to "test"
)
).embeddedCertificate
}
@Test(expected = CertificateExpiredException::class)
@Throws(CertificateExpiredException::class)
fun test_construct_ValidityExpiredThrowsError() {
Crypto.CodeSigningConfiguration(
testCertificateValidityExpired,
mapOf(
Crypto.CODE_SIGNING_METADATA_KEY_ID_KEY to "test"
)
).embeddedCertificate
}
@Test(expected = CertificateException::class)
@Throws(CertificateException::class)
fun test_construct_NoKeyUsageThrowsError() {
Crypto.CodeSigningConfiguration(
testCertificateNoKeyUsage,
mapOf(
Crypto.CODE_SIGNING_METADATA_KEY_ID_KEY to "test"
)
).embeddedCertificate
}
@Test(expected = CertificateException::class)
@Throws(CertificateException::class)
fun test_construct_NoCodeSigningExtendedKeyUsageThrowsError() {
Crypto.CodeSigningConfiguration(
testCertificateNoCodeSigningExtendedKeyUsage,
mapOf(
Crypto.CODE_SIGNING_METADATA_KEY_ID_KEY to "test"
)
).embeddedCertificate
}
}
| packages/expo-updates/android/src/androidTest/java/expo/modules/updates/loader/CryptoTest.kt | 1021928974 |
package expo.modules.devmenu.tests
import expo.interfaces.devmenu.DevMenuSettingsInterface
interface DevMenuTestInterceptor {
fun overrideSettings(): DevMenuSettingsInterface?
}
| packages/expo-dev-menu/android/src/main/java/expo/modules/devmenu/tests/DevMenuTestInterceptor.kt | 1395203057 |
package net.dean.jraw.test.unit
import com.winterbe.expekt.should
import net.dean.jraw.RedditClient
import net.dean.jraw.http.HttpRequest
import net.dean.jraw.http.SimpleHttpLogger
import net.dean.jraw.test.InMemoryLogAdapter
import net.dean.jraw.test.MockNetworkAdapter
import net.dean.jraw.test.expectException
import net.dean.jraw.test.newMockRedditClient
import org.jetbrains.spek.api.Spek
import org.jetbrains.spek.api.dsl.it
import kotlin.properties.Delegates
class SimpleHttpLoggerTest : Spek({
val logAdapter = InMemoryLogAdapter()
var reddit: RedditClient by Delegates.notNull()
val mockAdapter = MockNetworkAdapter()
beforeGroup {
reddit = newMockRedditClient(mockAdapter)
}
beforeEachTest {
mockAdapter.start()
reddit.logger = SimpleHttpLogger(out = logAdapter, maxLineLength = 120)
}
it("should log both input and output") {
val url = "http://example.com/foo"
val res = """{"foo":"bar"}"""
mockAdapter.enqueue(res)
reddit.request(HttpRequest.Builder()
.rawJson(false)
.url(url)
.build())
logAdapter.output().should.equal(listOf(
"[1 ->] GET $url",
"[<- 1] 200 application/json: '$res'"
))
}
it("should keep a record of all requests sent during its time logging") {
val times = 5
val res = """{"foo":"bar"}"""
for (i in 0 until times) {
mockAdapter.enqueue(res)
reddit.request(HttpRequest.Builder()
.url("http://example.com/foo")
.build())
}
val output = logAdapter.output()
output.should.have.size(times * 2) // 1 for the request, 1 for the response
for (i in 1..times) {
output[(i - 1) * 2].should.startWith("[$i ->] ")
output[(i - 1) * 2 + 1].should.startWith("[<- $i] ")
}
}
it("should truncate all lines to maxLineLength if above 0") {
val maxLineLength = 50
reddit.logger = SimpleHttpLogger(out = logAdapter, maxLineLength = maxLineLength)
mockAdapter.enqueue("""{"foo": "${"bar".repeat(100)}"}""")
reddit.request {
it.url("http://example.com/${"reallylongpath/".repeat(10)}")
.post(mapOf(
"key" to "value".repeat(15)
))
}
val output = logAdapter.output()
output.forEach { it.should.have.length(maxLineLength) }
}
it("should not truncate for a maxLineLength < 0") {
reddit.logger = SimpleHttpLogger(out = logAdapter, maxLineLength = -1)
val res = """{"foo": "${"bar".repeat(100)}"}"""
mockAdapter.enqueue(res)
reddit.request {
it.url("http://example.com/${"reallylongpath/".repeat(10)}")
.post(mapOf(
"key" to "value".repeat(30)
))
}
logAdapter.output().forEach { it.should.have.length.above(100) }
}
it("should throw an IllegalArgumentException if given a maxLineLength between 0 and ELLIPSIS.length") {
for (i in 0..SimpleHttpLogger.ELLIPSIS.length) {
expectException(IllegalArgumentException::class) {
SimpleHttpLogger(maxLineLength = i)
}
}
// Should not throw an exception
SimpleHttpLogger(maxLineLength = SimpleHttpLogger.ELLIPSIS.length + 1)
}
it("should log the request body when it's form URL-encoded data") {
val postData = mapOf("foo" to "bar", "baz" to "qux")
mockAdapter.enqueue("""{"foo":"bar"}""")
reddit.request(HttpRequest.Builder()
.url("http://example.com")
.post(postData)
.build())
val output = logAdapter.output()
/*
[12 ->] POST https://httpbin.org/post
form: form=foo
abc=123
[12 <-] application/json: <response>
*/
// One for the request, one for the response, one for every key-value pair in the post data
output.should.have.size(2 + postData.size)
// output[0] should be the basic request info
val baseIndent = " ".repeat("[0 ->]".length)
output[1].should.equal("$baseIndent form: foo=bar")
output[2].should.equal("$baseIndent baz=qux")
}
afterEachTest {
logAdapter.reset()
mockAdapter.reset()
}
})
| lib/src/test/kotlin/net/dean/jraw/test/unit/SimpleHttpLoggerTest.kt | 3681742118 |
/*
* Copyright 2002-2020 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 org.springframework.security.config.web.servlet
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.security.config.annotation.web.builders.HttpSecurity
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter
import org.springframework.security.config.test.SpringTestContext
import org.springframework.security.config.test.SpringTestContextExtension
import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestBuilders.formLogin
import org.springframework.security.web.savedrequest.NullRequestCache
import org.springframework.test.web.servlet.MockMvc
import org.springframework.test.web.servlet.get
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.redirectedUrl
/**
* Tests for [RequestCacheDsl]
*
* @author Eleftheria Stein
*/
@ExtendWith(SpringTestContextExtension::class)
class RequestCacheDslTests {
@JvmField
val spring = SpringTestContext(this)
@Autowired
lateinit var mockMvc: MockMvc
@Test
fun `GET when request cache enabled then redirected to cached page`() {
this.spring.register(RequestCacheConfig::class.java).autowire()
this.mockMvc.get("/test")
this.mockMvc.perform(formLogin())
.andExpect {
redirectedUrl("http://localhost/test")
}
}
@EnableWebSecurity
open class RequestCacheConfig : WebSecurityConfigurerAdapter() {
override fun configure(http: HttpSecurity) {
http {
requestCache { }
formLogin { }
}
}
}
@Test
fun `GET when custom request cache then custom request cache used`() {
this.spring.register(CustomRequestCacheConfig::class.java).autowire()
this.mockMvc.get("/test")
this.mockMvc.perform(formLogin())
.andExpect {
redirectedUrl("/")
}
}
@EnableWebSecurity
open class CustomRequestCacheConfig : WebSecurityConfigurerAdapter() {
override fun configure(http: HttpSecurity) {
http {
requestCache {
requestCache = NullRequestCache()
}
formLogin { }
}
}
}
}
| config/src/test/kotlin/org/springframework/security/config/web/servlet/RequestCacheDslTests.kt | 2166508636 |
package com.bluelinelabs.conductor.demo.controllers
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import com.bluelinelabs.conductor.Controller
import com.bluelinelabs.conductor.RouterTransaction.Companion.with
import com.bluelinelabs.conductor.autodispose.ControllerScopeProvider
import com.bluelinelabs.conductor.changehandler.HorizontalChangeHandler
import com.bluelinelabs.conductor.demo.R
import com.bluelinelabs.conductor.demo.ToolbarProvider
import com.bluelinelabs.conductor.demo.controllers.base.watchForLeaks
import com.bluelinelabs.conductor.demo.databinding.ControllerLifecycleBinding
import com.uber.autodispose.autoDisposable
import io.reactivex.Observable
import java.util.concurrent.TimeUnit
// Shamelessly borrowed from the official RxLifecycle demo by Trello and adapted for Conductor Controllers
// instead of Activities or Fragments.
class AutodisposeController : Controller() {
private val scopeProvider = ControllerScopeProvider.from(this)
init {
watchForLeaks()
Observable.interval(1, TimeUnit.SECONDS)
.doOnDispose { Log.i(TAG, "Disposing from constructor") }
.autoDisposable(scopeProvider)
.subscribe { num: Long ->
Log.i(TAG, "Started in constructor, running until onDestroy(): $num")
}
}
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup,
savedViewState: Bundle?
): View {
Log.i(TAG, "onCreateView() called")
val binding = ControllerLifecycleBinding.inflate(inflater, container, false)
binding.title.text = binding.root.resources.getString(R.string.rxlifecycle_title, TAG)
binding.nextReleaseView.setOnClickListener {
retainViewMode = RetainViewMode.RELEASE_DETACH
router.pushController(
with(TextController("Logcat should now report that the observables from onAttach() and onViewBound() have been disposed of, while the constructor observable is still running."))
.pushChangeHandler(HorizontalChangeHandler())
.popChangeHandler(HorizontalChangeHandler())
)
}
binding.nextRetainView.setOnClickListener {
retainViewMode = RetainViewMode.RETAIN_DETACH
router.pushController(
with(TextController("Logcat should now report that the observables from onAttach() has been disposed of, while the constructor and onViewBound() observables are still running."))
.pushChangeHandler(HorizontalChangeHandler())
.popChangeHandler(HorizontalChangeHandler())
)
}
Observable.interval(1, TimeUnit.SECONDS)
.doOnDispose { Log.i(TAG, "Disposing from onCreateView()") }
.autoDisposable(scopeProvider)
.subscribe { num: Long ->
Log.i(TAG, "Started in onCreateView(), running until onDestroyView(): $num")
}
return binding.root
}
override fun onAttach(view: View) {
super.onAttach(view)
Log.i(TAG, "onAttach() called")
(activity as ToolbarProvider).toolbar.title = "Autodispose Demo"
Observable.interval(1, TimeUnit.SECONDS)
.doOnDispose { Log.i(TAG, "Disposing from onAttach()") }
.autoDisposable(scopeProvider)
.subscribe { num: Long ->
Log.i(TAG, "Started in onAttach(), running until onDetach(): $num")
}
}
override fun onDestroyView(view: View) {
super.onDestroyView(view)
Log.i(TAG, "onDestroyView() called")
}
override fun onDetach(view: View) {
super.onDetach(view)
Log.i(TAG, "onDetach() called")
}
public override fun onDestroy() {
super.onDestroy()
Log.i(TAG, "onDestroy() called")
}
companion object {
private const val TAG = "AutodisposeController"
}
} | demo/src/main/java/com/bluelinelabs/conductor/demo/controllers/AutodisposeController.kt | 1015429832 |
package com.bajdcc.LALR1.syntax.token
/**
* 操作符
*
* @author bajdcc
*/
enum class OperatorType constructor(var desc: String) {
INFER("->"),
ALTERNATIVE("|"),
LPARAN("("),
RPARAN(")"),
LBRACE("{"),
RBRACE("}"),
LSQUARE("["),
RSQUARE("]"),
LT("<"),
GT(">")
}
| src/main/kotlin/com/bajdcc/LALR1/syntax/token/OperatorType.kt | 2480634382 |
package com.bajdcc.LALR1.grammar.error
import com.bajdcc.util.lexer.regex.IRegexStringIterator
import com.bajdcc.util.lexer.token.Token
/**
* 【语义分析】语义错误结构
*
* @author bajdcc
*/
class SemanticException(
/**
* 错误类型
*/
/**
* @return 错误类型
*/
val errorCode: SemanticError,
/**
* 操作符
*/
/**
* @return 错误位置
*/
val position: Token) : Exception(errorCode.message) {
fun toString(iter: IRegexStringIterator): String {
val snapshot = iter.ex().getErrorSnapshot(position.position)
return if (snapshot.isEmpty()) {
toString()
} else message + ": " + position + System.lineSeparator() +
snapshot + System.lineSeparator()
}
override fun toString(): String {
return message + ": " + position.toString()
}
/**
* 语义分析过程中的错误
*/
enum class SemanticError(var message: String?) {
UNKNOWN("未知"),
INVALID_OPERATOR("操作非法"),
MISSING_FUNCNAME("过程名不存在"),
DUP_ENTRY("不能设置为入口函数名"),
DUP_FUNCNAME("重复的函数名"),
VARIABLE_NOT_DECLARAED("变量未定义"),
VARIABLE_REDECLARAED("变量重复定义"),
VAR_FUN_CONFLICT("变量名与函数名冲突"),
MISMATCH_ARGS("参数个数不匹配"),
DUP_PARAM("参数重复定义"),
WRONG_EXTERN_SYMBOL("导出符号不存在"),
WRONG_CYCLE("缺少循环体"),
WRONG_YIELD("非法调用"),
WRONG_ENUMERABLE("要求枚举对象"),
TOO_MANY_ARGS("参数个数太多"),
INVALID_ASSIGNMENT("非法的赋值语句"),
DIFFERENT_FUNCNAME("过程名不匹配")
}
}
| src/main/kotlin/com/bajdcc/LALR1/grammar/error/SemanticException.kt | 1379514439 |
package com.joe.zatuji.base.staggered
import android.support.v7.widget.RecyclerView
import com.joe.zatuji.repo.bean.LoadMore
import com.joey.cheetah.core.list.CheetahAdapter
/**
* Description:
* author:Joey
* date:2018/10/26
*/
class LoadMoreAdapter(listener: LoadMoreDelegate.OnLoadMoreListener) : CheetahAdapter() {
private val loadMoreDelegate = LoadMoreDelegate(this, listener)
init {
// register(LoadMore::class.java, LoadMoreViewBinder())
}
fun attach(rv: RecyclerView) {
rv.adapter = this
loadMoreDelegate.attach(rv)
}
override fun setItems(items: List<*>) {
super.setItems(items)
loadMoreDelegate.setItems(this.items)
}
fun loadMoreComplete() {
loadMoreDelegate.loadMoreComplete()
}
} | app/src/main/java/com/joe/zatuji/base/staggered/LoadMoreAdapter.kt | 1412005013 |
package org.wordpress.android.ui.reader.repository.usecases
import dagger.Reusable
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.withContext
import org.wordpress.android.datasets.ReaderBlogTableWrapper
import org.wordpress.android.datasets.ReaderDiscoverCardsTableWrapper
import org.wordpress.android.datasets.wrappers.ReaderPostTableWrapper
import org.wordpress.android.fluxc.utils.AppLogWrapper
import org.wordpress.android.models.discover.ReaderDiscoverCard
import org.wordpress.android.models.discover.ReaderDiscoverCard.InterestsYouMayLikeCard
import org.wordpress.android.models.discover.ReaderDiscoverCard.ReaderPostCard
import org.wordpress.android.models.discover.ReaderDiscoverCard.ReaderRecommendedBlogsCard
import org.wordpress.android.models.discover.ReaderDiscoverCard.WelcomeBannerCard
import org.wordpress.android.models.discover.ReaderDiscoverCards
import org.wordpress.android.modules.IO_THREAD
import org.wordpress.android.ui.prefs.AppPrefsWrapper
import org.wordpress.android.ui.reader.ReaderConstants
import org.wordpress.android.util.AppLog.T.READER
import javax.inject.Inject
import javax.inject.Named
@Reusable
class GetDiscoverCardsUseCase @Inject constructor(
private val parseDiscoverCardsJsonUseCase: ParseDiscoverCardsJsonUseCase,
private val readerDiscoverCardsTableWrapper: ReaderDiscoverCardsTableWrapper,
private val readerPostTableWrapper: ReaderPostTableWrapper,
private val readerBlogTableWrapper: ReaderBlogTableWrapper,
private val appLogWrapper: AppLogWrapper,
private val appPrefsWrapper: AppPrefsWrapper,
@Named(IO_THREAD) private val ioDispatcher: CoroutineDispatcher
) {
suspend fun get(): ReaderDiscoverCards = withContext(ioDispatcher) {
val cardJsonList = readerDiscoverCardsTableWrapper.loadDiscoverCardsJsons()
val cards: ArrayList<ReaderDiscoverCard> = arrayListOf()
if (cardJsonList.isNotEmpty()) {
val jsonObjects = parseDiscoverCardsJsonUseCase.convertListOfJsonArraysIntoSingleJsonArray(
cardJsonList
)
forLoop@ for (i in 0 until jsonObjects.length()) {
val cardJson = jsonObjects.getJSONObject(i)
when (cardJson.getString(ReaderConstants.JSON_CARD_TYPE)) {
ReaderConstants.JSON_CARD_INTERESTS_YOU_MAY_LIKE -> {
val interests = parseDiscoverCardsJsonUseCase.parseInterestCard(cardJson)
cards.add(InterestsYouMayLikeCard(interests))
}
ReaderConstants.JSON_CARD_POST -> {
// TODO we might want to load the data in batch
val (blogId, postId) = parseDiscoverCardsJsonUseCase.parseSimplifiedPostCard(cardJson)
val post = readerPostTableWrapper.getBlogPost(blogId, postId, false)
if (post != null) {
cards.add(ReaderPostCard(post))
} else {
appLogWrapper.d(READER, "Post from /cards json not found in ReaderDatabase")
continue@forLoop
}
}
ReaderConstants.JSON_CARD_RECOMMENDED_BLOGS -> {
cardJson?.let {
val recommendedBlogs = parseDiscoverCardsJsonUseCase.parseSimplifiedRecommendedBlogsCard(it)
.mapNotNull { (blogId, feedId) ->
readerBlogTableWrapper.getReaderBlog(blogId, feedId)
}
cards.add(ReaderRecommendedBlogsCard(recommendedBlogs))
}
}
}
}
if (cards.isNotEmpty() && !appPrefsWrapper.readerDiscoverWelcomeBannerShown) {
cards.add(0, WelcomeBannerCard)
}
}
return@withContext ReaderDiscoverCards(cards)
}
}
| WordPress/src/main/java/org/wordpress/android/ui/reader/repository/usecases/GetDiscoverCardsUseCase.kt | 3658901965 |
/*
* Thrifty
*
* Copyright (c) Microsoft 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.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
* WITHOUT LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF TITLE,
* FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.
*
* See the Apache Version 2.0 License for specific language governing permissions and limitations under the License.
*/
package com.microsoft.thrifty.schema
/**
* Represents a Thrift `list<T>`.
*
* @property elementType The type of value contained within lists of this type.
*/
class ListType internal constructor(
val elementType: ThriftType,
override val annotations: Map<String, String> = emptyMap()
) : ThriftType("list<" + elementType.name + ">") {
override val isList: Boolean = true
override fun <T> accept(visitor: ThriftType.Visitor<T>): T = visitor.visitList(this)
override fun withAnnotations(annotations: Map<String, String>): ThriftType {
return ListType(elementType, mergeAnnotations(this.annotations, annotations))
}
/**
* Creates a [Builder] initialized with this type's values.
*/
fun toBuilder(): Builder {
return Builder(this)
}
/**
* An object that can build new [ListType] instances.
*/
class Builder(
private var elementType: ThriftType,
private var annotations: Map<String, String>
) {
internal constructor(type: ListType) : this(type.elementType, type.annotations)
/**
* Use the given [elementType] for the [ListType] under construction.
*/
fun elementType(elementType: ThriftType): Builder = apply {
this.elementType = elementType
}
/**
* Use the given [annotations] for the [ListType] under construction.
*/
fun annotations(annotations: Map<String, String>): Builder = apply {
this.annotations = annotations
}
/**
* Creates a new [ListType] instance.
*/
fun build(): ListType {
return ListType(elementType, annotations)
}
}
}
| thrifty-schema/src/main/kotlin/com/microsoft/thrifty/schema/ListType.kt | 779746026 |
package com.intellij.settingsSync.plugins
import com.intellij.ide.ApplicationInitializedListener
import com.intellij.ide.plugins.IdeaPluginDescriptor
import com.intellij.ide.plugins.PluginStateListener
import com.intellij.ide.plugins.PluginStateManager
import com.intellij.openapi.Disposable
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.components.*
import com.intellij.openapi.diagnostic.logger
import com.intellij.openapi.extensions.PluginId
import com.intellij.settingsSync.SettingsSyncSettings
import com.intellij.settingsSync.config.BUNDLED_PLUGINS_ID
import com.intellij.settingsSync.plugins.SettingsSyncPluginManager.Companion.FILE_SPEC
import org.jetbrains.annotations.TestOnly
@State(name = "SettingsSyncPlugins", storages = [Storage(FILE_SPEC)])
internal class SettingsSyncPluginManager : PersistentStateComponent<SettingsSyncPluginManager.SyncPluginsState>, Disposable {
internal companion object {
fun getInstance(): SettingsSyncPluginManager = ApplicationManager.getApplication().getService(SettingsSyncPluginManager::class.java)
const val FILE_SPEC = "settingsSyncPlugins.xml"
val LOG = logger<SettingsSyncPluginManager>()
}
private val pluginStateListener = object : PluginStateListener {
override fun install(descriptor: IdeaPluginDescriptor) {
sessionUninstalledPlugins.remove(descriptor.pluginId.idString)
}
override fun uninstall(descriptor: IdeaPluginDescriptor) {
val idString = descriptor.pluginId.idString
state.plugins[idString]?.let { it.isEnabled = false }
sessionUninstalledPlugins.add(idString)
}
}
init {
PluginStateManager.addStateListener(pluginStateListener)
}
private var state = SyncPluginsState()
private var noUpdateFromIde: Boolean = false
private val sessionUninstalledPlugins = HashSet<String>()
override fun getState(): SyncPluginsState {
updateStateFromIde()
return state
}
override fun loadState(state: SyncPluginsState) {
this.state = state
}
@TestOnly
fun clearState() {
state.plugins.clear()
}
class SyncPluginsState : BaseState() {
var plugins by map<String, PluginData>()
}
class PluginData : BaseState() {
var isEnabled by property(true)
var dependencies by stringSet()
var category by enum(SettingsCategory.PLUGINS)
}
private fun updateStateFromIde() {
if (noUpdateFromIde) return
PluginManagerProxy.getInstance().getPlugins().forEach {
val idString = it.pluginId.idString
if (shouldSaveState(it)) {
var pluginData = state.plugins[idString]
if (pluginData == null) {
pluginData = PluginData()
pluginData.category = SettingsSyncPluginCategoryFinder.getPluginCategory(it)
it.dependencies.forEach { dependency ->
if (!dependency.isOptional) {
pluginData.dependencies.add(dependency.pluginId.idString)
pluginData.intIncrementModificationCount()
}
}
state.plugins[idString] = pluginData
}
pluginData.isEnabled = it.isEnabled && !sessionUninstalledPlugins.contains(idString)
}
else {
if (state.plugins.containsKey(idString)) {
state.plugins.remove(idString)
}
}
}
}
fun pushChangesToIde() {
val pluginManagerProxy = PluginManagerProxy.getInstance()
val installer = pluginManagerProxy.createInstaller()
this.state.plugins.forEach { mapEntry ->
val plugin = findPlugin(mapEntry.key)
if (plugin != null) {
if (isPluginSyncEnabled(plugin.pluginId.idString, plugin.isBundled, SettingsSyncPluginCategoryFinder.getPluginCategory(plugin))) {
if (mapEntry.value.isEnabled != plugin.isEnabled) {
if (mapEntry.value.isEnabled) {
pluginManagerProxy.enablePlugin(plugin.pluginId)
LOG.info("Disabled plugin: ${plugin.pluginId.idString}")
}
else {
pluginManagerProxy.disablePlugin(plugin.pluginId)
LOG.info("Enabled plugin: ${plugin.pluginId.idString}")
}
}
}
}
else {
if (mapEntry.value.isEnabled &&
isPluginSyncEnabled(mapEntry.key, false, mapEntry.value.category) &&
checkDependencies(mapEntry.key, mapEntry.value)) {
val newPluginId = PluginId.getId(mapEntry.key)
installer.addPluginId(newPluginId)
LOG.info("New plugin installation requested: ${newPluginId.idString}")
}
}
}
installer.installPlugins()
}
private fun findPlugin(idString: String): IdeaPluginDescriptor? {
return PluginId.findId(idString)?.let { PluginManagerProxy.getInstance().findPlugin(it) }
}
private fun checkDependencies(idString: String, pluginState: PluginData): Boolean {
pluginState.dependencies.forEach {
if (findPlugin(it) == null) {
LOG.info("Skipping ${idString} plugin installation due to missing dependency: ${it}")
return false
}
}
return true
}
fun doWithNoUpdateFromIde(runnable: Runnable) {
noUpdateFromIde = true
try {
runnable.run()
}
finally {
noUpdateFromIde = false
}
}
private fun shouldSaveState(plugin: IdeaPluginDescriptor): Boolean {
return isPluginSyncEnabled(plugin.pluginId.idString, plugin.isBundled, SettingsSyncPluginCategoryFinder.getPluginCategory(plugin)) &&
(!plugin.isBundled || !plugin.isEnabled || state.plugins.containsKey(plugin.pluginId.idString))
}
private fun isPluginSyncEnabled(idString: String, isBundled: Boolean, category: SettingsCategory): Boolean {
val settings = SettingsSyncSettings.getInstance()
return settings.isCategoryEnabled(category) &&
(category != SettingsCategory.PLUGINS ||
isBundled && settings.isSubcategoryEnabled(SettingsCategory.PLUGINS, BUNDLED_PLUGINS_ID) ||
settings.isSubcategoryEnabled(SettingsCategory.PLUGINS, idString))
}
override fun dispose() {
PluginStateManager.removeStateListener(pluginStateListener)
}
} | plugins/settings-sync/src/com/intellij/settingsSync/plugins/SettingsSyncPluginManager.kt | 3872358610 |
package com.kelsos.mbrc.commands.model
import android.app.Application
import com.fasterxml.jackson.databind.node.ObjectNode
import com.kelsos.mbrc.di.modules.AppDispatchers
import com.kelsos.mbrc.domain.TrackInfo
import com.kelsos.mbrc.events.bus.RxBus
import com.kelsos.mbrc.events.ui.RemoteClientMetaData
import com.kelsos.mbrc.events.ui.TrackInfoChangeEvent
import com.kelsos.mbrc.interfaces.ICommand
import com.kelsos.mbrc.interfaces.IEvent
import com.kelsos.mbrc.model.MainDataModel
import com.kelsos.mbrc.repository.ModelCache
import com.kelsos.mbrc.widgets.UpdateWidgets
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch
import timber.log.Timber
import javax.inject.Inject
class UpdateNowPlayingTrack
@Inject
constructor(
private val model: MainDataModel,
private val context: Application,
private val bus: RxBus,
private val cache: ModelCache,
dispatchers: AppDispatchers
) : ICommand {
private val job = SupervisorJob()
private val scope = CoroutineScope(job + dispatchers.io)
override fun execute(e: IEvent) {
val node = e.data as ObjectNode
val artist = node.path("artist").textValue()
val album = node.path("album").textValue()
val title = node.path("title").textValue()
val year = node.path("year").textValue()
val path = node.path("path").textValue()
model.trackInfo = TrackInfo(artist, title, album, year, path)
save(model.trackInfo)
bus.post(RemoteClientMetaData(model.trackInfo, model.coverPath, model.duration))
bus.post(TrackInfoChangeEvent(model.trackInfo))
UpdateWidgets.updateTrackInfo(context, model.trackInfo)
}
private fun save(info: TrackInfo) {
scope.launch {
try {
cache.persistInfo(info)
Timber.v("Playing track info successfully persisted")
} catch (e: Exception) {
Timber.v(e, "Failed to persist the playing track info")
}
}
}
}
| app/src/main/kotlin/com/kelsos/mbrc/commands/model/UpdateNowPlayingTrack.kt | 1306374302 |
/*
* Copyright 2015 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 org.jetbrains.kotlin.android.robowrapper
import org.robolectric.internal.bytecode.InstrumentingClassLoader
import java.lang.reflect.Field
import java.net.URL
import java.net.URLClassLoader
public class ClassLoaderManager {
public fun replaceClassLoader(packageName: String) {
// Context ClassLoader is set in RobolectricTestRunner
val currentClassLoader = Thread.currentThread().getContextClassLoader()
if (currentClassLoader !is InstrumentingClassLoader) {
throw RuntimeException("Not an InstrumentingClassLoader")
}
val parentClassLoader = Thread.currentThread().getContextClassLoader().getParent()
val asmClazz = parentClassLoader.loadClass("org.robolectric.internal.bytecode.InstrumentingClassLoader")
val configField = asmClazz.getDeclaredField("config")
val urlsField = asmClazz.getDeclaredField("urls")
val classesField = asmClazz.getDeclaredField("classes")
configField.setAccessible(true)
urlsField.setAccessible(true)
classesField.setAccessible(true)
val setup = configField.get(currentClassLoader)
val urlClassLoader = urlsField.get(currentClassLoader) as URLClassLoader
@suppress("UNCHECKED_CAST")
val oldClasses = classesField.get(currentClassLoader) as Map<String, Class<Any>>
val urls = urlClassLoader.getURLs()
// Create new ClassLoader instance
val newClassLoader = asmClazz.getConstructors()[0].newInstance(setup, urls) as InstrumentingClassLoader
// Copy all Map entries from the old AsmInstrumentingClassLoader
@suppress("UNCHECKED_CAST")
val classes = classesField.get(newClassLoader) as MutableMap<String, Class<Any>>
replicateCache(packageName, oldClasses, classes)
// We're now able to get newClassLoader using Thread.currentThread().getContextClassLoader()
Thread.currentThread().setContextClassLoader(newClassLoader)
System.gc()
}
private fun replicateCache(
removePackage: String,
oldClasses: Map<String, Class<Any>>,
newClasses: MutableMap<String, Class<Any>>
) {
if (removePackage.isEmpty()) return
val oldClassesList = oldClasses.toList()
val checkPackageName = removePackage.isNotEmpty()
for (clazz in oldClassesList) {
val key = clazz.first
if (checkPackageName && !key.startsWith(removePackage)) {
newClasses.put(key, clazz.second)
}
}
}
}
| preview/robowrapper/src/org/jetbrains/kotlin/android/robowrapper/ClassLoaderManager.kt | 4128139541 |
// 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.editorconfig.language.schema.parser.handlers.impl
import com.google.gson.JsonObject
import org.editorconfig.language.schema.descriptors.EditorConfigDescriptor
import org.editorconfig.language.schema.descriptors.impl.*
import org.editorconfig.language.schema.parser.EditorConfigJsonSchemaConstants
import org.editorconfig.language.schema.parser.EditorConfigJsonSchemaConstants.ALLOW_REPETITIONS
import org.editorconfig.language.schema.parser.EditorConfigJsonSchemaConstants.LIST
import org.editorconfig.language.schema.parser.EditorConfigJsonSchemaConstants.MIN_LENGTH
import org.editorconfig.language.schema.parser.EditorConfigJsonSchemaConstants.OPTION
import org.editorconfig.language.schema.parser.EditorConfigJsonSchemaConstants.PAIR
import org.editorconfig.language.schema.parser.EditorConfigJsonSchemaConstants.TYPE
import org.editorconfig.language.schema.parser.EditorConfigJsonSchemaConstants.VALUES
import org.editorconfig.language.schema.parser.EditorConfigJsonSchemaException
import org.editorconfig.language.schema.parser.EditorConfigJsonSchemaParser
import org.editorconfig.language.schema.parser.handlers.EditorConfigDescriptorParseHandlerBase
class EditorConfigListDescriptorParseHandler : EditorConfigDescriptorParseHandlerBase() {
override val requiredKeys = listOf(TYPE, VALUES)
override val optionalKeys = super.optionalKeys + listOf(MIN_LENGTH, ALLOW_REPETITIONS)
override val forbiddenChildren = listOf(PAIR, LIST, OPTION)
override fun doHandle(jsonObject: JsonObject, parser: EditorConfigJsonSchemaParser): EditorConfigDescriptor {
val minLength = tryGetInt(jsonObject, MIN_LENGTH) ?: 0
val allowRepetitions = tryGetBoolean(jsonObject, ALLOW_REPETITIONS) ?: false
val values = jsonObject[VALUES]
if (!values.isJsonArray) throw EditorConfigJsonSchemaException(jsonObject)
val children = values.asJsonArray.map(parser::parse)
if (!children.all(::isAcceptable)) throw EditorConfigJsonSchemaException(jsonObject)
val documentation = tryGetString(jsonObject, EditorConfigJsonSchemaConstants.DOCUMENTATION)
val deprecation = tryGetString(jsonObject, EditorConfigJsonSchemaConstants.DEPRECATION)
return EditorConfigListDescriptor(minLength, allowRepetitions, children, documentation, deprecation)
}
private fun isAcceptable(descriptor: EditorConfigDescriptor) = when (descriptor) {
is EditorConfigConstantDescriptor -> true
is EditorConfigNumberDescriptor -> true
is EditorConfigUnionDescriptor -> true
is EditorConfigStringDescriptor -> true
else -> false
}
}
| plugins/editorconfig/src/org/editorconfig/language/schema/parser/handlers/impl/EditorConfigListDescriptorParseHandler.kt | 1765782449 |
/*******************************************************************************
* Copyright 2000-2022 JetBrains s.r.o. and contributors.
*
* 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 com.jetbrains.packagesearch.intellij.plugin.configuration
import com.intellij.ide.ui.search.SearchableOptionContributor
import com.intellij.ide.ui.search.SearchableOptionProcessor
import com.jetbrains.packagesearch.intellij.plugin.configuration.ui.PackageSearchGeneralConfigurable
class PackageSearchSearchableOptionContributor : SearchableOptionContributor() {
override fun processOptions(processor: SearchableOptionProcessor) {
// Make settings searchable
addSearchConfigurationMap(
processor,
"packagesearch", "package", "search", "dependency", "dependencies",
"gradle", "configuration", "maven", "scope"
)
}
}
fun addSearchConfigurationMap(processor: SearchableOptionProcessor, vararg entries: String) {
for (entry in entries) {
processor.addOptions(entry, null, entry, PackageSearchGeneralConfigurable.ID, null, false)
}
}
| plugins/package-search/src/com/jetbrains/packagesearch/intellij/plugin/configuration/PackageSearchSearchableOptionContributor.kt | 1000578244 |
package edu.byu.suite.features.myFinancialCenter.controller
import android.content.Intent
import edu.byu.suite.features.myFinancialCenter.service.MfcClient
import edu.byu.support.payment.controller.PaymentAccountsActivity
import edu.byu.support.payment.controller.PaymentReviewActivity
import edu.byu.support.payment.model.PaymentAccount
import retrofit2.Response
/**
* Created by geogor37 on 2/16/18
*/
class MfcPaymentAccountsActivity: PaymentAccountsActivity() {
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
if (requestCode == UnpaidChargesFragment.CHECKOUT_REQUEST) {
setResult(resultCode)
finish()
}
super.onActivityResult(requestCode, resultCode, data)
}
override fun loadPaymentMethods() {
enqueueCall(MfcClient().getApi(this).getPaymentTypes(), object: PaymentAccountsCallback<List<PaymentAccount>>(this, MfcClient.PATH_TO_READABLE_ERROR) {
override fun parseResponse(response: Response<List<PaymentAccount>>?): List<PaymentAccount>? {
return response?.body()
}
})
}
override fun continuePaymentProcess(selectedPaymentAccount: PaymentAccount) {
startActivityForResult(Intent(this, MfcPaymentReviewActivity::class.java)
.putExtra(PaymentReviewActivity.PAYMENT_ACCOUNT_TAG, selectedPaymentAccount)
.putExtras(intent), UnpaidChargesFragment.CHECKOUT_REQUEST)
}
} | app/src/main/java/edu/byu/suite/features/myFinancialCenter/controller/MfcPaymentAccountsActivity.kt | 1028336592 |
package de.welt.widgetadapter
import android.support.v7.util.DiffUtil
import android.support.v7.widget.RecyclerView
import android.view.LayoutInflater
import android.view.ViewGroup
import java.util.*
open class WidgetAdapter(
val layoutInflater: LayoutInflater
) : RecyclerView.Adapter<RecyclerView.ViewHolder>() {
var supportsCollapsableGroups: Boolean = false
var widgetProviders = LinkedHashMap<Class<out Any>, () -> Widget<*>>()
private var allItems = listOf<Any>()
private var visibleItems = listOf<Any>()
inline fun <reified T : Any> addWidget(noinline widgetProvider: () -> Widget<T>) {
widgetProviders[T::class.java] = widgetProvider
}
fun setItems(items: List<Any>) {
doSetItems(items)
notifyDataSetChanged()
}
fun getItems() = allItems
fun updateItems(items: List<Any>) {
val oldItems = this.visibleItems
doSetItems(items)
DiffUtil.calculateDiff(SimpleDiffCallback(this.visibleItems, oldItems))
.dispatchUpdatesTo(this)
}
fun swapItems(fromPosition: Int, toPosition: Int) {
if (supportsCollapsableGroups) throw UnsupportedOperationException("swapping items on adapters that support collapsable groups is not supported yet. Please raise an issue if you need this feature: https://github.com/WeltN24/WidgetAdapter/issues")
Collections.swap(visibleItems, fromPosition, toPosition)
notifyItemMoved(fromPosition, toPosition)
}
override fun getItemCount() = visibleItems.size
override fun getItemViewType(position: Int) = widgetProviders.keys.indexOf(visibleItems[position].javaClass)
override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
bindViewHolder(holder, visibleItems[position])
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
val provider = widgetProviders.values.elementAt(viewType)
val widget = provider()
return WidgetViewHolder(widget, widget.createView(layoutInflater, parent))
}
override fun onViewRecycled(holder: RecyclerView.ViewHolder) {
super.onViewRecycled(holder)
val viewHolder = holder as WidgetViewHolder<*>
viewHolder.widget.onViewRecycled()
}
private fun doSetItems(items: List<Any>) {
allItems = items
visibleItems = if (supportsCollapsableGroups) items.visibleItems else items
}
private val List<Any>.visibleItems: List<Any>
get() {
if (widgetProviders.isEmpty()) throw IllegalStateException("You have to add widget providers before you set items.")
return if (supportsCollapsableGroups)
applyCollapsedState()
else
filter { widgetProviders.contains(it.javaClass) }
}
private fun List<Any>.applyCollapsedState(): List<Any> {
val collapsedGroups = this
.filterIsInstance<CollapsableGroupHeaderWidgetData>()
.filter { it.isCollapsed }
.map { it.collapsableGroupId }
return this.filter { widgetProviders.contains(it.javaClass) && it.isNotCollapsed(collapsedGroups) }
}
private fun Any.isNotCollapsed(collapsedGroups: List<String>): Boolean {
val id = (this as? CollapsableWidgetData)?.collapsableGroupId ?: return true
return !collapsedGroups.contains(id)
}
@Suppress("UNCHECKED_CAST")
private fun <T> bindViewHolder(holder: RecyclerView.ViewHolder, item: T) {
(holder as WidgetViewHolder<T>).widget.apply {
setData(item as T)
onViewBound()
}
}
}
| library/src/main/java/de/welt/widgetadapter/WidgetAdapter.kt | 2735777763 |
package com.andgate.ikou.actor.player;
import com.andgate.ikou.actor.Actor
import com.andgate.ikou.actor.Scene
import com.andgate.ikou.actor.messaging.Message
import com.andgate.ikou.actor.player.commands.*
import com.andgate.ikou.actor.player.messages.*
import com.andgate.ikou.animate.Animator
import com.andgate.ikou.graphics.player.PlayerModel
import com.badlogic.gdx.math.Vector3
class PlayerActor(id: String,
scene: Scene,
val model: PlayerModel)
: Actor(id, scene)
{
private val TAG: String = "PlayerActor"
val animator = Animator(model.transform)
init {
// Bind to events that are coming from the maze
scene.dispatcher.subscribe("SmoothSlide", channel)
channel.bind("SmoothSlide", { msg ->
val msg = msg as SmoothSlideMessage
if(msg.playerId == id) cmd_proc.accept(SmoothSlideCommand(this, msg.start, msg.end))
})
scene.dispatcher.subscribe("StickySlide", channel)
channel.bind("StickySlide", { msg ->
val msg = msg as StickySlideMessage
if(msg.playerId == id) cmd_proc.accept(StickySlideCommand(this, msg.start, msg.end))
})
scene.dispatcher.subscribe("DropDown", channel)
channel.bind("DropDown", { msg ->
val msg = msg as DropDownMessage
if(msg.playerId == id) cmd_proc.accept(DropDownCommand(this, msg.start, msg.end))
})
scene.dispatcher.subscribe("HitEdge", channel)
channel.bind("HitEdge", { msg ->
val msg = msg as HitEdgeMessage
if(msg.playerId == id) cmd_proc.accept(HitEdgeCommand(this))
})
scene.dispatcher.subscribe("FinishGame", channel)
channel.bind("FinishGame", { msg ->
val msg = msg as FinishGameMessage
if(msg.playerId == id) cmd_proc.accept(FinishGameCommand(this))
})
}
override fun receive(event: Message)
{
// Actor bound to all the relevant events,
// no events that need to be received asynchronously
}
override fun update(delta_time: Float)
{
animator.update(delta_time)
}
override fun dispose()
{
super.dispose()
model.dispose()
}
}
| core/src/com/andgate/ikou/actor/player/PlayerActor.kt | 1241344457 |
/*
* Copyright 2017 Netflix, Inc.
*
* 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.netflix.spinnaker.orca.q.handler
import com.netflix.spinnaker.orca.api.pipeline.models.ExecutionStatus.TERMINAL
import com.netflix.spinnaker.orca.api.pipeline.models.ExecutionType.PIPELINE
import com.netflix.spinnaker.orca.pipeline.persistence.ExecutionRepository
import com.netflix.spinnaker.orca.q.ConfigurationError
import com.netflix.spinnaker.orca.q.InvalidExecutionId
import com.netflix.spinnaker.orca.q.InvalidStageId
import com.netflix.spinnaker.orca.q.InvalidTask
import com.netflix.spinnaker.orca.q.InvalidTaskId
import com.netflix.spinnaker.orca.q.InvalidTaskType
import com.netflix.spinnaker.orca.q.NoDownstreamTasks
import com.netflix.spinnaker.q.Queue
import com.nhaarman.mockito_kotlin.mock
import com.nhaarman.mockito_kotlin.reset
import com.nhaarman.mockito_kotlin.verify
import com.nhaarman.mockito_kotlin.verifyZeroInteractions
import org.jetbrains.spek.api.dsl.describe
import org.jetbrains.spek.api.dsl.it
import org.jetbrains.spek.api.dsl.on
import org.jetbrains.spek.api.lifecycle.CachingMode.GROUP
import org.jetbrains.spek.subject.SubjectSpek
object ConfigurationErrorHandlerTest : SubjectSpek<ConfigurationErrorHandler>({
val queue: Queue = mock()
val repository: ExecutionRepository = mock()
subject(GROUP) {
ConfigurationErrorHandler(queue, repository)
}
fun resetMocks() = reset(queue, repository)
InvalidExecutionId(PIPELINE, "1", "foo").let { message ->
describe("handing a ${message.javaClass.simpleName} event") {
afterGroup(::resetMocks)
on("receiving $message") {
subject.handle(message)
}
it("does not try to update the execution status") {
verifyZeroInteractions(repository)
}
it("does not push any messages to the queue") {
verifyZeroInteractions(queue)
}
}
}
setOf<ConfigurationError>(
InvalidStageId(PIPELINE, "1", "foo", "1"),
InvalidTaskId(PIPELINE, "1", "foo", "1", "1"),
InvalidTaskType(PIPELINE, "1", "foo", "1", InvalidTask::class.java.name),
NoDownstreamTasks(PIPELINE, "1", "foo", "1", "1")
).forEach { message ->
describe("handing a ${message.javaClass.simpleName} event") {
afterGroup(::resetMocks)
on("receiving $message") {
subject.handle(message)
}
it("marks the execution as terminal") {
verify(repository).updateStatus(PIPELINE, message.executionId, TERMINAL)
}
it("does not push any messages to the queue") {
verifyZeroInteractions(queue)
}
}
}
})
| orca-queue/src/test/kotlin/com/netflix/spinnaker/orca/q/handler/ConfigurationErrorHandlerTest.kt | 537580873 |
package com.intellij.codeInsight.codeVision.ui.popup
import com.intellij.codeInsight.codeVision.CodeVisionEntryExtraActionModel
import com.intellij.codeInsight.codeVision.ui.model.isEnabled
import com.intellij.openapi.ui.popup.ListSeparator
import com.intellij.openapi.ui.popup.PopupStep
import com.intellij.openapi.ui.popup.util.BaseListPopupStep
import com.intellij.openapi.util.NlsContexts
open class SubCodeVisionMenu(val list: List<CodeVisionEntryExtraActionModel>,
val onClick: (String) -> Unit,
@NlsContexts.PopupTitle title: String? = null) :
BaseListPopupStep<CodeVisionEntryExtraActionModel>(title, list.filter { it.isEnabled() }) {
override fun isSelectable(value: CodeVisionEntryExtraActionModel): Boolean {
return value.isEnabled()
}
override fun isAutoSelectionEnabled(): Boolean {
return false
}
override fun isSpeedSearchEnabled(): Boolean {
return true
}
override fun isMnemonicsNavigationEnabled(): Boolean {
return true
}
override fun getTextFor(value: CodeVisionEntryExtraActionModel): String {
return value.displayText
}
override fun onChosen(value: CodeVisionEntryExtraActionModel, finalChoice: Boolean): PopupStep<*>? {
value.actionId?.let {
doFinalStep {
onClick.invoke(value.actionId!!)
}
}
return PopupStep.FINAL_CHOICE
}
override fun getSeparatorAbove(value: CodeVisionEntryExtraActionModel): ListSeparator? {
val index = list.indexOf(value)
val prevIndex = index - 1
if (prevIndex >= 0) {
val prevValue = list[prevIndex]
if (!prevValue.isEnabled()) {
return ListSeparator(prevValue.displayText)
}
}
return null
}
} | platform/lang-impl/src/com/intellij/codeInsight/codeVision/ui/popup/SubCodeVisionMenu.kt | 522782786 |
/*
* Copyright 2019 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.example.drivebackupsample
import android.content.Context
import androidx.work.CoroutineWorker
import androidx.work.WorkerParameters
import com.google.api.services.drive.Drive
import kotlinx.coroutines.coroutineScope
class DriveUploadWorker(
appContext: Context,
workerParams: WorkerParameters,
private val driveService: Drive
) : CoroutineWorker(appContext, workerParams) {
override suspend fun doWork(): Result {
val fileName = inputData.getString(KEY_NAME_ARG)!!
val contents = inputData.getString(KEY_CONTENTS_ARG)!!
val folderId = inputData.getString(KEY_CONTENTS_FOLDER_ID)!!
return coroutineScope {
val fileId = driveService.createFile(folderId, fileName)
driveService.saveFile(fileId, fileName, contents)
Result.success()
}
}
companion object {
const val KEY_NAME_ARG = "name"
const val KEY_CONTENTS_ARG = "contents"
const val KEY_CONTENTS_FOLDER_ID = "folder_id"
}
} | app/src/main/java/com/example/drivebackupsample/DriveUploadWorker.kt | 4234148660 |
package foo
import foo.foo as bar
fun foo() {}
fun main() {
foo.<caret>foo()
foo.foo()
}
| plugins/kotlin/idea/tests/testData/inspectionsLocal/replaceWithImportAlias/function.kt | 3260295247 |
// 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.compilerPlugin.kotlinxSerialization.compiler.extensions
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.PropertyDescriptor
import org.jetbrains.kotlin.descriptors.SimpleFunctionDescriptor
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider
import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.idea.compilerPlugin.kotlinxSerialization.getIfEnabledOn
import org.jetbrains.kotlin.idea.compilerPlugin.kotlinxSerialization.runIfEnabledOn
import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationResolveExtension
import java.util.*
class SerializationIDEResolveExtension : SerializationResolveExtension() {
override fun getSyntheticNestedClassNames(thisDescriptor: ClassDescriptor): List<Name> =
getIfEnabledOn(thisDescriptor) { super.getSyntheticNestedClassNames(thisDescriptor) } ?: emptyList()
override fun getPossibleSyntheticNestedClassNames(thisDescriptor: ClassDescriptor): List<Name>? {
val enabled = getIfEnabledOn(thisDescriptor) { true } ?: false
return if (enabled) super.getPossibleSyntheticNestedClassNames(thisDescriptor)
else emptyList()
}
override fun getSyntheticFunctionNames(thisDescriptor: ClassDescriptor): List<Name> =
getIfEnabledOn(thisDescriptor) { super.getSyntheticFunctionNames(thisDescriptor) } ?: emptyList()
override fun generateSyntheticClasses(
thisDescriptor: ClassDescriptor,
name: Name,
ctx: LazyClassContext,
declarationProvider: ClassMemberDeclarationProvider,
result: MutableSet<ClassDescriptor>
) = runIfEnabledOn(thisDescriptor) {
super.generateSyntheticClasses(thisDescriptor, name, ctx, declarationProvider, result)
}
override fun getSyntheticCompanionObjectNameIfNeeded(thisDescriptor: ClassDescriptor): Name? = getIfEnabledOn(thisDescriptor) {
super.getSyntheticCompanionObjectNameIfNeeded(thisDescriptor)
}
override fun addSyntheticSupertypes(thisDescriptor: ClassDescriptor, supertypes: MutableList<KotlinType>) =
runIfEnabledOn(thisDescriptor) {
super.addSyntheticSupertypes(thisDescriptor, supertypes)
}
override fun generateSyntheticMethods(
thisDescriptor: ClassDescriptor,
name: Name,
bindingContext: BindingContext,
fromSupertypes: List<SimpleFunctionDescriptor>,
result: MutableCollection<SimpleFunctionDescriptor>
) = runIfEnabledOn(thisDescriptor) {
super.generateSyntheticMethods(thisDescriptor, name, bindingContext, fromSupertypes, result)
}
override fun generateSyntheticProperties(
thisDescriptor: ClassDescriptor,
name: Name,
bindingContext: BindingContext,
fromSupertypes: ArrayList<PropertyDescriptor>,
result: MutableSet<PropertyDescriptor>
) = runIfEnabledOn(thisDescriptor) {
super.generateSyntheticProperties(thisDescriptor, name, bindingContext, fromSupertypes, result)
}
}
| plugins/kotlin/compiler-plugins/kotlinx-serialization/common/src/org/jetbrains/kotlin/idea/compilerPlugin/kotlinxSerialization/compiler/extensions/SerializationIDEResolveExtension.kt | 1340627031 |
// 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.toolbar.floating
interface FloatingToolbarComponent {
fun scheduleHide()
fun scheduleShow()
fun hideImmediately()
} | platform/platform-impl/src/com/intellij/openapi/editor/toolbar/floating/FloatingToolbarComponent.kt | 3403304506 |
package rustyice.physics;
import com.badlogic.gdx.physics.box2d.Fixture
class Collision(val thisFixture: Fixture,
val otherFixture: Fixture,
val isBegin: Boolean)
| core/src/rustyice/physics/Collision.kt | 3658310601 |
/*
* 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.client.engine.jetty
import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.plugins.*
import io.ktor.client.request.*
import io.ktor.client.tests.utils.*
import io.ktor.test.dispatcher.*
import io.ktor.utils.io.errors.*
import kotlin.test.*
class JettyHttp2EngineTest {
@Test
fun testConnectingToNonHttp2Server() = testSuspend {
HttpClient(Jetty).use { client ->
assertFailsWith<IOException> {
client.get("$TEST_SERVER/content/hello").body<String>()
}
}
}
@Test
fun testReuseClientsInCache() = testSuspend {
val engine = JettyHttp2Engine(JettyEngineConfig())
val timeoutConfig11 = HttpTimeout.HttpTimeoutCapabilityConfiguration(
requestTimeoutMillis = 1,
connectTimeoutMillis = 1,
socketTimeoutMillis = 1
)
val timeoutConfig12 = HttpTimeout.HttpTimeoutCapabilityConfiguration(
requestTimeoutMillis = 1,
connectTimeoutMillis = 1,
socketTimeoutMillis = 1
)
val timeoutConfig21 = HttpTimeout.HttpTimeoutCapabilityConfiguration(
requestTimeoutMillis = 2,
connectTimeoutMillis = 2,
socketTimeoutMillis = 2
)
val timeoutConfig22 = HttpTimeout.HttpTimeoutCapabilityConfiguration(
requestTimeoutMillis = 2,
connectTimeoutMillis = 2,
socketTimeoutMillis = 2
)
val request11 = HttpRequestBuilder().apply {
setCapability(HttpTimeout, timeoutConfig11)
}.build()
engine.getOrCreateClient(request11)
assertEquals(1, engine.clientCache.size)
val request12 = HttpRequestBuilder().apply {
setCapability(HttpTimeout, timeoutConfig12)
}.build()
engine.getOrCreateClient(request12)
assertEquals(1, engine.clientCache.size)
val request21 = HttpRequestBuilder().apply {
setCapability(HttpTimeout, timeoutConfig21)
}.build()
engine.getOrCreateClient(request21)
assertEquals(2, engine.clientCache.size)
val request22 = HttpRequestBuilder().apply {
setCapability(HttpTimeout, timeoutConfig22)
}.build()
engine.getOrCreateClient(request22)
assertEquals(2, engine.clientCache.size)
}
}
| ktor-client/ktor-client-jetty/jvm/test/io/ktor/client/engine/jetty/JettyHttp2EngineTest.kt | 3450684879 |
/*
* 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.tests
import io.ktor.http.*
import io.ktor.http.CacheControl.*
import io.ktor.server.plugins.cachingheaders.*
import kotlin.test.*
class CacheControlMergeTest {
@Test
fun testMergeEmpty() {
assertEquals(emptyList(), merge())
}
@Test
fun testMergeSingleEntry() {
assertEquals(listOf(NoStore(null)), merge(NoStore(null)))
assertEquals(listOf(NoStore(Visibility.Public)), merge(NoStore(Visibility.Public)))
assertEquals(listOf(NoStore(Visibility.Private)), merge(NoStore(Visibility.Private)))
assertEquals(listOf(NoCache(null)), merge(NoCache(null)))
assertEquals(listOf(NoCache(Visibility.Public)), merge(NoCache(Visibility.Public)))
assertEquals(listOf(NoCache(Visibility.Private)), merge(NoCache(Visibility.Private)))
assertEquals(listOf(MaxAge(1)), merge(MaxAge(1)))
assertEquals(listOf(MaxAge(2)), merge(MaxAge(2)))
assertEquals(
listOf(MaxAge(3, visibility = Visibility.Private)),
merge(MaxAge(3, visibility = Visibility.Private))
)
}
@Test
fun testOrderNoMaxAge() {
assertEquals(listOf(NoCache(null), NoStore(null)), merge(NoCache(null), NoStore(null)))
assertEquals(listOf(NoCache(null), NoStore(null)), merge(NoStore(null), NoCache(null)))
}
@Test
fun testMergeNoMaxAge() {
assertEquals(listOf(NoCache(null), NoStore(null)), merge(NoCache(null), NoStore(null)))
assertEquals(listOf(NoCache(null)), merge(NoCache(null), NoCache(null)))
assertEquals(listOf(NoCache(Visibility.Private)), merge(NoCache(null), NoCache(Visibility.Private)))
assertEquals(listOf(NoCache(Visibility.Private)), merge(NoCache(Visibility.Private), NoCache(null)))
}
@Test
fun testTripleMergeNoMaxAge() {
assertEquals(
listOf(NoCache(Visibility.Private)),
merge(
NoCache(Visibility.Private),
NoCache(null),
NoCache(Visibility.Public),
)
)
assertEquals(
listOf(NoCache(Visibility.Public)),
merge(
NoCache(Visibility.Public),
NoCache(null),
NoCache(Visibility.Public),
)
)
}
@Test
fun testPrivateMergeNoMaxAge() {
assertEquals(
listOf(NoCache(Visibility.Private), NoStore(null)),
merge(NoCache(Visibility.Private), NoStore(null))
)
assertEquals(
listOf(NoCache(Visibility.Private), NoStore(null)),
merge(NoCache(Visibility.Private), NoStore(Visibility.Private))
)
assertEquals(
listOf(NoCache(Visibility.Private), NoStore(null)),
merge(NoCache(Visibility.Private), NoStore(Visibility.Public))
)
assertEquals(
listOf(NoCache(Visibility.Private), NoStore(null)),
merge(NoCache(Visibility.Public), NoStore(Visibility.Private))
)
}
@Test
fun testPublicMergeNoMaxAge() {
assertEquals(
listOf(NoCache(Visibility.Public), NoStore(null)),
merge(NoCache(Visibility.Public), NoStore(null))
)
assertEquals(
listOf(NoCache(Visibility.Public), NoStore(null)),
merge(NoCache(null), NoStore(Visibility.Public))
)
assertEquals(
listOf(NoCache(Visibility.Public), NoStore(null)),
merge(NoCache(Visibility.Public), NoStore(Visibility.Public))
)
}
@Test
fun testSimpleMaxAgeMerge() {
assertEquals(
listOf(MaxAge(1, 1, true, true, Visibility.Private)),
merge(
MaxAge(1, 2, true, false, null),
MaxAge(2, 1, false, true, Visibility.Public),
MaxAge(20, 10, false, false, Visibility.Private)
)
)
}
@Test
fun testAgeMergeWithNoCache() {
assertEquals(
listOf(
NoCache(null),
MaxAge(1, 2, true, false, Visibility.Private)
),
merge(
MaxAge(1, 2, true, false, null),
NoCache(Visibility.Private)
)
)
assertEquals(
listOf(
NoCache(null),
MaxAge(1, 2, true, false, Visibility.Private)
),
merge(
MaxAge(1, 2, true, false, Visibility.Public),
NoCache(Visibility.Private)
)
)
assertEquals(
listOf(
NoCache(null),
MaxAge(1, 2, true, false, Visibility.Public)
),
merge(
MaxAge(1, 2, true, false, Visibility.Public),
NoCache(null)
)
)
}
@Test
fun testAgeMergeWithNoStore() {
assertEquals(
listOf(
NoStore(null),
MaxAge(1, 2, true, false, Visibility.Private)
),
merge(
MaxAge(1, 2, true, false, null),
NoStore(Visibility.Private)
)
)
assertEquals(
listOf(
NoStore(null),
MaxAge(1, 2, true, false, Visibility.Private)
),
merge(
MaxAge(1, 2, true, false, Visibility.Public),
NoStore(Visibility.Private)
)
)
assertEquals(
listOf(
NoStore(null),
MaxAge(1, 2, true, false, Visibility.Public)
),
merge(
MaxAge(1, 2, true, false, Visibility.Public),
NoStore(null)
)
)
}
@Test
fun testAgeMergeWithNoCacheAndNoStore() {
assertEquals(
listOf(
NoCache(null),
NoStore(null),
MaxAge(1, 2, true, false, Visibility.Private)
),
merge(
MaxAge(1, 2, true, false, null),
NoStore(Visibility.Private),
NoCache(Visibility.Private)
)
)
assertEquals(
listOf(
NoCache(null),
NoStore(null),
MaxAge(1, 2, true, false, null)
),
merge(
MaxAge(1, 2, true, false, null),
NoStore(null),
NoCache(null)
)
)
assertEquals(
listOf(
NoCache(null),
NoStore(null),
MaxAge(1, 2, true, false, Visibility.Public)
),
merge(
MaxAge(1, 2, true, false, null),
NoStore(Visibility.Public),
NoCache(Visibility.Public)
)
)
assertEquals(
listOf(
NoCache(null),
NoStore(null),
MaxAge(1, 2, true, false, Visibility.Private)
),
merge(
MaxAge(1, 2, true, false, Visibility.Private),
NoStore(null),
NoCache(null)
)
)
assertEquals(
listOf(
NoCache(null),
NoStore(null),
MaxAge(1, 2, true, false, Visibility.Private)
),
merge(
MaxAge(1, 2, true, false, Visibility.Public),
NoStore(null),
NoCache(null),
NoCache(Visibility.Public),
NoStore(Visibility.Private),
)
)
}
private fun merge(vararg cacheControl: CacheControl): List<CacheControl> {
return cacheControl.asList().mergeCacheControlDirectives()
}
}
| ktor-server/ktor-server-plugins/ktor-server-caching-headers/jvmAndNix/test/io/ktor/tests/CacheControlMergeTest.kt | 3762140559 |
/*
* Copyright 2014-2019 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
*/
package io.ktor.server.engine
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.engine.internal.*
import io.ktor.server.engine.internal.ClosedChannelException
import io.ktor.server.logging.*
import io.ktor.server.plugins.*
import io.ktor.server.response.*
import io.ktor.util.*
import io.ktor.util.cio.*
import io.ktor.util.logging.*
import io.ktor.util.pipeline.*
import io.ktor.utils.io.*
import io.ktor.utils.io.errors.*
import kotlinx.coroutines.*
import kotlinx.coroutines.CancellationException
/**
* Default engine pipeline for all engines. Use it only if you are writing your own application engine implementation.
*/
@OptIn(InternalAPI::class)
public fun defaultEnginePipeline(environment: ApplicationEnvironment): EnginePipeline {
val pipeline = EnginePipeline(environment.developmentMode)
configureShutdownUrl(environment, pipeline)
pipeline.intercept(EnginePipeline.Call) {
try {
call.application.execute(call)
} catch (error: ChannelIOException) {
call.application.mdcProvider.withMDCBlock(call) {
call.application.environment.logFailure(call, error)
}
} catch (error: Throwable) {
handleFailure(call, error)
} finally {
try {
call.request.receiveChannel().discard()
} catch (ignore: Throwable) {
}
}
}
return pipeline
}
public suspend fun handleFailure(call: ApplicationCall, error: Throwable) {
logError(call, error)
tryRespondError(call, defaultExceptionStatusCode(error) ?: HttpStatusCode.InternalServerError)
}
@OptIn(InternalAPI::class)
public suspend fun logError(call: ApplicationCall, error: Throwable) {
call.application.mdcProvider.withMDCBlock(call) {
call.application.environment.logFailure(call, error)
}
}
/**
* Map [cause] to the corresponding status code or `null` if no default exception mapping for this [cause] type
*/
public fun defaultExceptionStatusCode(cause: Throwable): HttpStatusCode? {
return when (cause) {
is BadRequestException -> HttpStatusCode.BadRequest
is NotFoundException -> HttpStatusCode.NotFound
is UnsupportedMediaTypeException -> HttpStatusCode.UnsupportedMediaType
is TimeoutException, is TimeoutCancellationException -> HttpStatusCode.GatewayTimeout
else -> null
}
}
private suspend fun tryRespondError(call: ApplicationCall, statusCode: HttpStatusCode) {
try {
if (call.response.status() == null) {
call.respond(statusCode)
}
} catch (ignore: BaseApplicationResponse.ResponseAlreadySentException) {
}
}
private fun ApplicationEnvironment.logFailure(call: ApplicationCall, cause: Throwable) {
try {
val status = call.response.status() ?: "Unhandled"
val logString = try {
call.request.toLogString()
} catch (cause: Throwable) {
"(request error: $cause)"
}
val infoString = "$status: $logString. Exception ${cause::class}: ${cause.message}]"
when (cause) {
is CancellationException,
is ClosedChannelException,
is ChannelIOException,
is IOException,
is BadRequestException,
is NotFoundException,
is UnsupportedMediaTypeException -> log.debug(infoString, cause)
else -> log.error("$status: $logString", cause)
}
} catch (oom: OutOfMemoryError) {
try {
log.error(cause)
} catch (oomAttempt2: OutOfMemoryError) {
printError("OutOfMemoryError: ")
printError(cause.message)
printError("\n")
}
}
}
| ktor-server/ktor-server-host-common/jvmAndNix/src/io/ktor/server/engine/DefaultEnginePipeline.kt | 1615260092 |
package eu.kanade.tachiyomi.ui.setting
import android.Manifest.permission.WRITE_EXTERNAL_STORAGE
import android.app.Activity
import android.app.Dialog
import android.content.ActivityNotFoundException
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.view.Menu
import android.view.MenuInflater
import android.view.MenuItem
import android.view.View
import android.widget.Toast
import androidx.appcompat.app.AlertDialog
import androidx.core.net.toUri
import androidx.core.os.bundleOf
import androidx.preference.PreferenceScreen
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import com.hippo.unifile.UniFile
import eu.kanade.tachiyomi.R
import eu.kanade.tachiyomi.data.backup.BackupConst
import eu.kanade.tachiyomi.data.backup.BackupCreateService
import eu.kanade.tachiyomi.data.backup.BackupCreatorJob
import eu.kanade.tachiyomi.data.backup.BackupRestoreService
import eu.kanade.tachiyomi.data.backup.ValidatorParseException
import eu.kanade.tachiyomi.data.backup.full.FullBackupRestoreValidator
import eu.kanade.tachiyomi.data.backup.full.models.BackupFull
import eu.kanade.tachiyomi.data.backup.legacy.LegacyBackupRestoreValidator
import eu.kanade.tachiyomi.ui.base.controller.DialogController
import eu.kanade.tachiyomi.ui.base.controller.requestPermissionsSafe
import eu.kanade.tachiyomi.util.preference.bindTo
import eu.kanade.tachiyomi.util.preference.entriesRes
import eu.kanade.tachiyomi.util.preference.infoPreference
import eu.kanade.tachiyomi.util.preference.intListPreference
import eu.kanade.tachiyomi.util.preference.onChange
import eu.kanade.tachiyomi.util.preference.onClick
import eu.kanade.tachiyomi.util.preference.preference
import eu.kanade.tachiyomi.util.preference.preferenceCategory
import eu.kanade.tachiyomi.util.preference.summaryRes
import eu.kanade.tachiyomi.util.preference.titleRes
import eu.kanade.tachiyomi.util.system.DeviceUtil
import eu.kanade.tachiyomi.util.system.openInBrowser
import eu.kanade.tachiyomi.util.system.toast
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach
class SettingsBackupController : SettingsController() {
/**
* Flags containing information of what to backup.
*/
private var backupFlags = 0
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
requestPermissionsSafe(arrayOf(WRITE_EXTERNAL_STORAGE), 500)
}
override fun setupPreferenceScreen(screen: PreferenceScreen) = screen.apply {
titleRes = R.string.label_backup
preference {
key = "pref_create_backup"
titleRes = R.string.pref_create_backup
summaryRes = R.string.pref_create_backup_summ
onClick {
if (DeviceUtil.isMiui && DeviceUtil.isMiuiOptimizationDisabled()) {
context.toast(R.string.restore_miui_warning, Toast.LENGTH_LONG)
}
if (!BackupCreateService.isRunning(context)) {
val ctrl = CreateBackupDialog()
ctrl.targetController = this@SettingsBackupController
ctrl.showDialog(router)
} else {
context.toast(R.string.backup_in_progress)
}
}
}
preference {
key = "pref_restore_backup"
titleRes = R.string.pref_restore_backup
summaryRes = R.string.pref_restore_backup_summ
onClick {
if (DeviceUtil.isMiui && DeviceUtil.isMiuiOptimizationDisabled()) {
context.toast(R.string.restore_miui_warning, Toast.LENGTH_LONG)
}
if (!BackupRestoreService.isRunning(context)) {
val intent = Intent(Intent.ACTION_GET_CONTENT).apply {
addCategory(Intent.CATEGORY_OPENABLE)
type = "*/*"
}
val title = resources?.getString(R.string.file_select_backup)
val chooser = Intent.createChooser(intent, title)
startActivityForResult(chooser, CODE_BACKUP_RESTORE)
} else {
context.toast(R.string.restore_in_progress)
}
}
}
preferenceCategory {
titleRes = R.string.pref_backup_service_category
intListPreference {
bindTo(preferences.backupInterval())
titleRes = R.string.pref_backup_interval
entriesRes = arrayOf(
R.string.update_never,
R.string.update_6hour,
R.string.update_12hour,
R.string.update_24hour,
R.string.update_48hour,
R.string.update_weekly
)
entryValues = arrayOf("0", "6", "12", "24", "48", "168")
summary = "%s"
onChange { newValue ->
val interval = (newValue as String).toInt()
BackupCreatorJob.setupTask(context, interval)
true
}
}
preference {
bindTo(preferences.backupsDirectory())
titleRes = R.string.pref_backup_directory
onClick {
try {
val intent = Intent(Intent.ACTION_OPEN_DOCUMENT_TREE)
startActivityForResult(intent, CODE_BACKUP_DIR)
} catch (e: ActivityNotFoundException) {
activity?.toast(R.string.file_picker_error)
}
}
visibleIf(preferences.backupInterval()) { it > 0 }
preferences.backupsDirectory().asFlow()
.onEach { path ->
val dir = UniFile.fromUri(context, path.toUri())
summary = dir.filePath + "/automatic"
}
.launchIn(viewScope)
}
intListPreference {
bindTo(preferences.numberOfBackups())
titleRes = R.string.pref_backup_slots
entries = arrayOf("1", "2", "3", "4", "5")
entryValues = entries
summary = "%s"
visibleIf(preferences.backupInterval()) { it > 0 }
}
}
infoPreference(R.string.backup_info)
}
override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
inflater.inflate(R.menu.settings_backup, menu)
}
override fun onOptionsItemSelected(item: MenuItem): Boolean {
when (item.itemId) {
R.id.action_backup_help -> activity?.openInBrowser(HELP_URL)
}
return super.onOptionsItemSelected(item)
}
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
if (data != null && resultCode == Activity.RESULT_OK) {
val activity = activity ?: return
val uri = data.data
if (uri == null) {
activity.toast(R.string.backup_restore_invalid_uri)
return
}
when (requestCode) {
CODE_BACKUP_DIR -> {
// Get UriPermission so it's possible to write files
val flags = Intent.FLAG_GRANT_READ_URI_PERMISSION or
Intent.FLAG_GRANT_WRITE_URI_PERMISSION
activity.contentResolver.takePersistableUriPermission(uri, flags)
preferences.backupsDirectory().set(uri.toString())
}
CODE_BACKUP_CREATE -> {
val flags = Intent.FLAG_GRANT_READ_URI_PERMISSION or
Intent.FLAG_GRANT_WRITE_URI_PERMISSION
activity.contentResolver.takePersistableUriPermission(uri, flags)
BackupCreateService.start(
activity,
uri,
backupFlags,
)
}
CODE_BACKUP_RESTORE -> {
RestoreBackupDialog(uri).showDialog(router)
}
}
}
}
fun createBackup(flags: Int) {
backupFlags = flags
try {
// Use Android's built-in file creator
val intent = Intent(Intent.ACTION_CREATE_DOCUMENT)
.addCategory(Intent.CATEGORY_OPENABLE)
.setType("application/*")
.putExtra(Intent.EXTRA_TITLE, BackupFull.getDefaultFilename())
startActivityForResult(intent, CODE_BACKUP_CREATE)
} catch (e: ActivityNotFoundException) {
activity?.toast(R.string.file_picker_error)
}
}
class CreateBackupDialog(bundle: Bundle? = null) : DialogController(bundle) {
override fun onCreateDialog(savedViewState: Bundle?): Dialog {
val activity = activity!!
val options = arrayOf(
R.string.manga,
R.string.categories,
R.string.chapters,
R.string.track,
R.string.history
)
.map { activity.getString(it) }
val selected = options.map { true }.toBooleanArray()
return MaterialAlertDialogBuilder(activity)
.setTitle(R.string.backup_choice)
.setMultiChoiceItems(options.toTypedArray(), selected) { dialog, which, checked ->
if (which == 0) {
(dialog as AlertDialog).listView.setItemChecked(which, true)
} else {
selected[which] = checked
}
}
.setPositiveButton(R.string.action_create) { _, _ ->
var flags = 0
selected.forEachIndexed { i, checked ->
if (checked) {
when (i) {
1 -> flags = flags or BackupCreateService.BACKUP_CATEGORY
2 -> flags = flags or BackupCreateService.BACKUP_CHAPTER
3 -> flags = flags or BackupCreateService.BACKUP_TRACK
4 -> flags = flags or BackupCreateService.BACKUP_HISTORY
}
}
}
(targetController as? SettingsBackupController)?.createBackup(flags)
}
.setNegativeButton(android.R.string.cancel, null)
.create()
}
}
class RestoreBackupDialog(bundle: Bundle? = null) : DialogController(bundle) {
constructor(uri: Uri) : this(
bundleOf(KEY_URI to uri)
)
override fun onCreateDialog(savedViewState: Bundle?): Dialog {
val activity = activity!!
val uri: Uri = args.getParcelable(KEY_URI)!!
return try {
var type = BackupConst.BACKUP_TYPE_FULL
val results = try {
FullBackupRestoreValidator().validate(activity, uri)
} catch (_: ValidatorParseException) {
type = BackupConst.BACKUP_TYPE_LEGACY
LegacyBackupRestoreValidator().validate(activity, uri)
}
var message = if (type == BackupConst.BACKUP_TYPE_FULL) {
activity.getString(R.string.backup_restore_content_full)
} else {
activity.getString(R.string.backup_restore_content)
}
if (results.missingSources.isNotEmpty()) {
message += "\n\n${activity.getString(R.string.backup_restore_missing_sources)}\n${results.missingSources.joinToString("\n") { "- $it" }}"
}
if (results.missingTrackers.isNotEmpty()) {
message += "\n\n${activity.getString(R.string.backup_restore_missing_trackers)}\n${results.missingTrackers.joinToString("\n") { "- $it" }}"
}
MaterialAlertDialogBuilder(activity)
.setTitle(R.string.pref_restore_backup)
.setMessage(message)
.setPositiveButton(R.string.action_restore) { _, _ ->
BackupRestoreService.start(activity, uri, type)
}
.create()
} catch (e: Exception) {
MaterialAlertDialogBuilder(activity)
.setTitle(R.string.invalid_backup_file)
.setMessage(e.message)
.setPositiveButton(android.R.string.cancel, null)
.create()
}
}
}
}
private const val KEY_URI = "RestoreBackupDialog.uri"
private const val CODE_BACKUP_DIR = 503
private const val CODE_BACKUP_CREATE = 504
private const val CODE_BACKUP_RESTORE = 505
private const val HELP_URL = "https://tachiyomi.org/help/guides/backups/"
| app/src/main/java/eu/kanade/tachiyomi/ui/setting/SettingsBackupController.kt | 3570274306 |
package me.camdenorrb.minibus
import me.camdenorrb.minibus.event.EventWatcher
import me.camdenorrb.minibus.event.type.Cancellable
import me.camdenorrb.minibus.listener.ListenerPriority.*
import me.camdenorrb.minibus.listener.MiniListener
import org.junit.After
import org.junit.Before
import org.junit.Test
import kotlin.system.measureNanoTime
internal open class BenchmarkEvent
internal class GenericEvent<T>(var called: Boolean = false) : BenchmarkEvent()
internal class TestEvent(var count: Int = 0, var abc: String = ""): Cancellable()
internal class MiniBusTest: MiniListener {
val miniBus = MiniBus()
@Before
fun setUp() { miniBus.register(this) }
@Test
fun eventTest() {
val calledEvent = miniBus(TestEvent())
println("Count: ${calledEvent.count} Order: ${calledEvent.abc}")
check(calledEvent.count == 3) { "Not all events were called!" }
check(calledEvent.abc == "a b c") { "The events were not called in order!" }
check(calledEvent.isCancelled) { "Event was not cancelled after the last listener!" }
var totalTime = 0L
val benchmarkEvent = BenchmarkEvent()
// Generic tests
val negateTest = miniBus(GenericEvent<Int>())
check(!negateTest.called) { "Negated generic event was called!" }
val positiveTest = miniBus(GenericEvent<String>())
check(positiveTest.called) { "Positive generic event wasn't called!" }
// Benchmark
/* Warm Up */
for (i in 0..100_000) miniBus(benchmarkEvent)
for (i in 1..1000) totalTime += measureNanoTime { miniBus(benchmarkEvent) }
println("1000 * BenchEvent { Average: ${totalTime / 1000}/ns Total: $totalTime/ns }")
totalTime = 0
val meow = "Meow"
/* Warm Up */
for (i in 0..100_000) miniBus(meow)
for (i in 1..1000) totalTime += measureNanoTime { miniBus(meow) }
println("1000 * NonExistent Event { Average: ${totalTime / 1000}/ns Total: $totalTime/ns }")
}
@After
fun tearDown() {
miniBus.unregister(this)
check(miniBus.listenerTable.map.isEmpty()) {
"Listeners not empty ${miniBus.listenerTable.map}"
}
}
@EventWatcher
fun BenchmarkEvent.onBenchMark() = Unit
@EventWatcher
fun GenericEvent<String>.onGenericEvent() {
called = true
}
@EventWatcher(FIRST)
fun TestEvent.onTest1() {
count++
abc += "a "
}
@EventWatcher(NORMAL)
fun TestEvent.onTest3() {
count++
abc += "b "
}
@EventWatcher(LAST)
fun TestEvent.onTest6() {
count++
abc += "c"
isCancelled = true
}
} | src/test/kotlin/me/camdenorrb/minibus/MiniBusTest.kt | 1812168757 |
package imgui.internal.classes
import glm_.glm
import glm_.max
import imgui.*
import imgui.api.g
import imgui.internal.api.inputText.Companion.inputTextCalcTextSizeW
import imgui.internal.isBlankW
import imgui.internal.textCountUtf8BytesFromStr
import imgui.stb.te
import imgui.stb.te.key
import imgui.stb.te.makeUndoReplace
import org.lwjgl.system.Platform
import uno.kotlin.NUL
/** Internal state of the currently focused/edited text input box
* For a given item ID, access with ImGui::GetInputTextState() */
class InputTextState {
/** widget id owning the text state */
var id: ID = 0
var curLenA = 0 // we need to maintain our buffer length in both UTF-8 and wchar format. UTF-8 length is valid even if TextA is not.
var curLenW = 0
/** edit buffer, we need to persist but can't guarantee the persistence of the user-provided buffer. So we copy into own buffer. */
var textW = CharArray(0)
/** temporary buffer for callbacks and other operations. size=capacity. */
var textA = ByteArray(0)
/** backup of end-user buffer at the time of focus (in UTF-8, unaltered) */
var initialTextA = ByteArray(0)
/** temporary UTF8 buffer is not initially valid before we make the widget active (until then we pull the data from user argument) */
var textAIsValid = false
/** end-user buffer size */
var bufCapacityA = 0
/** horizontal scrolling/offset */
var scrollX = 0f
/** state for stb_textedit.h */
val stb = te.State()
/** timer for cursor blink, reset on every user action so the cursor reappears immediately */
var cursorAnim = 0f
/** set when we want scrolling to follow the current cursor position (not always!) */
var cursorFollow = false
/** after a double-click to select all, we ignore further mouse drags to update selection */
var selectedAllMouseLock = false
/** edited this frame */
var edited = false
/** Temporarily set when active */
var userFlags: InputTextFlags = 0
/** Temporarily set when active */
var userCallback: InputTextCallback? = null
/** Temporarily set when active */
var userCallbackData: Any? = null
fun clearText() {
curLenW = 0
curLenA = 0
textW = CharArray(0)
textA = ByteArray(0)
cursorClamp()
}
fun clearFreeMemory() {
textW = CharArray(0)
textA = ByteArray(0)
initialTextA = ByteArray(0)
}
val undoAvailCount: Int
get() = stb.undoState.undoPoint
val redoAvailCount: Int
get() = te.UNDOSTATECOUNT - stb.undoState.redoPoint
/** Cannot be inline because we call in code in stb_textedit.h implementation */
fun onKeyPressed(key: Int) {
key(key)
cursorFollow = true
cursorAnimReset()
}
// Cursor & Selection
/** After a user-input the cursor stays on for a while without blinking */
fun cursorAnimReset() {
cursorAnim = -0.3f
}
fun cursorClamp() = with(stb) {
cursor = glm.min(cursor, curLenW)
selectStart = glm.min(selectStart, curLenW)
selectEnd = glm.min(selectEnd, curLenW)
}
val hasSelection get() = stb.hasSelection
fun clearSelection() {
stb.selectStart = stb.cursor
stb.selectEnd = stb.cursor
}
fun selectAll() {
stb.selectStart = 0
stb.selectEnd = curLenW
stb.cursor = curLenW
stb.hasPreferredX = false
}
//-------------------------------------------------------------------------
// STB libraries includes
//-------------------------------------------------------------------------
val GETWIDTH_NEWLINE = -1f
/*
====================================================================================================================
Wrapper for stb_textedit.h to edit text (our wrapper is for: statically sized buffer, single-line, wchar characters.
InputText converts between UTF-8 and wchar)
====================================================================================================================
*/
val stringLen: Int get() = curLenW
fun getChar(idx: Int): Char = textW[idx]
fun getWidth(lineStartIdx: Int, charIdx: Int): Float = when (val c = textW[lineStartIdx + charIdx]) {
'\n' -> GETWIDTH_NEWLINE
else -> g.font.getCharAdvance(c) * (g.fontSize / g.font.fontSize)
}
fun keyToText(key: Int): Int = if (key >= 0x200000) 0 else key
val NEWLINE = '\n'
private var textRemaining = 0
fun layoutRow(r: te.Row, lineStartIdx: Int) {
val size = inputTextCalcTextSizeW(textW, lineStartIdx, curLenW, ::textRemaining, stopOnNewLine = true)
r.apply {
x0 = 0f
x1 = size.x
baselineYDelta = size.y
yMin = 0f
yMax = size.y
numChars = textRemaining - lineStartIdx
}
}
val Char.isSeparator: Boolean
get() = let { c ->
isBlankW || c == ',' || c == ';' || c == '(' || c == ')' || c == '{' || c == '}' || c == '[' || c == ']' || c == '|'
}
infix fun isWordBoundaryFromRight(idx: Int): Boolean = when {
idx > 0 -> textW[idx - 1].isSeparator && !textW[idx].isSeparator
else -> true
}
infix fun isWordBoundaryFromLeft(idx: Int): Boolean = when {
idx > 0 -> !textW[idx - 1].isSeparator && textW[idx].isSeparator
else -> true
}
infix fun moveWordLeft(idx: Int): Int {
var i = idx - 1
while (i >= 0 && !isWordBoundaryFromRight(i)) i--
return if (i < 0) 0 else i
}
infix fun moveWordRight(idx_: Int): Int {
var idx = idx_ + 1
val len = curLenW
fun isWordBoundary() = when (Platform.get()) {
Platform.MACOSX -> isWordBoundaryFromLeft(idx)
else -> isWordBoundaryFromRight(idx)
}
while (idx < len && !isWordBoundary()) idx++
return if (idx > len) len else idx
}
fun deleteChars(pos: Int, n: Int) {
if (n == 0) // TODO [JVM] needed?
return
var dst = pos
// We maintain our buffer length in both UTF-8 and wchar formats
edited = true
curLenA -= textCountUtf8BytesFromStr(textW, dst, dst + n)
curLenW -= n
// Offset remaining text (FIXME-OPT: Use memmove)
var src = pos + n
var c = textW[src++]
while (c != NUL) {
textW[dst++] = c
c = textW[src++]
}
if (dst < textW.size) textW[dst] = NUL
}
fun insertChar(pos: Int, newText: Char): Boolean = insertChars(pos, charArrayOf(newText), 0, 1)
fun insertChars(pos: Int, newText: CharArray, ptr: Int, newTextLen: Int): Boolean {
val isResizable = userFlags has InputTextFlag.CallbackResize
val textLen = curLenW
assert(pos <= textLen)
val newTextLenUtf8 = textCountUtf8BytesFromStr(newText, ptr, newTextLen)
if (!isResizable && newTextLenUtf8 + curLenA > bufCapacityA)
return false
// Grow internal buffer if needed
if (newTextLen + textLen > textW.size) {
if (!isResizable)
return false
assert(textLen <= textW.size) // [JVM] <= instead < because we dont use the termination NUL
val tmp = CharArray(textLen + glm.clamp(newTextLen * 4, 32, 256 max newTextLen))
System.arraycopy(textW, 0, tmp, 0, textW.size)
textW = tmp
}
if (pos != textLen)
for (i in 0 until textLen - pos) textW[textLen - 1 + newTextLen - i] = textW[textLen - 1 - i]
for (i in 0 until newTextLen) textW[pos + i] = newText[ptr + i]
edited = true
curLenW += newTextLen
curLenA += newTextLenUtf8
if (curLenW < textW.size) textW[curLenW] = NUL
return true
}
/* We don't use an enum so we can build even with conflicting symbols (if another user of stb_textedit.h leak their
STB_TEXTEDIT_K_* symbols) */
object K {
/** keyboard input to move cursor left */
val LEFT = 0x200000
/** keyboard input to move cursor right */
val RIGHT = 0x200001
/** keyboard input to move cursor up */
val UP = 0x200002
/** keyboard input to move cursor down */
val DOWN = 0x200003
/** keyboard input to move cursor to start of line */
val LINESTART = 0x200004
/** keyboard input to move cursor to end of line */
val LINEEND = 0x200005
/** keyboard input to move cursor to start of text */
val TEXTSTART = 0x200006
/** keyboard input to move cursor to end of text */
val TEXTEND = 0x200007
/** keyboard input to delete selection or character under cursor */
val DELETE = 0x200008
/** keyboard input to delete selection or character left of cursor */
val BACKSPACE = 0x200009
/** keyboard input to perform undo */
val UNDO = 0x20000A
/** keyboard input to perform redo */
val REDO = 0x20000B
/** keyboard input to move cursor left one word */
val WORDLEFT = 0x20000C
/** keyboard input to move cursor right one word */
val WORDRIGHT = 0x20000D
/** keyboard input to move cursor up a page */
val PGUP = 0x20000E
/** keyboard input to move cursor down a page */
val PGDOWN = 0x20000F
val SHIFT = 0x400000
}
/** stb_textedit internally allows for a single undo record to do addition and deletion, but somehow, calling
* the stb_textedit_paste() function creates two separate records, so we perform it manually. (FIXME: Report to nothings/stb?) */
fun replace(text: CharArray, textLen: Int = text.size) {
makeUndoReplace(0, curLenW, textLen)
deleteChars(0, curLenW)
if (textLen <= 0)
return
if (insertChars(0, text, 0, textLen)) {
stb.cursor = textLen
stb.hasPreferredX = false
return
}
assert(false) { "Failed to insert character, normally shouldn't happen because of how we currently use stb_textedit_replace()" }
}
// /*
// ====================================================================================================================
// stb_textedit.h - v1.9 - public domain - Sean Barrett
// Development of this library was sponsored by RAD Game Tools
// ====================================================================================================================
// */
//
// companion object {
// val UNDOSTATECOUNT = 99
// val UNDOCHARCOUNT = 999
// fun memmove(dst: CharArray, pDst: Int, src: CharArray, pSrc: Int, len: Int) {
// val tmp = CharArray(len) { src[pSrc + it] }
// for (i in 0 until len) dst[pDst + i] = tmp[i]
// }
//
// fun memmove(dst: Array<UndoRecord>, pDst: Int, src: Array<UndoRecord>, pSrc: Int, len: Int) {
// val tmp = Array(len) { UndoRecord(src[pSrc + it]) }
// for (i in 0 until len) dst[pDst + i] = tmp[i]
// }
// }
//
// class UndoRecord {
// var where = 0
// var insertLength = 0
// var deleteLength = 0
// var charStorage = 0
//
// constructor()
// constructor(undoRecord: UndoRecord) {
// where = undoRecord.where
// insertLength = undoRecord.insertLength
// deleteLength = undoRecord.deleteLength
// charStorage = undoRecord.charStorage
// }
//
// infix fun put(other: UndoRecord) {
// where = other.where
// insertLength = other.insertLength
// deleteLength = other.deleteLength
// charStorage = other.charStorage
// }
// }
//
// class UndoState {
// val undoRec = Array(UNDOSTATECOUNT) { UndoRecord() }
// val undoChar = CharArray(UNDOCHARCOUNT)
// var undoPoint = 0
// var redoPoint = 0
// var undoCharPoint = 0
// var redoCharPoint = 0
//
// fun clear() {
// undoPoint = 0
// undoCharPoint = 0
// redoPoint = UNDOSTATECOUNT
// redoCharPoint = UNDOCHARCOUNT
// }
//
// /////////////////////////////////////////////////////////////////////////////
// //
// // Undo processing
// //
// // @OPTIMIZE: the undo/redo buffer should be circular
// //
// /////////////////////////////////////////////////////////////////////////////
//
// fun flushRedo() {
// redoPoint = UNDOSTATECOUNT
// redoCharPoint = UNDOCHARCOUNT
// }
//
// /** discard the oldest entry in the undo list */
// fun discardUndo() {
// if (undoPoint > 0) {
// // if the 0th undo state has characters, clean those up
// if (undoRec[0].charStorage >= 0) {
// val n = undoRec[0].insertLength
// // delete n characters from all other records
// undoCharPoint -= n // vsnet05
// memmove(undoChar, 0, undoChar, n, undoCharPoint)
// for (i in 0 until undoPoint)
// if (undoRec[i].charStorage >= 0)
// // vsnet05 // @OPTIMIZE: get rid of char_storage and infer it
// undoRec[i].charStorage = undoRec[i].charStorage - n
// }
// --undoPoint
// memmove(undoRec, 0, undoRec, 1, undoPoint)
// }
// }
//
// /** discard the oldest entry in the redo list--it's bad if this ever happens, but because undo & redo have to
// * store the actual characters in different cases, the redo character buffer can fill up even though the undo
// * buffer didn't */
// fun discardRedo() {
//
// val k = UNDOSTATECOUNT - 1
//
// if (redoPoint <= k) {
// // if the k'th undo state has characters, clean those up
// if (undoRec[k].charStorage >= 0) {
// val n = undoRec[k].insertLength
// // delete n characters from all other records
// redoCharPoint += n // vsnet05
// memmove(undoChar, redoCharPoint, undoChar, redoCharPoint - n, UNDOCHARCOUNT - redoCharPoint)
// for (i in redoPoint until k)
// if (undoRec[i].charStorage >= 0)
// undoRec[i].charStorage = undoRec[i].charStorage + n // vsnet05
// }
// memmove(undoRec, redoPoint, undoRec, redoPoint - 1, UNDOSTATECOUNT - redoPoint)
// ++redoPoint
// }
// }
//
// fun createUndoRecord(numChars: Int): UndoRecord? {
//
// // any time we create a new undo record, we discard redo
// flushRedo()
//
// // if we have no free records, we have to make room, by sliding the existing records down
// if (undoPoint == UNDOSTATECOUNT)
// discardUndo()
//
// // if the characters to store won't possibly fit in the buffer, we can't undo
// if (numChars > UNDOCHARCOUNT) {
// undoPoint = 0
// undoCharPoint = 0
// return null
// }
//
// // if we don't have enough free characters in the buffer, we have to make room
// while (undoCharPoint + numChars > UNDOCHARCOUNT)
// discardUndo()
//
// return undoRec[undoPoint++]
// }
//
// fun createundo(pos: Int, insertLen: Int, deleteLen: Int): Int? {
//
// val r = createUndoRecord(insertLen) ?: return null
//
// r.where = pos
// r.insertLength = insertLen
// r.deleteLength = deleteLen
//
// if (insertLen == 0) {
// r.charStorage = -1
// return null
// } else {
// r.charStorage = undoCharPoint
// undoCharPoint += insertLen
// return r.charStorage
// }
// }
// }
//
// class State {
//
// /** position of the text cursor within the string */
// var cursor = 0
//
// /* selection start and end point in characters; if equal, no selection.
// note that start may be less than or greater than end (e.g. when dragging the mouse, start is where the
// initial click was, and you can drag in either direction) */
//
// /** selection start point */
// var selectStart = 0
//
// /** selection end point */
// var selectEnd = 0
//
// /** each textfield keeps its own insert mode state. to keep an app-wide insert mode, copy this value in/out of
// * the app state */
// var insertMode = false
//
// /** not implemented yet */
// var cursorAtEndOfLine = false
// var initialized = false
// var hasPreferredX = false
// var singleLine = false
// var padding1 = NUL
// var padding2 = NUL
// var padding3 = NUL
//
// /** this determines where the cursor up/down tries to seek to along x */
// var preferredX = 0f
// val undostate = UndoState()
//
//
// /** reset the state to default */
// fun clear(isSingleLine: Boolean) {
//
// undostate.clear()
// selectStart = 0
// selectEnd = 0
// cursor = 0
// hasPreferredX = false
// preferredX = 0f
// cursorAtEndOfLine = false
// initialized = true
// singleLine = isSingleLine
// insertMode = false
// }
// }
//
// /** Result of layout query, used by stb_textedit to determine where the text in each row is.
// * result of layout query */
// class Row {
// /** starting x location */
// var x0 = 0f
//
// /** end x location (allows for align=right, etc) */
// var x1 = 0f
//
// /** position of baseline relative to previous row's baseline */
// var baselineYDelta = 0f
//
// /** height of row above baseline */
// var yMin = 0f
//
// /** height of row below baseline */
// var yMax = 0f
//
// var numChars = 0
// }
//
// /////////////////////////////////////////////////////////////////////////////
// //
// // Mouse input handling
// //
// /////////////////////////////////////////////////////////////////////////////
//
// /** traverse the layout to locate the nearest character to a display position */
// fun locateCoord(x: Float, y: Float): Int {
//
// val r = Row()
// val n = curLenW
// var baseY = 0f
// var prevX: Float
// var i = 0
//
// // search rows to find one that straddles 'y'
// while (i < n) {
// layoutRow(r, i)
// if (r.numChars <= 0)
// return n
//
// if (i == 0 && y < baseY + r.yMin)
// return 0
//
// if (y < baseY + r.yMax)
// break
//
// i += r.numChars
// baseY += r.baselineYDelta
// }
//
// // below all text, return 'after' last character
// if (i >= n)
// return n
//
// // check if it's before the beginning of the line
// if (x < r.x0)
// return i
//
// // check if it's before the end of the line
// if (x < r.x1) {
// // search characters in row for one that straddles 'x'
// prevX = r.x0
// for (k in 0 until r.numChars) {
// val w = getWidth(i, k)
// if (x < prevX + w) {
// return if (x < prevX + w / 2) k + i else k + i + 1
// }
// prevX += w
// }
// // shouldn't happen, but if it does, fall through to end-of-line case
// }
//
// // if the last character is a newline, return that. otherwise return 'after' the last character
// return if (textW[i + r.numChars - 1] == '\n') i + r.numChars - 1 else i + r.numChars
// }
//
// /** API click: on mouse down, move the cursor to the clicked location, and reset the selection */
// fun click(x: Float, y: Float) = with(stb) {
// cursor = locateCoord(x, y)
// selectStart = cursor
// selectEnd = cursor
// hasPreferredX = false
// }
//
// /** API drag: on mouse drag, move the cursor and selection endpoint to the clicked location */
// fun drag(x: Float, y: Float) {
// val p = locateCoord(x, y)
// if (stb.selectStart == stb.selectEnd)
// stb.selectStart = stb.cursor
// stb.cursor = p
// stb.selectEnd = p
// }
//
// /////////////////////////////////////////////////////////////////////////////
// //
// // Keyboard input handling
// //
// /////////////////////////////////////////////////////////////////////////////
//
// fun undo() {
//
// val s = stb.undoState
// if (s.undoPoint == 0) return
//
// // we need to do two things: apply the undo record, and create a redo record
// val u = UndoRecord(s.undoRec[s.undoPoint - 1])
// var r = s.undoRec[s.redoPoint - 1]
// r put u
// r.charStorage = -1
//
// if (u.deleteLength != 0) {
// /* if the undo record says to delete characters, then the redo record will need to re-insert the characters
// that get deleted, so we need to store them.
//
// there are three cases:
// - there's enough room to store the characters
// - characters stored for *redoing* don't leave room for redo
// - characters stored for *undoing* don't leave room for redo
// if the last is true, we have to bail */
//
// if (s.undoCharPoint + u.deleteLength >= UNDOCHARCOUNT)
// // the undo records take up too much character space; there's no space to store the redo characters
// r.insertLength = 0
// else {
// // there's definitely room to store the characters eventually
// while (s.undoCharPoint + u.deleteLength > s.redoCharPoint) {
// // there's currently not enough room, so discard a redo record
// s.discardRedo()
// // should never happen:
// if (s.redoPoint == UNDOSTATECOUNT)
// return
// }
// r = s.undoRec[s.redoPoint - 1]
//
// r.charStorage = s.redoCharPoint - u.deleteLength
// s.redoCharPoint = s.redoCharPoint - u.deleteLength
//
// // now save the characters
// repeat(u.deleteLength) { s.undoChar[r.charStorage + it] = getChar(u.where + it) }
// }
//
// // now we can carry out the deletion
// deleteChars(u.where, u.deleteLength)
// }
//
// // check type of recorded action:
// if (u.insertLength != 0) {
// // easy case: was a deletion, so we need to insert n characters
// insertChars(u.where, s.undoChar, u.charStorage, u.insertLength)
// s.undoCharPoint -= u.insertLength
// }
//
// stb.cursor = u.where + u.insertLength
//
// s.undoPoint--
// s.redoPoint--
// }
//
// fun redo() {
//
// val s = stb.undoState
// if (s.redoPoint == UNDOSTATECOUNT) return
//
// // we need to do two things: apply the redo record, and create an undo record
// val u = s.undoRec[s.undoPoint]
// val r = UndoRecord(s.undoRec[s.redoPoint])
//
// // we KNOW there must be room for the undo record, because the redo record was derived from an undo record
//
// u put r
// u.charStorage = -1
//
// if (r.deleteLength != 0) {
// // the redo record requires us to delete characters, so the undo record needs to store the characters
//
// if (s.undoCharPoint + u.insertLength > s.redoCharPoint) {
// u.insertLength = 0
// u.deleteLength = 0
// } else {
// u.charStorage = s.undoCharPoint
// s.undoCharPoint = s.undoCharPoint + u.insertLength
//
// // now save the characters
// for (i in 0 until u.insertLength)
// s.undoChar[u.charStorage + i] = getChar(u.where + i)
// }
//
// deleteChars(r.where, r.deleteLength)
// }
//
// if (r.insertLength != 0) {
// // easy case: need to insert n characters
// insertChars(r.where, s.undoChar, r.charStorage, r.insertLength)
// s.redoCharPoint += r.insertLength
// }
//
// stb.cursor = r.where + r.insertLength
//
// s.undoPoint++
// s.redoPoint++
// }
//
// fun makeundoInsert(where: Int, length: Int) = stb.undoState.createundo(where, 0, length)
//
// fun makeundoDelete(where: Int, length: Int) = stb.undoState.createundo(where, length, 0)?.let {
// for (i in 0 until length)
// stb.undoState.undoChar[it + i] = getChar(where + i)
// }
//
// fun makeundoReplace(where: Int, oldLength: Int, newLength: Int) = stb.undoState.createundo(where, oldLength, newLength)?.let {
// for (i in 0 until oldLength)
// stb.undoState.undoChar[i] = getChar(where + i)
// }
//
//
// class FindState {
// // position of n'th character
// var x = 0f
// var y = 0f
//
// /** height of line */
// var height = 0f
//
// /** first char of row */
// var firstChar = 0
//
// /** first char length */
// var length = 0
//
// /** first char of previous row */
// var prevFirst = 0
// }
//
// val hasSelection get() = stb.selectStart != stb.selectEnd
//
// /** find the x/y location of a character, and remember info about the previous row in case we get a move-up event
// * (for page up, we'll have to rescan) */
// fun findCharpos(find: FindState, n: Int, singleLine: Boolean) {
// val r = Row()
// var prevStart = 0
// val z = curLenW
// var i = 0
// var first: Int
//
// if (n == z) {
// // if it's at the end, then find the last line -- simpler than trying to
// // explicitly handle this case in the regular code
// if (singleLine) {
// layoutRow(r, 0)
// with(find) {
// y = 0f
// firstChar = 0
// length = z
// height = r.yMax - r.yMin
// x = r.x1
// }
// } else with(find) {
// y = 0f
// x = 0f
// height = 1f
// while (i < z) {
// layoutRow(r, i)
// prevStart = i
// i += r.numChars
// }
// firstChar = i
// length = 0
// prevFirst = prevStart
// }
// return
// }
//
// // search rows to find the one that straddles character n
// find.y = 0f
//
// while (true) {
// layoutRow(r, i)
// if (n < i + r.numChars)
// break
// prevStart = i
// i += r.numChars
// find.y += r.baselineYDelta
// }
//
// with(find) {
// first = i
// firstChar = i
// length = r.numChars
// height = r.yMax - r.yMin
// prevFirst = prevStart
//
// // now scan to find xpos
// x = r.x0
// i = 0
// while (first + i < n) {
// x += getWidth(first, i)
// ++i
// }
// }
// }
//
// /** make the selection/cursor state valid if client altered the string */
// fun clamp() {
// val n = stringLen
// with(stb) {
// if (hasSelection) {
// if (selectStart > n) selectStart = n
// if (selectEnd > n) selectEnd = n
// // if clamping forced them to be equal, move the cursor to match
// if (selectStart == selectEnd)
// cursor = selectStart
// }
// if (cursor > n) cursor = n
// }
// }
//
// /** delete characters while updating undo */
// fun delete(where: Int, len: Int) {
// makeundoDelete(where, len)
// deleteChars(where, len)
// stb.hasPreferredX = false
// }
//
// /** delete the section */
// fun deleteSelection() {
// clamp()
// with(stb) {
// if (hasSelection) {
// if (stb.selectStart < stb.selectEnd) {
// delete(selectStart, selectEnd - selectStart)
// cursor = selectStart
// selectEnd = selectStart
// } else {
// delete(selectEnd, selectStart - selectEnd)
// cursor = selectEnd
// selectStart = selectEnd
// }
// hasPreferredX = false
// }
// }
// }
//
// /** canoncialize the selection so start <= end */
// fun sortSelection() = with(stb) {
// if (selectEnd < selectStart) {
// val temp = selectEnd
// selectEnd = selectStart
// selectStart = temp
// }
// }
//
// /** move cursor to first character of selection */
// fun moveToFirst() = with(stb) {
// if (hasSelection) {
// sortSelection()
// cursor = selectStart
// selectEnd = selectStart
// hasPreferredX = false
// }
// }
//
// /* move cursor to last character of selection */
// fun moveToLast() = with(stb) {
// if (hasSelection) {
// sortSelection()
// clamp()
// cursor = selectEnd
// selectStart = selectEnd
// hasPreferredX = false
// }
// }
//
// /** update selection and cursor to match each other */
// fun prepSelectionAtCursor() = with(stb) {
// if (!hasSelection) {
// selectStart = cursor
// selectEnd = cursor
// } else
// cursor = selectEnd
// }
//
// /** API cut: delete selection */
// fun cut(): Boolean = when {
// hasSelection -> {
// deleteSelection() // implicitly clamps
// stb.hasPreferredX = false
// true
// }
// else -> false
// }
//
// /** API paste: replace existing selection with passed-in text */
// fun paste(text: CharArray, len: Int): Boolean {
//
// // if there's a selection, the paste should delete it
// clamp()
// deleteSelection()
// // try to insert the characters
// if (insertChars(stb.cursor, text, 0, len)) {
// makeundoInsert(stb.cursor, len)
// stb.cursor += len
// stb.hasPreferredX = false
// return true
// }
// // remove the undo since we didn't actually insert the characters
// if (stb.undoState.undoPoint != 0)
// --stb.undoState.undoPoint
// return false
// }
//
// /** API key: process a keyboard input */
// fun key(key: Int): Unit = with(stb) {
// when (key) {
// K.UNDO -> {
// undo()
// hasPreferredX = false
// }
// K.REDO -> {
// redo()
// hasPreferredX = false
// }
// K.LEFT -> {
// if (hasSelection) // if currently there's a selection, move cursor to start of selection
// moveToFirst()
// else if (cursor > 0)
// --cursor
// hasPreferredX = false
// }
// K.RIGHT -> {
// if (hasSelection) // if currently there's a selection, move cursor to end of selection
// moveToLast()
// else
// ++cursor
// clamp()
// hasPreferredX = false
// }
// K.LEFT or K.SHIFT -> {
// clamp()
// prepSelectionAtCursor()
// // move selection left
// if (selectEnd > 0)
// --selectEnd
// cursor = selectEnd
// hasPreferredX = false
// }
// K.WORDLEFT ->
// if (hasSelection) moveToFirst()
// else {
// cursor = moveWordLeft(cursor)
// clamp()
// }
// K.WORDLEFT or K.SHIFT -> {
// if (!hasSelection)
// prepSelectionAtCursor()
// cursor = moveWordLeft(cursor)
// selectEnd = cursor
// clamp()
// }
// K.WORDRIGHT ->
// if (hasSelection) moveToLast()
// else {
// cursor = moveWordRight(cursor)
// clamp()
// }
// K.WORDRIGHT or K.SHIFT -> {
// if (!hasSelection) prepSelectionAtCursor()
// cursor = moveWordRight(cursor)
// selectEnd = cursor
// clamp()
// }
// K.RIGHT or K.SHIFT -> {
// prepSelectionAtCursor()
// ++selectEnd // move selection right
// clamp()
// cursor = selectEnd
// hasPreferredX = false
// }
// K.DOWN, K.DOWN or K.SHIFT -> {
// val find = FindState()
// val row = Row()
// val sel = key has K.SHIFT
//
// if (singleLine)
// key(K.RIGHT or (key and K.SHIFT)) // on windows, up&down in single-line behave like left&right
//
// if (sel) prepSelectionAtCursor()
// else if (hasSelection) moveToLast()
//
// // compute current position of cursor point
// clamp()
// findCharpos(find, cursor, singleLine)
//
// // now find character position down a row
// if (find.length != 0) {
// val goalX = if (hasPreferredX) preferredX else find.x
// var x = row.x0
// val start = find.firstChar + find.length
// cursor = start
// layoutRow(row, cursor)
// for (i in 0 until row.numChars) {
// val dx = getWidth(start, i)
// if (dx == GETWIDTH_NEWLINE)
// break
// x += dx
// if (x > goalX)
// break
// ++cursor
// }
// clamp()
//
// hasPreferredX = true
// preferredX = goalX
//
// if (sel) selectEnd = cursor
// }
// Unit
// }
// K.UP, K.UP or K.SHIFT -> {
// val find = FindState()
// val row = Row()
// var i = 0
// val sel = key has K.SHIFT
//
// if (singleLine)
// key(K.LEFT or (key and K.SHIFT)) // on windows, up&down become left&right
//
// if (sel) prepSelectionAtCursor()
// else if (hasSelection) moveToFirst()
//
// // compute current position of cursor point
// clamp()
// findCharpos(find, cursor, singleLine)
//
// // can only go up if there's a previous row
// if (find.prevFirst != find.firstChar) {
// // now find character position up a row
// val goalX = if (hasPreferredX) preferredX else find.x
// cursor = find.prevFirst
// layoutRow(row, cursor)
// var x = row.x0
// while (i < row.numChars) {
// val dx = getWidth(find.prevFirst, i++)
// if (dx == GETWIDTH_NEWLINE)
// break
// x += dx
// if (x > goalX)
// break
// ++cursor
// }
// clamp()
//
// hasPreferredX = true
// preferredX = goalX
//
// if (sel) selectEnd = cursor
// }
// Unit
// }
// K.DELETE, K.DELETE or K.SHIFT -> {
// if (hasSelection) deleteSelection()
// else if (cursor < stringLen)
// delete(cursor, 1)
// hasPreferredX = false
// }
// K.BACKSPACE, K.BACKSPACE or K.SHIFT -> {
// if (hasSelection) deleteSelection()
// else {
// clamp()
// if (cursor > 0) {
// delete(cursor - 1, 1)
// --cursor
// }
// }
// hasPreferredX = false
// }
// K.TEXTSTART -> {
// cursor = 0
// selectStart = 0
// selectEnd = 0
// hasPreferredX = false
// }
// K.TEXTEND -> {
// cursor = stringLen
// selectStart = 0
// selectEnd = 0
// hasPreferredX = false
// }
// K.TEXTSTART or K.SHIFT -> {
// prepSelectionAtCursor()
// cursor = 0
// selectEnd = 0
// hasPreferredX = false
// }
// K.TEXTEND or K.SHIFT -> {
// prepSelectionAtCursor()
// cursor = stringLen
// selectEnd = cursor
// hasPreferredX = false
// }
// K.LINESTART -> {
// clamp()
// moveToFirst()
// if (singleLine)
// cursor = 0
// else while (cursor > 0 && getChar(cursor - 1) != '\n')
// --cursor
// hasPreferredX = false
// }
// K.LINEEND -> {
// val n = stringLen
// clamp()
// moveToFirst()
// if (singleLine)
// cursor = n
// else while (cursor < n && getChar(cursor) != 'n')
// ++cursor
// hasPreferredX = false
// }
// K.LINESTART or K.SHIFT -> {
// clamp()
// prepSelectionAtCursor()
// if (singleLine)
// cursor = 0
// else while (cursor > 0 && getChar(cursor - 1) != '\n')
// --cursor
// selectEnd = cursor
// stb.hasPreferredX = false
// }
// K.LINEEND or K.SHIFT -> {
// val n = stringLen
// clamp()
// prepSelectionAtCursor()
// if (singleLine)
// cursor = n
// else while (cursor < n && getChar(cursor) != '\n')
// ++cursor
// selectEnd = cursor
// hasPreferredX = false
// }
// else -> {
// val c = keyToText(key)
// if (c > 0) {
// val ch = c.c
// // can't add newline in single-line mode
// if (ch == '\n' && singleLine) return@with
//
// if (insertMode && !hasSelection && cursor < stringLen) {
// makeundoReplace(cursor, 1, 1)
// deleteChars(cursor, 1)
// if (insertChars(cursor, charArrayOf(ch), 0, 1)) {
// ++cursor
// hasPreferredX = false
// }
// } else {
// deleteSelection() // implicitly clamps
// if (insertChars(cursor, charArrayOf(ch), 0, 1)) {
// makeundoInsert(cursor, 1)
// ++cursor
// hasPreferredX = false
// }
// }
// }
// }
// }
// }
} | core/src/main/kotlin/imgui/internal/classes/InputTextState.kt | 534941095 |
package com.prt2121.ktown
import android.os.Bundle
import android.support.design.widget.FloatingActionButton
import android.support.v4.widget.SwipeRefreshLayout
import android.support.v7.app.AppCompatActivity
import android.support.v7.widget.LinearLayoutManager
import android.support.v7.widget.RecyclerView
import android.support.v7.widget.Toolbar
import android.view.Menu
import com.github.salomonbrys.kotson.fromJson
import com.google.gson.GsonBuilder
import com.jakewharton.rxbinding.support.v4.widget.RxSwipeRefreshLayout
import com.jakewharton.rxbinding.support.v7.widget.RxRecyclerView
import com.jakewharton.rxbinding.support.v7.widget.RxToolbar
import com.jakewharton.rxbinding.view.RxView
import com.squareup.okhttp.Callback
import com.squareup.okhttp.OkHttpClient
import com.squareup.okhttp.Request
import com.squareup.okhttp.Response
import rx.Observable
import rx.Subscription
import rx.android.schedulers.AndroidSchedulers
import timber.log.Timber
import java.io.IOException
import java.util.concurrent.TimeUnit
/**
* Created by pt2121 on 10/26/15.
*/
open class MyActivity : AppCompatActivity() {
val client = OkHttpClient()
var userList: MutableList<User> = arrayListOf()
var adapter: UserListAdapter = UserListAdapter(userList)
var subscription: Subscription? = null
val visibleThreshold = 5
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_rx)
val refreshButton = findViewById(R.id.refreshButton) as FloatingActionButton
val recyclerView = findViewById(R.id.recyclerView) as RecyclerView
val swipeRefreshLayout = findViewById(R.id.swipeRefreshLayout) as SwipeRefreshLayout
val toolbar = findViewById(R.id.toolbar) as Toolbar
val layoutManager = LinearLayoutManager(this)
setSupportActionBar(toolbar)
recyclerView.adapter = adapter
recyclerView.layoutManager = layoutManager
val menuClickStream = RxToolbar.itemClicks(toolbar)
.filter { it.itemId == R.id.action_refresh }
.map { Unit }
val refreshClickStream = RxView.clicks(refreshButton)
.mergeWith(RxSwipeRefreshLayout.refreshes(swipeRefreshLayout))
.map { Unit }
.mergeWith(menuClickStream)
val requestStream = refreshClickStream
.startWith(Unit)
.map { it ->
var randomOffset = Math.floor(Math.random() * 500);
"https://api.github.com/users?since=$randomOffset";
}
val responseStream: Observable<List<User>> = requestStream.flatMap { url -> getJson(url) }
.map { jsonString -> GsonBuilder().create().fromJson<List<User>>(jsonString) }
RxRecyclerView.scrollEvents(recyclerView)
.map { event ->
val view = event.view()
val manager = view.layoutManager as LinearLayoutManager
val totalItemCount = manager.itemCount
val visibleItemCount = view.childCount
val firstVisibleItem = manager.findFirstVisibleItemPosition()
(totalItemCount - visibleItemCount) <= (firstVisibleItem + visibleThreshold)
}
.distinctUntilChanged()
.filter { it }.throttleLast(2, TimeUnit.SECONDS)
.map { it ->
var randomOffset = Math.floor(Math.random() * 500);
"https://api.github.com/users?since=$randomOffset";
}
.flatMap { url -> getJson(url) }
.map { jsonString -> GsonBuilder().create().fromJson<List<User>>(jsonString) }
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ users ->
userList.addAll(users!!.toList())
adapter.notifyDataSetChanged()
}, {
Timber.e(it.message)
})
subscription = responseStream
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ users ->
swipeRefreshLayout.isRefreshing = false
userList.clear()
userList.addAll(users)
adapter.notifyDataSetChanged()
}, {
Timber.e(it.message)
})
}
override fun onCreateOptionsMenu(menu: Menu): Boolean {
menuInflater.inflate(R.menu.menu_main, menu)
return true
}
override fun onDestroy() {
super.onDestroy()
if (subscription != null && subscription!!.isUnsubscribed) {
subscription?.unsubscribe()
}
}
private fun getJson(url: String): Observable<String> {
return Observable.create { observer ->
val request = Request.Builder()
.url(url)
.build()
client.newCall(request).enqueue(object : Callback {
override fun onFailure(request: Request, e: IOException) {
if (!observer.isUnsubscribed) {
observer.onError(e)
}
}
override fun onResponse(response: Response) {
if (!observer.isUnsubscribed) {
observer.onNext(response.body().string())
observer.onCompleted()
}
}
})
}
}
} | app/src/main/kotlin/com/prt2121/ktown/MyActivity.kt | 404114317 |
package me.williamhester.reddit.ui.activities
import android.app.Activity
import android.os.Bundle
import io.realm.Realm
import me.williamhester.reddit.R
import me.williamhester.reddit.messages.LogInFinishedMessage
import me.williamhester.reddit.models.AccessTokenJson
import me.williamhester.reddit.models.Account
import me.williamhester.reddit.ui.fragments.LogInProgressFragment
import me.williamhester.reddit.ui.fragments.LogInWebViewFragment
import org.greenrobot.eventbus.Subscribe
/** Activity responsible for handing user log in and returning them to the app, logged in. */
class LogInActivity : BaseActivity() {
override val layoutId = R.layout.activity_content
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val fragment = fragmentManager.findFragmentById(R.id.fragment_container)
if (fragment == null) {
supportFragmentManager.beginTransaction()
.add(R.id.fragment_container, LogInWebViewFragment.newInstance())
.commit()
}
}
fun startLogIn(code: String) {
// Start blocking UI
supportFragmentManager.beginTransaction()
.replace(R.id.fragment_container, LogInProgressFragment.newInstance())
.commit()
// Start request for token
redditClient.logIn(code)
}
@Subscribe
fun onLoggedIn(accessToken: AccessTokenJson) {
val account = Account()
account.accessToken = accessToken.accessToken
account.refreshToken = accessToken.refreshToken
// Get the account info
redditClient.getMe(account)
}
@Subscribe
fun onAccountDetailsReceived(logInFinished: LogInFinishedMessage) {
// Set the active account
accountManager.setAccount(logInFinished.account)
// Save the account
Realm.getDefaultInstance().executeTransaction {
it.copyToRealmOrUpdate(logInFinished.account)
}
setResult(Activity.RESULT_OK)
finish()
}
}
| app/app/src/main/java/me/williamhester/reddit/ui/activities/LogInActivity.kt | 2875685263 |
/*
* Copyright 2021 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.datacapture.contrib.views.barcode.mlkit.md.camera
import android.app.Application
import android.content.Context
import androidx.annotation.MainThread
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.MutableLiveData
import com.google.mlkit.vision.barcode.Barcode
import java.util.HashSet
/** View model for handling application workflow based on camera preview. */
class WorkflowModel(application: Application) : AndroidViewModel(application) {
val workflowState = MutableLiveData<WorkflowState>()
val detectedBarcode = MutableLiveData<Barcode>()
private val objectIdsToSearch = HashSet<Int>()
var isCameraLive = false
private set
private val context: Context
get() = getApplication<Application>().applicationContext
/** State set of the application workflow. */
enum class WorkflowState {
NOT_STARTED,
DETECTING,
DETECTED,
CONFIRMING,
CONFIRMED,
SEARCHING,
SEARCHED
}
@MainThread
fun setWorkflowState(workflowState: WorkflowState) {
this.workflowState.value = workflowState
}
fun markCameraLive() {
isCameraLive = true
objectIdsToSearch.clear()
}
fun markCameraFrozen() {
isCameraLive = false
}
}
| contrib/barcode/src/main/java/com/google/android/fhir/datacapture/contrib/views/barcode/mlkit/md/camera/WorkflowModel.kt | 4219202787 |
/*
* Copyright (c) 2004-2022, University of Oslo
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* Neither the name of the HISP project nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.hisp.dhis.android.core.arch.call.queries.internal
internal open class BaseQueryKt(
open val page: Int,
open val pageSize: Int,
open val paging: Boolean
) {
companion object {
const val DEFAULT_PAGE_SIZE = 50
}
}
| core/src/main/java/org/hisp/dhis/android/core/arch/call/queries/internal/BaseQueryKt.kt | 4016978384 |
/*
* Copyright (c) 2004-2022, University of Oslo
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* Neither the name of the HISP project nor the names of its contributors may
* be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.hisp.dhis.android.realservertests.apischema
internal data class ApiSchema(
val properties: List<SchemaProperty>
) {
internal companion object {
internal data class SchemaProperty(
val propertyType: String,
val klass: String,
val constants: List<String>?
)
}
}
| core/src/androidTest/java/org/hisp/dhis/android/realservertests/apischema/ApiSchema.kt | 156976162 |
package science.apolline.utils
import android.Manifest
import android.annotation.SuppressLint
import android.content.Context
import android.content.Context.LOCATION_SERVICE
import android.content.Intent
import android.content.pm.PackageManager
import android.location.LocationManager
import android.net.ConnectivityManager
import android.net.NetworkInfo
import android.net.Uri
import android.net.wifi.WifiManager
import android.os.Build
import android.os.PowerManager
import android.provider.Settings
import android.support.v4.content.ContextCompat
import android.support.v7.app.AlertDialog
import android.telephony.TelephonyManager
import android.widget.Toast
import es.dmoral.toasty.Toasty
import org.jetbrains.anko.AnkoLogger
import org.jetbrains.anko.info
import java.util.*
import java.text.SimpleDateFormat
/**
* Created by sparow on 22/12/2017.
*/
object CheckUtility : AnkoLogger {
/**
* To get device consuming netowork type is 2g,3g,4g
*
* @param context
* @return "2g","3g","4g" as a String based on the network type
*/
fun getNetworkType(context: Context): String {
val mTelephonyManager = context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
val networkType = mTelephonyManager.networkType
return when (networkType) {
TelephonyManager.NETWORK_TYPE_GPRS, TelephonyManager.NETWORK_TYPE_EDGE,
TelephonyManager.NETWORK_TYPE_CDMA, TelephonyManager.NETWORK_TYPE_1xRTT,
TelephonyManager.NETWORK_TYPE_IDEN -> "2G"
TelephonyManager.NETWORK_TYPE_UMTS, TelephonyManager.NETWORK_TYPE_EVDO_0,
TelephonyManager.NETWORK_TYPE_EVDO_A,
TelephonyManager.NETWORK_TYPE_HSDPA, TelephonyManager.NETWORK_TYPE_HSUPA,
TelephonyManager.NETWORK_TYPE_HSPA, TelephonyManager.NETWORK_TYPE_EVDO_B,
TelephonyManager.NETWORK_TYPE_EHRPD, TelephonyManager.NETWORK_TYPE_HSPAP -> "3G"
TelephonyManager.NETWORK_TYPE_LTE -> "4G"
else -> "Notfound"
}
}
private fun checkNetworkStatus(context: Context): String {
val networkStatus: String
val manager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
//Check Wifi
val wifi = manager.activeNetworkInfo
//Check for mobile data
val mobile = manager.activeNetworkInfo
if (wifi.type == ConnectivityManager.TYPE_WIFI) {
networkStatus = "wifi"
} else if (mobile.type == ConnectivityManager.TYPE_MOBILE) {
networkStatus = "mobileData"
} else {
networkStatus = "noNetwork"
}
return networkStatus
}
/**
* To check device has internet
*
* @param context
* @return boolean as per status
*/
fun isNetworkConnected(context: Context): Boolean {
val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val netInfo: NetworkInfo? = cm.activeNetworkInfo
return netInfo != null && netInfo.isConnected
}
fun isWifiNetworkConnected(context: Context): Boolean {
var wifiNetworkState = false
val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
val netInfo : NetworkInfo? = cm.activeNetworkInfo
if (netInfo?.type == ConnectivityManager.TYPE_WIFI)
wifiNetworkState = true
return netInfo != null && wifiNetworkState
}
fun checkFineLocationPermission(context: Context): Boolean {
return ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
}
fun checkReandPhoneStatePermission(context: Context): Boolean {
return ContextCompat.checkSelfPermission(context, Manifest.permission.READ_PHONE_STATE) == PackageManager.PERMISSION_GRANTED
}
fun checkWriteToExternalStoragePermissionPermission(context: Context): Boolean {
return ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
}
fun canGetLocation(context: Context): Boolean {
var gpsEnabled = false
var networkEnabled = false
val lm = context.getSystemService(LOCATION_SERVICE) as LocationManager
try {
gpsEnabled = lm.isProviderEnabled(LocationManager.GPS_PROVIDER)
} catch (ex: Exception) {
}
try {
networkEnabled = lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
} catch (ex: Exception) {
}
return gpsEnabled || networkEnabled
}
fun requestLocation(context: Context): AlertDialog {
val alertDialog = AlertDialog.Builder(context).create()
if (!canGetLocation(context)) {
alertDialog.setMessage("Your GPS seems to be disabled, do you want to enable it?")
alertDialog.setButton(AlertDialog.BUTTON_NEGATIVE, "No") { _, _ ->
Toasty.warning(context, "Your GPS is disabled", Toast.LENGTH_SHORT, true).show()
}
alertDialog.setButton(AlertDialog.BUTTON_POSITIVE, "Yes") { _, _ ->
val intent = Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS)
context.startActivity(intent)
}
alertDialog.show()
}
return alertDialog
}
@SuppressLint("BatteryLife")
fun requestDozeMode(context: Context) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
val intent = Intent()
val packageName = context.packageName
val pm = context.getSystemService(Context.POWER_SERVICE) as PowerManager
if (!pm.isIgnoringBatteryOptimizations(packageName)) {
intent.action = Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS
intent.data = Uri.parse("package:$packageName")
context.startActivity(intent)
}
}
}
fun requestPartialWakeUp(context: Context, timeout: Long): PowerManager.WakeLock {
val packageName = context.packageName
val pm = context.getSystemService(Context.POWER_SERVICE) as PowerManager
val wl = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, packageName)
wl.acquire(timeout)
info("Partial wake up is: " + wl.isHeld)
return wl
}
fun requestWifiFullMode(context: Context): WifiManager.WifiLock {
val packageName = context.packageName
val pm = context.applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
val wf = pm.createWifiLock(WifiManager.WIFI_MODE_FULL, packageName)
wf.acquire()
info("WiFi full mode is: " + wf.isHeld)
return wf
}
fun newDate() : String {
val c = Calendar.getInstance().time
val df = SimpleDateFormat("dd-MMM-yyyy", Locale.FRANCE)
return df.format(c)
}
fun dateParser(timestamp: Long): String {
val c = Date(timestamp / 1000000)
val df = SimpleDateFormat("dd-MMM-yyyy HH:mm:ss", Locale.FRANCE)
return df.format(c)
}
} | app/src/main/java/science/apolline/utils/CheckUtility.kt | 1275856786 |
/*
* Copyright (C) 2016-2021 Álinson Santos Xavier <[email protected]>
*
* This file is part of Loop Habit Tracker.
*
* Loop Habit Tracker 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.
*
* Loop Habit Tracker 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 org.isoron.uhabits.activities.habits.list.views
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.MediumTest
import com.nhaarman.mockitokotlin2.doReturn
import com.nhaarman.mockitokotlin2.mock
import com.nhaarman.mockitokotlin2.verify
import com.nhaarman.mockitokotlin2.verifyNoMoreInteractions
import com.nhaarman.mockitokotlin2.whenever
import org.isoron.uhabits.BaseViewTest
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
@RunWith(AndroidJUnit4::class)
@MediumTest
class HeaderViewTest : BaseViewTest() {
private lateinit var view: HeaderView
@Before
override fun setUp() {
super.setUp()
prefs = mock()
view = HeaderView(targetContext, prefs, mock())
view.buttonCount = 5
measureView(view, dpToPixels(600), dpToPixels(48))
}
@Test
@Throws(Exception::class)
fun testRender() {
whenever(prefs.isCheckmarkSequenceReversed).thenReturn(false)
assertRenders(view, PATH + "render.png")
verify(prefs).isCheckmarkSequenceReversed
verifyNoMoreInteractions(prefs)
}
@Test
@Throws(Exception::class)
fun testRender_reverse() {
doReturn(true).whenever(prefs).isCheckmarkSequenceReversed
assertRenders(view, PATH + "render_reverse.png")
verify(prefs).isCheckmarkSequenceReversed
verifyNoMoreInteractions(prefs)
}
companion object {
const val PATH = "habits/list/HeaderView/"
}
}
| uhabits-android/src/androidTest/java/org/isoron/uhabits/activities/habits/list/views/HeaderViewTest.kt | 2815323925 |
package org.spekframework.spek2.integration
import org.spekframework.spek2.Spek
import org.spekframework.spek2.lifecycle.CachingMode
import kotlin.test.assertEquals
object NonUniquePathTest: Spek({
group("duplicate description is allowed") {
val list by memoized(CachingMode.SCOPE) { mutableListOf<Int>() }
test("duplicate test") {
list.add(1)
}
test("duplicate test") {
list.add(2)
}
afterGroup {
assertEquals(2, list.size)
}
}
})
| integration-test/src/commonTest/kotlin/org/spekframework/spek2/integration/NonUniquePathTest.kt | 2351651613 |
package test
import test.E.E1
import kotlin.reflect.KClass
annotation class Simple(
val i: Int,
val l: Long,
val b: Byte,
val d: Double,
val f: Float,
val c: Char,
val b1: Boolean,
val b2: Boolean
)
@Simple(
12,
12L,
12,
3.3,
f = 3.3F,
c = 'a',
b1 = true,
b2 = false
)
class WithSimple
// ===============================
annotation class StringLiteral(
val s1: String,
val s2: String,
val s3: String
)
const val CONSTANT = 12
@StringLiteral("some", "", "H$CONSTANT")
class WithStringLiteral
// ===============================
enum class E {
E1, E2
}
annotation class EnumLiteral(
val e1: E,
val e2: E,
val e3: E
)
@EnumLiteral(E1, E.E2, e3 = test.E.E2)
class WithEnumLiteral
// ===============================
annotation class VarArg(
vararg val v: Int
)
@VarArg(1, 2, 3)
class WithVarArg
// ===============================
annotation class Arrays(
val ia: IntArray,
val la: LongArray,
val fa: FloatArray,
val da: DoubleArray,
val ca: CharArray,
val ba: BooleanArray
)
@Arrays(
[1, 2, 3],
[1L],
[],
[2.2],
['a'],
[true, false]
)
class WithArrays
// ===============================
annotation class ClassLiteral(
val c1: KClass<*>,
val c2: KClass<*>,
val c3: KClass<*>
)
@ClassLiteral(
WithClassLiteral::class,
String::class,
T::class // Error intentionally
)
class WithClassLiteral<T>
// ===============================
annotation class Nested(
val i: Int,
val s: String
)
annotation class Outer(
val some: String,
val nested: Nested
)
@Outer("value", nested = Nested(12, "nested value"))
class WithNested
// ==============================
annotation class ArraysSpread(
vararg val ia: Int
)
@ArraysSpread(
*[1, 2, 3]
)
class WithSpreadOperatorArrays
@SomeAnno1(x = (1 + 2).toLong())
@SomeAnno2(x = 1.toLong())
@SomeAnno3(x = 1.toLong() + 2)
@SomeAnno4(x = 1 + some.value + 2)
class WithComplexDotQualifiedAnnotation | plugins/kotlin/idea/tests/testData/stubs/AnnotationValues.kt | 3364533607 |
package com.tungnui.abccomputer.activity
import android.os.Bundle
import android.support.v7.widget.DefaultItemAnimator
import android.support.v7.widget.LinearLayoutManager
import android.util.Log
import android.view.MenuItem
import android.view.View
import android.widget.Toast
import com.tungnui.abccomputer.R
import com.tungnui.abccomputer.adapter.OrderDetailAdapter
import com.tungnui.abccomputer.adapter.RecyclerDividerDecorator
import com.tungnui.abccomputer.api.OrderServices
import com.tungnui.abccomputer.api.ServiceGenerator
import com.tungnui.abccomputer.data.constant.AppConstants
import com.tungnui.abccomputer.model.OrderItem
import com.tungnui.abccomputer.models.Order
import com.tungnui.abccomputer.utils.DialogUtils
import com.tungnui.abccomputer.utils.formatPrice
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.schedulers.Schedulers
import kotlinx.android.synthetic.main.activity_order_detail.*
import kotlinx.android.synthetic.main.view_common_loader.*
import java.util.ArrayList
class OrderDetailActivity : BaseActivity() {
private var orderService : OrderServices
private var orderList: ArrayList<OrderItem>
init {
orderList = ArrayList()
orderService = ServiceGenerator.createService(OrderServices::class.java)
}
private lateinit var productAdapter: OrderDetailAdapter
private var orderId:Int=0
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val intent = intent
if (intent.hasExtra(AppConstants.KEY_ORDER_DETAIL)) {
orderId = intent.getIntExtra(AppConstants.KEY_ORDER_DETAIL,0)
}
initView()
initToolbar()
initListener()
loadData()
}
private fun initView() {
setContentView(R.layout.activity_order_detail)
initToolbar()
setToolbarTitle("Chi tiết đơn hàng")
enableBackButton()
order_detail_recycler.addItemDecoration(RecyclerDividerDecorator(this))
order_detail_recycler.itemAnimator = DefaultItemAnimator()
order_detail_recycler.setHasFixedSize(true)
order_detail_recycler.layoutManager = LinearLayoutManager(this)
productAdapter = OrderDetailAdapter()
order_detail_recycler.adapter = productAdapter
}
private fun loadData(){
val progressDialog = DialogUtils.showProgressDialog(this@OrderDetailActivity, getString(R.string.msg_loading), false)
Log.e("OrderList2",orderId.toString())
var disposable = orderService.single(orderId)
.subscribeOn((Schedulers.io()))
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ item ->
item?.let{
productAdapter.refreshItems(item.lineItems!!)
tvTempPrice.text =item.total?.formatPrice()
tvTotalPrice.text=item.total?.formatPrice()
tvDiscount.text = item.shippingTotal?.formatPrice()
tvPaymentMethod.text= item.paymentMethodTitle
if(item.shippingTotal?.toDouble() == 0.0){
tvShippingMethod.text = "Nhận tại cửa hàng"
tvShippingFee.text="Miễn phí"
}
else{
tvShippingMethod.text = "Giao hàng tận nhà"
tvShippingFee.text=item.shippingTotal
}
if(item.status == "pending"){
footerView.visibility = View.VISIBLE
}else{
footerView.visibility = View.GONE
}
}
DialogUtils.dismissProgressDialog(progressDialog)
},
{ error ->
Log.e("OrderList",error.message)
DialogUtils.dismissProgressDialog(progressDialog)
})
}
private fun initListener() {
btnCancelOrder.setOnClickListener { cancelOrder() }
}
private fun cancelOrder() {
DialogUtils.showDialogPrompt(this, null, getString(R.string.cancel_order_item), getString(R.string.dialog_btn_yes), getString(R.string.dialog_btn_no), true) {
// start progress dialog
val progressDialog = DialogUtils.showProgressDialog(this, getString(R.string.msg_loading), false)
var temp = Order(status = "cancelled")
orderService.update(orderId,temp)
.subscribeOn((Schedulers.io()))
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ item ->
DialogUtils.dismissProgressDialog(progressDialog)
if (item != null) {
loadData()
}
},
{ error ->
showEmptyView()
info_text.text = getString(R.string.empty)
Toast.makeText(applicationContext, getString(R.string.failed), Toast.LENGTH_SHORT).show()
})
}
}
override fun onOptionsItemSelected(item: MenuItem): Boolean {
when (item.itemId) {
android.R.id.home -> {
finish()
return true
}
else -> return super.onOptionsItemSelected(item)
}
}
} | app/src/main/java/com/tungnui/abccomputer/activity/OrderDetailActivity.kt | 1397427432 |
/*
* Copyright (c) 2019 Spotify AB.
*
* 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.
*/
package com.spotify.heroic.shell.task.parameters
import com.spotify.heroic.shell.AbstractShellTaskParams
import org.kohsuke.args4j.Option
import java.nio.file.Path
import java.nio.file.Paths
internal class MetadataLoadParameters : AbstractShellTaskParams() {
@Option(name = "-t", aliases = ["--target"], usage = "Backend group to migrate to", metaVar = "<metadata-group>")
val target: String? = null
@Option(name = "-f", usage = "File to load from", required = true)
val file: Path = Paths.get("series")
@Option(name = "-r", usage = "Rate-limit for writing to ES. 0 means disabled")
val rate = 0
}
| heroic-core/src/main/java/com/spotify/heroic/shell/task/parameters/MetadataLoadParameters.kt | 673363204 |
package klay.tests.core
import klay.scene.ImageLayer
class DepthTest(game: TestsGame) : Test(game, "Depth", "Tests that layers added with non-zero depth are inserted/rendered in proper order.") {
override fun init() {
val depths = intArrayOf(0, -1, 1, 3, 2, -4, -3, 4, -2)
val fills = intArrayOf(0xFF99CCFF.toInt(), 0xFFFFFF33.toInt(), 0xFF9933FF.toInt(), 0xFF999999.toInt(), 0xFFFF0033.toInt(), 0xFF00CC00.toInt(), 0xFFFF9900.toInt(), 0xFF0066FF.toInt(), 0x0FFCC6666.toInt())
val width = 200f
val height = 200f
for (ii in depths.indices) {
val depth = depths[ii]
val canvas = game.graphics.createCanvas(width, height)
canvas.setFillColor(fills[ii]).fillRect(0f, 0f, width, height)
canvas.setFillColor(0xFF000000.toInt()).drawText(depth.toString() + "/" + ii, 5f, 15f)
val layer = ImageLayer(canvas.toTexture())
layer.setDepth(depth.toFloat()).setTranslation(225f - 50f * depth, 125f + 25f * depth)
game.rootLayer.add(layer)
}
}
}
| klay-demo/src/main/kotlin/klay/tests/core/DepthTest.kt | 3986377766 |
// 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.compilerPlugin.parcelize.quickfixes
import com.intellij.openapi.diagnostic.Logger
import org.jetbrains.kotlin.builtins.StandardNames
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
import org.jetbrains.kotlin.idea.caches.resolve.analyze
import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
import org.jetbrains.kotlin.idea.core.getOrCreateCompanionObject
import org.jetbrains.kotlin.idea.intentions.branchedTransformations.unwrapBlockOrParenthesis
import org.jetbrains.kotlin.idea.util.findAnnotation
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.load.java.JvmAbi.JVM_FIELD_ANNOTATION_FQ_NAME
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.idea.compilerPlugin.parcelize.KotlinParcelizeBundle
import org.jetbrains.kotlin.parcelize.ParcelizeNames
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.addRemoveModifier.setModifierList
import org.jetbrains.kotlin.psi.psiUtil.containingClass
import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject
import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
import org.jetbrains.kotlin.psi.typeRefHelpers.setReceiverTypeReference
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperClassifiers
import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
import org.jetbrains.kotlin.resolve.source.KotlinSourceElement
import org.jetbrains.kotlin.types.TypeUtils
class ParcelMigrateToParcelizeQuickFix(function: KtClass) : AbstractParcelizeQuickFix<KtClass>(function) {
companion object {
private val PARCELER_FQNAME = FqName("kotlinx.parcelize.Parceler")
private val PARCELER_WRITE_FUNCTION_NAME = Name.identifier("write")
private val PARCELER_CREATE_FUNCTION_NAME = Name.identifier("create")
private val LOG = Logger.getInstance(ParcelMigrateToParcelizeQuickFix::class.java)
private fun KtClass.findParcelerCompanionObject(): Pair<KtObjectDeclaration, ClassDescriptor>? {
for (obj in companionObjects) {
val objDescriptor = obj.resolveToDescriptorIfAny() ?: continue
for (superClassifier in objDescriptor.getAllSuperClassifiers()) {
val superClass = superClassifier as? ClassDescriptor ?: continue
if (superClass.fqNameSafe == PARCELER_FQNAME) return Pair(obj, objDescriptor)
}
}
return null
}
private fun KtNamedFunction.doesLookLikeWriteToParcelOverride(): Boolean {
return name == "writeToParcel"
&& hasModifier(KtTokens.OVERRIDE_KEYWORD)
&& receiverTypeReference == null
&& valueParameters.size == 2
&& typeParameters.size == 0
&& valueParameters[0].typeReference?.getFqName() == ParcelizeNames.PARCEL_ID.asFqNameString()
&& valueParameters[1].typeReference?.getFqName() == StandardNames.FqNames._int.asString()
}
private fun KtNamedFunction.doesLookLikeNewArrayOverride(): Boolean {
return name == "newArray"
&& hasModifier(KtTokens.OVERRIDE_KEYWORD)
&& receiverTypeReference == null
&& valueParameters.size == 1
&& typeParameters.size == 0
&& valueParameters[0].typeReference?.getFqName() == StandardNames.FqNames._int.asString()
}
private fun KtNamedFunction.doesLookLikeDescribeContentsOverride(): Boolean {
return name == "describeContents"
&& hasModifier(KtTokens.OVERRIDE_KEYWORD)
&& receiverTypeReference == null
&& valueParameters.size == 0
&& typeParameters.size == 0
&& typeReference?.getFqName() == StandardNames.FqNames._int.asString()
}
private fun KtClass.findWriteToParcelOverride() = findFunction { doesLookLikeWriteToParcelOverride() }
private fun KtClass.findDescribeContentsOverride() = findFunction { doesLookLikeDescribeContentsOverride() }
private fun KtObjectDeclaration.findNewArrayOverride() = findFunction { doesLookLikeNewArrayOverride() }
private fun KtClass.findCreatorClass(): KtClassOrObject? {
for (companion in companionObjects) {
if (companion.name == "CREATOR") {
return companion
}
val creatorProperty = companion.declarations.asSequence()
.filterIsInstance<KtProperty>()
.firstOrNull { it.name == "CREATOR" }
?: continue
creatorProperty.findAnnotation(JVM_FIELD_ANNOTATION_FQ_NAME) ?: continue
val initializer = creatorProperty.initializer ?: continue
when (initializer) {
is KtObjectLiteralExpression -> return initializer.objectDeclaration
is KtCallExpression -> {
val constructedClass = (initializer.resolveToCall()
?.resultingDescriptor as? ConstructorDescriptor)?.constructedClass
if (constructedClass != null) {
val sourceElement = constructedClass.source as? KotlinSourceElement
(sourceElement?.psi as? KtClassOrObject)?.let { return it }
}
}
}
}
return null
}
private fun KtNamedFunction.doesLookLikeCreateFromParcelOverride(): Boolean {
return name == "createFromParcel"
&& hasModifier(KtTokens.OVERRIDE_KEYWORD)
&& receiverTypeReference == null
&& valueParameters.size == 1
&& typeParameters.size == 0
&& valueParameters[0].typeReference?.getFqName() == ParcelizeNames.PARCEL_ID.asFqNameString()
}
private fun findCreateFromParcel(creator: KtClassOrObject) = creator.findFunction { doesLookLikeCreateFromParcelOverride() }
private fun KtNamedFunction.doesLookLikeWriteImplementation(): Boolean {
val containingParcelableClassFqName = containingClassOrObject?.containingClass()?.fqName?.asString()
return name == PARCELER_WRITE_FUNCTION_NAME.asString()
&& hasModifier(KtTokens.OVERRIDE_KEYWORD)
&& receiverTypeReference?.getFqName() == containingParcelableClassFqName
&& valueParameters.size == 2
&& typeParameters.size == 0
&& valueParameters[0].typeReference?.getFqName() == ParcelizeNames.PARCEL_ID.asFqNameString()
&& valueParameters[1].typeReference?.getFqName() == StandardNames.FqNames._int.asString()
}
private fun KtNamedFunction.doesLookLikeCreateImplementation(): Boolean {
return name == PARCELER_CREATE_FUNCTION_NAME.asString()
&& hasModifier(KtTokens.OVERRIDE_KEYWORD)
&& receiverTypeReference == null
&& valueParameters.size == 1
&& typeParameters.size == 0
&& valueParameters[0].typeReference?.getFqName() == ParcelizeNames.PARCEL_ID.asFqNameString()
}
private fun KtObjectDeclaration.findCreateImplementation() = findFunction { doesLookLikeCreateImplementation() }
private fun KtObjectDeclaration.findWriteImplementation() = findFunction { doesLookLikeWriteImplementation() }
private fun KtClassOrObject.findFunction(f: KtNamedFunction.() -> Boolean) =
declarations.asSequence().filterIsInstance<KtNamedFunction>().firstOrNull(f)
private fun KtTypeReference.getFqName(): String? = analyze(BodyResolveMode.PARTIAL)[BindingContext.TYPE, this]
?.constructor?.declarationDescriptor?.fqNameSafe?.asString()
}
object FactoryForWrite : AbstractFactory({ findElement<KtClass>()?.let { ParcelMigrateToParcelizeQuickFix(it) } })
object FactoryForCREATOR : AbstractFactory({
findElement<KtObjectDeclaration>()?.getStrictParentOfType<KtClass>()
?.let { ParcelMigrateToParcelizeQuickFix(it) }
})
override fun getText() = KotlinParcelizeBundle.message("parcelize.fix.migrate.to.parceler.companion.object")
@Suppress("PARAMETER_NAME_CHANGED_ON_OVERRIDE")
override fun invoke(ktPsiFactory: KtPsiFactory, parcelableClass: KtClass) {
val parcelerObject = parcelableClass.findParcelerCompanionObject()?.first ?: parcelableClass.getOrCreateCompanionObject()
val bindingContext = parcelerObject.analyze(BodyResolveMode.PARTIAL)
val parcelerTypeArg = parcelableClass.name ?: run {
LOG.error("Parceler class should not be an anonymous class")
return
}
val parcelerObjectDescriptor = bindingContext[BindingContext.CLASS, parcelerObject] ?: run {
LOG.error("Unable to resolve parceler object for ${parcelableClass.name ?: "<unnamed Parcelable class>"}")
return
}
if (!parcelerObjectDescriptor.getAllSuperClassifiers().any { it.fqNameSafe == PARCELER_FQNAME }) {
val entryText = PARCELER_FQNAME.asString() + "<" + parcelerTypeArg + ">"
parcelerObject.addSuperTypeListEntry(ktPsiFactory.createSuperTypeEntry(entryText)).shortenReferences()
}
val oldWriteToParcelFunction = parcelableClass.findWriteToParcelOverride()
val oldCreateFromParcelFunction = parcelableClass.findCreatorClass()?.let { findCreateFromParcel(it) }
for (superTypeEntry in parcelerObject.superTypeListEntries) {
val superClass =
bindingContext[BindingContext.TYPE, superTypeEntry.typeReference]?.constructor?.declarationDescriptor ?: continue
if (superClass.getAllSuperClassifiers().any { it.fqNameSafe == ParcelizeNames.CREATOR_FQN }) {
parcelerObject.removeSuperTypeListEntry(superTypeEntry)
}
}
if (parcelerObject.name == "CREATOR") {
parcelerObject.nameIdentifier?.delete()
}
if (oldWriteToParcelFunction != null) {
parcelerObject.findWriteImplementation()?.delete() // Remove old implementation
val newFunction = oldWriteToParcelFunction.copy() as KtFunction
oldWriteToParcelFunction.delete()
newFunction.setName(PARCELER_WRITE_FUNCTION_NAME.asString())
newFunction.setModifierList(ktPsiFactory.createModifierList(KtTokens.OVERRIDE_KEYWORD))
newFunction.setReceiverTypeReference(ktPsiFactory.createType(parcelerTypeArg))
newFunction.valueParameterList?.apply {
assert(parameters.size == 2)
val parcelParameterName = parameters[0].name ?: "parcel"
val flagsParameterName = parameters[1].name ?: "flags"
repeat(parameters.size) { removeParameter(0) }
addParameter(ktPsiFactory.createParameter("$parcelParameterName : ${ParcelizeNames.PARCEL_ID.asFqNameString()}"))
addParameter(ktPsiFactory.createParameter("$flagsParameterName : Int"))
}
parcelerObject.addDeclaration(newFunction).valueParameterList?.shortenReferences()
} else if (parcelerObject.findWriteImplementation() == null) {
val writeFunction = "fun $parcelerTypeArg.write(parcel: ${ParcelizeNames.PARCEL_ID.asFqNameString()}, flags: Int) = TODO()"
parcelerObject.addDeclaration(ktPsiFactory.createFunction(writeFunction)).valueParameterList?.shortenReferences()
}
if (oldCreateFromParcelFunction != null) {
parcelerObject.findCreateImplementation()?.delete() // Remove old implementation
val newFunction = oldCreateFromParcelFunction.copy() as KtFunction
if (oldCreateFromParcelFunction.containingClassOrObject == parcelerObject) {
oldCreateFromParcelFunction.delete()
}
newFunction.setName(PARCELER_CREATE_FUNCTION_NAME.asString())
newFunction.setModifierList(ktPsiFactory.createModifierList(KtTokens.OVERRIDE_KEYWORD))
newFunction.setReceiverTypeReference(null)
newFunction.valueParameterList?.apply {
assert(parameters.size == 1)
val parcelParameterName = parameters[0].name ?: "parcel"
removeParameter(0)
addParameter(ktPsiFactory.createParameter("$parcelParameterName : ${ParcelizeNames.PARCEL_ID.asFqNameString()}"))
}
parcelerObject.addDeclaration(newFunction).valueParameterList?.shortenReferences()
} else if (parcelerObject.findCreateImplementation() == null) {
val createFunction = "override fun create(parcel: ${ParcelizeNames.PARCEL_ID.asFqNameString()}): $parcelerTypeArg = TODO()"
parcelerObject.addDeclaration(ktPsiFactory.createFunction(createFunction)).valueParameterList?.shortenReferences()
}
// Always use the default newArray() implementation
parcelerObject.findNewArrayOverride()?.delete()
parcelableClass.findDescribeContentsOverride()?.let { describeContentsFunction ->
val returnExpr = describeContentsFunction.bodyExpression?.unwrapBlockOrParenthesis()
if (returnExpr is KtReturnExpression && returnExpr.getTargetLabel() == null) {
val returnValue = returnExpr.analyze()[BindingContext.COMPILE_TIME_VALUE, returnExpr.returnedExpression]
?.getValue(TypeUtils.NO_EXPECTED_TYPE)
if (returnValue == 0) {
// There are no additional overrides in the hierarchy
if (bindingContext[BindingContext.FUNCTION, describeContentsFunction]?.overriddenDescriptors?.size == 1) {
describeContentsFunction.delete()
}
}
}
}
for (property in parcelerObject.declarations.asSequence().filterIsInstance<KtProperty>().filter { it.name == "CREATOR" }) {
if (property.findAnnotation(JVM_FIELD_ANNOTATION_FQ_NAME) != null) {
property.delete()
}
}
}
}
| plugins/kotlin/compiler-plugins/parcelize/common/src/org/jetbrains/kotlin/idea/compilerPlugin/parcelize/quickfixes/ParcelMigrateToParcelizeQuickFix.kt | 2341590059 |
/*
* Kores - Java source and Bytecode generation framework <https://github.com/JonathanxD/Kores>
*
* The MIT License (MIT)
*
* Copyright (c) 2020 TheRealBuggy/JonathanxD (https://github.com/JonathanxD/) <[email protected]>
* Copyright (c) contributors
*
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package com.github.jonathanxd.kores.base
import com.github.jonathanxd.kores.KoresPart
import java.lang.reflect.Type
/**
* An implementation holder
*/
interface ImplementationHolder : KoresPart {
/**
* Implementations
*/
val implementations: List<Type>
override fun builder(): Builder<ImplementationHolder, *>
interface Builder<out T : ImplementationHolder, S : Builder<T, S>> :
com.github.jonathanxd.kores.builder.Builder<T, S> {
/**
* See [T.implementations]
*/
fun implementations(value: List<Type>): S
/**
* See [T.implementations]
*/
fun implementations(vararg values: Type): S = implementations(values.toList())
}
} | src/main/kotlin/com/github/jonathanxd/kores/base/ImplementationHolder.kt | 262296306 |
package ii_collections
import junit.framework.Assert
import org.junit.Test
import ii_collections.data.*
import ii_collections.shopBuilders.*
class _22_Fold {
@Test fun testGetProductsOrderedByAllCustomers() {
val testShop = shop("test shop for 'fold'") {
customer(lucas, Canberra) {
order(idea)
order(webStorm)
}
customer(reka, Budapest) {
order(idea)
order(youTrack)
}
}
Assert.assertEquals(setOf(idea), testShop.getProductsOrderedByAllCustomers())
}
}
| test/ii_collections/_22_Fold.kt | 39128263 |
package jp.juggler.subwaytooter.dialog
import android.annotation.SuppressLint
import android.app.AlertDialog
import android.app.Dialog
import android.view.View
import android.view.WindowManager
import android.widget.Button
import android.widget.EditText
import jp.juggler.util.dismissSafe
import java.lang.ref.WeakReference
import android.view.Gravity
import jp.juggler.subwaytooter.*
import jp.juggler.subwaytooter.api.entity.TootVisibility
import jp.juggler.subwaytooter.pref.PrefS
import jp.juggler.subwaytooter.pref.put
class DlgQuickTootMenu(
internal val activity: ActMain,
internal val callback: Callback
) : View.OnClickListener {
companion object {
val etTextIds = intArrayOf(
R.id.etText0,
R.id.etText1,
R.id.etText2,
R.id.etText3,
R.id.etText4,
R.id.etText5
)
val btnTextIds = intArrayOf(
R.id.btnText0,
R.id.btnText1,
R.id.btnText2,
R.id.btnText3,
R.id.btnText4,
R.id.btnText5
)
val visibilityList = arrayOf(
TootVisibility.AccountSetting,
TootVisibility.WebSetting,
TootVisibility.Public,
TootVisibility.UnlistedHome,
TootVisibility.PrivateFollowers,
TootVisibility.DirectSpecified
)
}
interface Callback {
fun onMacro(text: String)
var visibility: TootVisibility
}
private var refDialog: WeakReference<Dialog>? = null
fun toggle() {
val dialog = refDialog?.get()
if (dialog != null && dialog.isShowing) {
dialog.dismissSafe()
} else {
show()
}
}
private val etText = arrayOfNulls<EditText>(6)
private lateinit var btnVisibility: Button
@SuppressLint("InflateParams")
fun show() {
val view = activity.layoutInflater.inflate(R.layout.dlg_quick_toot_menu, null, false)
view.findViewById<Button>(R.id.btnCancel).setOnClickListener(this)
val btnListener: View.OnClickListener = View.OnClickListener { v ->
val text = etText[v.tag as? Int ?: 0]?.text?.toString()
if (text != null) {
refDialog?.get()?.dismissSafe()
callback.onMacro(text)
}
}
val strings = loadStrings()
val size = etText.size
for (i in 0 until size) {
val et: EditText = view.findViewById(etTextIds[i])
val btn: Button = view.findViewById(btnTextIds[i])
btn.tag = i
btn.setOnClickListener(btnListener)
etText[i] = et
et.setText(
if (i >= strings.size) {
""
} else {
strings[i]
}
)
}
btnVisibility = view.findViewById(R.id.btnVisibility)
btnVisibility.setOnClickListener(this)
showVisibility()
val dialog = Dialog(activity)
this.refDialog = WeakReference(dialog)
dialog.setCanceledOnTouchOutside(true)
dialog.setContentView(view)
dialog.setOnDismissListener { saveStrings() }
dialog.window?.apply {
val wlp = attributes
wlp.gravity = Gravity.BOTTOM or Gravity.START
wlp.flags = wlp.flags and WindowManager.LayoutParams.FLAG_DIM_BEHIND.inv()
attributes = wlp
setLayout(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.WRAP_CONTENT)
}
dialog.show()
}
private fun loadStrings() =
PrefS.spQuickTootMacro(activity.pref).split("\n")
private fun saveStrings() = activity.pref
.edit()
.put(
PrefS.spQuickTootMacro,
etText.joinToString("\n") {
(it?.text?.toString() ?: "").replace("\n", " ")
}
)
.apply()
override fun onClick(v: View?) { // TODO
when (v?.id) {
R.id.btnCancel -> refDialog?.get()?.dismissSafe()
R.id.btnVisibility -> performVisibility()
}
}
private fun performVisibility() {
val captionList = visibilityList
.map { Styler.getVisibilityCaption(activity, false, it) }
.toTypedArray()
AlertDialog.Builder(activity)
.setTitle(R.string.choose_visibility)
.setItems(captionList) { _, which ->
if (which in visibilityList.indices) {
callback.visibility = visibilityList[which]
showVisibility()
}
}
.setNegativeButton(R.string.cancel, null)
.show()
}
private fun showVisibility() {
btnVisibility.text = Styler.getVisibilityCaption(activity, false, callback.visibility)
}
}
| app/src/main/java/jp/juggler/subwaytooter/dialog/DlgQuickTootMenu.kt | 205562845 |
package org.amshove.kluent
import org.amshove.kluent.internal.assertTrue
import java.time.LocalDate
import java.time.LocalDateTime
import java.time.LocalTime
abstract class AbstractJavaTimeComparator<T> where T : Comparable<T> {
internal var comparatorType = ComparatorType.Exactly
internal lateinit var startValue: T
internal fun assertAfter(theOther: T) =
when (comparatorType) {
ComparatorType.AtLeast -> assertAtLeastAfter(calculateComparedValue(theOther))
ComparatorType.Exactly -> assertExactlyAfter(calculateComparedValue(theOther))
ComparatorType.AtMost -> assertAtMostAfter(calculateComparedValue(theOther))
}
internal fun assertBefore(theOther: T) =
when (comparatorType) {
ComparatorType.AtLeast -> assertAtLeastBefore(calculateComparedValue(theOther, -1))
ComparatorType.Exactly -> assertExactlyBefore(calculateComparedValue(theOther, -1))
ComparatorType.AtMost -> assertAtMostBefore(calculateComparedValue(theOther, -1))
}
internal fun withStartValue(startValue: T): AbstractJavaTimeComparator<T> {
this.startValue = startValue
return this
}
internal fun withComparatorType(comparatorType: ComparatorType): AbstractJavaTimeComparator<T> {
this.comparatorType = comparatorType
return this
}
protected fun assertAtLeastAfter(theOther: T) {
assertTrue(
"Expected $startValue to be at least { ${getExpectedOffset()} } after $theOther",
startValue >= theOther
)
}
protected fun assertAtMostAfter(theOther: T) {
assertTrue(
"Expected $startValue to be at most { ${getExpectedOffset()} } after $theOther",
startValue <= theOther
)
}
protected fun assertExactlyAfter(theOther: T) {
assertTrue("Expected $startValue to be { ${getExpectedOffset()} } after $theOther", startValue == theOther)
}
protected fun assertExactlyBefore(theOther: T) {
assertTrue("Expected $startValue to be { ${getExpectedOffset()} } before $theOther", startValue == theOther)
}
protected fun assertAtLeastBefore(theOther: T) {
assertTrue(
"Expected $startValue to be at least { ${getExpectedOffset()} } before $theOther",
startValue <= theOther
)
}
protected fun assertAtMostBefore(theOther: T) {
assertTrue(
"Expected $startValue to be at most { ${getExpectedOffset()} } before $theOther",
startValue >= theOther
)
}
protected abstract fun calculateComparedValue(currentValue: T, multiplier: Int = 1): T
internal abstract fun getExpectedOffset(): String
}
class DateTimeComparator(
internal var dateComparator: DateComparator? = null,
internal var timeComparator: TimeComparator? = null
) : AbstractJavaTimeComparator<LocalDateTime>() {
internal fun assertAfter(theDate: LocalDate) =
dateComparator!!.withStartValue(startValue.toLocalDate()).withComparatorType(comparatorType)
.assertAfter(theDate)
internal fun assertBefore(theDate: LocalDate) =
dateComparator!!.withStartValue(startValue.toLocalDate()).withComparatorType(comparatorType)
.assertBefore(theDate)
internal fun assertAfter(theTime: LocalTime) =
timeComparator!!.withStartValue(startValue.toLocalTime()).withComparatorType(comparatorType)
.assertAfter(theTime)
internal fun assertBefore(theTime: LocalTime) =
timeComparator!!.withStartValue(startValue.toLocalTime()).withComparatorType(comparatorType)
.assertBefore(theTime)
override fun getExpectedOffset() =
"${dateComparator?.getExpectedOffset()} ${timeComparator?.getExpectedOffset()}".trim()
override fun calculateComparedValue(currentValue: LocalDateTime, multiplier: Int) =
currentValue.plusYears((dateComparator?.addedYears?.toLong() ?: 0) * multiplier)
.plusMonths((dateComparator?.addedMonths?.toLong() ?: 0) * multiplier)
.plusDays((dateComparator?.addedDays?.toLong() ?: 0) * multiplier)
.plusHours((timeComparator?.addedHours?.toLong() ?: 0) * multiplier)
.plusMinutes((timeComparator?.addedMinutes?.toLong() ?: 0) * multiplier)
.plusSeconds((timeComparator?.addedSeconds?.toLong() ?: 0) * multiplier)
}
class DateComparator(
internal val addedYears: Int = 0,
internal val addedMonths: Int = 0,
internal val addedDays: Int = 0
) : AbstractJavaTimeComparator<LocalDate>() {
override fun calculateComparedValue(currentValue: LocalDate, multiplier: Int) =
currentValue.plusYears(addedYears.toLong() * multiplier)
.plusMonths(addedMonths.toLong() * multiplier)
.plusDays(addedDays.toLong() * multiplier)
override fun getExpectedOffset() = "$addedYears years, $addedMonths months, $addedDays days"
}
class TimeComparator(
internal val addedHours: Int = 0,
internal val addedMinutes: Int = 0,
internal val addedSeconds: Int = 0
) : AbstractJavaTimeComparator<LocalTime>() {
override fun getExpectedOffset() = "$addedHours hours, $addedMinutes minutes, $addedSeconds seconds"
override fun calculateComparedValue(currentValue: LocalTime, multiplier: Int) =
currentValue.plusHours(addedHours.toLong() * multiplier)
.plusMinutes(addedMinutes.toLong() * multiplier)
.plusSeconds(addedSeconds.toLong() * multiplier)
}
| jvm/src/main/kotlin/org/amshove/kluent/JavaTimeComparators.kt | 2944631033 |
/*
* Copyright 2014 Cazcade Limited (http://cazcade.com)
*
* 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.
*/
/**
* @todo document.
* @author <a href="http://uk.linkedin.com/in/neilellis">Neil Ellis</a>
*/
package kontrol.postmortem
import kontrol.api.Postmortem
import kontrol.api.Machine
import kontrol.ext.string.ssh.onHost
import kontrol.api.PostmortemResult
import java.util.HashMap
import kontrol.api.PostmortemPart
public class UbuntuPostmortem(val logMax: Int = 1000) : Postmortem {
override fun perform(machine: Machine): PostmortemResult {
println("Performing Centos Postmortem for ${machine.name()}")
return PostmortemResult("centos", machine, arrayListOf<PostmortemPart>(
LogPart("syslog", "cat /var/log/messages | tail -${logMax}" onHost machine.ip()),
TextPart("ps", "ps aux" onHost machine.ip()),
TextPart("who", "who" onHost machine.ip()),
TextPart("w", "w" onHost machine.ip()),
TextPart("uptime", "uptime" onHost machine.ip()),
TextPart("uname", "uname -a" onHost machine.ip()),
TextPart("ifconfig", "ifconfig -a" onHost machine.ip()),
TextPart("mem", "cat /proc/meminfo" onHost machine.ip()),
TextPart("cpu", "cat /proc/cpuinfo" onHost machine.ip()),
TextPart("ulimit", "ulimit -a" onHost machine.ip()),
TextPart("du", "du -sh /*".onHost (machine.ip(), timeoutInSeconds = 120)),
TextPart("df", "df -h" onHost machine.ip()),
TextPart("services", "service --status-all" onHost machine.ip()),
TextPart("netstat", "netstat -tulpn" onHost machine.ip())
), HashMap(machine.latestDataValues()));
}
} | postmortem/src/main/kotlin/UbuntuPostMortem.kt | 634134928 |
// 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.configurationStore
import com.intellij.configurationStore.schemeManager.createDir
import com.intellij.configurationStore.schemeManager.getOrCreateChild
import com.intellij.openapi.application.runUndoTransparentWriteAction
import com.intellij.openapi.components.PathMacroSubstitutor
import com.intellij.openapi.components.StateSplitter
import com.intellij.openapi.components.StateSplitterEx
import com.intellij.openapi.components.impl.stores.DirectoryStorageUtil
import com.intellij.openapi.components.impl.stores.FileStorageCoreUtil
import com.intellij.openapi.vfs.LocalFileSystem
import com.intellij.openapi.vfs.VirtualFile
import com.intellij.util.LineSeparator
import com.intellij.util.SmartList
import com.intellij.util.containers.SmartHashSet
import com.intellij.util.io.systemIndependentPath
import com.intellij.util.isEmpty
import gnu.trove.THashMap
import gnu.trove.THashSet
import org.jdom.Element
import java.io.IOException
import java.nio.ByteBuffer
import java.nio.file.Path
abstract class DirectoryBasedStorageBase(@Suppress("DEPRECATION") protected val splitter: StateSplitter,
protected val pathMacroSubstitutor: PathMacroSubstitutor? = null) : StateStorageBase<StateMap>() {
protected var componentName: String? = null
protected abstract val virtualFile: VirtualFile?
public override fun loadData(): StateMap = StateMap.fromMap(DirectoryStorageUtil.loadFrom(virtualFile, pathMacroSubstitutor))
override fun createSaveSessionProducer(): SaveSessionProducer? = null
override fun analyzeExternalChangesAndUpdateIfNeed(componentNames: MutableSet<in String>) {
// todo reload only changed file, compute diff
val newData = loadData()
storageDataRef.set(newData)
if (componentName != null) {
componentNames.add(componentName!!)
}
}
override fun getSerializedState(storageData: StateMap, component: Any?, componentName: String, archive: Boolean): Element? {
this.componentName = componentName
if (storageData.isEmpty()) {
return null
}
// FileStorageCoreUtil on load check both component and name attributes (critical important for external store case, where we have only in-project artifacts, but not external)
val state = Element(FileStorageCoreUtil.COMPONENT).setAttribute(FileStorageCoreUtil.NAME, componentName)
if (splitter is StateSplitterEx) {
for (fileName in storageData.keys()) {
val subState = storageData.getState(fileName, archive) ?: return null
splitter.mergeStateInto(state, subState.clone())
}
}
else {
val subElements = SmartList<Element>()
for (fileName in storageData.keys()) {
val subState = storageData.getState(fileName, archive) ?: return null
subElements.add(subState.clone())
}
if (!subElements.isEmpty()) {
splitter.mergeStatesInto(state, subElements.toTypedArray())
}
}
return state
}
override fun hasState(storageData: StateMap, componentName: String): Boolean = storageData.hasStates()
}
open class DirectoryBasedStorage(private val dir: Path,
@Suppress("DEPRECATION") splitter: StateSplitter,
pathMacroSubstitutor: PathMacroSubstitutor? = null) : DirectoryBasedStorageBase(splitter, pathMacroSubstitutor) {
override val isUseVfsForWrite: Boolean
get() = true
@Volatile
private var cachedVirtualFile: VirtualFile? = null
override val virtualFile: VirtualFile?
get() {
var result = cachedVirtualFile
if (result == null) {
result = LocalFileSystem.getInstance().findFileByPath(dir.systemIndependentPath)
cachedVirtualFile = result
}
return result
}
internal fun setVirtualDir(dir: VirtualFile?) {
cachedVirtualFile = dir
}
override fun createSaveSessionProducer(): SaveSessionProducer? = if (checkIsSavingDisabled()) null else MySaveSession(this, getStorageData())
private class MySaveSession(private val storage: DirectoryBasedStorage, private val originalStates: StateMap) : SaveSessionBase(), SaveSession {
private var copiedStorageData: MutableMap<String, Any>? = null
private val dirtyFileNames = SmartHashSet<String>()
private var someFileRemoved = false
override fun setSerializedState(componentName: String, element: Element?) {
storage.componentName = componentName
val stateAndFileNameList = if (element.isEmpty()) emptyList() else storage.splitter.splitState(element!!)
if (stateAndFileNameList.isEmpty()) {
if (copiedStorageData != null) {
copiedStorageData!!.clear()
}
else if (!originalStates.isEmpty()) {
copiedStorageData = THashMap()
}
return
}
val existingFiles = THashSet<String>(stateAndFileNameList.size)
for (pair in stateAndFileNameList) {
doSetState(pair.second, pair.first)
existingFiles.add(pair.second)
}
for (key in originalStates.keys()) {
if (existingFiles.contains(key)) {
continue
}
if (copiedStorageData == null) {
copiedStorageData = originalStates.toMutableMap()
}
someFileRemoved = true
copiedStorageData!!.remove(key)
}
}
private fun doSetState(fileName: String, subState: Element) {
if (copiedStorageData == null) {
copiedStorageData = setStateAndCloneIfNeed(fileName, subState, originalStates)
if (copiedStorageData != null) {
dirtyFileNames.add(fileName)
}
}
else if (updateState(copiedStorageData!!, fileName, subState)) {
dirtyFileNames.add(fileName)
}
}
override fun createSaveSession() = if (storage.checkIsSavingDisabled() || copiedStorageData == null) null else this
override fun save() {
val stateMap = StateMap.fromMap(copiedStorageData!!)
var dir = storage.virtualFile
if (copiedStorageData!!.isEmpty()) {
if (dir != null && dir.exists()) {
deleteFile(this, dir)
}
storage.setStorageData(stateMap)
return
}
if (dir == null || !dir.isValid) {
dir = createDir(storage.dir, this)
storage.cachedVirtualFile = dir
}
if (!dirtyFileNames.isEmpty) {
saveStates(dir, stateMap)
}
if (someFileRemoved && dir.exists()) {
deleteFiles(dir)
}
storage.setStorageData(stateMap)
}
private fun saveStates(dir: VirtualFile, states: StateMap) {
for (fileName in states.keys()) {
if (!dirtyFileNames.contains(fileName)) {
continue
}
try {
val element = states.getElement(fileName) ?: continue
val file = dir.getOrCreateChild(fileName, this)
// we don't write xml prolog due to historical reasons (and should not in any case)
val macroManager = if (storage.pathMacroSubstitutor == null) null else (storage.pathMacroSubstitutor as TrackingPathMacroSubstitutorImpl).macroManager
val xmlDataWriter = XmlDataWriter(FileStorageCoreUtil.COMPONENT, listOf(element), mapOf(FileStorageCoreUtil.NAME to storage.componentName!!), macroManager, dir.path)
writeFile(null, this, file, xmlDataWriter, getOrDetectLineSeparator(file) ?: LineSeparator.getSystemLineSeparator(), false)
}
catch (e: IOException) {
LOG.error(e)
}
}
}
private fun deleteFiles(dir: VirtualFile) {
runUndoTransparentWriteAction {
for (file in dir.children) {
val fileName = file.name
if (fileName.endsWith(FileStorageCoreUtil.DEFAULT_EXT) && !copiedStorageData!!.containsKey(fileName)) {
if (file.isWritable) {
file.delete(this)
}
else {
throw ReadOnlyModificationException(file, null)
}
}
}
}
}
}
private fun setStorageData(newStates: StateMap) {
storageDataRef.set(newStates)
}
}
private fun getOrDetectLineSeparator(file: VirtualFile): LineSeparator? {
if (!file.exists()) {
return null
}
file.detectedLineSeparator?.let {
return LineSeparator.fromString(it)
}
val lineSeparator = detectLineSeparators(Charsets.UTF_8.decode(ByteBuffer.wrap(file.contentsToByteArray())))
file.detectedLineSeparator = lineSeparator.separatorString
return lineSeparator
} | platform/configuration-store-impl/src/DirectoryBasedStorage.kt | 3636407902 |
// 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.intellij.build.images.sync
import java.io.File
import java.io.OutputStream
import java.io.PrintStream
import java.util.concurrent.TimeUnit
import java.util.function.Consumer
internal var logger: Consumer<String> = Consumer { println(it) }
internal fun log(msg: String) = logger.accept(msg)
internal fun String.splitWithSpace(): List<String> = this.splitNotBlank(" ")
internal fun String.splitNotBlank(delimiter: String): List<String> = this.split(delimiter).filter { it.isNotBlank() }
internal fun String.splitWithTab(): List<String> = this.split("\t".toRegex())
internal fun execute(workingDir: File?, vararg command: String, withTimer: Boolean = false): String {
val errOutputFile = File.createTempFile("errOutput", "txt")
val processCall = {
val process = ProcessBuilder(*command.filter { it.isNotBlank() }.toTypedArray())
.directory(workingDir)
.redirectOutput(ProcessBuilder.Redirect.PIPE)
.redirectError(errOutputFile)
.apply {
environment()["GIT_SSH_COMMAND"] = "ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no"
environment()["LANG"] = "en_US.UTF-8"
}.start()
val output = process.inputStream.bufferedReader().use { it.readText() }
process.waitFor(1, TimeUnit.MINUTES)
val error = errOutputFile.readText().trim()
if (process.exitValue() != 0) {
error("Command ${command.joinToString(" ")} failed in ${workingDir?.absolutePath} with ${process.exitValue()} : $output\n$error")
}
output
}
return try {
if (withTimer) callWithTimer("Executing command ${command.joinToString(" ")}", processCall) else processCall()
}
finally {
errOutputFile.delete()
}
}
internal fun <T> List<T>.split(eachSize: Int): List<List<T>> {
if (this.size < eachSize) return listOf(this)
val result = mutableListOf<List<T>>()
var start = 0
while (start < this.size) {
val sub = this.subList(start, Math.min(start + eachSize, this.size))
if (!sub.isEmpty()) result += sub
start += eachSize
}
return result
}
internal fun <T> callSafely(printStackTrace: Boolean = false, call: () -> T): T? = try {
call()
}
catch (e: Exception) {
if (printStackTrace) e.printStackTrace() else log(e.message ?: e::class.java.simpleName)
null
}
internal fun <T> callWithTimer(msg: String? = null, call: () -> T): T {
if (msg != null) log(msg)
val start = System.currentTimeMillis()
try {
return call()
}
finally {
log("Took ${System.currentTimeMillis() - start} ms")
}
}
internal fun <T> retry(maxRetries: Int = 20,
secondsBeforeRetry: Long = 30,
doRetry: (Throwable) -> Boolean = { true },
action: () -> T): T {
repeat(maxRetries) {
val number = it + 1
try {
return action()
}
catch (e: Exception) {
if (number < maxRetries && doRetry(e)) {
log("$number attempt of $maxRetries has failed with ${e.message}. Retrying in ${secondsBeforeRetry}s..")
TimeUnit.SECONDS.sleep(secondsBeforeRetry)
}
else throw e
}
}
error("Unable to complete")
}
internal fun guessEmail(invalidEmail: String): Collection<String> {
val (username, domain) = invalidEmail.split("@")
val guesses = mutableListOf(
username.splitNotBlank(".").joinToString(".", transform = String::capitalize) + "@$domain",
invalidEmail.toLowerCase()
)
if (domain != "jetbrains.com") guesses += "[email protected]"
return guesses
}
internal inline fun <T> protectStdErr(block: () -> T): T {
val err = System.err
return try {
block()
}
finally {
System.setErr(err)
}
}
private val mutedStream = PrintStream(object : OutputStream() {
override fun write(b: ByteArray) {}
override fun write(b: ByteArray, off: Int, len: Int) {}
override fun write(b: Int) {}
})
internal inline fun <T> muteStdOut(block: () -> T): T {
val out = System.out
System.setOut(mutedStream)
return try {
block()
}
finally {
System.setOut(out)
}
}
internal inline fun <T> muteStdErr(block: () -> T): T = protectStdErr {
System.setErr(mutedStream)
return block()
}
internal fun File.isAncestorOf(file: File): Boolean = this == file.parentFile || file.parentFile != null && isAncestorOf(file.parentFile) | platform/build-scripts/icons/src/org/jetbrains/intellij/build/images/sync/utils.kt | 2638648787 |
package org.abendigo.controller.network
import io.netty.buffer.ByteBuf
private val sb = StringBuilder()
fun ByteBuf.readString(): String {
val length = readUnsignedByte().toInt()
sb.delete(0, sb.length)
for (i in 1..length) sb.append(readUnsignedByte().toChar())
return sb.toString()
}
fun ByteBuf.writeString(string: String) {
val bytes = string.toByteArray()
writeByte(bytes.size)
writeBytes(bytes)
} | Client Files/IntrepidClient-menu/src/main/kotlin/org/abendigo/controller/network/ByteBufString.kt | 769269765 |
// 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.nj2k.conversions
import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext
import org.jetbrains.kotlin.nj2k.parenthesizeIfCompoundExpression
import org.jetbrains.kotlin.nj2k.tree.*
import org.jetbrains.kotlin.utils.addToStdlib.safeAs
class AssignmentExpressionUnfoldingConversion(context: NewJ2kConverterContext) : RecursiveApplicableConversionBase(context) {
override fun applyToElement(element: JKTreeElement): JKTreeElement {
val unfolded = when (element) {
is JKBlock -> element.convertAssignments()
is JKExpressionStatement -> element.convertAssignments()
is JKJavaAssignmentExpression -> element.convertAssignments()
else -> null
} ?: return recurse(element)
return recurse(unfolded)
}
private fun JKBlock.convertAssignments(): JKBlock? {
val hasAssignments = statements.any { it.containsAssignment() }
if (!hasAssignments) return null
val newStatements = mutableListOf<JKStatement>()
for (statement in statements) {
when {
statement is JKExpressionStatement && statement.expression is JKJavaAssignmentExpression -> {
val assignment = statement.expression as JKJavaAssignmentExpression
newStatements += assignment
.unfoldToStatementsList(assignmentTarget = null)
.withFormattingFrom(statement)
}
statement is JKDeclarationStatement && statement.containsAssignment() -> {
val variable = statement.declaredStatements.single() as JKVariable
val assignment = variable.initializer as JKJavaAssignmentExpression
newStatements += assignment
.unfoldToStatementsList(variable.detached(statement))
.withFormattingFrom(statement)
}
else -> {
newStatements += statement
}
}
}
statements = newStatements
return this
}
private fun JKExpressionStatement.convertAssignments(): JKStatement? {
val assignment = expression as? JKJavaAssignmentExpression ?: return null
return when {
canBeConvertedToBlock() && assignment.expression is JKJavaAssignmentExpression ->
JKBlockStatement(JKBlockImpl(assignment.unfoldToStatementsList(assignmentTarget = null)))
else -> createKtAssignmentStatement(
assignment::field.detached(),
assignment::expression.detached(),
assignment.operator
)
}.withFormattingFrom(this)
}
private fun JKExpressionStatement.canBeConvertedToBlock() = when (val parent = parent) {
is JKLoopStatement -> parent.body == this
is JKIfElseStatement -> parent.thenBranch == this || parent.elseBranch == this
is JKJavaSwitchCase -> true
else -> false
}
private fun JKJavaAssignmentExpression.convertAssignments() =
unfoldToExpressionsChain().withFormattingFrom(this)
private fun JKDeclarationStatement.containsAssignment() =
declaredStatements.singleOrNull()?.safeAs<JKVariable>()?.initializer is JKJavaAssignmentExpression
private fun JKStatement.containsAssignment() = when (this) {
is JKExpressionStatement -> expression is JKJavaAssignmentExpression
is JKDeclarationStatement -> containsAssignment()
else -> false
}
private fun JKJavaAssignmentExpression.unfold() = generateSequence(this) { assignment ->
assignment.expression as? JKJavaAssignmentExpression
}.toList().asReversed()
private fun JKJavaAssignmentExpression.unfoldToExpressionsChain(): JKExpression {
val links = unfold()
val first = links.first()
return links.subList(1, links.size)
.fold(first.toExpressionChainLink(first::expression.detached())) { state, assignment ->
assignment.toExpressionChainLink(state)
}
}
private fun JKJavaAssignmentExpression.unfoldToStatementsList(assignmentTarget: JKVariable?): List<JKStatement> {
val links = unfold()
val first = links.first()
val statements = links.subList(1, links.size)
.foldIndexed(listOf(first.toDeclarationChainLink(first::expression.detached()))) { index, list, assignment ->
list + assignment.toDeclarationChainLink(links[index].field.copyTreeAndDetach())
}
return when (assignmentTarget) {
null -> statements
else -> {
assignmentTarget.initializer = statements.last().field.copyTreeAndDetach()
statements + JKDeclarationStatement(listOf(assignmentTarget))
}
}
}
private fun JKJavaAssignmentExpression.toExpressionChainLink(receiver: JKExpression): JKExpression {
val assignment = createKtAssignmentStatement(
this::field.detached(),
JKKtItExpression(operator.returnType),
operator
).withFormattingFrom(this)
return when {
operator.isSimpleToken() ->
JKAssignmentChainAlsoLink(receiver, assignment, field.copyTreeAndDetach())
else ->
JKAssignmentChainLetLink(receiver, assignment, field.copyTreeAndDetach())
}
}
private fun JKJavaAssignmentExpression.toDeclarationChainLink(expression: JKExpression) =
createKtAssignmentStatement(this::field.detached(), expression, this.operator)
.withFormattingFrom(this)
private fun createKtAssignmentStatement(
field: JKExpression,
expression: JKExpression,
operator: JKOperator
) = when {
operator.isOnlyJavaToken() ->
JKKtAssignmentStatement(
field,
JKBinaryExpression(
field.copyTreeAndDetach(),
expression.parenthesizeIfCompoundExpression(),
JKKtOperatorImpl(
onlyJavaAssignTokensToKotlinOnes[operator.token]!!,
operator.returnType
)
),
JKOperatorToken.EQ
)
else -> JKKtAssignmentStatement(field, expression, operator.token)
}
private fun JKOperator.isSimpleToken() = when {
isOnlyJavaToken() -> false
token == JKOperatorToken.PLUSEQ
|| token == JKOperatorToken.MINUSEQ
|| token == JKOperatorToken.MULTEQ
|| token == JKOperatorToken.DIVEQ -> false
else -> true
}
private fun JKOperator.isOnlyJavaToken() = token in onlyJavaAssignTokensToKotlinOnes
companion object {
private val onlyJavaAssignTokensToKotlinOnes = mapOf(
JKOperatorToken.ANDEQ to JKOperatorToken.AND,
JKOperatorToken.OREQ to JKOperatorToken.OR,
JKOperatorToken.XOREQ to JKOperatorToken.XOR,
JKOperatorToken.LTLTEQ to JKOperatorToken.SHL,
JKOperatorToken.GTGTEQ to JKOperatorToken.SHR,
JKOperatorToken.GTGTGTEQ to JKOperatorToken.USHR
)
}
} | plugins/kotlin/j2k/new/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentExpressionUnfoldingConversion.kt | 1525040355 |
// 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.bookmark.actions
import com.intellij.ide.bookmark.Bookmark
import com.intellij.ide.bookmark.BookmarkType
import com.intellij.ide.bookmark.BookmarksManager
import com.intellij.ide.bookmark.providers.LineBookmarkProvider
import com.intellij.ide.bookmark.ui.BookmarksView
import com.intellij.ide.bookmark.ui.BookmarksViewState
import com.intellij.ide.bookmark.ui.tree.GroupNode
import com.intellij.ide.util.treeView.AbstractTreeNode
import com.intellij.ide.util.treeView.NodeDescriptor
import com.intellij.ide.util.treeView.SmartElementDescriptor
import com.intellij.openapi.Disposable
import com.intellij.openapi.actionSystem.*
import com.intellij.openapi.editor.ex.EditorGutterComponentEx
import com.intellij.openapi.project.LightEditActionFactory
import com.intellij.openapi.wm.ToolWindowId
import com.intellij.ui.speedSearch.SpeedSearchSupply
import com.intellij.util.OpenSourceUtil
import com.intellij.util.ui.UIUtil
import com.intellij.util.ui.tree.TreeUtil
import java.awt.event.ActionListener
import java.awt.event.KeyEvent
import javax.swing.JComponent
import javax.swing.JTree
import javax.swing.KeyStroke
internal val AnActionEvent.bookmarksManager
get() = project?.let { BookmarksManager.getInstance(it) }
internal val AnActionEvent.bookmarksViewState
get() = project?.let { BookmarksViewState.getInstance(it) }
internal val AnActionEvent.bookmarksView
get() = getData(BookmarksView.BOOKMARKS_VIEW)
internal val AnActionEvent.bookmarkNodes: List<AbstractTreeNode<*>>?
get() = bookmarksView?.let { getData(PlatformDataKeys.SELECTED_ITEMS)?.asList() as? List<AbstractTreeNode<*>> }
internal val AnActionEvent.selectedGroupNode
get() = bookmarkNodes?.singleOrNull() as? GroupNode
internal val AnActionEvent.contextBookmark: Bookmark?
get() {
val editor = getData(CommonDataKeys.EDITOR) ?: getData(CommonDataKeys.EDITOR_EVEN_IF_INACTIVE)
val project = editor?.project ?: project ?: return null
if (editor != null) {
val provider = LineBookmarkProvider.find(project) ?: return null
val line = getData(EditorGutterComponentEx.LOGICAL_LINE_AT_CURSOR)
return provider.createBookmark(editor, line)
}
val manager = BookmarksManager.getInstance(project) ?: return null
val window = getData(PlatformDataKeys.TOOL_WINDOW)
if (window?.id == ToolWindowId.BOOKMARKS) return null
val component = getData(PlatformDataKeys.CONTEXT_COMPONENT)
val allowed = UIUtil.getClientProperty(component, BookmarksManager.ALLOWED) ?: (window?.id == ToolWindowId.PROJECT_VIEW)
if (!allowed) return null
// TODO mouse shortcuts as in gutter/LOGICAL_LINE_AT_CURSOR
val items = getData(PlatformDataKeys.SELECTED_ITEMS)
if (items != null && items.size > 1) return null
val item = items?.firstOrNull() ?: getData(CommonDataKeys.PSI_ELEMENT) ?: getData(CommonDataKeys.VIRTUAL_FILE)
return when (item) {
is AbstractTreeNode<*> -> manager.createBookmark(item.value)
is SmartElementDescriptor -> manager.createBookmark(item.psiElement)
is NodeDescriptor<*> -> manager.createBookmark(item.element)
else -> manager.createBookmark(item)
}
}
internal val Bookmark.bookmarksManager
get() = BookmarksManager.getInstance(provider.project)
internal val Bookmark.firstGroupWithDescription
get() = bookmarksManager?.getGroups(this)?.firstOrNull { it.getDescription(this).isNullOrBlank().not() }
/**
* Creates and registers an action that navigates to a bookmark by a digit or a letter, if speed search is not active.
*/
internal fun JComponent.registerBookmarkTypeAction(parent: Disposable, type: BookmarkType) = createBookmarkTypeAction(type)
.registerCustomShortcutSet(CustomShortcutSet.fromString(type.mnemonic.toString()), this, parent)
/**
* Creates an action that navigates to a bookmark by its type, if speed search is not active.
*/
private fun createBookmarkTypeAction(type: BookmarkType) = GotoBookmarkTypeAction(type) {
null == it.bookmarksView?.run { SpeedSearchSupply.getSupply(tree) }
}
/**
* Creates an action that navigates to a selected bookmark by the EditSource shortcut.
*/
internal fun JComponent.registerEditSourceAction(parent: Disposable) = LightEditActionFactory
.create { OpenSourceUtil.navigate(*it.getData(CommonDataKeys.NAVIGATABLE_ARRAY)) }
.registerCustomShortcutSet(CommonShortcuts.getEditSource(), this, parent)
internal fun JTree.registerNavigateOnEnterAction() {
val enter = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0)
// perform previous action if the specified action is failed
// it is needed to expand/collapse a tree node
val oldListener = getActionForKeyStroke(enter)
val newListener = ActionListener {
when (val node = TreeUtil.getAbstractTreeNode(selectionPath)) {
null -> oldListener?.actionPerformed(it)
is GroupNode -> oldListener?.actionPerformed(it)
else -> node.navigate(true)
}
}
registerKeyboardAction(newListener, enter, JComponent.WHEN_FOCUSED)
}
| platform/lang-impl/src/com/intellij/ide/bookmark/actions/extensions.kt | 2746651668 |
// 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.feedback
import com.intellij.CommonBundle
import com.intellij.icons.AllIcons
import com.intellij.ide.actions.AboutDialog
import com.intellij.ide.actions.SendFeedbackAction
import com.intellij.notification.Notification
import com.intellij.notification.NotificationListener
import com.intellij.notification.NotificationType
import com.intellij.openapi.application.ApplicationBundle
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.application.ApplicationNamesInfo
import com.intellij.openapi.application.ex.ApplicationInfoEx
import com.intellij.openapi.application.impl.ZenDeskForm
import com.intellij.openapi.project.Project
import com.intellij.openapi.ui.DialogWrapper
import com.intellij.ui.CollectionComboBoxModel
import com.intellij.ui.LicensingFacade
import com.intellij.ui.PopupBorder
import com.intellij.ui.components.JBScrollPane
import com.intellij.ui.components.JBTextArea
import com.intellij.ui.components.TextComponentEmptyText
import com.intellij.ui.components.dialog
import com.intellij.ui.dsl.builder.*
import com.intellij.ui.dsl.builder.panel
import com.intellij.ui.dsl.gridLayout.HorizontalAlign
import com.intellij.ui.dsl.gridLayout.VerticalAlign
import com.intellij.ui.layout.*
import com.intellij.util.ui.JBFont
import com.intellij.util.ui.JBUI
import org.jetbrains.annotations.Nls
import java.awt.Component
import java.awt.event.ActionEvent
import java.awt.event.KeyAdapter
import java.awt.event.KeyEvent
import java.util.function.Predicate
import javax.swing.AbstractAction
import javax.swing.Action
import javax.swing.JComboBox
import javax.swing.JComponent
import javax.swing.event.HyperlinkEvent
private data class ZenDeskComboOption(val displayName: @Nls String, val id: String) {
override fun toString(): String = displayName
}
private val topicOptions = listOf(
ZenDeskComboOption(ApplicationBundle.message("feedback.form.topic.bug"), "ij_bug"),
ZenDeskComboOption(ApplicationBundle.message("feedback.form.topic.howto"), "ij_howto"),
ZenDeskComboOption(ApplicationBundle.message("feedback.form.topic.problem"), "ij_problem"),
ZenDeskComboOption(ApplicationBundle.message("feedback.form.topic.suggestion"), "ij_suggestion"),
ZenDeskComboOption(ApplicationBundle.message("feedback.form.topic.misc"), "ij_misc")
)
class FeedbackForm(
private val project: Project?,
val form: ZenDeskForm,
val isEvaluation: Boolean
) : DialogWrapper(project, false) {
private var details = ""
private var email = LicensingFacade.INSTANCE?.getLicenseeEmail().orEmpty()
private var needSupport = false
private var shareSystemInformation = false
private var ratingComponent: RatingComponent? = null
private var missingRatingTooltip: JComponent? = null
private var topic: ZenDeskComboOption? = null
private lateinit var topicComboBox: JComboBox<ZenDeskComboOption?>
init {
title = if (isEvaluation) ApplicationBundle.message("feedback.form.title") else ApplicationBundle.message("feedback.form.prompt")
init()
}
override fun createCenterPanel(): JComponent {
return panel {
if (isEvaluation) {
row {
label(ApplicationBundle.message("feedback.form.evaluation.prompt")).applyToComponent {
font = JBFont.h1()
}
}
row {
label(ApplicationBundle.message("feedback.form.comment"))
}
row {
label(ApplicationBundle.message("feedback.form.rating", ApplicationNamesInfo.getInstance().fullProductName))
}
row {
ratingComponent = RatingComponent().also {
it.addPropertyChangeListener { evt ->
if (evt.propertyName == RatingComponent.RATING_PROPERTY) {
missingRatingTooltip?.isVisible = false
}
}
cell(it)
}
missingRatingTooltip = label(ApplicationBundle.message("feedback.form.rating.required")).applyToComponent {
border = JBUI.Borders.compound(PopupBorder.Factory.createColored(JBUI.CurrentTheme.Validator.errorBorderColor()),
JBUI.Borders.empty(4, 8))
background = JBUI.CurrentTheme.Validator.errorBackgroundColor()
isVisible = false
isOpaque = true
}.component
}
}
else {
row {
topicComboBox = comboBox(CollectionComboBoxModel(topicOptions))
.label(ApplicationBundle.message("feedback.form.topic"), LabelPosition.TOP)
.bindItem({ topic }, { topic = it})
.errorOnApply(ApplicationBundle.message("feedback.form.topic.required")) {
it.selectedItem == null
}.component
icon(AllIcons.General.BalloonInformation)
.gap(RightGap.SMALL)
.visibleIf(topicComboBox.selectedValueMatches { it?.id == "ij_bug" })
text(ApplicationBundle.message("feedback.form.issue")) {
SendFeedbackAction.submit(project, ApplicationInfoEx.getInstanceEx().youtrackUrl, SendFeedbackAction.getDescription(project))
}.visibleIf(topicComboBox.selectedValueMatches { it?.id == "ij_bug" })
}
}
row {
val label = if (isEvaluation) ApplicationBundle.message("feedback.form.evaluation.details") else ApplicationBundle.message("feedback.form.details")
textArea()
.label(label, LabelPosition.TOP)
.bindText(::details)
.horizontalAlign(HorizontalAlign.FILL)
.verticalAlign(VerticalAlign.FILL)
.rows(5)
.focused()
.errorOnApply(ApplicationBundle.message("feedback.form.details.required")) {
it.text.isBlank()
}
.applyToComponent {
emptyText.text = if (isEvaluation)
ApplicationBundle.message("feedback.form.evaluation.details.emptyText")
else
ApplicationBundle.message("feedback.form.details.emptyText")
putClientProperty(TextComponentEmptyText.STATUS_VISIBLE_FUNCTION, Predicate<JBTextArea> { it.text.isEmpty() })
addKeyListener(object : KeyAdapter() {
override fun keyPressed(e: KeyEvent) {
if (e.keyCode == KeyEvent.VK_TAB) {
if ((e.modifiersEx and KeyEvent.SHIFT_DOWN_MASK) != 0) {
transferFocusBackward()
}
else {
transferFocus()
}
e.consume()
}
}
})
}
}.resizableRow()
row {
textField()
.label(ApplicationBundle.message("feedback.form.email"), LabelPosition.TOP)
.bindText(::email)
.columns(COLUMNS_MEDIUM)
.errorOnApply(ApplicationBundle.message("feedback.form.email.required")) { it.text.isBlank() }
.errorOnApply(ApplicationBundle.message("feedback.form.email.invalid")) { !it.text.matches(Regex(".+@.+\\..+")) }
}
row {
checkBox(ApplicationBundle.message("feedback.form.need.support"))
.bindSelected(::needSupport)
}
row {
checkBox(ApplicationBundle.message("feedback.form.share.system.information"))
.bindSelected(::shareSystemInformation)
.gap(RightGap.SMALL)
@Suppress("DialogTitleCapitalization")
link(ApplicationBundle.message("feedback.form.share.system.information.link")) {
showSystemInformation()
}
}
row {
comment(ApplicationBundle.message("feedback.form.consent"))
}
}
}
private fun showSystemInformation() {
val systemInfo = AboutDialog(project).extendedAboutText
val scrollPane = JBScrollPane(JBTextArea(systemInfo))
dialog(ApplicationBundle.message("feedback.form.system.information.title"), scrollPane, createActions = {
listOf(object : AbstractAction(CommonBundle.getCloseButtonText()) {
init {
putValue(DEFAULT_ACTION, true)
}
override fun actionPerformed(event: ActionEvent) {
val wrapper = findInstance(event.source as? Component)
wrapper?.close(OK_EXIT_CODE)
}
})
}).show()
}
override fun getOKAction(): Action {
return object : DialogWrapper.OkAction() {
init {
putValue(Action.NAME, ApplicationBundle.message("feedback.form.ok"))
}
override fun doAction(e: ActionEvent) {
val ratingComponent = ratingComponent
missingRatingTooltip?.isVisible = ratingComponent?.myRating == 0
if (ratingComponent == null || ratingComponent.myRating != 0) {
super.doAction(e)
}
else {
enabled = false
}
}
}
}
override fun getCancelAction(): Action {
return super.getCancelAction().apply {
if (isEvaluation) {
putValue(Action.NAME, ApplicationBundle.message("feedback.form.cancel"))
}
}
}
override fun doOKAction() {
super.doOKAction()
val systemInfo = if (shareSystemInformation) AboutDialog(project).extendedAboutText else ""
ApplicationManager.getApplication().executeOnPooledThread {
ZenDeskRequests().submit(
form,
email,
ApplicationNamesInfo.getInstance().fullProductName + " Feedback",
details.ifEmpty { "No details" },
mapOf(
"systeminfo" to systemInfo,
"needsupport" to needSupport
) + (ratingComponent?.let { mapOf("rating" to it.myRating) } ?: mapOf()) + (topic?.let { mapOf("topic" to it.id) } ?: emptyMap())
, onDone = {
ApplicationManager.getApplication().invokeLater {
var message = ApplicationBundle.message("feedback.form.thanks", ApplicationNamesInfo.getInstance().fullProductName)
if (isEvaluation) {
message += "<br/>" + ApplicationBundle.message("feedback.form.share.later")
}
Notification("feedback.form",
ApplicationBundle.message("feedback.form.thanks.title"),
message,
NotificationType.INFORMATION).notify(project)
}
}, onError = {
ApplicationManager.getApplication().invokeLater {
Notification("feedback.form",
ApplicationBundle.message("feedback.form.error.title"),
ApplicationBundle.message("feedback.form.error.text"),
NotificationType.ERROR
)
.setListener(object : NotificationListener.Adapter() {
override fun hyperlinkActivated(notification: Notification, e: HyperlinkEvent) {
SendFeedbackAction.submit(project)
}
})
.notify(project)
}
})
}
}
override fun doCancelAction() {
super.doCancelAction()
if (isEvaluation) {
Notification("feedback.form", ApplicationBundle.message("feedback.form.share.later"), NotificationType.INFORMATION).notify(project)
}
}
}
| platform/platform-impl/src/com/intellij/ide/feedback/FeedbackForm.kt | 1212814505 |
// 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 com.intellij.ide.actions
import com.intellij.CommonBundle
import com.intellij.diagnostic.VMOptions
import com.intellij.ide.IdeBundle
import com.intellij.ide.util.PsiNavigationSupport
import com.intellij.openapi.actionSystem.ActionUpdateThread
import com.intellij.openapi.actionSystem.AnActionEvent
import com.intellij.openapi.application.ApplicationNamesInfo
import com.intellij.openapi.application.PathManager
import com.intellij.openapi.diagnostic.Logger
import com.intellij.openapi.editor.EditorFactory
import com.intellij.openapi.editor.ex.EditorEx
import com.intellij.openapi.fileEditor.impl.NonProjectFileWritingAccessExtension
import com.intellij.openapi.fileTypes.FileTypeManager
import com.intellij.openapi.project.DefaultProjectFactory
import com.intellij.openapi.project.DumbAwareAction
import com.intellij.openapi.project.Project
import com.intellij.openapi.ui.DialogWrapper
import com.intellij.openapi.ui.Messages
import com.intellij.openapi.util.io.FileUtil
import com.intellij.openapi.vfs.LocalFileSystem
import com.intellij.openapi.vfs.VfsUtilCore
import com.intellij.openapi.vfs.VirtualFile
import com.intellij.openapi.wm.impl.welcomeScreen.WelcomeFrame
import com.intellij.psi.PsiManager
import com.intellij.ui.EditorTextField
import com.intellij.util.ui.IoErrorText
import java.io.File
import java.io.IOException
import java.nio.charset.Charset
import java.nio.charset.StandardCharsets
import java.nio.file.Files
import java.nio.file.Path
import javax.swing.JFrame
import javax.swing.ScrollPaneConstants
abstract class EditCustomSettingsAction : DumbAwareAction() {
protected abstract fun file(): Path?
protected abstract fun template(): String
protected open fun charset(): Charset = StandardCharsets.UTF_8
override fun getActionUpdateThread() = ActionUpdateThread.EDT
override fun update(e: AnActionEvent) {
e.presentation.isEnabled = (e.project != null || WelcomeFrame.getInstance() != null) && file() != null
}
override fun actionPerformed(e: AnActionEvent) {
val file = file() ?: return
val project = e.project
if (project != null) {
openInEditor(file, project)
}
else {
val frame = WelcomeFrame.getInstance() as JFrame?
if (frame != null) {
openInDialog(file, frame)
}
}
}
private fun openInEditor(file: Path, project: Project) {
if (!Files.exists(file)) {
try {
Files.write(file, template().lines(), charset())
}
catch (e: IOException) {
Logger.getInstance(javaClass).warn(file.toString(), e)
val message = IdeBundle.message("file.write.error.details", file, IoErrorText.message(e))
Messages.showErrorDialog(project, message, CommonBundle.getErrorTitle())
return
}
}
val vFile = LocalFileSystem.getInstance().refreshAndFindFileByNioFile(file)
if (vFile != null) {
vFile.refresh(false, false)
val psiFile = PsiManager.getInstance(project).findFile(vFile)
if (psiFile != null) {
PsiNavigationSupport.getInstance().createNavigatable(project, vFile, psiFile.textLength).navigate(true)
}
}
}
private fun openInDialog(file: Path, frame: JFrame) {
val lines = if (!Files.exists(file)) template().lines()
else {
try {
Files.readAllLines(file, charset())
}
catch (e: IOException) {
Logger.getInstance(javaClass).warn(file.toString(), e)
val message = IdeBundle.message("file.read.error.details", file, IoErrorText.message(e))
Messages.showErrorDialog(frame, message, CommonBundle.getErrorTitle())
return
}
}
val text = lines.joinToString("\n")
object : DialogWrapper(frame, true) {
private val editor: EditorTextField
init {
title = FileUtil.getLocationRelativeToUserHome(file.toString())
setOKButtonText(IdeBundle.message("button.save"))
val document = EditorFactory.getInstance().createDocument(text)
val defaultProject = DefaultProjectFactory.getInstance().defaultProject
val fileType = FileTypeManager.getInstance().getFileTypeByFileName(file.fileName.toString())
editor = object : EditorTextField(document, defaultProject, fileType, false, false) {
override fun createEditor(): EditorEx {
val editor = super.createEditor()
editor.scrollPane.verticalScrollBarPolicy = ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED
editor.scrollPane.horizontalScrollBarPolicy = ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED
return editor
}
}
init()
}
override fun createCenterPanel() = editor
override fun getPreferredFocusedComponent() = editor
override fun getDimensionServiceKey() = "ide.config.custom.settings"
override fun doOKAction() {
try {
Files.write(file, editor.text.split('\n'), charset())
close(OK_EXIT_CODE)
}
catch (e: IOException) {
Logger.getInstance(javaClass).warn(file.toString(), e)
val message = IdeBundle.message("file.write.error.details", file, IoErrorText.message(e))
Messages.showErrorDialog(this.window, message, CommonBundle.getErrorTitle())
}
}
}.show()
}
}
class EditCustomPropertiesAction : EditCustomSettingsAction() {
private companion object {
val file: Lazy<Path?> = lazy { PathManager.getCustomOptionsDirectory()?.let { Path.of(it, PathManager.PROPERTIES_FILE_NAME) } }
}
override fun file(): Path? = file.value
override fun template(): String =
"# custom ${ApplicationNamesInfo.getInstance().fullProductName} properties (expand/override 'bin${File.separator}idea.properties')\n\n"
class AccessExtension : NonProjectFileWritingAccessExtension {
override fun isWritable(file: VirtualFile): Boolean =
EditCustomPropertiesAction.file.value?.let { VfsUtilCore.pathEqualsTo(file, it.toString()) } ?: false
}
}
class EditCustomVmOptionsAction : EditCustomSettingsAction() {
private companion object {
val file: Lazy<Path?> = lazy { VMOptions.getUserOptionsFile() }
}
override fun file(): Path? = file.value
override fun template(): String =
"# custom ${ApplicationNamesInfo.getInstance().fullProductName} VM options (expand/override 'bin${File.separator}${VMOptions.getFileName()}')\n\n"
override fun charset(): Charset = VMOptions.getFileCharset()
fun isEnabled(): Boolean = file() != null
class AccessExtension : NonProjectFileWritingAccessExtension {
override fun isWritable(file: VirtualFile): Boolean =
EditCustomVmOptionsAction.file.value?.let { VfsUtilCore.pathEqualsTo(file, it.toString()) } ?: false
}
}
| platform/platform-impl/src/com/intellij/ide/actions/EditCustomSettingsAction.kt | 3942393221 |
// 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.fir.low.level.api.ide
import com.intellij.psi.search.GlobalSearchScope
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.services.PackagePartProviderFactory
import org.jetbrains.kotlin.idea.caches.resolve.IDEPackagePartProvider
import org.jetbrains.kotlin.load.kotlin.PackagePartProvider
internal class PackagePartProviderFactoryIdeImpl : PackagePartProviderFactory() {
override fun createPackagePartProviderForLibrary(scope: GlobalSearchScope): PackagePartProvider {
return IDEPackagePartProvider(scope)
}
} | plugins/kotlin/fir-low-level-api-ide-impl/src/org/jetbrains/kotlin/idea/fir/low/level/api/ide/PackagePartProviderFactoryIdeImpl.kt | 3084381607 |
// WITH_STDLIB
fun main() {
val a: Any = 0
println(<warning descr="Condition 'a is Int' is always true">a is Int</warning>)
}
fun main2(b: Boolean) {
var a: Any = 0
if (b) a = 1
println(<warning descr="Condition 'a is Int' is always true">a is Int</warning>)
} | plugins/kotlin/idea/tests/testData/inspections/dfa/AnyType.kt | 3861895966 |
/*
* Copyright 2019 The Chromium Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
package io.flutter.tests.gui
import com.intellij.ide.fileTemplates.impl.UrlUtil
import com.intellij.openapi.diagnostic.Logger
import com.intellij.openapi.util.io.StreamUtil
import com.intellij.platform.templates.github.ZipUtil
import com.intellij.testGuiFramework.fixtures.IdeFrameFixture
import com.intellij.testGuiFramework.framework.Timeouts
import com.intellij.testGuiFramework.impl.*
import com.intellij.testGuiFramework.util.step
import com.intellij.testGuiFramework.utils.TestUtilsClass
import com.intellij.testGuiFramework.utils.TestUtilsClassCompanion
import com.intellij.util.UriUtil
import com.intellij.util.io.URLUtil
import io.flutter.tests.gui.fixtures.FlutterMessagesToolWindowFixture
import org.fest.swing.exception.WaitTimedOutError
import org.fest.swing.timing.Pause.pause
import java.io.BufferedOutputStream
import java.io.File
import java.io.FileOutputStream
import java.net.URL
val GuiTestCase.ProjectCreator by ProjectCreator
// Inspired by CommunityProjectCreator
class ProjectCreator(guiTestCase: GuiTestCase) : TestUtilsClass(guiTestCase) {
companion object : TestUtilsClassCompanion<ProjectCreator>({ ProjectCreator(it) })
private val defaultProjectName = "untitled"
private val sampleProjectName = "simple_app"
private val log = Logger.getInstance(this.javaClass)
var flutterMessagesFixture: FlutterMessagesToolWindowFixture.FlutterContentFixture? = null
fun importProject(projectName: String = sampleProjectName): File {
return step("Import project $projectName") {
val projectDirFile = extractProject(projectName)
val projectPath: File = guiTestCase.guiTestRule.importProject(projectDirFile)
with(guiTestCase) {
waitForFirstIndexing()
step("Get packages") {
openPubspecInProject()
ideFrame {
editor {
val note = notificationPanel()
if (note?.getLabelText() == "Flutter commands") {
note.clickLink("Packages get")
flutterMessagesFixture = flutterMessagesToolWindowFixture().getFlutterContent(projectName)
flutterMessagesFixture!!.findMessageContainingText("Process finished")
}
// TODO(messick) Close pubspec.yaml once editor tab fixtures are working.
//closeTab("pubspec.yaml")
}
}
}
openMainInProject(wait = true)
pause()
}
projectPath
}
}
private fun extractProject(projectName: String): File {
val projectDirUrl = this.javaClass.classLoader.getResource("flutter_projects/$projectName")
val children = UrlUtil.getChildrenRelativePaths(projectDirUrl)
val tempDir = java.nio.file.Files.createTempDirectory("test").toFile()
val projectDir = File(tempDir, projectName)
for (child in children) {
val url = childUrl(projectDirUrl, child)
val inputStream = URLUtil.openResourceStream(url)
val outputFile = File(projectDir, child)
File(outputFile.parent).mkdirs()
val outputStream = BufferedOutputStream(FileOutputStream(outputFile))
try {
StreamUtil.copyStreamContent(inputStream, outputStream)
}
finally {
inputStream.close()
outputStream.close()
}
}
val srcZip = File(projectDir, "src.zip")
if (srcZip.exists() && srcZip.isFile) {
run {
ZipUtil.unzip(null, projectDir, srcZip, null, null, true)
srcZip.delete()
}
}
return projectDir
}
private fun childUrl(parent: URL, child: String): URL {
return URL(UriUtil.trimTrailingSlashes(parent.toExternalForm()) + "/" + child)
}
fun createProject(projectName: String = defaultProjectName, needToOpenMain: Boolean = true) {
with(guiTestCase) {
step("Create project $projectName") {
welcomeFrame {
this.actionLink(name = "Create New Project").click()
dialog("New Project") {
jList("Flutter").clickItem("Flutter")
button("Next").click()
typeText(projectName)
button("Finish").click()
GuiTestUtilKt.waitProgressDialogUntilGone(
robot = robot(), progressTitle = "Creating Flutter Project", timeoutToAppear = Timeouts.seconds03)
}
}
waitForFirstIndexing()
}
if (needToOpenMain) openMainInProject(wait = true)
}
}
private fun GuiTestCase.waitForFirstIndexing() {
ideFrame {
val secondsToWait = 10
try {
waitForStartingIndexing(secondsToWait)
}
catch (timedOutError: WaitTimedOutError) {
log.warn("Wait for indexing exceeded $secondsToWait seconds")
}
waitForBackgroundTasksToFinish()
}
}
private fun GuiTestCase.openMainInProject(wait: Boolean = false) {
ideFrame {
projectView {
step("Open lib/main.dart") {
path(project.name, "lib", "main.dart").doubleClick()
if (wait) waitForBackgroundTasksToFinish()
}
}
}
}
private fun GuiTestCase.openPubspecInProject() {
ideFrame {
projectView {
step("Open pubspec.yaml") {
path(project.name, "pubspec.yaml").doubleClick()
}
}
}
}
fun IdeFrameFixture.flutterMessagesToolWindowFixture(): FlutterMessagesToolWindowFixture {
return FlutterMessagesToolWindowFixture(project, robot())
}
}
| flutter-gui-tests/testSrc/io/flutter/tests/gui/ProjectCreator.kt | 4171040339 |
/*
* 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
*
* 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 com.google.samples.apps.iosched.macrobenchmark
import androidx.benchmark.macro.CompilationMode
import androidx.benchmark.macro.StartupMode
import androidx.benchmark.macro.StartupTimingMetric
import androidx.benchmark.macro.junit4.MacrobenchmarkRule
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.LargeTest
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
@LargeTest
@RunWith(AndroidJUnit4::class)
class StartupBenchmarks {
@get:Rule
val benchmarkRule = MacrobenchmarkRule()
@Test
fun startupCompilationNone() = startup(CompilationMode.None())
@Test
fun startupCompilationPartial() = startup(CompilationMode.Partial())
@Test
fun startupCompilationFull() = startup(CompilationMode.Full())
private fun startup(compilationMode: CompilationMode) = benchmarkRule.measureRepeated(
packageName = TARGET_PACKAGE,
compilationMode = compilationMode,
startupMode = StartupMode.COLD,
iterations = 5,
metrics = listOf(StartupTimingMetric()),
setupBlock = {
pressHome()
}
) {
startMainAndWait()
}
}
| macrobenchmark/src/main/java/com/google/samples/apps/iosched/macrobenchmark/StartupBenchmarks.kt | 2490546718 |
/*
* Copyright 2018 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
*
* 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 com.google.samples.apps.iosched.shared.data.userevent
import com.google.firebase.firestore.DocumentSnapshot
import com.google.samples.apps.iosched.model.reservations.ReservationRequest
import com.google.samples.apps.iosched.model.reservations.ReservationRequestResult
import com.google.samples.apps.iosched.model.userdata.UserEvent
import com.google.samples.apps.iosched.shared.data.userevent.FirestoreUserEventDataSource.Companion.RESERVATION_REQUEST_ACTION_KEY
import com.google.samples.apps.iosched.shared.data.userevent.FirestoreUserEventDataSource.Companion.RESERVATION_REQUEST_KEY
import com.google.samples.apps.iosched.shared.data.userevent.FirestoreUserEventDataSource.Companion.RESERVATION_REQUEST_REQUEST_ID_KEY
import com.google.samples.apps.iosched.shared.data.userevent.FirestoreUserEventDataSource.Companion.RESERVATION_RESULT_KEY
import com.google.samples.apps.iosched.shared.data.userevent.FirestoreUserEventDataSource.Companion.RESERVATION_RESULT_REQ_ID_KEY
import com.google.samples.apps.iosched.shared.data.userevent.FirestoreUserEventDataSource.Companion.RESERVATION_RESULT_RESULT_KEY
import com.google.samples.apps.iosched.shared.data.userevent.FirestoreUserEventDataSource.Companion.RESERVATION_RESULT_TIME_KEY
import com.google.samples.apps.iosched.shared.data.userevent.FirestoreUserEventDataSource.Companion.RESERVATION_STATUS_KEY
import timber.log.Timber
/**
* Parse a user event that includes information about the reservation status.
*/
fun parseUserEvent(snapshot: DocumentSnapshot): UserEvent {
val reservationRequestResult: ReservationRequestResult? =
generateReservationRequestResult(snapshot)
val reservationRequest = parseReservationRequest(snapshot)
val reservationStatus = (snapshot[RESERVATION_STATUS_KEY] as? String)?.let {
UserEvent.ReservationStatus.getIfPresent(it)
}
return UserEvent(
id = snapshot.id,
reservationRequestResult = reservationRequestResult,
reservationStatus = reservationStatus,
isStarred = snapshot[FirestoreUserEventDataSource.IS_STARRED] as? Boolean ?: false,
reservationRequest = reservationRequest,
isReviewed = snapshot[FirestoreUserEventDataSource.REVIEWED] as? Boolean ?: false
)
}
/**
* Parse the result of a reservation request.
*/
private fun generateReservationRequestResult(
snapshot: DocumentSnapshot
): ReservationRequestResult? {
(snapshot[RESERVATION_RESULT_KEY] as? Map<*, *>)?.let { reservation ->
val requestResult = (reservation[RESERVATION_RESULT_RESULT_KEY] as? String)
?.let { ReservationRequestResult.ReservationRequestStatus.getIfPresent(it) }
val requestId = (reservation[RESERVATION_RESULT_REQ_ID_KEY] as? String)
val timestamp = reservation[RESERVATION_RESULT_TIME_KEY] as? Long ?: -1
// Mandatory fields or fail:
if (requestResult == null || requestId == null) {
Timber.e("Error parsing reservation request result: some fields null")
return null
}
return ReservationRequestResult(
requestResult = requestResult,
requestId = requestId,
timestamp = timestamp
)
}
// If there's no reservation:
return null
}
/**
* Parse the reservation request.
*/
private fun parseReservationRequest(snapshot: DocumentSnapshot): ReservationRequest? {
(snapshot[RESERVATION_REQUEST_KEY] as? Map<*, *>)?.let { request ->
val action = (request[RESERVATION_REQUEST_ACTION_KEY] as? String)?.let {
ReservationRequest.ReservationRequestEntityAction.getIfPresent(it)
}
val requestId = (request[RESERVATION_REQUEST_REQUEST_ID_KEY] as? String)
// Mandatory fields or fail:
if (action == null || requestId == null) {
Timber.e("Error parsing reservation request from Firestore")
return null
}
return ReservationRequest(action, requestId)
}
// If there's no reservation request:
return null
}
| shared/src/main/java/com/google/samples/apps/iosched/shared/data/userevent/FirestoreUserEventParser.kt | 1518818400 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package git4idea.ui.branch
import com.intellij.dvcs.branch.DvcsBranchManager
import com.intellij.dvcs.branch.GroupingKey
import com.intellij.dvcs.ui.DvcsBundle
import com.intellij.icons.AllIcons
import com.intellij.ide.DataManager
import com.intellij.ide.util.treeView.TreeState
import com.intellij.openapi.Disposable
import com.intellij.openapi.actionSystem.*
import com.intellij.openapi.actionSystem.ex.ActionUtil
import com.intellij.openapi.actionSystem.impl.SimpleDataContext
import com.intellij.openapi.application.runInEdt
import com.intellij.openapi.components.service
import com.intellij.openapi.ide.CopyPasteManager
import com.intellij.openapi.keymap.KeymapUtil
import com.intellij.openapi.project.Project
import com.intellij.openapi.ui.popup.*
import com.intellij.openapi.util.Disposer
import com.intellij.openapi.util.Key
import com.intellij.openapi.util.NlsContexts
import com.intellij.openapi.util.WindowStateService
import com.intellij.openapi.util.registry.Registry
import com.intellij.ui.*
import com.intellij.ui.popup.NextStepHandler
import com.intellij.ui.popup.PopupFactoryImpl
import com.intellij.ui.popup.WizardPopup
import com.intellij.ui.popup.util.PopupImplUtil
import com.intellij.ui.render.RenderingUtil
import com.intellij.ui.scale.JBUIScale
import com.intellij.ui.speedSearch.SpeedSearchUtil
import com.intellij.ui.tree.ui.Control
import com.intellij.ui.tree.ui.DefaultControl
import com.intellij.ui.tree.ui.DefaultTreeUI
import com.intellij.ui.treeStructure.Tree
import com.intellij.util.text.nullize
import com.intellij.util.ui.JBDimension
import com.intellij.util.ui.JBUI
import com.intellij.util.ui.UIUtil
import com.intellij.util.ui.tree.TreeUtil
import git4idea.GitBranch
import git4idea.actions.branch.GitBranchActionsUtil
import git4idea.branch.GitBranchType
import git4idea.i18n.GitBundle
import git4idea.repo.GitRepository
import git4idea.repo.GitRepositoryChangeListener
import git4idea.repo.GitRepositoryManager
import git4idea.ui.branch.GitBranchesTreePopupStep.Companion.SPEED_SEARCH_DEFAULT_ACTIONS_GROUP
import git4idea.ui.branch.GitBranchesTreeUtil.overrideBuiltInAction
import git4idea.ui.branch.GitBranchesTreeUtil.selectFirstLeaf
import git4idea.ui.branch.GitBranchesTreeUtil.selectLastLeaf
import git4idea.ui.branch.GitBranchesTreeUtil.selectNextLeaf
import git4idea.ui.branch.GitBranchesTreeUtil.selectPrevLeaf
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.flow.debounce
import kotlinx.coroutines.flow.drop
import java.awt.AWTEvent
import java.awt.Component
import java.awt.Cursor
import java.awt.Point
import java.awt.datatransfer.DataFlavor
import java.awt.event.*
import java.util.function.Function
import java.util.function.Supplier
import javax.swing.*
import javax.swing.tree.TreeCellRenderer
import javax.swing.tree.TreeModel
import javax.swing.tree.TreePath
import javax.swing.tree.TreeSelectionModel
import kotlin.math.min
class GitBranchesTreePopup(project: Project, step: GitBranchesTreePopupStep, parent: JBPopup? = null, parentValue: Any? = null)
: WizardPopup(project, parent, step),
TreePopup, NextStepHandler {
private lateinit var tree: BranchesTree
private var showingChildPath: TreePath? = null
private var pendingChildPath: TreePath? = null
private val treeStep: GitBranchesTreePopupStep
get() = step as GitBranchesTreePopupStep
private lateinit var searchPatternStateFlow: MutableStateFlow<String?>
internal var userResized: Boolean
private set
init {
setParentValue(parentValue)
setMinimumSize(JBDimension(300, 200))
dimensionServiceKey = if (isChild()) null else GitBranchPopup.DIMENSION_SERVICE_KEY
userResized = !isChild() && WindowStateService.getInstance(project).getSizeFor(project, dimensionServiceKey) != null
installGeneralShortcutActions()
installShortcutActions(step.treeModel)
if (!isChild()) {
setSpeedSearchAlwaysShown()
installHeaderToolbar()
installRepoListener()
installResizeListener()
warnThatBranchesDivergedIfNeeded()
}
installBranchSettingsListener()
DataManager.registerDataProvider(component, DataProvider { dataId ->
when {
POPUP_KEY.`is`(dataId) -> this
GitBranchActionsUtil.REPOSITORIES_KEY.`is`(dataId) -> treeStep.repositories
else -> null
}
})
}
private fun warnThatBranchesDivergedIfNeeded() {
if (treeStep.isBranchesDiverged()) {
setWarning(DvcsBundle.message("branch.popup.warning.branches.have.diverged"))
}
}
override fun createContent(): JComponent {
tree = BranchesTree(treeStep.treeModel).also {
configureTreePresentation(it)
overrideTreeActions(it)
addTreeMouseControlsListeners(it)
Disposer.register(this) {
it.model = null
}
val topBorder = if (step.title.isNullOrEmpty()) JBUIScale.scale(5) else 0
it.border = JBUI.Borders.empty(topBorder, JBUIScale.scale(10), 0, 0)
}
searchPatternStateFlow = MutableStateFlow(null)
speedSearch.installSupplyTo(tree, false)
@OptIn(FlowPreview::class)
with(uiScope(this)) {
launch {
searchPatternStateFlow.drop(1).debounce(100).collectLatest { pattern ->
applySearchPattern(pattern)
}
}
}
return tree
}
private fun isChild() = parent != null
private fun applySearchPattern(pattern: String? = speedSearch.enteredPrefix.nullize(true)) {
treeStep.setSearchPattern(pattern)
val haveBranches = haveBranchesToShow()
if (haveBranches) {
selectPreferred()
}
super.updateSpeedSearchColors(!haveBranches)
if (!pattern.isNullOrBlank()) {
tree.emptyText.text = GitBundle.message("git.branches.popup.tree.no.branches", pattern)
}
}
private fun haveBranchesToShow(): Boolean {
val model = tree.model
val root = model.root
return (0 until model.getChildCount(root))
.asSequence()
.map { model.getChild(root, it) }
.filterIsInstance<GitBranchType>()
.any { !model.isLeaf(it) }
}
internal fun restoreDefaultSize() {
userResized = false
WindowStateService.getInstance(project).putSizeFor(project, dimensionServiceKey, null)
pack(true, true)
}
private fun installRepoListener() {
project.messageBus.connect(this).subscribe(GitRepository.GIT_REPO_CHANGE, GitRepositoryChangeListener {
runInEdt {
val state = TreeState.createOn(tree)
applySearchPattern()
state.applyTo(tree)
}
})
}
private fun installResizeListener() {
addResizeListener({ userResized = true }, this)
}
private fun installBranchSettingsListener() {
project.messageBus.connect(this)
.subscribe(DvcsBranchManager.DVCS_BRANCH_SETTINGS_CHANGED,
object : DvcsBranchManager.DvcsBranchManagerListener {
override fun branchGroupingSettingsChanged(key: GroupingKey, state: Boolean) {
runInEdt {
treeStep.setPrefixGrouping(state)
}
}
override fun branchFavoriteSettingsChanged() {
runInEdt {
tree.repaint()
}
}
})
}
override fun storeDimensionSize() {
if (userResized) {
super.storeDimensionSize()
}
}
private fun toggleFavorite(branch: GitBranch) {
val branchType = GitBranchType.of(branch)
val branchManager = project.service<GitBranchManager>()
val anyNotFavorite = treeStep.repositories.any { repository -> !branchManager.isFavorite(branchType, repository, branch.name) }
treeStep.repositories.forEach { repository ->
branchManager.setFavorite(branchType, repository, branch.name, anyNotFavorite)
}
}
private fun installGeneralShortcutActions() {
registerAction("toggle_favorite", KeyStroke.getKeyStroke("SPACE"), object : AbstractAction() {
override fun actionPerformed(e: ActionEvent?) {
(tree.lastSelectedPathComponent?.let(TreeUtil::getUserObject) as? GitBranch)?.run(::toggleFavorite)
}
})
}
private fun installSpeedSearchActions() {
val updateSpeedSearch = {
val textInEditor = mySpeedSearchPatternField.textEditor.text
speedSearch.updatePattern(textInEditor)
applySearchPattern(textInEditor)
}
val editorActionsContext = mapOf(PlatformCoreDataKeys.CONTEXT_COMPONENT to mySpeedSearchPatternField.textEditor)
(ActionManager.getInstance()
.getAction(SPEED_SEARCH_DEFAULT_ACTIONS_GROUP) as ActionGroup)
.getChildren(null)
.forEach { action ->
registerAction(ActionManager.getInstance().getId(action),
KeymapUtil.getKeyStroke(action.shortcutSet),
createShortcutAction(action, editorActionsContext, updateSpeedSearch, false))
}
}
private fun installShortcutActions(model: TreeModel) {
val root = model.root
(0 until model.getChildCount(root))
.asSequence()
.map { model.getChild(root, it) }
.filterIsInstance<PopupFactoryImpl.ActionItem>()
.map(PopupFactoryImpl.ActionItem::getAction)
.forEach { action ->
registerAction(ActionManager.getInstance().getId(action),
KeymapUtil.getKeyStroke(action.shortcutSet),
createShortcutAction<Any>(action))
}
}
private fun installHeaderToolbar() {
val settingsGroup = ActionManager.getInstance().getAction(GitBranchesTreePopupStep.HEADER_SETTINGS_ACTION_GROUP)
val toolbarGroup = DefaultActionGroup(GitBranchPopupFetchAction(javaClass), settingsGroup)
val toolbar = ActionManager.getInstance()
.createActionToolbar(GitBranchesTreePopupStep.ACTION_PLACE, toolbarGroup, true)
.apply {
targetComponent = [email protected]
setReservePlaceAutoPopupIcon(false)
component.isOpaque = false
}
title.setButtonComponent(object : ActiveComponent.Adapter() {
override fun getComponent(): JComponent = toolbar.component
}, JBUI.Borders.emptyRight(2))
}
private fun <T> createShortcutAction(action: AnAction,
actionContext: Map<DataKey<T>, T> = emptyMap(),
afterActionPerformed: (() -> Unit)? = null,
closePopup: Boolean = true) = object : AbstractAction() {
override fun actionPerformed(e: ActionEvent?) {
if (closePopup) {
cancel()
}
val stepContext = GitBranchesTreePopupStep.createDataContext(project, treeStep.repositories)
val resultContext =
with(SimpleDataContext.builder().setParent(stepContext)) {
actionContext.forEach { (key, value) -> add(key, value) }
build()
}
ActionUtil.invokeAction(action, resultContext, GitBranchesTreePopupStep.ACTION_PLACE, null, afterActionPerformed)
}
}
private fun configureTreePresentation(tree: JTree) = with(tree) {
ClientProperty.put(this, RenderingUtil.CUSTOM_SELECTION_BACKGROUND, Supplier { JBUI.CurrentTheme.Tree.background(true, true) })
ClientProperty.put(this, RenderingUtil.CUSTOM_SELECTION_FOREGROUND, Supplier { JBUI.CurrentTheme.Tree.foreground(true, true) })
val renderer = Renderer(treeStep)
ClientProperty.put(this, Control.CUSTOM_CONTROL, Function { renderer.getLeftTreeIconRenderer(it) })
selectionModel.selectionMode = TreeSelectionModel.SINGLE_TREE_SELECTION
isRootVisible = false
showsRootHandles = true
visibleRowCount = min(calculateTopLevelVisibleRows(), 20)
cellRenderer = renderer
accessibleContext.accessibleName = GitBundle.message("git.branches.popup.tree.accessible.name")
ClientProperty.put(this, DefaultTreeUI.LARGE_MODEL_ALLOWED, true)
rowHeight = treeRowHeight
isLargeModel = true
expandsSelectedPaths = true
}
/**
* Local branches would be expanded by [GitBranchesTreePopupStep.getPreferredSelection].
*/
private fun JTree.calculateTopLevelVisibleRows() = model.getChildCount(model.root) + model.getChildCount(GitBranchType.LOCAL)
private fun overrideTreeActions(tree: JTree) = with(tree) {
overrideBuiltInAction("toggle") {
val path = selectionPath
if (path != null && model.getChildCount(path.lastPathComponent) == 0) {
handleSelect(true, null)
true
}
else false
}
overrideBuiltInAction(TreeActions.Left.ID) {
if (isChild()) {
cancel()
true
}
else false
}
overrideBuiltInAction(TreeActions.Right.ID) {
val path = selectionPath
if (path != null && (path.lastPathComponent is GitRepository || model.getChildCount(path.lastPathComponent) == 0)) {
handleSelect(false, null)
true
}
else false
}
overrideBuiltInAction(TreeActions.Down.ID) {
if (speedSearch.isHoldingFilter) selectNextLeaf()
else false
}
overrideBuiltInAction(TreeActions.Up.ID) {
if (speedSearch.isHoldingFilter) selectPrevLeaf()
else false
}
overrideBuiltInAction(TreeActions.Home.ID) {
if (speedSearch.isHoldingFilter) selectFirstLeaf()
else false
}
overrideBuiltInAction(TreeActions.End.ID) {
if (speedSearch.isHoldingFilter) selectLastLeaf()
else false
}
overrideBuiltInAction(TransferHandler.getPasteAction().getValue(Action.NAME) as String) {
speedSearch.type(CopyPasteManager.getInstance().getContents(DataFlavor.stringFlavor))
speedSearch.update()
true
}
}
private fun addTreeMouseControlsListeners(tree: JTree) = with(tree) {
addMouseMotionListener(SelectionMouseMotionListener())
addMouseListener(SelectOnClickListener())
}
override fun getActionMap(): ActionMap = tree.actionMap
override fun getInputMap(): InputMap = tree.inputMap
private val selectAllKeyStroke = KeymapUtil.getKeyStroke(ActionManager.getInstance().getAction(IdeActions.ACTION_SELECT_ALL).shortcutSet)
override fun process(e: KeyEvent?) {
if (e == null) return
val eventStroke = KeyStroke.getKeyStroke(e.keyCode, e.modifiersEx, e.id == KeyEvent.KEY_RELEASED)
if (selectAllKeyStroke == eventStroke) {
return
}
tree.processEvent(e)
}
override fun afterShow() {
selectPreferred()
if (treeStep.isSpeedSearchEnabled) {
installSpeedSearchActions()
}
}
override fun updateSpeedSearchColors(error: Boolean) {} // update colors only after branches tree model update
private fun selectPreferred() {
val preferredSelection = treeStep.getPreferredSelection()
if (preferredSelection != null) {
tree.makeVisible(preferredSelection)
tree.selectionPath = preferredSelection
TreeUtil.scrollToVisible(tree, preferredSelection, true)
}
else TreeUtil.promiseSelectFirstLeaf(tree)
}
override fun isResizable(): Boolean = true
private inner class SelectionMouseMotionListener : MouseMotionAdapter() {
private var lastMouseLocation: Point? = null
/**
* this method should be changed only in par with
* [com.intellij.ui.popup.list.ListPopupImpl.MyMouseMotionListener.isMouseMoved]
*/
private fun isMouseMoved(location: Point): Boolean {
if (lastMouseLocation == null) {
lastMouseLocation = location
return false
}
val prev = lastMouseLocation
lastMouseLocation = location
return prev != location
}
override fun mouseMoved(e: MouseEvent) {
if (!isMouseMoved(e.locationOnScreen)) return
val path = getPath(e)
if (path != null) {
tree.selectionPath = path
notifyParentOnChildSelection()
if (treeStep.isSelectable(TreeUtil.getUserObject(path.lastPathComponent))) {
tree.cursor = Cursor.getPredefinedCursor(Cursor.HAND_CURSOR)
if (pendingChildPath == null || pendingChildPath != path) {
pendingChildPath = path
restartTimer()
}
return
}
}
tree.cursor = Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR)
}
}
private inner class SelectOnClickListener : MouseAdapter() {
override fun mousePressed(e: MouseEvent) {
if (e.button != MouseEvent.BUTTON1) return
val path = getPath(e) ?: return
val selected = path.lastPathComponent
if (treeStep.isSelectable(TreeUtil.getUserObject(selected))) {
handleSelect(true, e)
}
}
}
private fun getPath(e: MouseEvent): TreePath? = tree.getClosestPathForLocation(e.point.x, e.point.y)
private fun handleSelect(handleFinalChoices: Boolean, e: MouseEvent?) {
val selectionPath = tree.selectionPath
val pathIsAlreadySelected = showingChildPath != null && showingChildPath == selectionPath
if (pathIsAlreadySelected) return
pendingChildPath = null
val selected = tree.lastSelectedPathComponent
if (selected != null) {
val userObject = TreeUtil.getUserObject(selected)
val point = e?.point
if (point != null && userObject is GitBranch && isMainIconAt(point, userObject)) {
toggleFavorite(userObject)
return
}
if (treeStep.isSelectable(userObject)) {
disposeChildren()
val hasNextStep = myStep.hasSubstep(userObject)
if (!hasNextStep && !handleFinalChoices) {
showingChildPath = null
return
}
val queriedStep = PopupImplUtil.prohibitFocusEventsInHandleSelect().use {
myStep.onChosen(userObject, handleFinalChoices)
}
if (queriedStep == PopupStep.FINAL_CHOICE || !hasNextStep) {
setFinalRunnable(myStep.finalRunnable)
setOk(true)
disposeAllParents(e)
}
else {
showingChildPath = selectionPath
handleNextStep(queriedStep, selected)
showingChildPath = null
}
}
}
}
private fun isMainIconAt(point: Point, selected: Any): Boolean {
val row = tree.getRowForLocation(point.x, point.y)
val rowBounds = tree.getRowBounds(row) ?: return false
point.translate(-rowBounds.x, -rowBounds.y)
val rowComponent = tree.cellRenderer
.getTreeCellRendererComponent(tree, selected, true, false, true, row, false) as? JComponent
?: return false
val iconComponent = UIUtil.uiTraverser(rowComponent)
.filter { ClientProperty.get(it, Renderer.MAIN_ICON) == true }
.firstOrNull() ?: return false
// todo: implement more precise check
return iconComponent.bounds.width >= point.x
}
override fun handleNextStep(nextStep: PopupStep<*>?, parentValue: Any) {
val selectionPath = tree.selectionPath ?: return
val pathBounds = tree.getPathBounds(selectionPath) ?: return
val point = Point(pathBounds.x, pathBounds.y)
SwingUtilities.convertPointToScreen(point, tree)
myChild =
if (nextStep is GitBranchesTreePopupStep) GitBranchesTreePopup(project, nextStep, this, parentValue)
else createPopup(this, nextStep, parentValue)
myChild.show(content, content.locationOnScreen.x + content.width - STEP_X_PADDING, point.y, true)
}
override fun onSpeedSearchPatternChanged() {
with(uiScope(this)) {
launch {
searchPatternStateFlow.emit(speedSearch.enteredPrefix.nullize(true))
}
}
}
override fun getPreferredFocusableComponent(): JComponent = tree
override fun onChildSelectedFor(value: Any) {
val path = treeStep.createTreePathFor(value) ?: return
if (tree.selectionPath != path) {
tree.selectionPath = path
}
}
companion object {
internal val POPUP_KEY = DataKey.create<GitBranchesTreePopup>("GIT_BRANCHES_TREE_POPUP")
private val treeRowHeight = if (ExperimentalUI.isNewUI()) JBUI.CurrentTheme.List.rowHeight() else JBUIScale.scale(22)
@JvmStatic
fun isEnabled() = Registry.`is`("git.branches.popup.tree", false)
&& !ExperimentalUI.isNewUI()
@JvmStatic
fun show(project: Project) {
create(project).showCenteredInCurrentWindow(project)
}
@JvmStatic
fun create(project: Project): JBPopup {
val repositories = GitRepositoryManager.getInstance(project).repositories
return GitBranchesTreePopup(project, GitBranchesTreePopupStep(project, repositories, true))
}
@JvmStatic
internal fun createTreeSeparator(text: @NlsContexts.Separator String? = null) =
SeparatorWithText().apply {
caption = text
border = JBUI.Borders.emptyTop(
if (text == null) treeRowHeight / 2 else JBUIScale.scale(SeparatorWithText.DEFAULT_H_GAP))
}
private fun uiScope(parent: Disposable) =
CoroutineScope(SupervisorJob() + Dispatchers.Main).also {
Disposer.register(parent) { it.cancel() }
}
private class BranchesTree(model: TreeModel): Tree(model) {
init {
background = JBUI.CurrentTheme.Popup.BACKGROUND
}
//Change visibility of processEvent to be able to delegate key events dispatched in WizardPopup directly to tree
//This will allow to handle events like "copy-paste" in AbstractPopup.speedSearch
public override fun processEvent(e: AWTEvent?) {
e?.source = this
super.processEvent(e)
}
}
private class Renderer(private val step: GitBranchesTreePopupStep) : TreeCellRenderer {
fun getLeftTreeIconRenderer(path: TreePath): Control? {
val lastComponent = path.lastPathComponent
val defaultIcon = step.getNodeIcon(lastComponent, false) ?: return null
val selectedIcon = step.getNodeIcon(lastComponent, true) ?: return null
return DefaultControl(defaultIcon, defaultIcon, selectedIcon, selectedIcon)
}
private val mainIconComponent = JLabel().apply {
ClientProperty.put(this, MAIN_ICON, true)
border = JBUI.Borders.emptyRight(4) // 6 px in spec, but label width is differed
}
private val mainTextComponent = SimpleColoredComponent().apply {
isOpaque = false
border = JBUI.Borders.empty()
}
private val secondaryLabel = JLabel().apply {
border = JBUI.Borders.emptyLeft(10)
horizontalAlignment = SwingConstants.RIGHT
}
private val arrowLabel = JLabel().apply {
border = JBUI.Borders.emptyLeft(4) // 6 px in spec, but label width is differed
}
private val incomingOutgoingLabel = JLabel().apply {
border = JBUI.Borders.emptyLeft(10)
}
private val textPanel = JBUI.Panels.simplePanel()
.addToLeft(JBUI.Panels.simplePanel(mainTextComponent)
.addToLeft(mainIconComponent)
.addToRight(incomingOutgoingLabel)
.andTransparent())
.addToCenter(secondaryLabel)
.andTransparent()
private val mainPanel = JBUI.Panels.simplePanel()
.addToCenter(textPanel)
.addToRight(arrowLabel)
.andTransparent()
.withBorder(JBUI.Borders.emptyRight(JBUI.CurrentTheme.ActionsList.cellPadding().right))
override fun getTreeCellRendererComponent(tree: JTree?,
value: Any?,
selected: Boolean,
expanded: Boolean,
leaf: Boolean,
row: Int,
hasFocus: Boolean): Component {
val userObject = TreeUtil.getUserObject(value)
mainIconComponent.apply {
icon = step.getIcon(userObject, selected)
isVisible = icon != null
}
mainTextComponent.apply {
background = JBUI.CurrentTheme.Tree.background(selected, true)
foreground = JBUI.CurrentTheme.Tree.foreground(selected, true)
clear()
append(step.getText(userObject).orEmpty())
}
val (inOutIcon, inOutTooltip) = step.getIncomingOutgoingIconWithTooltip(userObject)
tree?.toolTipText = inOutTooltip
incomingOutgoingLabel.apply {
icon = inOutIcon
isVisible = icon != null
}
arrowLabel.apply {
isVisible = step.hasSubstep(userObject)
icon = if (selected) AllIcons.Icons.Ide.MenuArrowSelected else AllIcons.Icons.Ide.MenuArrow
}
secondaryLabel.apply {
text = step.getSecondaryText(userObject)
//todo: LAF color
foreground = if (selected) JBUI.CurrentTheme.Tree.foreground(true, true) else JBColor.GRAY
border = if (!arrowLabel.isVisible && ExperimentalUI.isNewUI()) {
JBUI.Borders.empty(0, 10, 0, JBUI.CurrentTheme.Popup.Selection.innerInsets().right)
} else {
JBUI.Borders.emptyLeft(10)
}
}
if (tree != null && value != null) {
SpeedSearchUtil.applySpeedSearchHighlightingFiltered(tree, value, mainTextComponent, true, selected)
}
return mainPanel
}
companion object {
@JvmField
internal val MAIN_ICON = Key.create<Boolean>("MAIN_ICON")
}
}
}
}
| plugins/git4idea/src/git4idea/ui/branch/GitBranchesTreePopup.kt | 3888238408 |
package com.example.adrian.kotlinsample.feature.weather
import android.content.Context
/**
* Created by franciscoalfacemartin on 22/1/16.
*/
public interface Interactor<T> {
fun executeInteractor(listener : (T) -> Unit)
} | app/src/main/java/com/example/adrian/kotlinsample/feature/weather/Interactor.kt | 1871362239 |
package org.stepik.android.presentation.comment
import io.reactivex.Scheduler
import io.reactivex.Single
import io.reactivex.rxkotlin.Singles
import io.reactivex.rxkotlin.plusAssign
import io.reactivex.rxkotlin.subscribeBy
import io.reactivex.subjects.PublishSubject
import org.stepic.droid.di.qualifiers.BackgroundScheduler
import org.stepic.droid.di.qualifiers.MainScheduler
import ru.nobird.android.domain.rx.emptyOnErrorStub
import org.stepik.android.domain.comment.interactor.CommentInteractor
import org.stepik.android.domain.comment.interactor.ComposeCommentInteractor
import org.stepik.android.domain.comment.model.CommentsData
import org.stepik.android.domain.discussion_proxy.interactor.DiscussionProxyInteractor
import org.stepik.android.domain.discussion_proxy.model.DiscussionOrder
import org.stepik.android.domain.profile.interactor.ProfileGuestInteractor
import org.stepik.android.model.Step
import org.stepik.android.model.Submission
import org.stepik.android.model.comments.Comment
import org.stepik.android.model.comments.DiscussionProxy
import org.stepik.android.model.comments.Vote
import org.stepik.android.presentation.base.PresenterBase
import org.stepik.android.presentation.comment.mapper.CommentsStateMapper
import org.stepik.android.presentation.comment.model.CommentItem
import org.stepik.android.view.injection.step.StepDiscussionBus
import ru.nobird.app.core.model.PaginationDirection
import javax.inject.Inject
class CommentsPresenter
@Inject
constructor(
private val commentInteractor: CommentInteractor,
private val composeCommentInteractor: ComposeCommentInteractor,
private val discussionProxyInteractor: DiscussionProxyInteractor,
private val profileGuestInteractor: ProfileGuestInteractor,
private val commentsStateMapper: CommentsStateMapper,
@StepDiscussionBus
private val stepDiscussionSubject: PublishSubject<Long>,
@BackgroundScheduler
private val backgroundScheduler: Scheduler,
@MainScheduler
private val mainScheduler: Scheduler
) : PresenterBase<CommentsView>() {
private var state: CommentsView.State = CommentsView.State.Idle
set(value) {
field = value
view?.setState(value)
}
override fun attachView(view: CommentsView) {
super.attachView(view)
view.setState(state)
}
/**
* Data initialization variants
*/
fun onDiscussion(discussionProxyId: String, discussionId: Long?, forceUpdate: Boolean = false) {
if (state != CommentsView.State.Idle &&
!((state == CommentsView.State.NetworkError || state is CommentsView.State.DiscussionLoaded) && forceUpdate)
) {
return
}
val discussionOrderSource = (state as? CommentsView.State.DiscussionLoaded)
?.discussionOrder
?.let { Single.just(it) }
?: discussionProxyInteractor.getDiscussionOrder()
compositeDisposable.clear()
state = CommentsView.State.Loading
compositeDisposable += Singles
.zip(
profileGuestInteractor.isGuest(),
discussionProxyInteractor.getDiscussionProxy(discussionProxyId),
discussionOrderSource
)
.observeOn(mainScheduler)
.subscribeOn(backgroundScheduler)
.subscribeBy(
onSuccess = { (isGuest, discussionProxy, discussionOrder) ->
fetchComments(isGuest, discussionProxy, discussionOrder, discussionId)
},
onError = { state = CommentsView.State.NetworkError }
)
}
private fun fetchComments(
isGuest: Boolean,
discussionProxy: DiscussionProxy,
discussionOrder: DiscussionOrder,
discussionId: Long?,
keepCachedComments: Boolean = false
) {
if (discussionProxy.discussions.isEmpty()) {
state = CommentsView.State.DiscussionLoaded(isGuest, discussionProxy, discussionOrder, discussionId, CommentsView.CommentsState.EmptyComments)
} else {
val cachedComments: List<CommentItem.Data> = ((state as? CommentsView.State.DiscussionLoaded)
?.commentsState as? CommentsView.CommentsState.Loaded)
?.commentDataItems
?.takeIf { keepCachedComments }
?: emptyList()
val newState = CommentsView.State.DiscussionLoaded(isGuest, discussionProxy, discussionOrder, discussionId, CommentsView.CommentsState.Loading)
state = newState
compositeDisposable += commentInteractor
.getComments(discussionProxy, discussionOrder, discussionId, cachedComments)
.observeOn(mainScheduler)
.subscribeOn(backgroundScheduler)
.subscribeBy(
onSuccess = {
state = newState.copy(commentsState = CommentsView.CommentsState.Loaded(it, commentsStateMapper.mapCommentDataItemsToRawItems(it)))
if (discussionId != null) {
view?.focusDiscussion(discussionId)
}
},
onError = { state = CommentsView.State.NetworkError }
)
}
}
/**
* Discussion ordering
*/
fun changeDiscussionOrder(discussionOrder: DiscussionOrder) {
val oldState = (state as? CommentsView.State.DiscussionLoaded)
?: return
compositeDisposable += discussionProxyInteractor
.saveDiscussionOrder(discussionOrder)
.observeOn(mainScheduler)
.subscribeOn(backgroundScheduler)
.subscribeBy(onError = emptyOnErrorStub)
fetchComments(oldState.isGuest, oldState.discussionProxy, discussionOrder, oldState.discussionId, keepCachedComments = true)
}
/**
* Load more logic in both directions
*/
fun onLoadMore(direction: PaginationDirection) {
val oldState = (state as? CommentsView.State.DiscussionLoaded)
?: return
val commentsState = (oldState.commentsState as? CommentsView.CommentsState.Loaded)
?: return
val commentDataItems =
commentsState.commentDataItems
val lastCommentId =
when (direction) {
PaginationDirection.PREV ->
commentDataItems
.takeIf { it.hasPrev }
.takeIf { commentsState.commentItems.first() !is CommentItem.Placeholder }
?.first()
?.id
?: return
PaginationDirection.NEXT ->
commentDataItems
.takeIf { it.hasNext }
.takeIf { commentsState.commentItems.last() !is CommentItem.Placeholder }
?.last { it.comment.parent == null }
?.id
?: return
}
state = oldState.copy(commentsState = commentsStateMapper.mapToLoadMoreState(commentsState, direction))
compositeDisposable += commentInteractor
.getMoreComments(oldState.discussionProxy, oldState.discussionOrder, direction, lastCommentId)
.observeOn(mainScheduler)
.subscribeOn(backgroundScheduler)
.subscribeBy(
onSuccess = { state = commentsStateMapper.mapFromLoadMoreToSuccess(state, it, direction) },
onError = { state = commentsStateMapper.mapFromLoadMoreToError(state, direction); view?.showNetworkError() }
)
}
/**
* Load more comments logic
*/
fun onLoadMoreReplies(loadMoreReplies: CommentItem.LoadMoreReplies) {
val oldState = (state as? CommentsView.State.DiscussionLoaded)
?: return
val commentsState = (oldState.commentsState as? CommentsView.CommentsState.Loaded)
?: return
state = oldState.copy(commentsState = commentsStateMapper.mapToLoadMoreRepliesState(commentsState, loadMoreReplies))
compositeDisposable += commentInteractor
.getMoreReplies(loadMoreReplies.parentComment, loadMoreReplies.lastCommentId)
.observeOn(mainScheduler)
.subscribeOn(backgroundScheduler)
.subscribeBy(
onSuccess = { state = commentsStateMapper.mapFromLoadMoreRepliesToSuccess(state, it, loadMoreReplies) },
onError = { state = commentsStateMapper.mapFromLoadMoreRepliesToError(state, loadMoreReplies); view?.showNetworkError() }
)
}
/**
* Vote logic
*
* if [voteValue] is equal to current value new value will be null
*/
fun onChangeVote(commentDataItem: CommentItem.Data, voteValue: Vote.Value) {
if (commentDataItem.voteStatus !is CommentItem.Data.VoteStatus.Resolved ||
commentDataItem.comment.actions?.vote != true) {
return
}
val oldState = (state as? CommentsView.State.DiscussionLoaded)
?: return
val commentsState = (oldState.commentsState as? CommentsView.CommentsState.Loaded)
?: return
val newVote = commentDataItem.voteStatus.vote
.copy(value = voteValue.takeIf { it != commentDataItem.voteStatus.vote.value })
state = oldState.copy(commentsState = commentsStateMapper.mapToVotePending(commentsState, commentDataItem))
compositeDisposable += commentInteractor
.changeCommentVote(commentDataItem.id, newVote)
.observeOn(mainScheduler)
.subscribeOn(backgroundScheduler)
.subscribeBy(
onSuccess = { state = commentsStateMapper.mapFromVotePendingToSuccess(state, it) },
onError = { state = commentsStateMapper.mapFromVotePendingToError(state, commentDataItem.voteStatus.vote); view?.showNetworkError() }
)
}
fun onComposeCommentClicked(step: Step, parent: Long? = null, comment: Comment? = null, submission: Submission? = null) {
val oldState = (state as? CommentsView.State.DiscussionLoaded)
?: return
if (oldState.isGuest) {
view?.showAuthRequired()
} else {
view?.showCommentComposeDialog(step, parent, comment, submission)
}
}
/**
* Edit logic
*/
fun onCommentCreated(commentsData: CommentsData) {
val commentDataItem = commentInteractor
.mapCommentsDataToCommentItem(commentsData)
?: return
state =
if (commentDataItem.comment.parent != null) {
commentsStateMapper.insertCommentReply(state, commentDataItem)
} else {
stepDiscussionSubject.onNext(commentDataItem.comment.target)
commentsStateMapper.insertComment(state, commentDataItem)
}
view?.focusDiscussion(commentDataItem.id)
}
fun onCommentUpdated(commentsData: CommentsData) {
val commentDataItem = commentInteractor
.mapCommentsDataToCommentItem(commentsData)
?: return
state = commentsStateMapper.mapFromVotePendingToSuccess(state, commentDataItem)
}
fun removeComment(commentId: Long) {
val oldState = (state as? CommentsView.State.DiscussionLoaded)
?: return
val commentsState = (oldState.commentsState as? CommentsView.CommentsState.Loaded)
?: return
val commentDataItem = commentsState.commentDataItems.find { it.id == commentId }
?: return
state = oldState.copy(commentsState = commentsStateMapper.mapToRemovePending(commentsState, commentDataItem))
compositeDisposable += composeCommentInteractor
.removeComment(commentDataItem.id)
.observeOn(mainScheduler)
.subscribeOn(backgroundScheduler)
.doOnComplete {
if (commentDataItem.comment.parent == null) {
stepDiscussionSubject.onNext(commentDataItem.comment.target)
}
}
.subscribeBy(
onComplete = { state = commentsStateMapper.mapFromRemovePendingToSuccess(state, commentId) },
onError = { state = commentsStateMapper.mapFromRemovePendingToError(state, commentDataItem); view?.showNetworkError() }
)
}
} | app/src/main/java/org/stepik/android/presentation/comment/CommentsPresenter.kt | 3205547706 |
package io.github.chrislo27.toolboks.ui
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.Input
import com.badlogic.gdx.graphics.Color
import com.badlogic.gdx.graphics.g2d.BitmapFont
import com.badlogic.gdx.graphics.g2d.GlyphLayout
import com.badlogic.gdx.graphics.g2d.SpriteBatch
import com.badlogic.gdx.graphics.glutils.ShapeRenderer
import com.badlogic.gdx.utils.Align
import io.github.chrislo27.toolboks.ToolboksScreen
import io.github.chrislo27.toolboks.util.gdxutils.*
/**
* A single-line text field. Supports carets but not selection.
*/
open class TextField<S : ToolboksScreen<*, *>>(override var palette: UIPalette, parent: UIElement<S>,
parameterStage: Stage<S>)
: UIElement<S>(parent, parameterStage), Palettable, Backgrounded {
companion object {
const val BACKSPACE: Char = 8.toChar()
const val ENTER_DESKTOP = '\r'
const val ENTER_ANDROID = '\n'
const val TAB = '\t'
const val DELETE: Char = 127.toChar()
const val BULLET: Char = 149.toChar()
const val CARET_BLINK_RATE: Float = 0.5f
const val CARET_WIDTH: Float = 2f
const val CARET_MOVE_TIMER: Float = 0.05f
const val INITIAL_CARET_TIMER: Float = 0.4f
const val NEWLINE_WRAP: Char = '\uE056'
}
override var background: Boolean = false
var text: String = ""
set(value) {
val old = field
field = value
if (old != value) {
renderedText = (if (isPassword) BULLET.toString().repeat(text.length) else text).replace("\r\n", "$NEWLINE_WRAP").replace('\r', NEWLINE_WRAP).replace('\n', NEWLINE_WRAP)
val font = getFont()
val wasMarkup = font.data.markupEnabled
font.data.markupEnabled = false
font.scaleMul(palette.fontScale)
layout.setText(font, renderedText)
font.data.markupEnabled = wasMarkup
calculateTextPositions()
onTextChange(old)
font.scaleMul(1f / palette.fontScale)
}
caret = caret.coerceIn(0, text.length)
}
private var renderedText: String = ""
private val textPositions: List<Float> = mutableListOf()
private val layout = GlyphLayout()
private var xOffset: Float = 0f
var textWhenEmpty: String = ""
var textWhenEmptyColor: Color = palette.textColor
var textAlign: Int = Align.left
/**
* 0 = start, the number is the index and then behind that
*/
var caret: Int = 0
set(value) {
caretTimer = 0f
field = value.coerceIn(0, text.length)
if (layout.width > location.realWidth) {
val caretX: Float = textPositions[caret]
if (caretX < xOffset) {
xOffset = Math.max(0f, caretX)
} else if (caretX > xOffset + location.realWidth) {
xOffset = Math.min(layout.width - location.realWidth, caretX - location.realWidth + CARET_WIDTH)
}
} else {
xOffset = 0f
}
}
var hasFocus: Boolean = false
set(value) {
field = value
caretTimer = 0f
}
var canTypeText: (Char) -> Boolean = {
true
}
var characterLimit: Int = -1
private var caretTimer: Float = 0f
private var caretMoveTimer: Float = -1f
var isPassword: Boolean = false
set(value) {
field = value
text = text
}
override var visible: Boolean = super.visible
set(value) {
field = value
if (!value) {
hasFocus = false
}
}
var canPaste = true
var canInputNewlines = false
open fun getFont(): BitmapFont =
palette.font
protected fun calculateTextPositions() {
textPositions as MutableList
textPositions.clear()
val advances = layout.runs.firstOrNull()?.xAdvances ?: run {
textPositions as MutableList
textPositions.addAll(arrayOf(0f, 0f))
return
}
for (i in 0 until advances.size) {
textPositions += if (i == 0) {
advances[i]
} else {
advances[i] + textPositions[i - 1]
}
}
}
open fun onTextChange(oldText: String) {
}
open fun onEnterPressed(): Boolean {
return false
}
override fun render(screen: S, batch: SpriteBatch,
shapeRenderer: ShapeRenderer) {
if (background) {
val old = batch.packedColor
batch.color = palette.backColor
batch.fillRect(location.realX, location.realY, location.realWidth, location.realHeight)
batch.packedColor = old
}
caretTimer += Gdx.graphics.deltaTime
val labelWidth = location.realWidth
val labelHeight = location.realHeight
val font = getFont()
val isUsingEmpty = !hasFocus && renderedText.isEmpty()
val text = if (!isUsingEmpty) renderedText else textWhenEmpty
val textHeight = font.getTextHeight(text, labelWidth, false)
val y: Float
y = location.realY + location.realHeight / 2 + textHeight / 2
val oldColor = font.color
val oldScale = font.scaleX
val wasMarkupEnabled = font.data.markupEnabled
font.color = if (isUsingEmpty) textWhenEmptyColor else palette.textColor
font.data.setScale(palette.fontScale)
font.data.markupEnabled = false
shapeRenderer.prepareStencilMask(batch) {
this.projectionMatrix = batch.projectionMatrix
this.setColor(1f, 1f, 1f, 1f)
this.begin(ShapeRenderer.ShapeType.Filled)
this.rect(location.realX, location.realY, location.realWidth, location.realHeight)
this.end()
}.useStencilMask {
val layout: GlyphLayout = font.draw(batch, text, location.realX - xOffset, y, labelWidth, textAlign,
false)
val caretBlink: Boolean = !isUsingEmpty && hasFocus && (caretTimer % (CARET_BLINK_RATE * 2)) <= 0.5f
if (caretBlink) {
val oldColor = batch.packedColor
batch.color = font.color
val glyphX = if (textPositions.isNotEmpty())
textPositions[caret.coerceIn(0, (textPositions.size - 1).coerceAtLeast(0))]
else 0f
val xWithAlign: Float = when {
textAlign and Align.center == Align.center -> {
glyphX + location.realWidth / 2 - layout.width / 2
}
textAlign and Align.right == Align.right -> {
location.realWidth - layout.width + glyphX
}
else -> {
glyphX
}
}
batch.fillRect(
location.realX - xOffset + xWithAlign,
y - font.capHeight - CARET_WIDTH, CARET_WIDTH,
(font.capHeight + CARET_WIDTH * 2))
batch.packedColor = oldColor
}
}
font.color = oldColor
font.data.setScale(oldScale)
font.data.markupEnabled = wasMarkupEnabled
if (caretMoveTimer > 0) {
caretMoveTimer -= Gdx.graphics.deltaTime
caretMoveTimer = Math.max(caretMoveTimer, 0f)
if (caretMoveTimer == 0f) {
caretMoveTimer = CARET_MOVE_TIMER
if (Gdx.input.isKeyPressed(Input.Keys.LEFT)) {
caret--
} else if (Gdx.input.isKeyPressed(Input.Keys.RIGHT)) {
caret++
}
}
}
}
override fun frameUpdate(screen: S) {
super.frameUpdate(screen)
if (hasFocus) {
val control = Gdx.input.isControlDown()
val alt = Gdx.input.isAltDown()
val shift = Gdx.input.isShiftDown()
if (Gdx.input.isKeyJustPressed(Input.Keys.V) && control && !alt && !shift) {
try {
var data: String = Gdx.app.clipboard.contents?.replace("\r", "") ?: return
if (!canInputNewlines) {
data = data.replace("\n", "")
}
if (data.all(canTypeText) && canPaste) {
text = text.substring(0, caret) + data + text.substring(caret)
if (characterLimit > 0 && text.length > characterLimit) {
text = text.substring(0, characterLimit)
caret = text.length
} else {
caret += data.length
}
caretMoveTimer = 0f
}
} catch (ignored: Exception) {
}
}
}
}
override fun keyTyped(character: Char): Boolean {
if (!hasFocus)
return false
val control = Gdx.input.isControlDown()
val alt = Gdx.input.isAltDown()
val shift = Gdx.input.isShiftDown()
when (character) {
TAB -> return false
BACKSPACE -> {
return if (text.isNotEmpty() && caret > 0) {
val oldCaret = caret
if (control && !alt && !shift && text.isNotEmpty()) {
val lookIn = text.substring(0, caret)
caret = lookIn.indexOfLast { it == ' ' || it == '\n' }
} else {
caret--
}
text = text.substring(0, caret) + text.substring(oldCaret)
true
} else {
false
}
}
DELETE -> {
return if (text.isNotEmpty() && caret < text.length) {
val oldCaret = caret
val newNextIndex = if (control && !alt && !shift && text.isNotEmpty() && caret < text.length) {
val lookIn = text.substring(caret + 1)
val index = lookIn.indexOfFirst { it == ' ' || it == '\n' }
if (index != -1) (index + caret + 1) else text.length
} else (oldCaret + 1)
text = text.substring(0, oldCaret) + text.substring(newNextIndex)
true
} else {
false
}
}
ENTER_ANDROID, ENTER_DESKTOP -> {
return if (canInputNewlines && shift && !alt && !control) {
text = text.substring(0, caret) + "\n" + text.substring(caret)
caret++
caretMoveTimer = 0f
true
} else {
onEnterPressed()
}
}
else -> {
if (character < 32.toChar()) return false
if (!canTypeText(character) || (characterLimit > 0 && text.length >= characterLimit))
return false
text = text.substring(0, caret) + character + text.substring(caret)
caret++
caretMoveTimer = 0f
return true
}
}
}
override fun canBeClickedOn(): Boolean = true
fun checkFocus() {
if (hasFocus && (!isMouseOver() || !visible)) {
hasFocus = false
}
}
override fun touchDown(screenX: Int, screenY: Int, pointer: Int, button: Int): Boolean {
if (hasFocus && (!isMouseOver() || !visible)) {
hasFocus = false
return false
}
if (super.touchDown(screenX, screenY, pointer, button))
return true
return isMouseOver() && hasFocus && visible
}
override fun keyDown(keycode: Int): Boolean {
if (!hasFocus)
return false
val control = Gdx.input.isControlDown()
val alt = Gdx.input.isAltDown()
val shift = Gdx.input.isShiftDown()
when (keycode) {
Input.Keys.LEFT -> {
if (control && !alt && !shift && text.isNotEmpty()) {
val lookIn = text.substring(0, caret)
caret = lookIn.indexOfLast { it == ' ' || it == '\n' }
} else {
caret--
}
caretMoveTimer = INITIAL_CARET_TIMER
return true
}
Input.Keys.RIGHT -> {
if (control && !alt && !shift && text.isNotEmpty() && caret < text.length) {
val lookIn = text.substring(caret + 1)
val index = lookIn.indexOfFirst { it == ' ' || it == '\n' }
caret = if (index != -1) (index + caret + 1) else text.length
} else {
caret++
}
caretMoveTimer = INITIAL_CARET_TIMER
return true
}
Input.Keys.HOME -> {
caret = 0
caretMoveTimer = INITIAL_CARET_TIMER
return true
}
Input.Keys.END -> {
caret = text.length
caretMoveTimer = INITIAL_CARET_TIMER
return true
}
}
return super.keyDown(keycode)
}
override fun keyUp(keycode: Int): Boolean {
if (!hasFocus)
return false
when (keycode) {
Input.Keys.LEFT, Input.Keys.RIGHT -> {
caretMoveTimer = -1f
return true
}
}
return super.keyUp(keycode)
}
override fun onLeftClick(xPercent: Float, yPercent: Float) {
super.onLeftClick(xPercent, yPercent)
if (isMouseOver() && visible)
hasFocus = true
// copied from Kotlin stdlib with modifications
fun <T> List<T>.binarySearch(fromIndex: Int = 0, toIndex: Int = size, comparison: (T) -> Int): Int {
var low = fromIndex
var high = toIndex - 1
while (low <= high) {
val mid = (low + high).ushr(1) // safe from overflows
val midVal = get(mid)
val cmp = comparison(midVal)
if (cmp < 0)
low = mid + 1
else if (cmp > 0)
high = mid - 1
else
return mid // key found
}
return low // key not found
}
val rawpx = xPercent * location.realWidth
val thing = when {
textAlign and Align.center == Align.center -> {
rawpx - (location.realWidth / 2 - layout.width / 2)
}
textAlign and Align.right == Align.right -> {
rawpx - (location.realWidth - layout.width)
}
else -> {
rawpx
}
}
val px = (thing + xOffset)
caret = textPositions.sorted().binarySearch {
it.compareTo(px)
}
}
} | core/src/main/kotlin/io/github/chrislo27/toolboks/ui/TextField.kt | 2532475263 |
package com.jetbrains.edu.learning.courseFormat.tasks
import com.intellij.openapi.project.Project
import com.jetbrains.edu.learning.checker.OutputTaskChecker
/**
* Task type that allows to test output without any test files.
* Correct output is specified in output.txt file which is invisible for student.
* @see OutputTaskChecker
*/
class OutputTask : Task() {
companion object {
@JvmField
val OUTPUT_TASK_TYPE = "output"
}
override fun getTaskType() = OUTPUT_TASK_TYPE
override fun getChecker(project: Project) = OutputTaskChecker(this, project)
}
| python/educational-core/src/com/jetbrains/edu/learning/courseFormat/tasks/OutputTask.kt | 1696143577 |
package ch.difty.scipamato.core.persistence
import ch.difty.scipamato.core.auth.Role
import ch.difty.scipamato.core.entity.User
import ch.difty.scipamato.core.persistence.user.JooqUserRepo
import org.amshove.kluent.shouldBeEmpty
import org.amshove.kluent.shouldBeEqualTo
import org.amshove.kluent.shouldBeGreaterThan
import org.amshove.kluent.shouldBeInstanceOf
import org.amshove.kluent.shouldBeNull
import org.amshove.kluent.shouldContainAll
import org.amshove.kluent.shouldContainSame
import org.amshove.kluent.shouldHaveSize
import org.amshove.kluent.shouldNotBeEmpty
import org.amshove.kluent.shouldNotBeEqualTo
import org.amshove.kluent.shouldNotBeNull
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.fail
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.jooq.JooqTest
import org.testcontainers.junit.jupiter.Testcontainers
@Suppress("TooManyFunctions", "FunctionName", "MagicNumber", "SpellCheckingInspection")
@JooqTest
@Testcontainers
internal open class JooqUserRepoIntegrationTest {
@Autowired
private lateinit var repo: JooqUserRepo
@Test
fun findingAll() {
val users = repo.findAll()
users shouldHaveSize RECORD_COUNT_PREPOPULATED
users.map { it.id } shouldContainAll listOf(1, 2, 3, 4, 5, 6, 7, 8)
}
@Test
fun findingById_withExistingId_returnsEntity() {
val user = repo.findById(4) ?: fail { "Unable to find user" }
user.id shouldBeEqualTo 4
user.roles.map { it.id } shouldContainSame listOf(1, 2)
}
@Test
fun findingById_withNonExistingId_returnsNull() {
repo.findById(-1).shouldBeNull()
}
@Test
fun addingRecord_savesRecordAndRefreshesId() {
val p = makeMinimalUser()
p.id.shouldBeNull()
val saved = repo.add(p) ?: fail { "Unable to add user" }
saved.id?.shouldBeGreaterThan(MAX_ID_PREPOPULATED)
saved.userName shouldBeEqualTo "a"
}
private fun makeMinimalUser(): User {
return User().apply {
userName = "a"
firstName = "b"
lastName = "c"
email = "d"
password = "e"
}
}
@Test
fun updatingRecord() {
val user = repo.add(makeMinimalUser()) ?: fail { "Unable to add user" }
user.id?.shouldBeGreaterThan(MAX_ID_PREPOPULATED)
val id = user.id ?: error("id must no be null now")
user.userName shouldBeEqualTo "a"
user.userName = "b"
repo.update(user)
user.id as Int shouldBeEqualTo id
val newCopy = repo.findById(id) ?: fail { "Unable to find user" }
newCopy shouldNotBeEqualTo user
newCopy.id shouldBeEqualTo id
newCopy.userName shouldBeEqualTo "b"
}
@Test
fun deletingRecord() {
val user = repo.add(makeMinimalUser()) ?: fail { "Unable to add user" }
user.id?.shouldBeGreaterThan(MAX_ID_PREPOPULATED)
val id = user.id ?: error("id must no be null now")
user.userName shouldBeEqualTo "a"
val deleted = repo.delete(id, user.version)
deleted.id shouldBeEqualTo id
repo.findById(id).shouldBeNull()
}
@Test
fun findingUserByName_withNonExistingUserName_returnsNull() {
repo.findByUserName("lkajdsklj").shouldBeNull()
}
@Test
fun findingUserByName_withExistingUserName_returnsUserIncludingRoles() {
val name = "admin"
val admin = repo.findByUserName(name) ?: fail { "Unable to find user" }
admin.userName shouldBeEqualTo name
admin.roles.shouldNotBeEmpty()
}
@Test
fun updatingAssociatedEntities_addsAndRemovesRoles() {
val id = newUserAndSave()
addRoleViewerAndUserToUserWith(id)
addRoleAdminAndRemoveRoleViewerFrom(id)
removeRoleAdminFrom(id)
}
private fun newUserAndSave(): Int {
val u = User().apply {
userName = "test"
firstName = "fn"
lastName = "ln"
isEnabled = false
email = "[email protected]"
password = "xyz"
}
u.id.shouldBeNull()
val savedUser = repo.add(u) ?: fail { "Unable to add user" }
savedUser.shouldNotBeNull()
savedUser.id.shouldNotBeNull()
savedUser.userName shouldBeEqualTo "test"
savedUser.roles.shouldBeEmpty()
savedUser.version shouldBeEqualTo 1
return savedUser.id ?: error("id must no be null now")
}
private fun addRoleViewerAndUserToUserWith(id: Int) {
val user = repo.findById(id) ?: fail { "Unable to find user" }
user.addRole(Role.VIEWER)
user.addRole(Role.USER)
val viewer = repo.update(user) ?: fail { "Unable to update user" }
viewer.roles shouldContainSame listOf(Role.VIEWER, Role.USER)
}
private fun addRoleAdminAndRemoveRoleViewerFrom(id: Int) {
val user = repo.findById(id) ?: fail { "Unable to find user" }
user.addRole(Role.ADMIN)
user.removeRole(Role.VIEWER)
val u = repo.update(user) ?: fail { "Unable to update user" }
u.roles shouldContainSame listOf(Role.USER, Role.ADMIN)
}
private fun removeRoleAdminFrom(id: Int) {
val user = repo.findById(id) ?: fail { "Unable to find user" }
user.removeRole(Role.ADMIN)
val u = repo.update(user) ?: fail { "Unable to update user" }
u.roles shouldContainSame listOf(Role.USER)
}
@Test
fun canUpdateUser_thatHasBeenModifiedElsewhereInTheMeanTime() {
val user = makeAndValidateNewUser()
val secondReloaded = loadSameUserIndependentlyAndModifyAndUpdate(user)
user.lastName = "yetanother"
@Suppress("TooGenericExceptionCaught")
try {
repo.update(user)
fail { "should have thrown exception" }
} catch (ex: Exception) {
ex shouldBeInstanceOf OptimisticLockingException::class
}
val reloaded = repo.findById(user.id!!) ?: fail { "Unable to find user" }
reloaded.version shouldBeEqualTo 2
reloaded.firstName shouldBeEqualTo secondReloaded.firstName
reloaded.lastName shouldBeEqualTo secondReloaded.lastName
reloaded.version shouldBeEqualTo secondReloaded.version
}
private fun makeAndValidateNewUser(): User {
val user = repo.add(makeMinimalUser()) ?: fail { "Unable to add user" }
user.shouldNotBeNull()
user.version shouldBeEqualTo 1
user.id?.shouldBeGreaterThan(MAX_ID_PREPOPULATED)
return user
}
private fun loadSameUserIndependentlyAndModifyAndUpdate(user: User): User {
val secondInstance = repo.findById(user.id!!) ?: fail { "Unable to find user" }
user.version shouldBeEqualTo secondInstance.version
secondInstance.firstName = "changed"
val secondReloaded = repo.update(secondInstance) ?: fail { "Unable to update user" }
secondReloaded.version shouldBeEqualTo 2
return secondReloaded
}
@Test
fun cannotDeleteUser_thatHasBeenModifiedElsewhereInTheMeanTime() {
val user = makeAndValidateNewUser()
val secondReloaded = loadSameUserIndependentlyAndModifyAndUpdate(user)
@Suppress("TooGenericExceptionCaught")
try {
repo.delete(user.id!!, user.version)
fail { "Should have thrown exception" }
} catch (ex: Exception) {
ex shouldBeInstanceOf OptimisticLockingException::class
}
val deletedEntity = repo.delete(user.id!!, secondReloaded.version)
deletedEntity.version shouldBeEqualTo secondReloaded.version
}
companion object {
private const val MAX_ID_PREPOPULATED = 8
private const val RECORD_COUNT_PREPOPULATED = 8
}
}
| core/core-persistence-jooq/src/integration-test/kotlin/ch/difty/scipamato/core/persistence/JooqUserRepoIntegrationTest.kt | 4264413884 |
package org.jetbrains.io.webSocket
import io.netty.channel.Channel
import io.netty.channel.ChannelHandlerContext
import io.netty.channel.ChannelInboundHandlerAdapter
import io.netty.handler.codec.http.FullHttpResponse
import io.netty.handler.codec.http.websocketx.*
import io.netty.util.CharsetUtil
import io.netty.util.ReferenceCountUtil
import org.jetbrains.builtInWebServer.LOG
import org.jetbrains.io.NettyUtil
abstract class WebSocketProtocolHandler : ChannelInboundHandlerAdapter() {
final override fun channelRead(context: ChannelHandlerContext, message: Any) {
// Pong frames need to get ignored
when (message) {
!is WebSocketFrame, is PongWebSocketFrame -> ReferenceCountUtil.release(message)
is PingWebSocketFrame -> context.channel().writeAndFlush(PongWebSocketFrame(message.content()))
is CloseWebSocketFrame -> closeFrameReceived(context.channel(), message)
is TextWebSocketFrame -> {
try {
textFrameReceived(context.channel(), message)
}
finally {
// client should release buffer as soon as possible, so, message could be released already
if (message.refCnt() > 0) {
message.release()
}
}
}
else -> throw UnsupportedOperationException("${message.javaClass.name} frame types not supported")
}
}
protected abstract fun textFrameReceived(channel: Channel, message: TextWebSocketFrame)
protected open fun closeFrameReceived(channel: Channel, message: CloseWebSocketFrame) {
channel.close()
}
@Suppress("OverridingDeprecatedMember")
override fun exceptionCaught(context: ChannelHandlerContext, cause: Throwable) {
NettyUtil.logAndClose(cause, LOG, context.channel())
}
}
open class WebSocketProtocolHandshakeHandler(private val handshaker: WebSocketClientHandshaker) : ChannelInboundHandlerAdapter() {
final override fun channelRead(context: ChannelHandlerContext, message: Any) {
val channel = context.channel()
if (!handshaker.isHandshakeComplete) {
try {
handshaker.finishHandshake(channel, message as FullHttpResponse)
val pipeline = channel.pipeline()
@Suppress("HardCodedStringLiteral")
pipeline.replace(this, "aggregator", WebSocketFrameAggregator(NettyUtil.MAX_CONTENT_LENGTH))
// https codec is removed by finishHandshake
completed()
return
}
finally {
ReferenceCountUtil.release(message)
}
}
if (message is FullHttpResponse) {
throw IllegalStateException("Unexpected FullHttpResponse (getStatus=${message.status()}, content=${message.content().toString(CharsetUtil.UTF_8)})")
}
context.fireChannelRead(message)
}
protected open fun completed() {
}
} | platform/built-in-server/src/org/jetbrains/io/webSocket/WebSocketProtocolHandler.kt | 2494321970 |
// 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 training.learn.lesson.general.assistance
import training.dsl.LessonContext
import training.dsl.LessonSample
import training.dsl.LessonUtil.restoreIfModifiedOrMoved
import training.dsl.TaskRuntimeContext
import training.learn.LessonsBundle
import training.learn.course.KLesson
import kotlin.math.min
class ParameterInfoLesson(private val sample: LessonSample) :
KLesson("CodeAssistance.ParameterInfo", LessonsBundle.message("parameter.info.lesson.name")) {
override val lessonContent: LessonContext.() -> Unit = {
prepareSample(sample)
var caretOffset = 0
prepareRuntimeTask {
caretOffset = editor.caretModel.offset
}
actionTask("ParameterInfo") {
restoreIfModifiedOrMoved()
LessonsBundle.message("parameter.info.use.action", action(it))
}
task {
text(LessonsBundle.message("parameter.info.add.parameters", code("175"), code("100")))
stateCheck { checkParametersAdded(caretOffset) }
test {
type("175, 100")
}
}
}
private val parametersRegex = Regex("""175[ \n]*,[ \n]*100[\s\S]*""")
private fun TaskRuntimeContext.checkParametersAdded(caretOffset: Int): Boolean {
val sequence = editor.document.charsSequence
val partOfSequence = sequence.subSequence(caretOffset, min(caretOffset + 20, sequence.length))
return partOfSequence.matches(parametersRegex)
}
} | plugins/ide-features-trainer/src/training/learn/lesson/general/assistance/ParameterInfoLesson.kt | 361587237 |
package net.serverpeon.discord.internal.jsonmodels
import net.serverpeon.discord.model.DiscordId
import net.serverpeon.discord.model.Guild
import net.serverpeon.discord.model.Role
import java.time.ZonedDateTime
/**
* @property guild_id Only present in GuildMember* events
*/
data class MemberModel(val user: UserModel,
val roles: List<DiscordId<Role>>?,
val mute: Boolean,
val joined_at: ZonedDateTime,
val deaf: Boolean,
val guild_id: DiscordId<Guild>?) | implementation/src/main/kotlin/net/serverpeon/discord/internal/jsonmodels/MemberModel.kt | 3117163463 |
// 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.serialization
import com.amazon.ion.IonType
import java.lang.reflect.Type
import java.util.function.Consumer
internal abstract class BaseCollectionBinding(itemType: Type, context: BindingInitializationContext) : Binding {
private val itemBinding = createElementBindingByType(itemType, context)
protected fun createItemConsumer(context: WriteContext): Consumer<Any?> {
val writer = context.writer
return Consumer {
if (it == null) {
writer.writeNull()
}
else {
itemBinding.serialize(it, context)
}
}
}
fun readInto(hostObject: Any?, result: MutableCollection<Any?>, context: ReadContext) {
val reader = context.reader
reader.stepIn()
while (true) {
@Suppress("MoveVariableDeclarationIntoWhen")
val type = reader.next() ?: break
val item = when (type) {
IonType.NULL -> null
else -> itemBinding.deserialize(context, hostObject)
}
result.add(item)
}
reader.stepOut()
}
} | platform/object-serializer/src/BaseCollectionBinding.kt | 1462117206 |
package co.paystack.android.api.service
import co.paystack.android.api.model.ChargeResponse
import co.paystack.android.api.model.TransactionInitResponse
import co.paystack.android.api.service.converter.NoWrap
import co.paystack.android.model.AvsState
import retrofit2.Call
import retrofit2.http.*
internal interface PaystackApiService {
@GET("/address_verification/states")
suspend fun getAddressVerificationStates(@Query("country") countryCode: String): List<AvsState>
@GET("/checkout/request_inline")
fun initializeTransaction(@QueryMap params: Map<String, @JvmSuppressWildcards Any>): Call<TransactionInitResponse>
@FormUrlEncoded
@POST("/checkout/card/charge")
@NoWrap
fun chargeCard(@FieldMap params: Map<String, @JvmSuppressWildcards Any>): Call<ChargeResponse>
@NoWrap
@FormUrlEncoded
@POST("/checkout/card/validate")
fun validateOtp(@FieldMap params: Map<String, @JvmSuppressWildcards Any>): Call<ChargeResponse>
@NoWrap
@FormUrlEncoded
@POST("/checkout/card/avs")
fun validateAddress(@FieldMap fields: Map<String, String>): Call<ChargeResponse>
@NoWrap
@GET("/checkout/requery/{transactionId}")
fun requeryTransaction(@Path("transactionId") transactionId: String): Call<ChargeResponse>
} | paystack/src/main/java/co/paystack/android/api/service/PaystackApiService.kt | 996964113 |
/*
* Copyright (C) 2021 Veli Tasalı
*
* 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 2
* 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
package org.monora.uprotocol.client.android.di
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import org.monora.uprotocol.core.TransportSeat
import org.monora.uprotocol.core.TransportSession
import org.monora.uprotocol.core.persistence.PersistenceProvider
import org.monora.uprotocol.core.protocol.ConnectionFactory
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
class TransportSessionModule {
@Singleton
@Provides
fun provideTransportSession(
connectionFactory: ConnectionFactory,
persistenceProvider: PersistenceProvider,
transportSeat: TransportSeat,
): TransportSession {
return TransportSession(connectionFactory, persistenceProvider, transportSeat)
}
} | app/src/main/java/org/monora/uprotocol/client/android/di/TransportSessionModule.kt | 3675523034 |
package it.ncorti.emgvisualizer.ui.scan
import it.ncorti.emgvisualizer.BasePresenter
import it.ncorti.emgvisualizer.BaseView
import it.ncorti.emgvisualizer.ui.model.Device
interface ScanDeviceContract {
interface View : BaseView {
fun showStartMessage()
fun showEmptyListMessage()
fun hideEmptyListMessage()
fun wipeDeviceList()
fun addDeviceToList(device: Device)
fun populateDeviceList(list: List<Device>)
fun showScanLoading()
fun hideScanLoading()
fun showScanError()
fun showScanCompleted()
fun navigateToControlDevice()
}
abstract class Presenter(override val view: BaseView) : BasePresenter<BaseView>(view) {
abstract fun onScanToggleClicked()
abstract fun onDeviceSelected(index: Int)
}
}
| app/src/main/java/it/ncorti/emgvisualizer/ui/scan/ScanDeviceContract.kt | 3850542581 |
package todomvcfx.tornadofx.viewmodel
import javafx.beans.property.SimpleBooleanProperty
import javafx.beans.property.SimpleIntegerProperty
import javafx.beans.property.SimpleStringProperty
import tornadofx.getValue
import tornadofx.setValue
/**
* Model component for the TornadoFX version of the TodoItem app
*
* TodoItem is a property-based domain object for the app. It includes an id generation function.
*
* Created by ronsmits on 24/09/16.
*/
class TodoItem(text: String, completed: Boolean) {
val idProperty = SimpleIntegerProperty( nextId() )
var id by idProperty
val textProperty = SimpleStringProperty(text)
val completedProperty = SimpleBooleanProperty(completed)
var completed by completedProperty
companion object {
private var idgen = 1 // faux static class member
fun nextId() = idgen++
}
} | examples/tornadofx/src/main/kotlin/todomvcfx/tornadofx/viewmodel/TodoItem.kt | 3956159531 |
// 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.diff.tools.util.base
import com.intellij.diff.tools.util.breadcrumbs.BreadcrumbsPlacement
import com.intellij.diff.util.DiffPlaces
import com.intellij.diff.util.DiffUtil
import com.intellij.openapi.Disposable
import com.intellij.openapi.components.PersistentStateComponent
import com.intellij.openapi.components.State
import com.intellij.openapi.components.Storage
import com.intellij.openapi.components.service
import com.intellij.openapi.util.Key
import com.intellij.util.EventDispatcher
import com.intellij.util.xmlb.annotations.OptionTag
import com.intellij.util.xmlb.annotations.Transient
import com.intellij.util.xmlb.annotations.XMap
import java.util.*
@State(name = "TextDiffSettings", storages = [(Storage(value = DiffUtil.DIFF_CONFIG))])
class TextDiffSettingsHolder : PersistentStateComponent<TextDiffSettingsHolder.State> {
companion object {
@JvmField val CONTEXT_RANGE_MODES: IntArray = intArrayOf(1, 2, 4, 8, -1)
@JvmField val CONTEXT_RANGE_MODE_LABELS: Array<String> = arrayOf("1", "2", "4", "8", "Disable")
}
data class SharedSettings(
// Fragments settings
var CONTEXT_RANGE: Int = 4,
var MERGE_AUTO_APPLY_NON_CONFLICTED_CHANGES: Boolean = false,
var MERGE_LST_GUTTER_MARKERS: Boolean = true
)
data class PlaceSettings(
// Diff settings
var HIGHLIGHT_POLICY: HighlightPolicy = HighlightPolicy.BY_WORD,
var IGNORE_POLICY: IgnorePolicy = IgnorePolicy.DEFAULT,
// Presentation settings
var ENABLE_SYNC_SCROLL: Boolean = true,
// Editor settings
var SHOW_WHITESPACES: Boolean = false,
var SHOW_LINE_NUMBERS: Boolean = true,
var SHOW_INDENT_LINES: Boolean = false,
var USE_SOFT_WRAPS: Boolean = false,
var HIGHLIGHTING_LEVEL: HighlightingLevel = HighlightingLevel.INSPECTIONS,
var READ_ONLY_LOCK: Boolean = true,
var BREADCRUMBS_PLACEMENT: BreadcrumbsPlacement = BreadcrumbsPlacement.HIDDEN,
// Fragments settings
var EXPAND_BY_DEFAULT: Boolean = true
) {
@Transient
val eventDispatcher: EventDispatcher<TextDiffSettings.Listener> = EventDispatcher.create(TextDiffSettings.Listener::class.java)
}
class TextDiffSettings internal constructor(private val SHARED_SETTINGS: SharedSettings,
private val PLACE_SETTINGS: PlaceSettings,
val place: String?) {
constructor() : this(SharedSettings(), PlaceSettings(), null)
fun addListener(listener: Listener, disposable: Disposable) {
PLACE_SETTINGS.eventDispatcher.addListener(listener, disposable)
}
// Presentation settings
var isEnableSyncScroll: Boolean
get() = PLACE_SETTINGS.ENABLE_SYNC_SCROLL
set(value) { PLACE_SETTINGS.ENABLE_SYNC_SCROLL = value }
// Diff settings
var highlightPolicy: HighlightPolicy
get() = PLACE_SETTINGS.HIGHLIGHT_POLICY
set(value) { PLACE_SETTINGS.HIGHLIGHT_POLICY = value
PLACE_SETTINGS.eventDispatcher.multicaster.highlightPolicyChanged() }
var ignorePolicy: IgnorePolicy
get() = PLACE_SETTINGS.IGNORE_POLICY
set(value) { PLACE_SETTINGS.IGNORE_POLICY = value
PLACE_SETTINGS.eventDispatcher.multicaster.ignorePolicyChanged() }
//
// Merge
//
var isAutoApplyNonConflictedChanges: Boolean
get() = SHARED_SETTINGS.MERGE_AUTO_APPLY_NON_CONFLICTED_CHANGES
set(value) { SHARED_SETTINGS.MERGE_AUTO_APPLY_NON_CONFLICTED_CHANGES = value }
var isEnableLstGutterMarkersInMerge: Boolean
get() = SHARED_SETTINGS.MERGE_LST_GUTTER_MARKERS
set(value) { SHARED_SETTINGS.MERGE_LST_GUTTER_MARKERS = value }
// Editor settings
var isShowLineNumbers: Boolean
get() = PLACE_SETTINGS.SHOW_LINE_NUMBERS
set(value) { PLACE_SETTINGS.SHOW_LINE_NUMBERS = value }
var isShowWhitespaces: Boolean
get() = PLACE_SETTINGS.SHOW_WHITESPACES
set(value) { PLACE_SETTINGS.SHOW_WHITESPACES = value }
var isShowIndentLines: Boolean
get() = PLACE_SETTINGS.SHOW_INDENT_LINES
set(value) { PLACE_SETTINGS.SHOW_INDENT_LINES = value }
var isUseSoftWraps: Boolean
get() = PLACE_SETTINGS.USE_SOFT_WRAPS
set(value) { PLACE_SETTINGS.USE_SOFT_WRAPS = value }
var highlightingLevel: HighlightingLevel
get() = PLACE_SETTINGS.HIGHLIGHTING_LEVEL
set(value) { PLACE_SETTINGS.HIGHLIGHTING_LEVEL = value }
var contextRange: Int
get() = SHARED_SETTINGS.CONTEXT_RANGE
set(value) { SHARED_SETTINGS.CONTEXT_RANGE = value }
var isExpandByDefault: Boolean
get() = PLACE_SETTINGS.EXPAND_BY_DEFAULT
set(value) { PLACE_SETTINGS.EXPAND_BY_DEFAULT = value }
var isReadOnlyLock: Boolean
get() = PLACE_SETTINGS.READ_ONLY_LOCK
set(value) { PLACE_SETTINGS.READ_ONLY_LOCK = value }
var breadcrumbsPlacement: BreadcrumbsPlacement
get() = PLACE_SETTINGS.BREADCRUMBS_PLACEMENT
set(value) { PLACE_SETTINGS.BREADCRUMBS_PLACEMENT = value
PLACE_SETTINGS.eventDispatcher.multicaster.breadcrumbsPlacementChanged() }
//
// Impl
//
companion object {
@JvmField val KEY: Key<TextDiffSettings> = Key.create("TextDiffSettings")
@JvmStatic fun getSettings(): TextDiffSettings = getSettings(null)
@JvmStatic fun getSettings(place: String?): TextDiffSettings = service<TextDiffSettingsHolder>().getSettings(place)
internal fun getDefaultSettings(place: String): TextDiffSettings =
TextDiffSettings(SharedSettings(), service<TextDiffSettingsHolder>().defaultPlaceSettings(place), place)
}
interface Listener : EventListener {
fun highlightPolicyChanged() {}
fun ignorePolicyChanged() {}
fun breadcrumbsPlacementChanged() {}
abstract class Adapter : Listener
}
}
fun getSettings(place: String?): TextDiffSettings {
val placeKey = place ?: DiffPlaces.DEFAULT
val placeSettings = myState.PLACES_MAP.getOrPut(placeKey) { defaultPlaceSettings(placeKey) }
return TextDiffSettings(myState.SHARED_SETTINGS, placeSettings, placeKey)
}
private fun copyStateWithoutDefaults(): State {
val result = State()
result.SHARED_SETTINGS = myState.SHARED_SETTINGS
result.PLACES_MAP = DiffUtil.trimDefaultValues(myState.PLACES_MAP) { defaultPlaceSettings(it) }
return result
}
private fun defaultPlaceSettings(place: String): PlaceSettings {
val settings = PlaceSettings()
if (place == DiffPlaces.CHANGES_VIEW) {
settings.EXPAND_BY_DEFAULT = false
settings.SHOW_LINE_NUMBERS = false
}
if (place == DiffPlaces.COMMIT_DIALOG) {
settings.EXPAND_BY_DEFAULT = false
}
if (place == DiffPlaces.VCS_LOG_VIEW) {
settings.EXPAND_BY_DEFAULT = false
}
return settings
}
class State {
@OptionTag
@XMap
@JvmField var PLACES_MAP: TreeMap<String, PlaceSettings> = TreeMap()
@JvmField var SHARED_SETTINGS: SharedSettings = SharedSettings()
}
private var myState: State = State()
override fun getState(): State {
return copyStateWithoutDefaults()
}
override fun loadState(state: State) {
myState = state
}
} | platform/diff-impl/src/com/intellij/diff/tools/util/base/TextDiffSettingsHolder.kt | 1059032874 |
// 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.jsonProtocol
import com.google.gson.stream.JsonWriter
import com.intellij.util.containers.isNullOrEmpty
import com.intellij.util.io.writeUtf8
import gnu.trove.TIntArrayList
import gnu.trove.TIntHashSet
import io.netty.buffer.ByteBuf
import io.netty.buffer.ByteBufAllocator
import io.netty.buffer.ByteBufUtf8Writer
import org.jetbrains.io.JsonUtil
open class OutMessage {
val buffer: ByteBuf = ByteBufAllocator.DEFAULT.buffer()
val writer: JsonWriter = JsonWriter(ByteBufUtf8Writer(buffer))
private var finalized: Boolean = false
init {
writer.beginObject()
}
open fun beginArguments() {
}
fun writeMap(name: String, value: Map<String, String>? = null) {
if (value == null) return
beginArguments()
writer.name(name)
writer.beginObject()
for ((key, value1) in value) {
writer.name(key).value(value1)
}
writer.endObject()
}
protected fun writeLongArray(name: String, value: LongArray) {
beginArguments()
writer.name(name)
writer.beginArray()
for (v in value) {
writer.value(v)
}
writer.endArray()
}
fun writeDoubleArray(name: String, value: DoubleArray) {
beginArguments()
writer.name(name)
writer.beginArray()
for (v in value) {
writer.value(v)
}
writer.endArray()
}
fun writeIntArray(name: String, value: IntArray? = null) {
if (value == null) {
return
}
beginArguments()
writer.name(name)
writer.beginArray()
for (v in value) {
writer.value(v.toLong())
}
writer.endArray()
}
fun writeIntSet(name: String, value: TIntHashSet) {
beginArguments()
writer.name(name)
writer.beginArray()
value.forEach { value ->
writer.value(value.toLong())
true
}
writer.endArray()
}
fun writeIntList(name: String, value: TIntArrayList) {
beginArguments()
writer.name(name)
writer.beginArray()
for (i in 0..value.size() - 1) {
writer.value(value.getQuick(i).toLong())
}
writer.endArray()
}
fun writeSingletonIntArray(name: String, value: Int) {
beginArguments()
writer.name(name)
writer.beginArray()
writer.value(value.toLong())
writer.endArray()
}
fun <E : OutMessage> writeList(name: String, value: List<E>?) {
if (value.isNullOrEmpty()) {
return
}
beginArguments()
writer.name(name)
writer.beginArray()
var isNotFirst = false
for (item in value!!) {
try {
if (isNotFirst) {
buffer.writeByte(','.toInt()).writeByte(' '.toInt())
}
else {
isNotFirst = true
}
if (!item.finalized) {
item.finalized = true
try {
item.writer.endObject()
}
catch (e: IllegalStateException) {
if ("Nesting problem." == e.message) {
throw RuntimeException(item.buffer.toString(Charsets.UTF_8) + "\nparent:\n" + buffer.toString(Charsets.UTF_8), e)
}
else {
throw e
}
}
}
buffer.writeBytes(item.buffer)
} finally {
if (item.buffer.refCnt() > 0) {
item.buffer.release()
}
}
}
writer.endArray()
}
fun writeStringList(name: String, value: Collection<String>?) {
if (value == null) return
beginArguments()
JsonWriters.writeStringList(writer, name, value)
}
fun writeEnumList(name: String, values: Collection<Enum<*>>) {
beginArguments()
writer.name(name).beginArray()
for (item in values) {
writer.value(item.toString())
}
writer.endArray()
}
fun writeMessage(name: String, value: OutMessage?) {
if (value == null) {
return
}
try {
beginArguments()
prepareWriteRaw(this, name)
if (!value.finalized) {
value.close()
}
buffer.writeBytes(value.buffer)
}
finally {
if (value.buffer.refCnt() > 0) {
value.buffer.release()
}
}
}
fun close() {
assert(!finalized)
finalized = true
writer.endObject()
writer.close()
}
protected fun writeLong(name: String, value: Long) {
beginArguments()
writer.name(name).value(value)
}
fun writeString(name: String, value: String?) {
if (value != null) {
writeNullableString(name, value)
}
}
fun writeNullableString(name: String, value: CharSequence?) {
beginArguments()
writer.name(name).value(value?.toString())
}
}
fun prepareWriteRaw(message: OutMessage, name: String) {
message.writer.name(name).nullValue()
val itemBuffer = message.buffer
itemBuffer.writerIndex(itemBuffer.writerIndex() - "null".length)
}
fun doWriteRaw(message: OutMessage, rawValue: String) {
message.buffer.writeUtf8(rawValue)
}
fun OutMessage.writeEnum(name: String, value: Enum<*>?, defaultValue: Enum<*>?) {
if (value != null && value != defaultValue) {
writeEnum(name, value)
}
}
fun OutMessage.writeEnum(name: String, value: Enum<*>) {
beginArguments()
writer.name(name).value(value.toString())
}
fun OutMessage.writeString(name: String, value: CharSequence?, defaultValue: CharSequence?) {
if (value != null && value != defaultValue) {
writeString(name, value)
}
}
fun OutMessage.writeString(name: String, value: CharSequence) {
beginArguments()
prepareWriteRaw(this, name)
JsonUtil.escape(value, buffer)
}
fun OutMessage.writeInt(name: String, value: Int, defaultValue: Int) {
if (value != defaultValue) {
writeInt(name, value)
}
}
fun OutMessage.writeInt(name: String, value: Int?) {
if (value != null) {
beginArguments()
writer.name(name).value(value.toLong())
}
}
fun OutMessage.writeBoolean(name: String, value: Boolean, defaultValue: Boolean) {
if (value != defaultValue) {
writeBoolean(name, value)
}
}
fun OutMessage.writeBoolean(name: String, value: Boolean?) {
if (value != null) {
beginArguments()
writer.name(name).value(value)
}
}
fun OutMessage.writeDouble(name: String, value: Double?, defaultValue: Double?) {
if (value != null && value != defaultValue) {
writeDouble(name, value)
}
}
fun OutMessage.writeDouble(name: String, value: Double) {
beginArguments()
writer.name(name).value(value)
}
| platform/script-debugger/protocol/protocol-reader-runtime/src/org/jetbrains/jsonProtocol/OutMessage.kt | 3380220165 |
// 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.vcs.commit
import com.intellij.openapi.diagnostic.logger
import com.intellij.openapi.project.Project
import com.intellij.openapi.vcs.AbstractVcs
import com.intellij.openapi.vcs.VcsBundle.message
import com.intellij.openapi.vcs.changes.*
import com.intellij.openapi.vcs.changes.ui.CommitChangeListDialog.DIALOG_TITLE
import com.intellij.openapi.vcs.checkin.CheckinChangeListSpecificComponent
import com.intellij.openapi.vcs.checkin.CheckinHandler
import com.intellij.openapi.vcs.impl.PartialChangesUtil
import com.intellij.util.ui.UIUtil.removeMnemonic
import com.intellij.vcs.commit.SingleChangeListCommitter.Companion.moveToFailedList
private val LOG = logger<SingleChangeListCommitWorkflow>()
internal val CommitOptions.changeListSpecificOptions: Sequence<CheckinChangeListSpecificComponent>
get() = allOptions.filterIsInstance<CheckinChangeListSpecificComponent>()
internal fun CommitOptions.changeListChanged(changeList: LocalChangeList) = changeListSpecificOptions.forEach {
it.onChangeListSelected(changeList)
}
internal fun CommitOptions.saveChangeListSpecificOptions() = changeListSpecificOptions.forEach { it.saveState() }
internal fun removeEllipsisSuffix(s: String) = s.removeSuffix("...").removeSuffix("\u2026")
internal fun CommitExecutor.getPresentableText() = removeEllipsisSuffix(removeMnemonic(actionText))
open class SingleChangeListCommitWorkflow(
project: Project,
affectedVcses: Set<AbstractVcs>,
val initiallyIncluded: Collection<*>,
val initialChangeList: LocalChangeList? = null,
executors: List<CommitExecutor> = emptyList(),
final override val isDefaultCommitEnabled: Boolean = executors.isEmpty(),
private val isDefaultChangeListFullyIncluded: Boolean = true,
val initialCommitMessage: String? = null,
private val resultHandler: CommitResultHandler? = null
) : AbstractCommitWorkflow(project) {
init {
updateVcses(affectedVcses)
initCommitExecutors(executors)
}
val isPartialCommitEnabled: Boolean =
vcses.any { it.arePartialChangelistsSupported() } && (isDefaultCommitEnabled || commitExecutors.any { it.supportsPartialCommit() })
internal val commitMessagePolicy: SingleChangeListCommitMessagePolicy = SingleChangeListCommitMessagePolicy(project, initialCommitMessage)
internal lateinit var commitState: ChangeListCommitState
override fun processExecuteDefaultChecksResult(result: CheckinHandler.ReturnResult) = when (result) {
CheckinHandler.ReturnResult.COMMIT -> DefaultNameChangeListCleaner(project, commitState).use { doCommit(commitState) }
CheckinHandler.ReturnResult.CLOSE_WINDOW ->
moveToFailedList(project, commitState, message("commit.dialog.rejected.commit.template", commitState.changeList.name))
CheckinHandler.ReturnResult.CANCEL -> Unit
}
override fun executeCustom(executor: CommitExecutor, session: CommitSession): Boolean =
executeCustom(executor, session, commitState.changes, commitState.commitMessage)
override fun processExecuteCustomChecksResult(executor: CommitExecutor, session: CommitSession, result: CheckinHandler.ReturnResult) =
when (result) {
CheckinHandler.ReturnResult.COMMIT -> doCommitCustom(executor, session)
CheckinHandler.ReturnResult.CLOSE_WINDOW ->
moveToFailedList(project, commitState, message("commit.dialog.rejected.commit.template", commitState.changeList.name))
CheckinHandler.ReturnResult.CANCEL -> Unit
}
override fun doRunBeforeCommitChecks(checks: Runnable) =
PartialChangesUtil.runUnderChangeList(project, commitState.changeList, checks)
protected open fun doCommit(commitState: ChangeListCommitState) {
LOG.debug("Do actual commit")
with(object : SingleChangeListCommitter(project, commitState, commitContext, DIALOG_TITLE, isDefaultChangeListFullyIncluded) {
override fun afterRefreshChanges() = endExecution { super.afterRefreshChanges() }
}) {
addResultHandler(CommitHandlersNotifier(commitHandlers))
addResultHandler(getCommitEventDispatcher())
addResultHandler(resultHandler ?: ShowNotificationCommitResultHandler(this))
runCommit(DIALOG_TITLE, false)
}
}
private fun doCommitCustom(executor: CommitExecutor, session: CommitSession) {
val cleaner = DefaultNameChangeListCleaner(project, commitState)
with(CustomCommitter(project, session, commitState.changes, commitState.commitMessage)) {
addResultHandler(CommitHandlersNotifier(commitHandlers))
addResultHandler(CommitResultHandler { cleaner.clean() })
addResultHandler(getCommitCustomEventDispatcher())
resultHandler?.let { addResultHandler(it) }
addResultHandler(getEndExecutionHandler())
runCommit(executor.actionText)
}
}
}
private class DefaultNameChangeListCleaner(val project: Project, commitState: ChangeListCommitState) {
private val isChangeListFullyIncluded = commitState.changeList.changes.size == commitState.changes.size
private val isDefaultNameChangeList = commitState.changeList.hasDefaultName()
fun use(block: () -> Unit) {
block()
clean()
}
fun clean() {
if (isDefaultNameChangeList && isChangeListFullyIncluded) {
ChangeListManager.getInstance(project).editComment(LocalChangeList.getDefaultName(), "")
}
}
} | platform/vcs-impl/src/com/intellij/vcs/commit/SingleChangeListCommitWorkflow.kt | 1704131757 |
package pl.malopolska.smoksmog.model
import org.joda.time.LocalDate
data class History(
val value: Float,
val date: LocalDate) {
}
| network/src/main/kotlin/pl/malopolska/smoksmog/model/History.kt | 296668003 |
// 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.internal.statistics.logger
import com.google.gson.JsonObject
import com.google.gson.JsonParser
import com.intellij.internal.statistic.eventLog.*
import com.intellij.internal.statistics.StatisticsTestEventFactory.newEvent
import com.intellij.internal.statistics.StatisticsTestEventFactory.newStateEvent
import com.intellij.internal.statistics.StatisticsTestEventValidator.assertLogEventIsValid
import com.intellij.internal.statistics.StatisticsTestEventValidator.isValid
import com.intellij.openapi.util.io.FileUtil
import org.junit.Test
import kotlin.test.assertEquals
import kotlin.test.assertNull
import kotlin.test.assertTrue
class FeatureEventLogSerializationTest {
@Test
fun testEventWithoutData() {
testEventSerialization(newEvent(groupId = "test.group", eventId = "test.event"), false)
}
@Test
fun testEventWithData() {
val event = newEvent(groupId = "test.group", eventId = "test.event")
event.event.addData("param", 23L)
testEventSerialization(event, false, "param")
}
@Test
fun testGroupId() {
testEventSerialization(newEvent(groupId = "test group", eventId = "test.event"), false)
testEventSerialization(newEvent(groupId = "test.group", eventId = "test.event"), false)
testEventSerialization(newEvent(groupId = "test-group", eventId = "test.event"), false)
testEventSerialization(newEvent(groupId = "test-group-42", eventId = "test.event"), false)
}
@Test
fun testGroupIdWithUnicode() {
testEventSerialization(newEvent(groupId = "group-id\u7A97\u013C", eventId = "event-id"), false)
testEventSerialization(newEvent(groupId = "group\u5F39id", eventId = "event-id"), false)
testEventSerialization(newEvent(groupId = "group-id\u02BE", eventId = "event-id"), false)
testEventSerialization(newEvent(groupId = "��group-id", eventId = "event-id"), false)
}
@Test
fun testEventId() {
testEventSerialization(newEvent(groupId = "test-group", eventId = "test\tevent"), false)
testEventSerialization(newEvent(groupId = "test-group", eventId = "test\"event"), false)
testEventSerialization(newEvent(groupId = "test-group", eventId = "test\'event"), false)
testEventSerialization(newEvent(groupId = "test-group", eventId = "test event"), false)
testEventSerialization(newEvent(groupId = "test-group", eventId = "42-testevent"), false)
}
@Test
fun testEventIdWithUnicode() {
testEventSerialization(newEvent(groupId = "group-id", eventId = "event\u7A97type"), false)
testEventSerialization(newEvent(groupId = "group-id", eventId = "event\u5F39type\u02BE\u013C"), false)
testEventSerialization(newEvent(groupId = "group-id", eventId = "event\u02BE"), false)
testEventSerialization(newEvent(groupId = "group-id", eventId = "\uFFFD\uFFFD\uFFFDevent"), false)
}
@Test
fun testEventIdWithUnicodeAndSystemSymbols() {
testEventSerialization(newEvent(groupId = "group-id", eventId = "e'vent \u7A97typ\"e"), false)
testEventSerialization(newEvent(groupId = "group-id", eventId = "ev:e;nt\u5F39ty pe\u02BE\u013C"), false)
}
@Test
fun testEventDataWithTabInName() {
val event = newEvent()
event.event.addData("my key", "value")
testEventSerialization(event, false, "my_key")
}
@Test
fun testEventDataWithTabInValue() {
val event = newEvent()
event.event.addData("key", "my value")
testEventSerialization(event, false, "key")
}
@Test
fun testEventDataWithUnicodeInName() {
val event = newEvent()
event.event.addData("my\uFFFDkey", "value")
event.event.addData("some\u013C\u02BE\u037C", "value")
event.event.addData("\u013C\u037Ckey", "value")
testEventSerialization(event, false, "my?key", "some???", "??key")
}
@Test
fun testEventDataWithUnicodeInValue() {
val event = newEvent(groupId = "group-id", eventId = "test-event")
event.event.addData("first-key", "my\uFFFDvalue")
event.event.addData("second-key", "some\u013C\u02BE\u037C")
event.event.addData("third-key", "\u013C\u037Cvalue")
testEventSerialization(event, false, "first-key", "second-key", "third-key")
}
@Test
fun testEventDataWithListInValue() {
val event = newEvent(groupId = "group-id", eventId = "test-event")
event.event.addData("key", listOf("my value", "some value", "value"))
testEventSerialization(event, false, "key")
}
@Test
fun testEventRequestWithSingleRecord() {
val events = ArrayList<LogEvent>()
events.add(newEvent(groupId = "test.group.id", eventId = "first-id"))
events.add(newEvent(groupId = "test.group.id.2", eventId = "second-id"))
val request = requestByEvents("recorder-id","IU", "generated-device-id", false, events)
val json = JsonParser().parse(LogEventSerializer.toString(request)).asJsonObject
assertLogEventContentIsValid(json, "recorder-id", "IU", "generated-device-id", false, false)
}
@Test
fun testEventRequestWithMultipleRecords() {
val first = ArrayList<LogEvent>()
first.add(newEvent(groupId = "test.group.id", eventId = "first-id"))
first.add(newEvent(groupId = "test.group.id.2", eventId = "second-id"))
val second = ArrayList<LogEvent>()
second.add(newEvent(groupId = "test.group.id", eventId = "third-id"))
second.add(newEvent(groupId = "test.group.id.2", eventId = "forth-id"))
val records = ArrayList<LogEventRecord>()
records.add(LogEventRecord(first))
records.add(LogEventRecord(second))
val request = LogEventRecordRequest("recorder.id","IU", "generated-device-id", records, false)
val json = JsonParser().parse(LogEventSerializer.toString(request)).asJsonObject
assertLogEventContentIsValid(json, "recorder.id", "IU", "generated-device-id", false, false)
}
@Test
fun testEventRequestWithCustomProductCode() {
val events = ArrayList<LogEvent>()
events.add(newEvent(groupId = "test.group.id", eventId = "first-id"))
events.add(newEvent(groupId = "test.group.id.2", eventId = "second-id"))
val request = requestByEvents("recorder.id","IC", "generated-device-id", false, events)
val json = JsonParser().parse(LogEventSerializer.toString(request)).asJsonObject
assertLogEventContentIsValid(json, "recorder.id", "IC", "generated-device-id", false, false)
}
@Test
fun testEventRequestWithCustomDeviceId() {
val events = ArrayList<LogEvent>()
events.add(newEvent(groupId = "test.group.id", eventId = "first-id"))
events.add(newEvent(groupId = "test.group.id.2", eventId = "second-id"))
val request = requestByEvents("recorder.id","IU", "my-test-id", false, events)
val json = JsonParser().parse(LogEventSerializer.toString(request)).asJsonObject
assertLogEventContentIsValid(json, "recorder.id", "IU", "my-test-id", false, false)
}
@Test
fun testEventRequestWithInternal() {
val events = ArrayList<LogEvent>()
events.add(newEvent(groupId = "test.group.id", eventId = "first-id"))
events.add(newEvent(groupId = "test.group.id.2", eventId = "second-id"))
val request = requestByEvents("recorder.id","IU", "generated-device-id", true, events)
val json = JsonParser().parse(LogEventSerializer.toString(request)).asJsonObject
assertLogEventContentIsValid(json, "recorder.id", "IU", "generated-device-id", true, false)
}
@Test
fun testEventCustomRequest() {
val events = ArrayList<LogEvent>()
events.add(newEvent(groupId = "test.group.id", eventId = "first-id"))
events.add(newEvent(groupId = "test.group.id.2", eventId = "second-id"))
val request = requestByEvents("recorder.id","PY", "abcdefg", true, events)
val json = JsonParser().parse(LogEventSerializer.toString(request)).asJsonObject
assertLogEventContentIsValid(json, "recorder.id", "PY", "abcdefg", true, false)
}
@Test
fun testEventRequestWithStateEvents() {
val events = ArrayList<LogEvent>()
events.add(newStateEvent(groupId = "config.group.id", eventId = "first-id"))
events.add(newStateEvent(groupId = "config.group.id.2", eventId = "second-id"))
val request = requestByEvents("recorder.id", "IU", "generated-device-id", false, events)
val json = JsonParser().parse(LogEventSerializer.toString(request)).asJsonObject
assertLogEventContentIsValid(json, "recorder.id", "IU", "generated-device-id", false, true)
}
@Test
fun testEventCustomRequestWithStateEvents() {
val events = ArrayList<LogEvent>()
events.add(newStateEvent(groupId = "config.group.id", eventId = "first-id"))
events.add(newStateEvent(groupId = "config.group.id.2", eventId = "second-id"))
val request = requestByEvents("recorder.id", "IC", "abcdefg", true, events)
val json = JsonParser().parse(LogEventSerializer.toString(request)).asJsonObject
assertLogEventContentIsValid(json, "recorder.id", "IC", "abcdefg", true, true)
}
@Test
fun testEventWithBuildNumber() {
testEventSerialization(newEvent(build = "182.2567.1"), false)
}
@Test
fun testStateEvent() {
testEventSerialization(newStateEvent(groupId = "config.group.id", eventId = "my.config", build = "182.2567.1"), true)
}
@Test
fun testDeserializationNoEvents() {
testDeserialization()
}
@Test
fun testDeserializationSingleEvent() {
val events = ArrayList<LogEvent>()
events.add(newEvent(groupId = "group-id", eventId = "test-event"))
testDeserialization(events)
}
@Test
fun testDeserializationSingleBatch() {
val events = ArrayList<LogEvent>()
events.add(newEvent(groupId = "group-id", eventId = "first"))
events.add(newEvent(groupId = "group-id-1", eventId = "second"))
events.add(newEvent(groupId = "group-id-2", eventId = "third"))
testDeserialization(events)
}
@Test
fun testDeserializationTwoCompleteBatches() {
val firstBatch = ArrayList<LogEvent>()
val secondBatch = ArrayList<LogEvent>()
firstBatch.add(newEvent(groupId = "group-id", eventId = "first"))
firstBatch.add(newEvent(groupId = "group-id-1", eventId = "second"))
firstBatch.add(newEvent(groupId = "group-id-2", eventId = "third"))
secondBatch.add(newEvent(groupId = "group-id", eventId = "fourth"))
secondBatch.add(newEvent(groupId = "group-id-1", eventId = "fifth"))
secondBatch.add(newEvent(groupId = "group-id-2", eventId = "sixth"))
testDeserialization(firstBatch, secondBatch)
}
@Test
fun testDeserializationIncompleteBatch() {
val firstBatch = ArrayList<LogEvent>()
val secondBatch = ArrayList<LogEvent>()
firstBatch.add(newEvent(groupId = "group-id", eventId = "first"))
firstBatch.add(newEvent(groupId = "group-id-1", eventId = "second"))
firstBatch.add(newEvent(groupId = "group-id-2", eventId = "third"))
secondBatch.add(newEvent(groupId = "group-id", eventId = "fourth"))
testDeserialization(firstBatch, secondBatch)
}
@Test
fun testInvalidEventWithoutSession() {
val json =
"{\"build\":\"183.0\",\"bucket\":\"-1\",\"time\":1529428045322," +
"\"group\":{\"id\":\"lifecycle\",\"version\":\"2\"}," +
"\"event\":{\"count\":1,\"data\":{},\"id\":\"ideaapp.started\"}" +
"}"
val deserialized = LogEventDeserializer(TestDataCollectorDebugLogger).fromString(json)
assertNull(deserialized)
}
@Test
fun testInvalidEventWithTimeAsString() {
val json =
"{\"session\":12345,\"build\":\"183.0\",\"bucket\":\"-1\",\"time\":\"current-time\"," +
"\"group\":{\"id\":\"lifecycle\",\"version\":\"2\"}," +
"\"event\":{\"count\":1,\"data\":{},\"id\":\"ideaapp.started\"}" +
"}"
val deserialized = LogEventDeserializer(TestDataCollectorDebugLogger).fromString(json)
assertNull(deserialized)
}
@Test
fun testInvalidEventWithoutGroup() {
val json =
"{\"session\":12345,\"build\":\"183.0\",\"bucket\":\"-1\",\"time\":1529428045322," +
"\"event\":{\"count\":1,\"data\":{},\"id\":\"ideaapp.started\"}" +
"}"
val deserialized = LogEventDeserializer(TestDataCollectorDebugLogger).fromString(json)
assertNull(deserialized)
}
@Test
fun testInvalidEventWithoutEvent() {
val json =
"{\"session\":12345,\"build\":\"183.0\",\"bucket\":\"-1\",\"time\":1529428045322," +
"\"group\":{\"id\":\"lifecycle\",\"version\":\"2\"}" +
"}"
val deserialized = LogEventDeserializer(TestDataCollectorDebugLogger).fromString(json)
assertNull(deserialized)
}
@Test
fun testEventInOldFormat() {
val json =
"{\"session\":\"e4d6236d62f8\",\"bucket\":\"-1\",\"time\":1528885576020," +
"\"recorder\":{\"id\":\"action-stats\",\"version\":\"2\"}," +
"\"action\":{\"data\":{},\"id\":\"Run\"}" +
"}"
val deserialized = LogEventDeserializer(TestDataCollectorDebugLogger).fromString(json)
assertNull(deserialized)
}
@Test
fun testInvalidJsonEvent() {
val json = "\"session\":12345,\"build\":\"183.0\",\"bucket\":\"-1\",\"time\":1529428045322}"
val deserialized = LogEventDeserializer(TestDataCollectorDebugLogger).fromString(json)
assertNull(deserialized)
}
@Test
fun testInvalidEvent() {
val json = "{\"a\":12345,\"b\":\"183.0\",\"d\":\"-1\"}"
val deserialized = LogEventDeserializer(TestDataCollectorDebugLogger).fromString(json)
assertNull(deserialized)
}
private fun testDeserialization(vararg batches: List<LogEvent>) {
val events = ArrayList<LogEvent>()
val records = ArrayList<LogEventRecord>()
for (batch in batches) {
events.addAll(batch)
records.add(LogEventRecord(batch))
}
val expected = LogEventRecordRequest("recorder-id","IU", "user-id", records, false)
val log = FileUtil.createTempFile("feature-event-log", ".log")
try {
val out = StringBuilder()
for (event in events) {
out.append(LogEventSerializer.toString(event)).append("\n")
}
FileUtil.writeToFile(log, out.toString())
val actual = LogEventRecordRequest.create(
log, "recorder-id", "IU", "user-id",
600, LogEventTrueFilter, false, TestDataCollectorDebugLogger
)
assertEquals(expected, actual)
}
finally {
FileUtil.delete(log)
}
}
private fun testEventSerialization(event: LogEvent, isState: Boolean, vararg dataOptions: String) {
val line = LogEventSerializer.toString(event)
assertLogEventIsValid(JsonParser().parse(line).asJsonObject, isState, *dataOptions)
val deserialized = LogEventDeserializer(TestDataCollectorDebugLogger).fromString(line)
assertEquals(event, deserialized)
}
private fun assertLogEventContentIsValid(json: JsonObject, recorder: String, product: String, device: String, internal: Boolean, isState: Boolean) {
assertTrue(json.get("device").isJsonPrimitive)
assertTrue(isValid(json.get("device").asString))
assertEquals(device, json.get("device").asString)
assertTrue(json.get("product").isJsonPrimitive)
assertTrue(isValid(json.get("product").asString))
assertEquals(product, json.get("product").asString)
assertTrue(json.get("recorder").isJsonPrimitive)
assertTrue(isValid(json.get("recorder").asString))
assertEquals(recorder, json.get("recorder").asString)
assertEquals(internal, json.has("internal"))
if (internal) {
assertTrue(json.get("internal").asBoolean)
}
assertTrue(json.get("records").isJsonArray)
val records = json.get("records").asJsonArray
for (record in records) {
assertTrue(record.isJsonObject)
assertTrue(record.asJsonObject.get("events").isJsonArray)
val events = record.asJsonObject.get("events").asJsonArray
for (event in events) {
assertTrue(event.isJsonObject)
assertLogEventIsValid(event.asJsonObject, isState)
}
}
}
private fun requestByEvents(recorder: String, product: String, device: String, internal: Boolean, events: List<LogEvent>) : LogEventRecordRequest {
val records = ArrayList<LogEventRecord>()
records.add(LogEventRecord(events))
return LogEventRecordRequest(recorder, product, device, records, internal)
}
} | platform/platform-tests/testSrc/com/intellij/internal/statistics/logger/FeatureEventLogSerializationTest.kt | 2407050725 |
Subsets and Splits