removed behavior alias

Author: bjuric

CHANGELOG

@@ -10,10 +10,12 @@ m d, yyyy
       - `gwen.rp.heartbeat` renamed to `gwen.rp.heartbeat.enabled`
     - Changed settings defaults:
       - `gwen.associative.meta = true` instead of `false`
-      - `gwen.behavior.rules = strict` instead of `lenient`
+      - `gwen.behaviour.rules = strict` instead of `lenient`
       - `gwen.feature.mode = declarative` instead of `imperative`
       - `gwen.report.suppress.meta = true` instead of `false`
       - `gwen.auto.discover.data.csv = false` instead of `true`
+    - Removed settings alias
+      - `gwen.behavior.rules` in favor of `gwen.behaviour.rules`
     - New settings
       - Configurable output directory
         - `gwen.output.dir` (default = target)
@@ -277,8 +279,8 @@ March 11, 2020
 2.25.0
 ======
 March 8, 2020
-- Introduce behavior rules setting to enforce good Gherkin style
-  - `gwen.behavior.rules=strict|lenient`
+- Introduce behaviour rules setting to enforce good Gherkin style
+  - `gwen.behaviour.rules=strict|lenient`
     - `strict`: The following rules are enforced in feature files with violations reported as errors:
       - Steps in scenarios and backgrounds must satisfy *Given-When-Then* order
       - *Given* steps must set context
@@ -897,7 +899,7 @@ Feb 29, 2016, 8:50 PM GMT+11 (AEDT)
   interval can be set through the `gwen.rampup.interval.seconds` setting
   This setting is only applicable for parallel execution mode. If it is 
   not set or is set to zero, then no staggering will occur (as per default 
-  behavior). 
+  behaviour). 
 - Added new `gwen.report.suppress.meta` setting for controlling whether or 
   not meta reports should be generated with HTML reports (default value is 
   false). If you have a lot of meta, suppressing the meta reports can 

README.md

@@ -17,50 +17,11 @@ Visit the [Gwen home page](https://gweninterpreter.org) for our user documentati
 - [Latest release](https://github.com/gwen-interpreter/gwen/releases/latest)
 - [Change log](CHANGELOG)
 
-### What's New?
-
-- [Doc Strings as Parameters](https://github.com/gwen-interpreter/gwen/wiki/Doc-Strings/_edit#doc-strings-as-parameters)
-- [Report Portal integration](https://github.com/gwen-interpreter/gwen/wiki/Report-Portal-Integration) for centralised reporting and real-time analytics.
-- [Masked Settings](https://github.com/gwen-interpreter/gwen/wiki/Runtime-Settings#masked-settings) to make all your private and sensitive settings appear as `●●●●●` in all Gwen logs, reports, errors and console outputs
-
 System Requirements
 -------------------
 
 - Java 8 (version 1.8) or higher
 
-Key Features
-------------
-
-- Integrated [Gherkin](https://cucumber.io/docs/reference) parser from Cucubmer
-- [Runtime settings](https://github.com/gwen-interpreter/gwen/wiki/Runtime-Settings)
-- [Evaluation engines](https://github.com/gwen-interpreter/gwen/wiki/Evaluation-Engines)
-- [Evaluation reports](https://github.com/gwen-interpreter/gwen/wiki/Evaluation-Reports)
-- [Command line interface](https://github.com/gwen-interpreter/gwen/wiki/Command-Line-Interface)
-- [REPL console](https://github.com/gwen-interpreter/gwen/wiki/REPL-Console)
-- [Serial execution](https://github.com/gwen-interpreter/gwen/wiki/Execution-Modes#serial-execution)
-- [Parallel execution](https://github.com/gwen-interpreter/gwen/wiki/Execution-Modes#parallel-execution) for features or scenarios
-- [Dry run execution and validation](https://github.com/gwen-interpreter/gwen/wiki/Execution-Modes#dry-run-validation)
-- [Data driven execution](https://github.com/gwen-interpreter/gwen/wiki/Execution-Modes#data-driven-execution)
-- [Meta features](https://github.com/gwen-interpreter/gwen/wiki/Meta-Features)
-- [Composable step definitions](https://github.com/gwen-interpreter/gwen/wiki/Meta-Features#composable-step-definitions)
-- [Runtime settings](https://github.com/gwen-interpreter/gwen/wiki/Runtime-Settings)
-- [User settings](https://github.com/gwen-interpreter/gwen/wiki/User-Settings)
-- [String interpolation](https://github.com/gwen-interpreter/gwen/wiki/String-Interpolation)
-- [SQL data bindings](https://github.com/gwen-interpreter/gwen/wiki/SQL-Data-Bindings)
-- [Implicit attributes](https://github.com/gwen-interpreter/gwen/wiki/Implicit-Attributes)
-- [Template matching](https://github.com/gwen-interpreter/gwen/wiki/Template-Matching)
-- Hard, soft, and sustained [Assertion modes](https://github.com/gwen-interpreter/gwen/wiki/Assertion-Modes)
-- [Synchronized StepDef execution](https://github.com/gwen-interpreter/gwen/wiki/Synchronized-StepDefs)
-- Hard, soft, and sustained [Assertion modes](https://github.com/gwen-interpreter/gwen/wiki/Assertion-Modes)
-- Supports full Gherkin syntax including [example mapping](https://cucumber.io/blog/2015/12/08/example-mapping-introduction)
-- [State levels](https://github.com/gwen-interpreter/gwen/wiki/State-Levels) and [parallel execution](https://github.com/gwen-interpreter/gwen/wiki/Execution-Modes#parallel-scenario-execution) for scenarios in additon to features
-- [Declarative feature mode](https://github.com/gwen-interpreter/gwen/wiki/Runtime-Settings#gwenfeaturemode) to force all imperative steps to meta and promote cleaner features.
-- [Associative meta](https://github.com/gwen-interpreter/gwen/wiki/Runtime-Settings#gwenassociativemeta)
-- [Behavior rules](https://github.com/gwen-interpreter/gwen/wiki/Runtime-Settings#gwenbehaviorrules) to help enforce good Gherkin style
-- [Dialects](https://github.com/gwen-interpreter/gwen/wiki/Runtime-Settings#gwenfeaturedialect) for [Gherkin's spoken languages](https://cucumber.io/docs/gherkin/reference/#spoken-languages)
-- Configurable [maximum number of threads](https://github.com/gwen-interpreter/gwen/wiki/Runtime-Settings#gwenparallelmaxthreads) for parallel execution
-- Simplified [data table iteration with @ForEach](https://github.com/gwen-interpreter/gwen/wiki/Data-Tables#simplified-foreach)
-
 License
 -------
 

src/main/resources/gwen.conf

@@ -24,7 +24,7 @@ gwen {
       meta = true
     }
   }
-  behavior {
+  behaviour {
     rules = "strict"              # strict|lenient
   }
   cli {                           # Default CLI options

src/main/scala/gwen/core/GwenErrors.scala

@@ -20,7 +20,7 @@
  */
 package gwen.core
 
-import gwen.core.behavior.BehaviorType
+import gwen.core.behaviour.BehaviourType
 import gwen.core.node.SourceRef
 import gwen.core.node.gherkin._
 
@@ -76,9 +76,9 @@ object Errors {
   def invalidSettingError(name: String, value: String, msg: String) = throw new InvalidSettingException(name, value, msg)
   def imperativeStepError(step: Step) = throw new ImperativeStepException(step)
   def imperativeStepDefError(stepDef: Scenario) = throw new ImperativeStepDefException(stepDef)
-  def improperBehaviorError(node: GherkinNode) = throw new ImproperBehaviorException(node)
-  def unexpectedBehaviorError(step: Step, expected: BehaviorType, actual: BehaviorType) = throw new UnexpectedBehaviorException(step, expected, actual)
-  def undefinedStepDefBehaviorError(stepDef: Scenario) = throw new UndefinedStepDefBehaviorException(stepDef)
+  def improperBehaviourError(node: GherkinNode) = throw new ImproperBehaviourException(node)
+  def unexpectedBehaviourError(step: Step, expected: BehaviourType, actual: BehaviourType) = throw new UnexpectedBehaviourException(step, expected, actual)
+  def undefinedStepDefBehaviourError(stepDef: Scenario) = throw new UndefinedStepDefBehaviourException(stepDef)
   def keywordDialectError(language: String, keyword: String) = throw new KeywordDialectException(language, keyword)
   def metaDialectError(language: String, specFile: File) = throw new MetaDialectException(language, specFile)
   def fileAttachError(file: File, msg: String) = throw new FileAttachException(file, msg)
@@ -208,16 +208,16 @@ object Errors {
   class ImperativeStepDefException(stepDef: Scenario) extends GwenException(s"Declarative feature violation: StepDef declaration not permitted in feature${at(stepDef.sourceRef)}")
 
   /** Thrown in strict rules mode when Given-When-Then order is not satisfied in a scenario or background */
-  class ImproperBehaviorException(node: GherkinNode) 
+  class ImproperBehaviourException(node: GherkinNode) 
     extends GwenException(s"Strict behaviour violation: Given-When-Then order not satisfied by steps in ${node.nodeType.toString}${at(node.sourceRef)}")
 
-  /** Thrown in strict rules mode when a step' behavior type does not match its Given, When, or Then position. */
-  class UnexpectedBehaviorException(step: Step, expected: BehaviorType, actual: BehaviorType) 
-    extends GwenException(s"Strict behaviour violation: $actual behavior not permitted where ${expected.toString.toLowerCase} is expected (StepDef has @$actual tag${at(step.stepDef.flatMap(_.behaviorTag.flatMap(_.sourceRef)))})")
+  /** Thrown in strict rules mode when a step' behaviour type does not match its Given, When, or Then position. */
+  class UnexpectedBehaviourException(step: Step, expected: BehaviourType, actual: BehaviourType) 
+    extends GwenException(s"Strict behaviour violation: $actual behaviour not permitted where ${expected.toString.toLowerCase} is expected (StepDef has @$actual tag${at(step.stepDef.flatMap(_.behaviourTag.flatMap(_.sourceRef)))})")
 
   /** Thrown in strict rules mode when a step def does not declare a Given, When or Then tag. */
-  class UndefinedStepDefBehaviorException(stepDef: Scenario) 
-    extends GwenException(s"Strict behaviour violation: Missing @Context, @Action, or @Assertion behavior annotation on StepDef${at(stepDef.sourceRef)}")
+  class UndefinedStepDefBehaviourException(stepDef: Scenario) 
+    extends GwenException(s"Strict behaviour violation: Missing @Context, @Action, or @Assertion behaviour annotation on StepDef${at(stepDef.sourceRef)}")
 
   /** Thrown when a keyword is unknown for a given language dialect. */
   class KeywordDialectException(language: String, keyword: String) extends GwenException(s"Unsupported or unknown keyword: $keyword (language=$language)")

src/main/scala/gwen/core/GwenSettings.scala

@@ -16,8 +16,8 @@
 
 package gwen.core
 
-import gwen.core.behavior.BehaviorMode
-import gwen.core.behavior.FeatureMode
+import gwen.core.behaviour.BehaviourMode
+import gwen.core.behaviour.FeatureMode
 import gwen.core.state.StateLevel
 
 import scala.util.Try
@@ -39,7 +39,7 @@ object GwenSettings {
     `gwen.associative.meta`
     `gwen.auto.discover.data.csv`
     `gwen.auto.discover.meta`
-    `gwen.behavior.rules`
+    `gwen.behaviour.rules`
     `gwen.feature.dialect`
     `gwen.feature.failfast.enabled`
     `gwen.feature.failfast.exit`
@@ -186,15 +186,15 @@ object GwenSettings {
   }
 
   /**
-    * Provides access to the `gwen.behavior.rules` setting used to determine whether strict,
+    * Provides access to the `gwen.behaviour.rules` setting used to determine whether strict,
     * or lenient rules around Given-When-Then usage should be enforced in features (default value is
     * `strict`). When strict, scenarios and backgrounds must contain Given-When-Then ordered steps
     * and Given steps set context, When steps must perform actions, and Then or But steps must perform
-    * assertions. When `leneient` no behavioral rules are enforced. Note that `gwen.behaviour.rules` is
+    * assertions. When `leneient` no behavioural rules are enforced. Note that `gwen.behaviour.rules` is
     * an alias for this setting.
     */
-  def `gwen.behavior.rules`: BehaviorMode = {
-    BehaviorMode.valueOf(Settings.getOpt("gwen.behavior.rules").getOrElse(Settings.get("gwen.behaviour.rules")))
+  def `gwen.behaviour.rules`: BehaviourMode = {
+    BehaviourMode.valueOf(Settings.getOpt("gwen.behaviour.rules").getOrElse(Settings.get("gwen.behaviour.rules")))
   }
 
   /**

src/main/scala/gwen/core/behavior/BehaviorMode.scala src/main/scala/gwen/core/behaviour/BehaviourMode.scala

@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-package gwen.core.behavior
+package gwen.core.behaviour
 
 import gwen.core.GwenSettings
 
-enum BehaviorMode:
+enum BehaviourMode:
   case strict, lenient
 
-object BehaviorMode {
-  def isStrict = GwenSettings.`gwen.behavior.rules` == strict
-  def isLenient = GwenSettings.`gwen.behavior.rules` == lenient
+object BehaviourMode {
+  def isStrict = GwenSettings.`gwen.behaviour.rules` == strict
+  def isLenient = GwenSettings.`gwen.behaviour.rules` == lenient
 }

src/main/scala/gwen/core/behavior/BehaviorRules.scala src/main/scala/gwen/core/behaviour/BehaviourRules.scala

@@ -14,33 +14,33 @@
  * limitations under the License.
  */
 
-package gwen.core.behavior
+package gwen.core.behaviour
 
 import gwen.core._
 import gwen.core.node.gherkin._
 import gwen.core.state.Environment
 
  /**
-  * Enfores certain rules depending on `gwen.feature.mode` and `gwen.behavior.rules` settings.
+  * Enfores certain rules depending on `gwen.feature.mode` and `gwen.behaviour.rules` settings.
   */
-trait BehaviorRules {
+trait BehaviourRules {
 
   /**
-    * Checks that a background satisfies behavior rules before evaluation.
+    * Checks that a background satisfies behaviour rules before evaluation.
     *
     * @param background the background  to check
     * @param specType the spec type currently being evaluated
     */
   def checkBackgroundRules(background: Background, specType: SpecType): Unit = {
-    if (BehaviorMode.isStrict && specType.isFeature) {
-      if (!isProperBehavior(background.steps)) {
-        Errors.improperBehaviorError(background)
+    if (BehaviourMode.isStrict && specType.isFeature) {
+      if (!isProperBehaviour(background.steps)) {
+        Errors.improperBehaviourError(background)
       }
     }
   }
 
   /**
-    * Checks that a scenario or stepdef satisfies behavior rules before evaluation.
+    * Checks that a scenario or stepdef satisfies behaviour rules before evaluation.
     *
     * @param scenario the scenario to check
     * @param specType the spec type currently being evaluated
@@ -50,9 +50,9 @@ trait BehaviorRules {
       if (FeatureMode.isDeclarative && scenario.isStepDef) {
         Errors.imperativeStepDefError(scenario)
       }
-      if (BehaviorMode.isStrict && !(FeatureMode.isImperative && scenario.isStepDef)) {
-        if (!isProperBehavior(scenario.steps)) {
-          Errors.improperBehaviorError(scenario)
+      if (BehaviourMode.isStrict && !(FeatureMode.isImperative && scenario.isStepDef)) {
+        if (!isProperBehaviour(scenario.steps)) {
+          Errors.improperBehaviourError(scenario)
         }
       }
     }
@@ -66,14 +66,14 @@ trait BehaviorRules {
     */
   def checkStepDefRules(step: Step, env: Environment): Unit = {
     if (env.specType.isFeature && env.isEvaluatingTopLevelStep) {
-      if (BehaviorMode.isStrict) {
+      if (BehaviourMode.isStrict) {
         step.stepDef foreach { stepDef =>
           if (!stepDef.isSynthetic) {
-            stepDef.behaviorTag match {
-              case Some(behaviorTag) =>
-                checkStepRules(step, BehaviorType.valueOf(behaviorTag.name), env)
+            stepDef.behaviourTag match {
+              case Some(behaviourTag) =>
+                checkStepRules(step, BehaviourType.valueOf(behaviourTag.name), env)
               case _ =>
-                Errors.undefinedStepDefBehaviorError(stepDef)
+                Errors.undefinedStepDefBehaviourError(stepDef)
             }
           }
         }
@@ -85,30 +85,30 @@ trait BehaviorRules {
     * Checks that a step called in a feature satisfies behavoiur rules at evaluation.
     *
     * @param step the step to check
-    * @param actualBehavior the actual behavior type of the step
+    * @param actualBehaviour the actual behaviour type of the step
     * @param env the environment context
     */
-  def checkStepRules(step: Step, actualBehavior: BehaviorType, env: Environment): Unit = {
+  def checkStepRules(step: Step, actualBehaviour: BehaviourType, env: Environment): Unit = {
     if (env.specType.isFeature && env.isEvaluatingTopLevelStep) {
       if (FeatureMode.isDeclarative && step.stepDef.isEmpty) {
         Errors.imperativeStepError(step)
       }
-      if (BehaviorMode.isStrict) {
-        env.currentBehavior foreach { expectedBehavior =>
-          if (actualBehavior != expectedBehavior) {
-            Errors.unexpectedBehaviorError(step, expectedBehavior, actualBehavior)
+      if (BehaviourMode.isStrict) {
+        env.currentBehaviour foreach { expectedBehaviour =>
+          if (actualBehaviour != expectedBehaviour) {
+            Errors.unexpectedBehaviourError(step, expectedBehaviour, actualBehaviour)
           } else if (!StepKeyword.isAnd(step.keyword)) {
-            val stepBehavior = BehaviorType.of(step.keyword) 
-            if (stepBehavior != expectedBehavior) {
-              Errors.unexpectedBehaviorError(step, expectedBehavior, stepBehavior)
+            val stepBehaviour = BehaviourType.of(step.keyword) 
+            if (stepBehaviour != expectedBehaviour) {
+              Errors.unexpectedBehaviourError(step, expectedBehaviour, stepBehaviour)
             }
           }
         }
       }
     }
   }
 
-  private def isProperBehavior(steps: List[Step]): Boolean = {
+  private def isProperBehaviour(steps: List[Step]): Boolean = {
     val order = steps.map(_.keyword).filter(k => !StepKeyword.isAnd(k)).map { keyword => 
       StepKeyword.valueOf(keyword).toString
     }

src/main/scala/gwen/core/behavior/BehaviorType.scala src/main/scala/gwen/core/behaviour/BehaviourType.scala

@@ -14,18 +14,18 @@
  * limitations under the License.
  */
 
-package gwen.core.behavior
+package gwen.core.behaviour
 
 import gwen.core.node.gherkin.StepKeyword
 
-enum BehaviorType:
+enum BehaviourType:
   case  Context, Action, Assertion
 
-object BehaviorType {
-  def of(stepKeyword: String): BehaviorType = {
-    if (StepKeyword.isGiven(stepKeyword)) BehaviorType.Context
-    else if (StepKeyword.isWhen(stepKeyword)) BehaviorType.Action
-    else BehaviorType.Assertion
+object BehaviourType {
+  def of(stepKeyword: String): BehaviourType = {
+    if (StepKeyword.isGiven(stepKeyword)) BehaviourType.Context
+    else if (StepKeyword.isWhen(stepKeyword)) BehaviourType.Action
+    else BehaviourType.Assertion
   }
 
 }

src/main/scala/gwen/core/behavior/FeatureMode.scala src/main/scala/gwen/core/behaviour/FeatureMode.scala

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package gwen.core.behavior
+package gwen.core.behaviour
 
 import gwen.core.GwenSettings
 

src/main/scala/gwen/core/eval/GwenREPL.scala

@@ -17,7 +17,7 @@
 package gwen.core.eval
 
 import gwen.core._
-import gwen.core.behavior.FeatureMode
+import gwen.core.behaviour.FeatureMode
 import gwen.core.node.gherkin.Dialect
 import gwen.core.node.gherkin.GherkinKeyword
 import gwen.core.node.gherkin.StepKeyword

src/main/scala/gwen/core/eval/engine/StepEngine.scala

@@ -20,7 +20,7 @@ import gwen.core._
 import gwen.core.Errors
 import gwen.core.eval.EvalContext
 import gwen.core.eval.EvalEngine
-import gwen.core.behavior.BehaviorType
+import gwen.core.behaviour.BehaviourType
 import gwen.core.eval.lambda.CompositeStep
 import gwen.core.eval.lambda.composite.ForEachTableRecord
 import gwen.core.eval.lambda.composite.ForEachTableRecordAnnotated
@@ -63,19 +63,19 @@ trait StepEngine[T <: EvalContext] {
     * Evaluates a list of steps.
     */
   def evaluateSteps(parent: GwenNode, steps: List[Step], ctx: T): List[Step] = {
-    var behaviorCount = 0
+    var behaviourCount = 0
     try {
       steps.foldLeft(List[Step]()) {
         (acc: List[Step], step: Step) =>
           if (!StepKeyword.isAnd(step.keyword)) {
-            ctx.addBehavior(BehaviorType.of(step.keyword))
-            behaviorCount = behaviorCount + 1
+            ctx.addBehaviour(BehaviourType.of(step.keyword))
+            behaviourCount = behaviourCount + 1
           }
           evaluateOrTransitionStep(parent, step, acc, ctx) :: acc
       } reverse
     } finally {
-      0 until behaviorCount foreach { _ =>
-        ctx.popBehavior()
+      0 until behaviourCount foreach { _ =>
+        ctx.popBehaviour()
       }
     }
   }