added API26PrependNewLineOnStyledSpecialTextEvent and new value return ObservedOperationResultType to make sure whether we found a sequence but want the queue cleared within context

mzorz · mzorz · commit 4b7b220414ae · 2018-01-24T19:55:03.000-03:00
diff --git a/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/buckets/API26Bucket.kt b/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/buckets/API26Bucket.kt
@@ -1,13 +1,15 @@
 package org.wordpress.aztec.watchers.event.buckets
 
 import org.wordpress.aztec.watchers.event.sequence.known.space.API26InWordSpaceInsertionEvent
+import org.wordpress.aztec.watchers.event.sequence.known.space.API26PrependNewLineOnStyledSpecialTextEvent
 import org.wordpress.aztec.watchers.event.sequence.known.space.API26PrependNewLineOnStyledTextEvent
 
 class API26Bucket : Bucket() {
     init {
         // constructor - here add all identified sequences for this bucket
         userOperations.add(API26InWordSpaceInsertionEvent())
         userOperations.add(API26PrependNewLineOnStyledTextEvent())
+        userOperations.add(API26PrependNewLineOnStyledSpecialTextEvent())
         //mUserOperations.add(new ...);
         //mUserOperations.add(new ...);
         //mUserOperations.add(new ...);
diff --git a/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/sequence/ObservationQueue.kt b/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/sequence/ObservationQueue.kt
@@ -55,13 +55,19 @@ class ObservationQueue(val injector: IEventInjector) : EventSequence<TextWatcher
                     }
                 } else {
                     // does this particular event look like a part of any of the user operations as defined in this bucket?
-                    if (operation.isUserOperationObservedInSequence(this)) {
+                    val result = operation.isUserOperationObservedInSequence(this)
+                    if (operation.isFound(result)) {
                         // replace user operation with ONE TextWatcherEvent and inject this one in the actual
                         // textwatchers
                         val replacementEvent = operation.buildReplacementEventWithSequenceData(this)
                         injector.executeEvent(replacementEvent)
                         clear()
                     }
+
+                    // regardless of the operation being found, let's check if it needs the queue to be cleared
+                    if (operation.needsClear(result)) {
+                        clear()
+                    }
                 }
             }
         }
diff --git a/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/sequence/UserOperationEvent.kt b/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/sequence/UserOperationEvent.kt
@@ -1,9 +1,29 @@
 package org.wordpress.aztec.watchers.event.sequence
 
+import org.wordpress.android.util.AppLog
+import org.wordpress.aztec.spans.AztecCodeSpan
+import org.wordpress.aztec.spans.AztecHeadingSpan
+import org.wordpress.aztec.spans.AztecListItemSpan
+import org.wordpress.aztec.spans.AztecPreformatSpan
+import org.wordpress.aztec.watchers.event.text.BeforeTextChangedEventData
 import org.wordpress.aztec.watchers.event.text.TextWatcherEvent
 
 abstract class UserOperationEvent(var sequence: EventSequence<TextWatcherEvent> = EventSequence()) {
 
+    enum class ObservedOperationResultType {
+        SEQUENCE_FOUND,
+        SEQUENCE_NOT_FOUND,
+        SEQUENCE_FOUND_CLEAR_QUEUE
+    }
+
+    fun isFound(resultType: ObservedOperationResultType) : Boolean {
+        return resultType == ObservedOperationResultType.SEQUENCE_FOUND
+    }
+
+    fun needsClear(resultType: ObservedOperationResultType) : Boolean {
+        return resultType == ObservedOperationResultType.SEQUENCE_FOUND_CLEAR_QUEUE
+    }
+
     fun addSequenceStep(event: TextWatcherEvent) {
         sequence.add(event)
     }
@@ -43,7 +63,28 @@ abstract class UserOperationEvent(var sequence: EventSequence<TextWatcherEvent>
         return true
     }
 
-    abstract fun isUserOperationObservedInSequence(sequence: EventSequence<TextWatcherEvent>) : Boolean
+    fun isEventFoundWithinABlock(data: BeforeTextChangedEventData) : Boolean {
+        // ok finally let's make sure  we are not within a Block element
+        val inputStart = data.start + data.count
+        val inputEnd = data.start + data.count + 1
+
+        val text = data.textBefore!!
+        val isInsideList = text.getSpans(inputStart, inputEnd, AztecListItemSpan::class.java).isNotEmpty()
+        val isInsidePre = text.getSpans(inputStart, inputEnd, AztecPreformatSpan::class.java).isNotEmpty()
+        val isInsideCode = text.getSpans(inputStart, inputEnd, AztecCodeSpan::class.java).isNotEmpty()
+        var insideHeading = text.getSpans(inputStart, inputEnd, AztecHeadingSpan::class.java).isNotEmpty()
+
+        if (insideHeading && (text.length > inputEnd && text[inputEnd] == '\n')) {
+            insideHeading = false
+        }
+
+        AppLog.d(AppLog.T.EDITOR, "SEQUENCE OBSERVED COMPLETELY, IS IT WITHIN BLOCK?: " +
+                (isInsideList || insideHeading || isInsidePre || isInsideCode))
+
+        return isInsideList || insideHeading || isInsidePre || isInsideCode
+    }
+
+    abstract fun isUserOperationObservedInSequence(sequence: EventSequence<TextWatcherEvent>) : ObservedOperationResultType
     abstract fun buildReplacementEventWithSequenceData(sequence: EventSequence<TextWatcherEvent>) : TextWatcherEvent
 }
 
diff --git a/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/sequence/known/space/API26InWordSpaceInsertionEvent.kt b/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/sequence/known/space/API26InWordSpaceInsertionEvent.kt
@@ -42,7 +42,7 @@ class API26InWordSpaceInsertionEvent : UserOperationEvent() {
         addSequenceStep(step4)
     }
 
-    override fun isUserOperationObservedInSequence(sequence: EventSequence<TextWatcherEvent>): Boolean {
+    override fun isUserOperationObservedInSequence(sequence: EventSequence<TextWatcherEvent>): ObservedOperationResultType {
         /* here check:
 
         If we have 2 deletes followed by 2 inserts AND:
@@ -55,7 +55,7 @@ class API26InWordSpaceInsertionEvent : UserOperationEvent() {
 
             // populate data in our own sequence to be able to run the comparator checks
             if (!isUserOperationPartiallyObservedInSequence(sequence)) {
-                return false
+                return ObservedOperationResultType.SEQUENCE_NOT_FOUND
             }
 
             // ok all events are good individually and match the sequence we want to compare against.
@@ -68,12 +68,19 @@ class API26InWordSpaceInsertionEvent : UserOperationEvent() {
                 // now check that the inserted character is actually a space
                 val data = firstEvent.beforeEventData
                 if (lastEvent.afterEventData.textAfter!![data.start + data.count] == SPACE) {
-                    return true
+                    // okay sequence has been observed completely, let's make sure we are not within a Block
+                    if (!isEventFoundWithinABlock(data)) {
+                        return ObservedOperationResultType.SEQUENCE_FOUND
+                    } else {
+                        // we're within a Block, things are going to be handled by the BlockHandler so let's just request
+                        // a queue clear only
+                        return ObservedOperationResultType.SEQUENCE_FOUND_CLEAR_QUEUE
+                    }
                 }
             }
         }
 
-        return false
+        return ObservedOperationResultType.SEQUENCE_NOT_FOUND
     }
 
     override fun buildReplacementEventWithSequenceData(sequence: EventSequence<TextWatcherEvent>): TextWatcherEvent {
diff --git a/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/sequence/known/space/API26PrependNewLineOnStyledSpecialTextEvent.kt b/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/sequence/known/space/API26PrependNewLineOnStyledSpecialTextEvent.kt
@@ -0,0 +1,103 @@
+package org.wordpress.aztec.watchers.event.sequence.known.space
+
+import org.wordpress.android.util.AppLog
+import org.wordpress.aztec.Constants
+import org.wordpress.aztec.watchers.event.sequence.EventSequence
+import org.wordpress.aztec.watchers.event.sequence.UserOperationEvent
+import org.wordpress.aztec.watchers.event.sequence.known.space.steps.TextWatcherEventDeleteText
+import org.wordpress.aztec.watchers.event.sequence.known.space.steps.TextWatcherEventInsertText
+import org.wordpress.aztec.watchers.event.sequence.known.space.steps.TextWatcherEventInsertTextDelAfter
+import org.wordpress.aztec.watchers.event.text.AfterTextChangedEventData
+import org.wordpress.aztec.watchers.event.text.TextWatcherEvent
+
+/*
+ This case implements the behavior observed in https://github.com/wordpress-mobile/AztecEditor-Android/issues/610
+ special case for block formated text like HEADING, LIST, etc.
+ */
+class API26PrependNewLineOnStyledSpecialTextEvent : UserOperationEvent() {
+
+    init {
+        // here we populate our model of reference (which is the sequence of events we expect to find)
+        // note we don' populate the TextWatcherEvents with actual data, but rather we just want
+        // to instantiate them so we can populate them later and test whether data holds true to their
+        // validation.
+
+        // 1 generic delete, followed by 1 special insert, then 1 generic insert
+        val builder = TextWatcherEventDeleteText.Builder()
+        val step1 = builder.build()
+
+        val builderStep2 = TextWatcherEventInsertTextDelAfter.Builder()
+        val step2 = builderStep2.build()
+
+        val builderStep3 = TextWatcherEventInsertText.Builder()
+        val step3 = builderStep3.build()
+
+        // add each of the steps that make up for the identified API26InWordSpaceInsertionEvent here
+        clear()
+        addSequenceStep(step1)
+        addSequenceStep(step2)
+        addSequenceStep(step3)
+    }
+
+    override fun isUserOperationObservedInSequence(sequence: EventSequence<TextWatcherEvent>): ObservedOperationResultType {
+        /* here check:
+
+        If we have 1 delete followed by 2 inserts AND:
+        1) checking the first BEFORETEXTCHANGED and
+        2) checking the LAST AFTERTEXTCHANGED
+        text length is longer by 1, and the item that is now located start of AFTERTEXTCHANGED is a NEWLINE character.
+
+         */
+        if (this.sequence.size == sequence.size) {
+
+            AppLog.d(AppLog.T.EDITOR, "aca estamos")
+            // populate data in our own sequence to be able to run the comparator checks
+            if (!isUserOperationPartiallyObservedInSequence(sequence)) {
+                return ObservedOperationResultType.SEQUENCE_NOT_FOUND
+            }
+
+            AppLog.d(AppLog.T.EDITOR, "aca estamos 2")
+
+            // ok all events are good individually and match the sequence we want to compare against.
+            // now let's make sure the BEFORE / AFTER situation is what we are trying to identify
+            val firstEvent = sequence.first()
+            val lastEvent = sequence.last()
+            val midEvent = sequence[1]
+
+            // if new text length is equal as original text length
+            if (firstEvent.beforeEventData.textBefore?.length == lastEvent.afterEventData.textAfter!!.length) {
+                //but, middle event has a new line at the start index of change
+                if (midEvent.onEventData.textOn!![midEvent.onEventData.start] == Constants.NEWLINE) {
+                    // okay sequence has been observed completely, let's make sure we are not within a Block
+                    if (!isEventFoundWithinABlock(firstEvent.beforeEventData)) {
+                        return ObservedOperationResultType.SEQUENCE_FOUND
+                    } else {
+                        // we're within a Block, things are going to be handled by the BlockHandler so let's just request
+                        // a queue clear only
+                        return ObservedOperationResultType.SEQUENCE_FOUND_CLEAR_QUEUE
+                    }
+                }
+            }
+        }
+
+        return ObservedOperationResultType.SEQUENCE_NOT_FOUND
+    }
+
+    override fun buildReplacementEventWithSequenceData(sequence: EventSequence<TextWatcherEvent>): TextWatcherEvent {
+        val builder = TextWatcherEventInsertText.Builder()
+        // here make it all up as a unique event that does the insert as usual, as we'd get it on older APIs
+        val firstEvent = sequence.first()
+
+        val (oldText) = firstEvent.beforeEventData
+
+        val indexWhereToInsertNewLine = firstEvent.beforeEventData.start
+        oldText?.insert(indexWhereToInsertNewLine, Constants.NEWLINE_STRING)
+
+        builder.afterEventData = AfterTextChangedEventData(oldText)
+        val replacementEvent = builder.build()
+        replacementEvent.insertionStart = indexWhereToInsertNewLine
+        replacementEvent.insertionLength = 1
+
+        return replacementEvent
+    }
+}
diff --git a/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/sequence/known/space/API26PrependNewLineOnStyledTextEvent.kt b/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/sequence/known/space/API26PrependNewLineOnStyledTextEvent.kt
@@ -37,7 +37,7 @@ class API26PrependNewLineOnStyledTextEvent : UserOperationEvent() {
         addSequenceStep(step3)
     }
 
-    override fun isUserOperationObservedInSequence(sequence: EventSequence<TextWatcherEvent>): Boolean {
+    override fun isUserOperationObservedInSequence(sequence: EventSequence<TextWatcherEvent>): ObservedOperationResultType {
         /* here check:
 
         If we have 1 delete followed by 2 inserts AND:
@@ -50,7 +50,7 @@ class API26PrependNewLineOnStyledTextEvent : UserOperationEvent() {
 
             // populate data in our own sequence to be able to run the comparator checks
             if (!isUserOperationPartiallyObservedInSequence(sequence)) {
-                return false
+                return ObservedOperationResultType.SEQUENCE_NOT_FOUND
             }
 
             // ok all events are good individually and match the sequence we want to compare against.
@@ -63,12 +63,19 @@ class API26PrependNewLineOnStyledTextEvent : UserOperationEvent() {
                 // now check that the inserted character is actually a NEWLINE
                 val data = firstEvent.beforeEventData
                 if (lastEvent.afterEventData.textAfter!![data.start] == Constants.NEWLINE) {
-                    return true
+                    // okay sequence has been observed completely, let's make sure we are not within a Block
+                    if (!isEventFoundWithinABlock(data)) {
+                        return ObservedOperationResultType.SEQUENCE_FOUND
+                    } else {
+                        // we're within a Block, things are going to be handled by the BlockHandler so let's just request
+                        // a queue clear only
+                        return ObservedOperationResultType.SEQUENCE_FOUND_CLEAR_QUEUE
+                    }
                 }
             }
         }
 
-        return false
+        return ObservedOperationResultType.SEQUENCE_NOT_FOUND
     }
 
     override fun buildReplacementEventWithSequenceData(sequence: EventSequence<TextWatcherEvent>): TextWatcherEvent {
diff --git a/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/sequence/known/space/steps/TextWatcherEventInsertTextDelAfter.kt b/aztec/src/main/kotlin/org/wordpress/aztec/watchers/event/sequence/known/space/steps/TextWatcherEventInsertTextDelAfter.kt
@@ -0,0 +1,47 @@
+package org.wordpress.aztec.watchers.event.sequence.known.space.steps
+
+import org.wordpress.android.util.AppLog
+import org.wordpress.aztec.watchers.EndOfBufferMarkerAdder
+import org.wordpress.aztec.watchers.event.text.AfterTextChangedEventData
+import org.wordpress.aztec.watchers.event.text.BeforeTextChangedEventData
+import org.wordpress.aztec.watchers.event.text.OnTextChangedEventData
+import org.wordpress.aztec.watchers.event.text.TextWatcherEvent
+
+/*
+This is a special kind of observed midway event, where the afterTextChanged event has the same content as the beforeTextChanged, but
+both the beforeTextChanged and onTextChanged event data correspond to an insertion.
+ */
+
+class TextWatcherEventInsertTextDelAfter(beforeEventData: BeforeTextChangedEventData, onEventData: OnTextChangedEventData, afterEventData: AfterTextChangedEventData) : TextWatcherEvent(beforeEventData, onEventData, afterEventData) {
+
+    private var beforeText: CharSequence? = null
+
+    private fun testBeforeTextChangedEventData(data: BeforeTextChangedEventData): Boolean {
+        beforeText = data.textBefore
+        AppLog.d(AppLog.T.EDITOR, "INSERTSPECIAL testBeforeTextChangedEventData: " + (data.count == 0 && data.after > 0))
+        return data.count == 0 && data.after > 0
+    }
+
+    private fun testOnTextChangedEventData(data: OnTextChangedEventData): Boolean {
+        AppLog.d(AppLog.T.EDITOR, "INSERTSPECIAL testOnTextChangedEventData: " + (data.start >= 0 && data.count > 0 && data.textOn!!.length > 0))
+        return data.start >= 0 && data.count > 0 && data.textOn!!.length > 0
+    }
+
+    private fun testAfterTextChangedEventData(data: AfterTextChangedEventData): Boolean {
+        AppLog.d(AppLog.T.EDITOR, "INSERTSPECIAL testAfterTextChangedEventData: " + (EndOfBufferMarkerAdder.safeLength(beforeText!!) == EndOfBufferMarkerAdder.safeLength(data.textAfter!!)))
+        return EndOfBufferMarkerAdder.safeLength(beforeText!!) == EndOfBufferMarkerAdder.safeLength(data.textAfter!!)
+    }
+
+    override fun testFitsBeforeOnAndAfter(): Boolean {
+        return (testBeforeTextChangedEventData(beforeEventData)
+                && testOnTextChangedEventData(onEventData)
+                && testAfterTextChangedEventData(afterEventData))
+    }
+
+    class Builder : TextWatcherEvent.Builder() {
+        override fun build(): TextWatcherEventInsertTextDelAfter {
+            super.setGenericEventDataIfNotInit()
+            return TextWatcherEventInsertTextDelAfter(beforeEventData, onEventData, afterEventData)
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -55,13 +55,19 @@ class ObservationQueue(val injector: IEventInjector) : EventSequence<TextWatcher`
`55`	`55`	`}`
`56`	`56`	`} else {`
`57`	`57`	`// does this particular event look like a part of any of the user operations as defined in this bucket?`
`58`		`- if (operation.isUserOperationObservedInSequence(this)) {`
	`58`	`+ val result = operation.isUserOperationObservedInSequence(this)`
	`59`	`+ if (operation.isFound(result)) {`
`59`	`60`	`// replace user operation with ONE TextWatcherEvent and inject this one in the actual`
`60`	`61`	`// textwatchers`
`61`	`62`	`val replacementEvent = operation.buildReplacementEventWithSequenceData(this)`
`62`	`63`	`injector.executeEvent(replacementEvent)`
`63`	`64`	`clear()`
`64`	`65`	`}`
	`66`	`+`
	`67`	`+ // regardless of the operation being found, let's check if it needs the queue to be cleared`
	`68`	`+ if (operation.needsClear(result)) {`
	`69`	`+ clear()`
	`70`	`+ }`
`65`	`71`	`}`
`66`	`72`	`}`
`67`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ class API26InWordSpaceInsertionEvent : UserOperationEvent() {`
`42`	`42`	`addSequenceStep(step4)`
`43`	`43`	`}`
`44`	`44`
`45`		`- override fun isUserOperationObservedInSequence(sequence: EventSequence<TextWatcherEvent>): Boolean {`
	`45`	`+ override fun isUserOperationObservedInSequence(sequence: EventSequence<TextWatcherEvent>): ObservedOperationResultType {`
`46`	`46`	`/* here check:`
`47`	`47`
`48`	`48`	`If we have 2 deletes followed by 2 inserts AND:`
`@@ -55,7 +55,7 @@ class API26InWordSpaceInsertionEvent : UserOperationEvent() {`
`55`	`55`
`56`	`56`	`// populate data in our own sequence to be able to run the comparator checks`
`57`	`57`	`if (!isUserOperationPartiallyObservedInSequence(sequence)) {`
`58`		`- return false`
	`58`	`+ return ObservedOperationResultType.SEQUENCE_NOT_FOUND`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`// ok all events are good individually and match the sequence we want to compare against.`
`@@ -68,12 +68,19 @@ class API26InWordSpaceInsertionEvent : UserOperationEvent() {`
`68`	`68`	`// now check that the inserted character is actually a space`
`69`	`69`	`val data = firstEvent.beforeEventData`
`70`	`70`	`if (lastEvent.afterEventData.textAfter!![data.start + data.count] == SPACE) {`
`71`		`- return true`
	`71`	`+ // okay sequence has been observed completely, let's make sure we are not within a Block`
	`72`	`+ if (!isEventFoundWithinABlock(data)) {`
	`73`	`+ return ObservedOperationResultType.SEQUENCE_FOUND`
	`74`	`+ } else {`
	`75`	`+ // we're within a Block, things are going to be handled by the BlockHandler so let's just request`
	`76`	`+ // a queue clear only`
	`77`	`+ return ObservedOperationResultType.SEQUENCE_FOUND_CLEAR_QUEUE`
	`78`	`+ }`
`72`	`79`	`}`
`73`	`80`	`}`
`74`	`81`	`}`
`75`	`82`
`76`		`- return false`
	`83`	`+ return ObservedOperationResultType.SEQUENCE_NOT_FOUND`
`77`	`84`	`}`
`78`	`85`
`79`	`86`	`override fun buildReplacementEventWithSequenceData(sequence: EventSequence<TextWatcherEvent>): TextWatcherEvent {`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ class API26PrependNewLineOnStyledTextEvent : UserOperationEvent() {`
`37`	`37`	`addSequenceStep(step3)`
`38`	`38`	`}`
`39`	`39`
`40`		`- override fun isUserOperationObservedInSequence(sequence: EventSequence<TextWatcherEvent>): Boolean {`
	`40`	`+ override fun isUserOperationObservedInSequence(sequence: EventSequence<TextWatcherEvent>): ObservedOperationResultType {`
`41`	`41`	`/* here check:`
`42`	`42`
`43`	`43`	`If we have 1 delete followed by 2 inserts AND:`
`@@ -50,7 +50,7 @@ class API26PrependNewLineOnStyledTextEvent : UserOperationEvent() {`
`50`	`50`
`51`	`51`	`// populate data in our own sequence to be able to run the comparator checks`
`52`	`52`	`if (!isUserOperationPartiallyObservedInSequence(sequence)) {`
`53`		`- return false`
	`53`	`+ return ObservedOperationResultType.SEQUENCE_NOT_FOUND`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`// ok all events are good individually and match the sequence we want to compare against.`
`@@ -63,12 +63,19 @@ class API26PrependNewLineOnStyledTextEvent : UserOperationEvent() {`
`63`	`63`	`// now check that the inserted character is actually a NEWLINE`
`64`	`64`	`val data = firstEvent.beforeEventData`
`65`	`65`	`if (lastEvent.afterEventData.textAfter!![data.start] == Constants.NEWLINE) {`
`66`		`- return true`
	`66`	`+ // okay sequence has been observed completely, let's make sure we are not within a Block`
	`67`	`+ if (!isEventFoundWithinABlock(data)) {`
	`68`	`+ return ObservedOperationResultType.SEQUENCE_FOUND`
	`69`	`+ } else {`
	`70`	`+ // we're within a Block, things are going to be handled by the BlockHandler so let's just request`
	`71`	`+ // a queue clear only`
	`72`	`+ return ObservedOperationResultType.SEQUENCE_FOUND_CLEAR_QUEUE`
	`73`	`+ }`
`67`	`74`	`}`
`68`	`75`	`}`
`69`	`76`	`}`
`70`	`77`
`71`		`- return false`
	`78`	`+ return ObservedOperationResultType.SEQUENCE_NOT_FOUND`
`72`	`79`	`}`
`73`	`80`
`74`	`81`	`override fun buildReplacementEventWithSequenceData(sequence: EventSequence<TextWatcherEvent>): TextWatcherEvent {`