Laboratoire ICAR » Plateforme TXM

// Copyright © 2016 ENS de Lyon, CNRS, University of Franche-Comté

// Licensed under the terms of the GNU General Public License (http://www.gnu.org/licenses)

// @author mdecorde

// @author sheiden

// STANDARD DECLARATIONS

package org.txm.macro.urs.exploit

import org.apache.commons.lang.StringUtils

import org.kohsuke.args4j.*

import groovy.transform.Field

import org.txm.Toolbox

import org.txm.rcp.swt.widget.parameters.*

import org.txm.annotation.urs.*

import org.txm.concordance.core.functions.Concordance

import org.txm.concordance.rcp.editors.ConcordanceEditor

import org.txm.concordance.rcp.handlers.*

import org.txm.macro.urs.AnalecUtils

import org.txm.searchengine.cqp.AbstractCqiClient

import org.txm.searchengine.cqp.ReferencePattern

import org.txm.searchengine.cqp.corpus.*

import org.txm.searchengine.cqp.corpus.query.CQLQuery

import org.txm.searchengine.cqp.CQPSearchEngine

import visuAnalec.donnees.Structure

import visuAnalec.elements.*

def scriptName = this.class.getSimpleName()

def selection = []

for (def s : corpusViewSelections) {

        if (s instanceof CQPCorpus) selection << s

        else if (s instanceof Partition) selection.addAll(s.getParts())

}

if (selection.size() == 0) {

        println "** $scriptName: please select a Corpus or a Partition in the Corpus view: "+corpusViewSelections

        return false

} else {

        for (def c : selection) c.compute(false)

}

// BEGINNING OF PARAMETERS

@Field @Option(name="schema_ursql", usage="TYPE@PROP=VALUE", widget="String", required=true, def="CHAINE")

                String schema_ursql

@Field @Option(name="minimum_schema_size", usage="Minimum size needed to consider a schema", widget="Integer", required=true, def="3")

                int minimum_schema_size

@Field @Option(name="maximum_schema_size", usage="Maximum size needed to consider a schema", widget="Integer", required=true, def="9999999")

                int maximum_schema_size

@Field @Option(name="unit_ursql", usage="TYPE@PROP=VALUE", widget="String", required=false, def="MENTION")

                String unit_ursql

@Field @Option(name="position_in_schema", usage="Unit distance in schema (0 = no selection, 1 = first after limit, -1 = last before limit, etc.)", widget="Integer", required=true, def="0")

                int position_in_schema

@Field @Option(name="cql_limit", usage="CQL to build structure limits", widget="Query", required=false, def="")

                cql_limit

@Field @Option(name="strict_inclusion", usage="Units must be strictly included into corpus matches", widget="Boolean", required=true, def="true")

                boolean strict_inclusion

@Field @Option(name="position_in_matches", usage="Unit distance to structure limit (0 = no selection, 1 = first after limit, -1 = last before limit, etc.)", widget="Integer", required=true, def="0")

                int position_in_matches

@Field @Option(name="output_mode", usage="If selected units properties and words are shown", widget="StringArray", metaVar="FORMATED        TABULATED        COUNT        CQL        CONCORDANCE", required=true, def="FORMATED")

                output_mode

@Field @Option(name="debug", usage="Show internal variable content", widget="StringArray", metaVar="OFF        ON        ALL        REALLY ALL", required=true, def="OFF")

                debug

if (!ParametersDialog.open(this)) return;

if (debug == "OFF") debug = 0; else if (debug == "ON") debug = 1; else if (debug == "ALL") debug = 2 else if (debug == "REALLY ALL") debug = 3

def CQI = CQPSearchEngine.getCqiClient()

//corpus = corpusViewSelection

def allResults = [:]

for (def corpus : selection) {

        def word = corpus.getWordProperty()

        def analecCorpus = URSCorpora.getCorpus(corpus)

        def selectedUnits = AnalecUtils.selectUnitsInSchema(debug, analecCorpus, corpus, schema_ursql, minimum_schema_size, maximum_schema_size,

                        unit_ursql, position_in_schema, cql_limit, strict_inclusion, position_in_matches);

        def n = 1

        allResults[corpus] = selectedUnits

}

if (output_mode == "FORMATED") {

        for (def corpus : allResults.keySet()) {

                def word = corpus.getWordProperty()

                def selectedUnits = allResults[corpus]

                println "$corpus units: "+selectedUnits.size()

                def n = 1

                for (def unit : selectedUnits) {

                        int[] pos = null

                        if (unit.getDeb() == unit.getFin()) pos = [unit.getDeb()]

                        else pos = (unit.getDeb()..unit.getFin())

                        def form = StringUtils.join(CQI.cpos2Str(word.getQualifiedName(), pos), " ")

                        def props = unit.getProps().sort()

                        println sprintf("#%4d, %d-%d, \"%s\" %s", n, unit.getDeb(), unit.getFin(), form, props)

                        n++

                }

        }

} else if (output_mode == "TABULATED") {

        for (def corpus : allResults.keySet()) {

                def word = corpus.getWordProperty()

                def selectedUnits = allResults[corpus]

                println "$corpus units: "+selectedUnits.size()

                def n = 1

                for (def unit : selectedUnits) {

                        int[] pos = null

                        if (unit.getDeb() == unit.getFin()) pos = [unit.getDeb()]

                        else pos = (unit.getDeb()..unit.getFin())

                        def form = StringUtils.join(CQI.cpos2Str(word.getQualifiedName(), pos), " ")

                        def props = unit.getProps().sort()

                        println sprintf("#%4d\t%d\t%d\t%s\t%s", n, unit.getDeb(), unit.getFin(), form, props)

                        n++

                }

        }

} else if (output_mode == "COUNT") {

        for (def corpus : allResults.keySet()) {

                def selectedUnits = allResults[corpus]

                println "$corpus units: "+selectedUnits.size()

        }

} else if (output_mode == "CQL") {

        for (def corpus : allResults.keySet()) {

                def selectedUnits = allResults[corpus]

                println "$corpus units: "+selectedUnits.size()

                println AnalecUtils.getCQL(corpus.getID(), selectedUnits)

        }

} else if (output_mode == "CONCORDANCE") {

        for (def corpus : allResults.keySet()) {

                def word = corpus.getProperty("word")

                def text_id = corpus.getStructuralUnit("text").getProperty("id")

                def selectedUnits = allResults[corpus]

                def query = ""

                if (schema_ursql != null) query+= " $schema_ursql"

                if (unit_ursql != null) query+= " $unit_ursql"

                def ret  = AnalecUtils.getStartsEndsTargetsArrays(selectedUnits)

                def starts = ret[0]

                def ends = ret[1]

                def targets = ret[2]

                FakeQueryResult fqr = new FakeQueryResult("Fake", corpus, new CQLQuery(query), starts, ends, targets)

                Concordance concordance = new Concordance(corpus);

                concordance.setParameters(new CQLQuery(""), [word],[word],[word],

                [word],[word],[word],

                new ReferencePattern(text_id), new ReferencePattern(text_id), 7, 10)

                concordance.setQueryResult(fqr)

                if (monitor == null) {

                        println "Error: cannot open concordance editor: null monitor"

                        return

                }

                monitor.syncExec(new Runnable() {

                                        public void run() {

                                                try {

                                                        concordance.compute(); // skip the CQI.query step

                                                        ConcordanceEditor editor = ComputeConcordance.openEditor(concordance);

                                                } catch(Throwable error) {

                                                        println "Error: "+error;

                                                        error.printStackTrace();

                                                }

                                        }

                                });

        }

}

return allResults