merge

/** :name=Merge or split segments :description=Merge current segment with the next or split it at the selection
 *
 * @author  Yu Tang, Dimitry Prihodko, Kos Ivantsov
 * @date    2016-01-12
 * @version 0.3
 */
import org.apache.commons.lang.WordUtils
import org.omegat.core.segmentation.MapRule
import org.omegat.core.segmentation.Rule
import org.omegat.core.segmentation.SRX
import org.omegat.util.Language
import org.omegat.util.OStrings
import javax.swing.JOptionPane

import static javax.swing.JOptionPane.*
import static org.omegat.gui.main.ProjectUICommands.projectReload
import static org.omegat.util.StaticUtils.escapeNonRegex
import static org.omegat.util.StringUtil.makeValidXML

//check if we have selection at the end of the current source
def entry = editor.currentEntry
def src = entry.srcText
def split
if (editor.selectedText) {
    sel = editor.selectedText
    split = src.endsWith(sel) ? true : false
    if (split) {
        console.println(res.getString("endSelected"))
    }else{
        console.println(res.getString("wrongSelected"))
    }
}

split = split ? true : false

initializeScript()

// check if requirements are met
if (! isReadyForNewRule()) {
    return
}

//get fragments to split or merge
String beforeBreak = split ? src - sel : entry.srcText
String afterBreak = split ? sel : entry.key.next


// exists check for the MappingRule
Language srcLang = project.projectProperties.sourceLanguage
def mapRule = project.projectProperties.projectSRX.findMappingRule(srcLang)
if (! mapRule) {
    message = res.getString("noMappingRule") + res.getString("terminating")
    message.alert()
    return
}

// show confirm dialog
def separator = ""
if (! srcLang.isCJK()) {
    separator = " "
}
String message = split ?
WordUtils.wrap("$beforeBreak\n$afterBreak\n\n", 180) + res.getString("proceed") :
WordUtils.wrap("$beforeBreak$separator$afterBreak\n\n", 180) + res.getString("proceed")
if (message.confirm() == NO_OPTION) {
    console.clear()
    console.println(res.getString("noNewRule"))
    return
}

// create new rule
boolean breakRule = split ? true : false // Exception
beforeBreak = beforeBreak.toRegexPattern()
afterBreak = afterBreak.toRegexPattern()
if (! split && ! srcLang.isCJK()) {
    afterBreak = /\s/ + afterBreak
}
def rule = new Rule(breakRule, beforeBreak, afterBreak)

// check if there's a conficting split rule
def conflict = mapRule.rules.find {
    it.beforebreak.trim() == beforeBreak.trim() && it.afterbreak.replaceAll(/^\\s/, '').trim() == afterBreak.replaceAll(/^\\s/, '').trim()
}
if (conflict) {
    mapRule.rules.remove(conflict)
}


// exists check for the new rule
def found = mapRule.rules.find {
    it.beforebreak == beforeBreak && it.afterbreak == afterBreak
}
if (found) {
    message = res.getString("ruleExists") + res.getString("terminating")
    message.alert()
    return
}

// register new rule to the segmentation
mapRule.rules[0..<0] = rule // Appends a new rule to the head of List.

// reload the project
if (showConfirmDialog(mainWindow, OStrings.getString("MW_REOPEN_QUESTION"),
    OStrings.getString("MW_REOPEN_TITLE"), JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION) {
    projectReload()
    }else{
    console.print(res.getString("noReload"))
    return
}

// fin
console.println(res.getString("newSegmentationActive") + "(${new Date().timeString})")

// ******************************************************
// methods
// ******************************************************
boolean isReadyForNewRule() {
    if (! project.isProjectLoaded()) {
        message = res.getString("noProjectOpen") + res.getString("terminating")
        return message.alert()
    }

    def srx = project.projectProperties.projectSRX
    if (! srx) {
        message = res.getString("noProjectSegmentation") + res.getString("terminating")
        return message.alert()
    }

    def entry = editor.currentEntry
    def src = entry.srcText
    def split
    def sel
    if (editor.selectedText) {
        sel = editor.selectedText
        split = src.endsWith(sel) ? true : false
    }
    split = split ? true :false

    if (! split && (! entry.srcText || ! entry.key.next)) {
        message = res.getString("noMerge") + res.getString("terminating")
        return message.alert()
    }

    if ( split && (src == sel) ) {
        message = res.getString("noSplit") + res.getString("terminating")
        return message.alert()
    }

    // OK
    true
}

void initializeScript() {

    def entry = editor.currentEntry
    def src = entry.srcText
    def split
    if (editor.selectedText) {
        def sel = editor.selectedText
        split = src.endsWith(sel) ? true : false
    }

    // String class
    String.metaClass.toXML = { ->
        makeValidXML(delegate as String)
    }
    String.metaClass.toRegexPattern = { ->
        escapeNonRegex(delegate as String)
    }
    String.metaClass.alert = { ->
        showMessageDialog null, delegate, split ? res.getString("splitTitle") : res.getString("mergeTitle"), INFORMATION_MESSAGE
        false
    }
    String.metaClass.confirm = { ->
        showConfirmDialog null, delegate, split ? res.getString("splitMessage") : res.getString("mergeMessage"), YES_NO_OPTION
    }

    // SRX class
    SRX.metaClass.findMappingRule = { Language srclang ->
        delegate.mappingRules.find { MapRule maprule ->
            maprule.compiledPattern.matcher(srclang.language).matches()
        }
    }

    // Language class
    Language.metaClass.isCJK = { ->
        delegate.languageCode.toUpperCase(Locale.ENGLISH) in ['ZH', 'JA', 'KO']
    }
}