diff --git a/reactor/Test/src/program/MockProgram.kt b/reactor/Test/src/program/MockProgram.kt index 7dae7afc..72084d83 100644 --- a/reactor/Test/src/program/MockProgram.kt +++ b/reactor/Test/src/program/MockProgram.kt @@ -6,35 +6,30 @@ import jetbrains.mps.logic.reactor.evaluation.InvocationContext import jetbrains.mps.logic.reactor.logical.LogicalContext import jetbrains.mps.logic.reactor.logical.MetaLogical import jetbrains.mps.logic.reactor.program.* -import program.MockConstraint import java.util.* import java.util.Collections.* class ProgramBuilder(val registry: MockConstraintRegistry) { - private val handlers = ArrayList() - - fun addHandler(handler: Handler) { - for (r in handler.rules()) { - registry.update(r) + fun program(name: String, handlers: List): Program { + for (h in handlers) { + for (r in h.rules()) { + registry.update(r) + } } - handlers.add(handler) + return MockProgram(name, handlers, registry) } - - fun constraint(symbol: ConstraintSymbol, vararg args: Any): Constraint = MockConstraint(symbol, listOf(* args)) - - fun program(name: String): Program = MockProgram(name, handlers, registry) - + } -open class HandlerBuilder(val name: String, val primary: Iterable) { +open class HandlerBuilder(val name: String) { val rules = ArrayList() fun appendRule(rule: Rule) { rules.add(rule) } - fun toHandler(): Handler = MockHandler(name, primary, rules) + fun toHandler(): Handler = MockHandler(name, rules) } open class RuleBuilder(val tag: String) { @@ -61,7 +56,6 @@ open class RuleBuilder(val tag: String) { class MockHandler( val name: String, - val primary: Iterable, val rules: List) : Handler() { override fun name(): String = name diff --git a/reactor/Test/test/RulesHelper.kt b/reactor/Test/test/RulesHelper.kt index 24c67f96..c6642da1 100644 --- a/reactor/Test/test/RulesHelper.kt +++ b/reactor/Test/test/RulesHelper.kt @@ -9,10 +9,12 @@ import java.util.* * @author Fedor Isakov */ -class Builder(val env: Environment, val handlers: List) : RuleLookup { +class Builder(var handlers: List) : RuleLookup { val tag2rule = HashMap() + val programBuilder = ProgramBuilder(MockConstraintRegistry()) + init { handlers .flatMap { it.rules() } @@ -25,73 +27,57 @@ class Builder(val env: Environment, val handlers: List) : RuleLookup { override fun lookupRuleByTag(tag: String): Rule? = tag2rule[tag] fun ruleMatcher(): RuleMatcher = createRuleMatcher(this, rules.first().tag()) + + fun program(name: String): Program = programBuilder.program(name, handlers) } -@Deprecated("don't use") -class Environment(val programBuilder: ProgramBuilder? = null) { +fun programWithRules(vararg ruleBuilders: () -> Rule): Builder { + return builder(arrayOf(handler("test", * ruleBuilders))) } -fun programWithRules(vararg ruleBuilders: Environment.() -> Rule): Builder { - return programWithRules(Environment(), ruleBuilders) -} - -fun programWithRules(pb: ProgramBuilder, vararg ruleBuilders: Environment.() -> Rule): Builder { - return programWithRules(Environment(pb), ruleBuilders) -} - -private fun programWithRules(env: Environment, ruleBuilders: Array Rule>): Builder { - return builder(env, arrayOf(handler("test", emptyList(), * ruleBuilders))) -} - -fun programWithHandlers(vararg handlerBuilders: Environment.() -> Handler): Builder { - return builder(Environment(), handlerBuilders) -} - -private fun builder(env: Environment, handlerBlocks: Array Handler>): Builder { +private fun builder(handlerBlocks: Array Handler>): Builder { val handlers = ArrayList() - with(env) { - for (block in handlerBlocks) { - handlers.add(block()) - } + for (block in handlerBlocks) { + handlers.add(block()) } - return Builder(env, handlers) + return Builder(handlers) } -fun handler(name: String, primary: Iterable, vararg ruleBlocks: Environment.() -> Rule): Environment.() -> Handler = { - val hb = HandlerBuilder(name, primary) +fun handler(name: String, vararg ruleBlocks: () -> Rule): () -> Handler = { + val hb = HandlerBuilder(name) for (block in ruleBlocks) { - hb.appendRule(this.block()) + hb.appendRule(block()) } hb.toHandler() } -fun rule(tag: String, vararg component: RB.() -> Unit): Environment.() -> Rule = { - val rb = RB(this, tag) +fun rule(tag: String, vararg component: RuleBuilder.() -> Unit): () -> Rule = { + val rb = RuleBuilder(tag) for (cmp in component) { rb.cmp() } rb.toRule() } -fun headKept(vararg content: ConjBuilder.() -> Unit): RB.() -> Unit = { - appendHeadKept(* buildConjunction(Constraint::class.java, env, content).toArray()) +fun headKept(vararg content: ConjBuilder.() -> Unit): RuleBuilder.() -> Unit = { + appendHeadKept(* buildConjunction(Constraint::class.java, content).toArray()) } -fun headReplaced(vararg content: ConjBuilder.() -> Unit): RB.() -> Unit = { - appendHeadReplaced(* buildConjunction(Constraint::class.java, env, content).toArray()) +fun headReplaced(vararg content: ConjBuilder.() -> Unit): RuleBuilder.() -> Unit = { + appendHeadReplaced(* buildConjunction(Constraint::class.java, content).toArray()) } -fun guard(vararg content: ConjBuilder.() -> Unit): RB.() -> Unit = { - appendGuard(* buildConjunction(Predicate::class.java, env, content).toArray()) +fun guard(vararg content: ConjBuilder.() -> Unit): RuleBuilder.() -> Unit = { + appendGuard(* buildConjunction(Predicate::class.java, content).toArray()) } -fun body(vararg content: ConjBuilder.() -> Unit): RB.() -> Unit = { - appendBody(false, * buildConjunction(AndItem::class.java, env, content).toArray()) +fun body(vararg content: ConjBuilder.() -> Unit): RuleBuilder.() -> Unit = { + appendBody(false, * buildConjunction(AndItem::class.java, content).toArray()) } -fun altBody(vararg content: ConjBuilder.() -> Unit): RB.() -> Unit = { - appendBody(true, * buildConjunction(AndItem::class.java, env, content).toArray()) +fun altBody(vararg content: ConjBuilder.() -> Unit): RuleBuilder.() -> Unit = { + appendBody(true, * buildConjunction(AndItem::class.java, content).toArray()) } fun constraint(id: String, vararg args: Any): ConjBuilder.() -> Unit = { @@ -119,16 +105,11 @@ object fooObservable : FrameObservable { } } -class RB(val env: Environment, tag: String) : RuleBuilder(tag) { - -} - -class ConjBuilder(val type: Class, val env: Environment) { +class ConjBuilder(val type: Class) { val constraints = ArrayList() fun createConstraint(args: Array, id: String): Constraint { - return env.programBuilder?.constraint(ConstraintSymbol(id, args.size), * args) - ?: MockConstraint(ConstraintSymbol(id, args.size), * args) + return MockConstraint(ConstraintSymbol(id, args.size), * args) } fun add(item: AndItem): Unit { @@ -155,9 +136,8 @@ class ConjBuilder(val type: Class, val env: Environment) { } private fun buildConjunction(type: Class, - env: Environment, content: Array Unit>): ConjBuilder { - val conjBuilder = ConjBuilder(type, env) + val conjBuilder = ConjBuilder(type) for (c in content) { conjBuilder.c() } diff --git a/reactor/Test/test/TestIncrementalProgram.kt b/reactor/Test/test/TestIncrementalProgram.kt index 30aa7374..3541a80f 100644 --- a/reactor/Test/test/TestIncrementalProgram.kt +++ b/reactor/Test/test/TestIncrementalProgram.kt @@ -1,4 +1,5 @@ import jetbrains.mps.logic.reactor.core.ReactorLifecycle +import jetbrains.mps.logic.reactor.evaluation.EvaluationResult import jetbrains.mps.logic.reactor.evaluation.EvaluationSession import jetbrains.mps.logic.reactor.evaluation.StoreView import jetbrains.mps.logic.reactor.program.Constraint @@ -45,17 +46,20 @@ class TestIncrementalProgram { } } - private fun Builder.launch(name: String): StoreView { - val programBuilder = ProgramBuilder(MockConstraintRegistry()) - for (h in handlers) { - programBuilder.addHandler(h) - } - val result = EvaluationSession.newSession(programBuilder.program(name)) + private fun Builder.launch(name: String, resultHandler: (EvaluationResult) -> Unit): Pair { + val result = EvaluationSession.newSession(program(name)) .withParameter(EvaluationSession.ParameterKey.of("main", Constraint::class.java), MockConstraint(ConstraintSymbol("main", 0))) .start() - return result.storeView() + result.failure()?.let { throw it.cause } + resultHandler(result) + return this to result.storeView() } + private fun Builder.relaunch(name: String, storeView: StoreView, resultHandler: (EvaluationResult) -> Unit) { + + } + + // private fun StoreView.launch(name: String): StoreView { // val programBuilder = ProgramBuilder(MockConstraintRegistry()) // for (h in handlers) { @@ -84,8 +88,11 @@ class TestIncrementalProgram { constraint("bar") ) ) - ).launch("replace").apply { - Assert.assertEquals(setOf(ConstraintSymbol("foo", 0), ConstraintSymbol("bar", 0)), constraintSymbols()) + ).launch("replace") { result -> + result.storeView().constraintSymbols() shouldBe setOf(ConstraintSymbol("foo", 0), ConstraintSymbol("bar", 0)) + + }.also { (builder, storeView) -> + } } diff --git a/reactor/Test/test/TestProgram.kt b/reactor/Test/test/TestProgram.kt index 21610319..a2ff27ef 100644 --- a/reactor/Test/test/TestProgram.kt +++ b/reactor/Test/test/TestProgram.kt @@ -32,11 +32,7 @@ class TestProgram { } private fun Builder.session(name: String): StoreView { - val programBuilder = ProgramBuilder(MockConstraintRegistry()) - for (h in handlers) { - programBuilder.addHandler(h) - } - val session = EvaluationSession.newSession(programBuilder.program(name)) + val session = EvaluationSession.newSession(program(name)) .withParameter(EvaluationSession.ParameterKey.of("main", Constraint::class.java), MockConstraint(ConstraintSymbol("main", 0))) .start() return session.storeView() diff --git a/reactor/Test/test/TestProgramBuilder.kt b/reactor/Test/test/TestProgramBuilder.kt index 28f572f1..2bcfa101 100644 --- a/reactor/Test/test/TestProgramBuilder.kt +++ b/reactor/Test/test/TestProgramBuilder.kt @@ -10,27 +10,22 @@ import org.junit.Test class TestProgramBuilder { - @Before fun beforeTest() { - programBuilder = ProgramBuilder(MockConstraintRegistry()) - } - - lateinit var programBuilder: ProgramBuilder - @Test(expected = InvalidRuleException::class) fun emptyBody() { - programWithRules(programBuilder, + programWithRules( rule("foo", headKept( constraint("bar") - ))).run { - - programBuilder.addHandler(MockHandler("test", emptyList(), rules)) + ) + ) + ).run { + program("test") } } @Test fun replace() { - programWithRules(programBuilder, + programWithRules( rule("foo", headReplaced( constraint("bar") @@ -47,25 +42,26 @@ class TestProgramBuilder { ), body( constraint("blah") - ))).run { - - programBuilder.addHandler(MockHandler("test", emptyList(), rules)) - assertEquals(programBuilder.program("test").handlers().flatMap { it.rules() }.count(), 2) + ) + ) + ).run { + assertEquals(program("test").handlers().flatMap { it.rules() }.count(), 2) } } @Test(expected = InvalidConstraintException::class) fun fail() { - programWithRules(programBuilder, + programWithRules( rule("foo", headReplaced( constraint("bar", 1) ), body( constraint("bar", "1") - ))).run { - - programBuilder.addHandler(MockHandler("test", emptyList(), rules)) + ) + ) + ).run { + program("test") } } }