1# - Manage Zanata translation service support 2# 3# Zanata is a web-based translation services, this module creates required targets. 4# for common Zanata operation, like put-project, put-version, 5# push source and/or translation, pull translation and/or sources. 6# 7# 8# Included Modules: 9# - ManageFile 10# - ManageMessage 11# - ManageString 12# - ManageTranslation 13# 14# Define following functions: 15# MANAGE_ZANATA([[URL] <serverUrl>] [YES] [ERRORS] [DEBUG] 16# [CHUNK_SIZE <sizeInByte>] 17# [CLEAN_ZANATA_XML] 18# [CLIENT_COMMAND <command> ] 19# [COPY_TRANS <bool>] 20# [CREATE_SKELETONS] 21# [DISABLE_SSL_CERT] 22# [ENCODE_TABS <bool>] 23# [EXCLUDES <filePatternList>] 24# [GENERATE_ZANATA_XML] 25# [INCLUDES <filePatternList>] 26# [LOCALES <locale1,locale2...> ] 27# [PROJECT <projectId>] 28# [PROJECT_CONFIG <zanata.xml>] 29# [PROJECT_DESC "<Description>"] 30# [PROJECT_NAME "<project name>"] 31# [PROJECT_TYPE <projectType>] 32# [SRC_DIR <srcDir>] 33# [TRANS_DIR <transDir>] 34# [TRANS_DIR_PULL <transDir>] 35# [USER_CONFIG <zanata.ini>] 36# [USERNAME <username>] 37# [VERSION <ver>] 38# [ZANATA_EXECUTABLE <command> ] 39# ) 40# - Use Zanata as translation service. 41# Zanata is a web-based translation manage system. 42# It uses ${PROJECT_NAME} as project Id (slug); 43# ${PRJ_NAME} as project name; 44# ${PRJ_SUMMARY} as project description 45# (truncate to 80 characters); 46# and ${PRJ_VER} as version, unless VERSION option is defined. 47# 48# In order to use Zanata with command line, you will need either 49# Zanata client: 50# * zanata-cli: Zanata java command line client. 51# * mvn: Maven build system. 52# * zanata: Zanata python command line client. 53# 54# In addition, ~/.config/zanata.ini is also required as it contains API key. 55# API key should not be put in source tree, otherwise it might be 56# misused. 57# 58# Feature disabled warning (M_OFF) will be shown if Zanata client 59# or zanata.ini is missing. 60# * Parameters: 61# + serverUrl: (Optional) The URL of Zanata server 62# Default: https://translate.zanata.org/zanata/ 63# + YES: (Optional) Assume yes for all questions. 64# + ERROR: (Optional) Show errors. As "-e" in maven. 65# + DEBUG: (Optional) Show debug message. As "-X" in maven. 66# + CLEAN_ZANATA_XML: (Optional) zanata.xml will be removed with 67# "make clean" 68# + CLIENT_COMMAND command: (Optional)(Depreciated) command path to Zanata client. 69# Use ZANATA_EXECUTABLE instead. 70# Default: "zanata-cli" 71# + COPY_TRANS bool: (Optional) Copy translation from existing versions. 72# Default: "true" 73# + CREATE_SKELETONS: (Optional) Create .po file even if there is no translation 74# + DISABLE_SSL_CERT: (Optional) Disable SSL Cert check. 75# + ENCODE_TABS bool: (Optional) Encode tab as "\t"/ 76# + EXCLUDES: (Optional) The file pattern that should not be pushed as source. 77# e.g. **/debug*.properties 78# + GENERATE_ZANATA_XML: (Optional) Automatic generate a zanata.xml 79# + INCLUDES: (Optional) The file pattern that should be pushed as source. 80# e.g. **/debug*.properties 81# + LOCALES locales: Locales to sync with Zanata. 82# Specify the locales to sync with this Zanata server. 83# If not specified, it uses client side system locales. 84# + PROJECT projectId: (Optional) This project ID in Zanata. 85# (Space not allowed) 86# Default: CMake Variable PROJECT_NAME 87# + PROJECT_CONFIG zanata.xml: (Optoional) Path to zanata.xml 88# If not specified, it will try to find zanata.xml in following directories: 89# ${CMAKE_SOURCE_DIRECTORY} 90# ${CMAKE_SOURCE_DIRECTORY}/po 91# ${CMAKE_CURRENT_SOURCE_DIRECTORY} 92# ${CMAKE_CURRENT_SOURCE_DIRECTORY}/po 93# ${CMAKE_CURRENT_BINARY_DIR} 94# if none found, it will set to: 95# ${CMAKE_CURRENT_BINARY_DIR}/zanata.xml 96# + PROJECT_DESC "Project description": (Optoional) Project description in Zanata. 97# Default: ${PRJ_DESCRIPTION} 98# + PROJECT_NAME "project name": (Optional) Project display name in Zanata. 99# (Space allowed) 100# Default: CMake Variable PROJECT_NAME 101# + PROJECT_TYPE projectType::(Optional) Zanata project type 102# for this version. 103# Normally version inherit the project-type from project, 104# if this is not the case, use this parameter to specify 105# the project type. 106# Valid values: file, gettext, podir, properties, 107# utf8properties, xliff 108# + SRC_DIR dir: (Optional) Directory to put source documents like .pot 109# This value will be put in zanata.xml, so it should be relative. 110# Default: "." 111# + TRANS_DIR dir: (Optional) Relative directory to push the translated 112# translated documents like .po 113# This value will be put in zanata.xml, so it should be relative. 114# Default: "." 115# + TRANS_DIR_PULL dir: (Optional) Directory to pull translated documents. 116# Default: CMAKE_CURRENT_BINARY_DIR 117# + USER_CONFIG zanata.ini: (Optoional) Path to zanata.ini 118# Feature disabled warning (M_OFF) will be shown if 119# if zanata.ini is missing. 120# Default: $HOME/.config/zanata.ini 121# + USERNAME username: (Optional) Zanata username 122# + VERSION version: (Optional) The version to push 123# + ZANATA_EXECUTABLE command : (Optional) command path to Zanata client. 124# Default: "zanata-cli" 125# * Targets: 126# + zanata_put_projet: Put project in zanata server. 127# + zanata_put_version: Put version in zanata server. 128# + zanata_push: Push source messages to zanata server. 129# + zanata_push_trans: Push translations to zanata server. 130# + zanata_push_both: Push source messages and translations to 131# zanata server. 132# + zanata_pull: Pull translations from zanata server. 133# * Variable Cached: 134# + ZANATA_CLIENT_EXECUTABLE: Full path of the client program. 135# + ZANATA_CLIENT_TYPE: The type of Zanata client, either 136# java: Java client 137# python: Python client 138# mvn: zanata-maven-plugin 139# 140 141 142IF(DEFINED _MANAGE_ZANATA_CMAKE_) 143 RETURN() 144ENDIF(DEFINED _MANAGE_ZANATA_CMAKE_) 145SET(_MANAGE_ZANATA_CMAKE_ "DEFINED") 146INCLUDE(ManageMessage) 147INCLUDE(ManageFile) 148INCLUDE(ManageString) 149INCLUDE(ManageTranslation) 150INCLUDE(ManageVariable) 151INCLUDE(ManageZanataDefinition) 152INCLUDE(ManageZanataSuggest) 153 154## Variable ZANATA_* are compulsory 155SET(ZANATA_DESCRIPTION_SIZE 80 CACHE STRING "Zanata description size") 156 157####################################### 158# ZANATA "Object" 159# 160MACRO(MANAGE_ZANATA_XML_OBJECT_NEW var url ) 161 SET(${var} "url") 162 SET(${var}_url "${url}") 163 FOREACH(arg ${ARGN}) 164 IF("${${var}_project}" STREQUAL "") 165 MANAGE_ZANATA_XML_OBJECT_ADD_PROPERTY(${var} "project" "${arg}") 166 ELSEIF("${${var}_version}" STREQUAL "") 167 MANAGE_ZANATA_XML_OBJECT_ADD_PROPERTY(${var} "version" "${arg}") 168 ELSEIF("${${var}_type}" STREQUAL "") 169 MANAGE_ZANATA_XML_OBJECT_ADD_PROPERTY(${var} "type" "${arg}") 170 ENDIF() 171 ENDFOREACH(arg) 172ENDMACRO(MANAGE_ZANATA_XML_OBJECT_NEW) 173 174MACRO(MANAGE_ZANATA_XML_OBJECT_ADD_PROPERTY var key value ) 175 LIST(APPEND ${var} "${key}") 176 SET(${var}_${key} "${value}") 177ENDMACRO(MANAGE_ZANATA_XML_OBJECT_ADD_PROPERTY) 178 179FUNCTION(MANAGE_ZANATA_XML_OBJECT_TO_STRING outputVar var) 180 SET(buf "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>") 181 STRING_APPEND(buf "<config xmlns=\"http://zanata.org/namespace/config/\">" "\n") 182 STRING_APPEND(buf " <url>${${var}_url}</url>" "\n") 183 STRING_APPEND(buf " <project>${${var}_project}</project>" "\n") 184 STRING_APPEND(buf " <project-version>${${var}_version}</project-version>" "\n") 185 STRING(TOLOWER "${${var}_type}" projectType) 186 STRING_APPEND(buf " <project-type>${projectType}</project-type>" "\n") 187 IF(NOT "${${var}_srcdir}" STREQUAL "") 188 STRING_APPEND(buf " <src-dir>${${var}_srcdir}</src-dyr>" "\n") 189 ENDIF() 190 IF(NOT "${${var}_transdir}" STREQUAL "") 191 STRING_APPEND(buf " <trans-dir>${${var}_transdir}</trans-dir>" "\n") 192 ENDIF() 193 IF(NOT "${${var}_locales}" STREQUAL "") 194 STRING_APPEND(buf " <locales>" "\n") 195 FOREACH(l ${${${var}_locales}) 196 IF(NOT "${${var}_locales_${l}}" STREQUAL "") 197 STRING_APPEND(buf " <locale map-from=\"${${var}_locales_${l}}\">${l}</locale>" "\n") 198 ELSE() 199 STRING_APPEND(buf " <locale>${l}</locale>" "\n") 200 ENDIF() 201 ENDFOREACH(l) 202 STRING_APPEND(buf " </locales>" "\n") 203 ENDIF() 204 STRING_APPEND(buf "</config>" "\n") 205 SET(${outputVar} "${buf}" PARENT_SCOPE) 206ENDFUNCTION(MANAGE_ZANATA_XML_OBJECT_TO_STRING) 207 208####################################### 209## Option Conversion Function 210 211## ZANATA_STRING_DASH_TO_CAMEL_CASE(var opt) 212FUNCTION(ZANATA_STRING_DASH_TO_CAMEL_CASE var opt) 213 STRING_SPLIT(_strList "-" "${opt}") 214 SET(_first 1) 215 SET(_retStr "") 216 FOREACH(_s ${_strList}) 217 IF("${_retStr}" STREQUAL "") 218 SET(_retStr "${_s}") 219 ELSE() 220 STRING(LENGTH "${_s}" _len) 221 MATH(EXPR _tailLen ${_len}-1) 222 STRING(SUBSTRING "${_s}" 0 1 _head) 223 STRING(SUBSTRING "${_s}" 1 ${_tailLen} _tail) 224 STRING(TOUPPER "${_head}" _head) 225 STRING(TOLOWER "${_tail}" _tail) 226 STRING_APPEND(_retStr "${_head}${_tail}") 227 ENDIF() 228 ENDFOREACH(_s) 229 SET(${var} "${_retStr}" PARENT_SCOPE) 230ENDFUNCTION(ZANATA_STRING_DASH_TO_CAMEL_CASE) 231 232FUNCTION(ZANATA_STRING_UPPERCASE_UNDERSCORE_TO_LOWERCASE_DASH var optName) 233 STRING(REPLACE "_" "-" result "${optName}") 234 STRING(TOLOWER "${result}" result) 235 SET(${var} "${result}" PARENT_SCOPE) 236ENDFUNCTION(ZANATA_STRING_UPPERCASE_UNDERSCORE_TO_LOWERCASE_DASH) 237 238FUNCTION(ZANATA_STRING_LOWERCASE_DASH_TO_UPPERCASE_UNDERSCORE var optName) 239 STRING(REPLACE "-" "_" result "${optName}") 240 STRING(TOUPPER "${result}" result) 241 SET(${var} "${result}" PARENT_SCOPE) 242ENDFUNCTION(ZANATA_STRING_LOWERCASE_DASH_TO_UPPERCASE_UNDERSCORE) 243 244FUNCTION(ZANATA_CLIENT_OPTNAME_LIST_APPEND_MVN listVar subCommandName optName) 245 IF("${optName}" STREQUAL "BATCH") 246 LIST(APPEND ${listVar} "-B") 247 ELSEIF("${optName}" STREQUAL "ERRORS") 248 LIST(APPEND ${listVar} "-e") 249 ELSEIF("${optName}" STREQUAL "DEBUG") 250 LIST(APPEND ${listVar} "-X") 251 ELSEIF("${optName}" STREQUAL "DISABLE_SSL_CERT") 252 LIST(APPEND ${listVar} "-Dzanata.disableSSLCert") 253 ELSEIF(DEFINED ZANATA_MVN_${subCommandName}_OPTION_NAME_${optName}) 254 ## Option name that changed in subCommandName 255 ZANATA_STRING_UPPERCASE_UNDERSCORE_TO_LOWERCASE_DASH(optNameReal 256 "${ZANATA_MVN_${subCommandName}_OPTION_NAME_${optName}}") 257 ZANATA_STRING_DASH_TO_CAMEL_CASE(optNameReal "${optNameReal}") 258 IF(NOT "${ARGN}" STREQUAL "") 259 LIST(APPEND ${listVar} "-Dzanata.${optNameReal}=${ARGN}") 260 ELSE() 261 LIST(APPEND ${listVar} "-Dzanata.${optNameReal}") 262 ENDIF() 263 ELSE() 264 ZANATA_STRING_UPPERCASE_UNDERSCORE_TO_LOWERCASE_DASH(optNameReal "${optName}") 265 ZANATA_STRING_DASH_TO_CAMEL_CASE(optNameReal "${optNameReal}") 266 IF(NOT "${ARGN}" STREQUAL "") 267 LIST(APPEND ${listVar} "-Dzanata.${optNameReal}=${ARGN}") 268 ELSE() 269 LIST(APPEND ${listVar} "-Dzanata.${optNameReal}") 270 ENDIF() 271 ENDIF() 272 SET(${listVar} "${${listVar}}" PARENT_SCOPE) 273ENDFUNCTION(ZANATA_CLIENT_OPTNAME_LIST_APPEND_MVN) 274 275FUNCTION(ZANATA_CLIENT_OPTNAME_LIST_APPEND_JAVA listVar subCommandName optName) 276 IF("${optName}" STREQUAL "BATCH") 277 LIST(APPEND ${listVar} "-B") 278 ELSEIF("${optName}" STREQUAL "ERRORS") 279 LIST(APPEND ${listVar} "-e") 280 ELSEIF("${optName}" STREQUAL "DEBUG") 281 LIST(APPEND ${listVar} "-X") 282 ELSEIF(DEFINED ZANATA_MVN_${subCommandName}_OPTION_NAME_${optName}) 283 ## Option name that changed in subCommand 284 ## Option name in mvn and zanata-cli is similar, 285 ## thus use ZANATA_MVN_<subCommandName>... 286 ZANATA_STRING_UPPERCASE_UNDERSCORE_TO_LOWERCASE_DASH(optNameReal 287 "${ZANATA_MVN_${subCommandName}_OPTION_NAME_${optName}}") 288 IF(NOT "${ARGN}" STREQUAL "") 289 LIST(APPEND ${listVar} "--${optNameReal}" "${ARGN}") 290 ELSE() 291 LIST(APPEND ${listVar} "--${optNameReal}") 292 ENDIF() 293 ELSE() 294 ZANATA_STRING_UPPERCASE_UNDERSCORE_TO_LOWERCASE_DASH(optNameReal "${optName}") 295 IF(NOT "${ARGN}" STREQUAL "") 296 LIST(APPEND ${listVar} "--${optNameReal}" "${ARGN}") 297 ELSE() 298 LIST(APPEND ${listVar} "--${optNameReal}") 299 ENDIF() 300 ENDIF() 301 SET(${listVar} "${${listVar}}" PARENT_SCOPE) 302ENDFUNCTION(ZANATA_CLIENT_OPTNAME_LIST_APPEND_JAVA) 303 304FUNCTION(ZANATA_CLIENT_OPTNAME_LIST_APPEND_PYTHON listVar subCommandName optName) 305 IF("${optName}" STREQUAL "BATCH") 306 ## Python client don't have BATCH 307 ELSEIF("${optName}" STREQUAL "ERRORS") 308 ## Python client don't have ERRORS 309 ELSEIF("${optName}" STREQUAL "DEBUG") 310 ## Python client don't have DEBUG 311 ELSE() 312 ZANATA_STRING_UPPERCASE_UNDERSCORE_TO_LOWERCASE_DASH(optNameReal "${optName}") 313 IF(NOT "${ARGN}" STREQUAL "") 314 LIST(APPEND ${listVar} "--${optNameReal}" "${ARGN}") 315 ELSE() 316 LIST(APPEND ${listVar} "--${optNameReal}") 317 ENDIF() 318 ENDIF() 319 SET(${listVar} "${${listVar}}" PARENT_SCOPE) 320ENDFUNCTION(ZANATA_CLIENT_OPTNAME_LIST_APPEND_PYTHON) 321 322FUNCTION(ZANATA_CLIENT_OPTNAME_LIST_APPEND listVar subCommand optName) 323 ZANATA_STRING_LOWERCASE_DASH_TO_UPPERCASE_UNDERSCORE(subCommandName "${subCommand}") 324 ## Skip Options that should not in the final command 325 IF(optName STREQUAL "ZANATA_EXECUTABLE") 326 RETURN() 327 ENDIF() 328 329 ## Invoke corresponding command 330 IF(ZANATA_CLIENT_TYPE STREQUAL "mvn") 331 ZANATA_CLIENT_OPTNAME_LIST_APPEND_MVN(${listVar} ${subCommandName} ${optName} ${ARGN}) 332 ELSEIF(ZANATA_CLIENT_TYPE STREQUAL "java") 333 ZANATA_CLIENT_OPTNAME_LIST_APPEND_JAVA(${listVar} ${subCommandName} ${optName} ${ARGN}) 334 ELSEIF(ZANATA_CLIENT_TYPE STREQUAL "python") 335 ZANATA_CLIENT_OPTNAME_LIST_APPEND_PYTHON(${listVar} ${subCommandName} ${optName} ${ARGN}) 336 ELSE() 337 M_MSG(${M_ERROR} "ManageZanata: Unrecognized zanata client type ${ZANATA_CLIENT_TYPE}") 338 ENDIF() 339 SET(${listVar} "${${listVar}}" PARENT_SCOPE) 340ENDFUNCTION(ZANATA_CLIENT_OPTNAME_LIST_APPEND) 341 342## ZANATA_CLIENT_OPTNAME_LIST_PARSE_APPEND(var subCommand opt) 343## e.g ZANATA_CLIENT_OPTNAME_LIST_PARSE_APPEND(srcDir push "srcDir=.") 344FUNCTION(ZANATA_CLIENT_OPTNAME_LIST_PARSE_APPEND var subCommand opt) 345 STRING_SPLIT(_list "=" "${opt}") 346 ZANATA_CLIENT_OPTNAME_LIST_APPEND(${var} ${subCommand} ${_list}) 347 SET(${var} "${${var}}" PARENT_SCOPE) 348ENDFUNCTION(ZANATA_CLIENT_OPTNAME_LIST_PARSE_APPEND) 349 350## Internal 351FUNCTION(ZANATA_CLIENT_SUB_COMMAND var subCommand) 352 IF(ZANATA_CLIENT_TYPE STREQUAL "mvn") 353 SET(${var} "${ZANATA_MAVEN_SUBCOMMAND_PREFIX}:${subCommand}" PARENT_SCOPE) 354 ELSEIF(ZANATA_CLIENT_TYPE STREQUAL "python") 355 ## Python client 356 IF("${subCommand}" STREQUAL "put-project") 357 SET(${var} "project" "create" PARENT_SCOPE) 358 ELSEIF("${subCommand}" STREQUAL "put-version") 359 SET(${var} "version" "create" PARENT_SCOPE) 360 ELSE() 361 SET(${var} "${subCommand}" PARENT_SCOPE) 362 ENDIF() 363 ELSE() 364 ## java 365 SET(${var} "${subCommand}" PARENT_SCOPE) 366 ENDIF() 367ENDFUNCTION(ZANATA_CLIENT_SUB_COMMAND) 368 369## Set variable for ZANATA 370FUNCTION(ZANATA_SET_CACHE_VAR mapVar key) 371 IF(NOT DEFINED ZANATA_OPTION_NAME_${key}_VAR_TYPE) 372 M_MSG(${M_ERROR} "[ManageZanata] key ${key} is invalid") 373 RETURN() 374 ENDIF() 375 376 IF("${${mapVar}_${key}}" STREQUAL "") 377 IF(key STREQUAL "PROJECT") 378 SET(v "${PROJECT_NAME}") 379 ELSEIF(key STREQUAL "PROJECT_CONFIG") 380 SET(v "") 381 FOREACH(d ${CMAKE_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/po 382 ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/po) 383 IF(EXISTS "${d}/zanata.xml") 384 SET(v "${d}/zanata.xml") 385 BREAK() 386 ENDIF() 387 ENDFOREACH() 388 IF("${v}" STREQUAL "") 389 SET(v "${CMAKE_CURRENT_BINARY_DIR}/zanata.xml") 390 ENDIF() 391 ELSEIF(key STREQUAL "USER_CONFIG") 392 SET(v "$ENV{HOME}/.config/zanata.ini") 393 ELSE() 394 SET(v "${ZANATA_OPTION_NAME_${key}_DEFAULT}") 395 ENDIF() 396 SET(force "") 397 ELSE() 398 SET(v "${${mapVar}_${key}}") 399 SET(force "FORCE") 400 ENDIF() 401 SET(ZANATA_${key} "${v}" CACHE "${ZANATA_OPTION_NAME_VAR_TYPE}" "ZANATA_${key}" ${force}) 402ENDFUNCTION(ZANATA_SET_CACHE_VAR) 403 404## ZANATA_CMAKE_OPTIONS_PARSE_OPTIONSMAP <varPrefix> [ARGN] 405## Parse the arguments from MANAGE_ZANATA. 406## Returns: <varPrefix> contains the specified arguments 407## Defines: <varPrefix>_<ARGUMENT> with value 408FUNCTION(ZANATA_CMAKE_OPTIONS_PARSE_OPTIONS_MAP varPrefix) 409 ## isValue=2 Must be an option value 410 ## isValue=1 Maybe either 411 ## isValue=0 Must be an option name 412 SET(result "") 413 SET(isValue 1) 414 SET(isOptName 1) 415 SET(optName "") 416 SET(dependencyMissing 0) 417 418 FOREACH(opt ${ARGN}) 419 IF(isValue EQUAL 1) 420 ## Can be either, determine what it is 421 IF(DEFINED ZANATA_OPTION_NAME_${opt}) 422 ## This is a new option name 423 SET(isValue 0) 424 ELSEIF(NOT "${optName}" STREQUAL "") 425 ## This should be an option value 426 SET(isValue 2) 427 ELSEIF(opt MATCHES "^http") 428 ## Zanata server url 429 SET(optName "URL") 430 SET(isValue 2) 431 LIST(APPEND ${varPrefix} "${optName}") 432 ELSE() 433 ## Cannot decided 434 M_MSG(${M_ERROR} "ManageZanata: String '${opt}' is neither a option name, nor a value") 435 ENDIF() 436 ENDIF() 437 438 IF (isValue EQUAL 0) 439 ## Must be option name 440 IF(NOT DEFINED ZANATA_OPTION_NAME_${opt}) 441 M_MSG(${M_ERROR} "ManageZanata: Unrecognized option name ${opt}") 442 ENDIF() 443 444 IF(DEFINED ZANATA_OPTION_ALIAS_${opt}) 445 SET(optName "${ZANATA_OPTION_ALIAS_${opt}}") 446 ELSE() 447 SET(optName "${opt}") 448 ENDIF() 449 LIST(APPEND ${varPrefix} "${optName}") 450 451 ## Find on next opt is value or option name 452 LIST(GET ZANATA_OPTION_NAME_${optName} 0 isValue) 453 454 ## Set value as 1 for no or optional value, as DEFINED is not reliable for sibling functions 455 IF(isValue LESS 2) 456 SET(${varPrefix}_${optName} "1") 457 SET(${varPrefix}_${optName} "1" PARENT_SCOPE) 458 ENDIF() 459 ELSEIF (${isValue} EQUAL 2) 460 ## Must be option value 461 IF("${optName}" STREQUAL "") 462 M_MSG(${M_ERROR} "ManageZanata: Value without associated option ${opt}") 463 ENDIF() 464 SET(${varPrefix}_${optName} "${opt}") 465 SET(${varPrefix}_${optName} "${opt}" PARENT_SCOPE) 466 SET(optName "") 467 SET(isValue 0) 468 ELSE() 469 ## Invalid Argument 470 M_MSG(${M_ERROR} "ManageZanata: Error: isValue should not be ${isValue} with string '${opt}' ") 471 ENDIF() 472 ENDFOREACH() 473 474 ##== Set cache variable 475 FOREACH(optName ${ZANATA_OPTION_INIT_LIST}) 476 ZANATA_SET_CACHE_VAR(${varPrefix} "${optName}") 477 ENDFOREACH() 478 479 ##== Variable that need to check 480 ## USER_CONFIG 481 IF(NOT EXISTS "${ZANATA_USER_CONFIG}") 482 SET(dependencyMissing 1) 483 M_MSG(${M_OFF} "MANAGE_ZANATA: Failed to find zanata.ini at ${ZANATA_USER_CONFIG}") 484 ENDIF() 485 486 ## ZANATA_CLIENT_EXECUTABLE 487 IF("${_o_ZANATA_EXECUTABLE}" STREQUAL "") 488 IF("${ZANATA_CLIENT_EXECUTABLE}" STREQUAL "") 489 SET(zanataClientMissing 0) 490 FIND_PROGRAM_ERROR_HANDLING(ZANATA_CLIENT_EXECUTABLE 491 ERROR_MSG " Zanata support is disabled." 492 ERROR_VAR zanataClientMissing 493 VERBOSE_LEVEL ${M_OFF} 494 FIND_ARGS NAMES zanata-cli mvn zanata 495 ) 496 IF(zanataClientMissing EQUAL 1) 497 SET(dependencyMissing 1) 498 M_MSG(${M_OFF} "MANAGE_ZANATA: Failed to find zanata client, Zanata support disabled") 499 ELSE() 500 SET(ZANATA_CLIENT_EXECUTABLE "${ZANATA_CLIENT_EXECUTABLE}" 501 CACHE FILEPATH "Zanata client excutable" 502 ) 503 ENDIF() 504 ENDIF() 505 ELSE() 506 LIST(GET ${varPrefix}_ZANATA_EXECUTABLE 0 ZANATA_CLIENT_EXECUTABLE) 507 SET(ZANATA_CLIENT_EXECUTABLE "${${varPrefix}_ZANATA_EXECUTABLE}" 508 CACHE FILEPATH "Zanata client excutable" FORCE 509 ) 510 ENDIF() 511 GET_FILENAME_COMPONENT(zanataClientFilename "${ZANATA_CLIENT_EXECUTABLE}" NAME) 512 IF(zanataClientFilename STREQUAL "zanata") 513 SET(ZANATA_CLIENT_TYPE "python" CACHE INTERNAL "Zanata Client Type") 514 ELSEIF(zanataClientFilename STREQUAL "zanata-cli") 515 SET(ZANATA_CLIENT_TYPE "java" CACHE INTERNAL "Zanata Client Type") 516 ELSEIF(zanataClientFilename STREQUAL "mvn") 517 SET(ZANATA_CLIENT_TYPE "mvn" CACHE INTERNAL "Zanata Client Type") 518 ELSE() 519 M_MSG(${M_OFF} "${ZANATA_CLIENT_EXECUTABLE} is not a supported Zanata client") 520 SET(dependencyMissing 1) 521 ENDIF() 522 523 IF(dependencyMissing EQUAL 1) 524 SET(${varPrefix}_DEPENDENCY_MISSING 1 PARENT_SCOPE) 525 RETURN() 526 ENDIF() 527 528 ##== Other Variables 529 IF("${${varPrefix}_PROJECT_DESC}" STREQUAL "") 530 SET(${varPrefix}_PROJECT_DESC "${PRJ_SUMMARY}") 531 ENDIF() 532 STRING(LENGTH "${${varPrefix}_PROJECT_DESC}" _prjSummaryLen) 533 IF(_prjSummaryLen GREATER ${ZANATA_DESCRIPTION_SIZE}) 534 STRING(SUBSTRING "${${varPrefix}_PROJECT_DESC}" 0 ${ZANATA_DESCRIPTION_SIZE} 535 ${varPrefix}_PROJECT_DESC 536 ) 537 ENDIF() 538 SET(${varPrefix}_PROJECT_DESC "${${varPrefix}_PROJECT_DESC}" PARENT_SCOPE) 539 540 SET(${varPrefix} "${${varPrefix}}" PARENT_SCOPE) 541ENDFUNCTION(ZANATA_CMAKE_OPTIONS_PARSE_OPTIONS_MAP) 542 543# MANAGE_ZANATA_OBTAIN_REAL_COMMAND(<cmdListVar> 544# <subCommand> <optionMapVar> 545# [YES] [BATCH] [ERRORS] [DEBUG] 546# [DISABLE_SSL_CERT] 547# [URL <url>] 548# [USERNAME <username>] 549# [KEY <key>] 550# [USER_CONFIG <zanata.ini>] 551# ... 552# ) 553 554FUNCTION(MANAGE_ZANATA_OBTAIN_REAL_COMMAND cmdListVar subCommand optionMapVar) 555 IF(${optionMapVar}_BATCH) 556 IF(${optionMapVar}_BACKEND STREQUAL "python") 557 SET(result "yes" "|" "${ZANATA_CLIENT_EXECUTABLE}") 558 ELSE() 559 SET(result "${ZANATA_CLIENT_EXECUTABLE}") 560 ZANATA_CLIENT_OPTNAME_LIST_APPEND(result "${subCommand}" "BATCH" ) 561 ENDIF() 562 ELSE() 563 SET(result "${ZANATA_CLIENT_EXECUTABLE}") 564 ENDIF() 565 566 FOREACH(optName "DEBUG" "ERRORS") 567 IF(${optionMapVar}_${optName}) 568 ZANATA_CLIENT_OPTNAME_LIST_APPEND(result "${subCommand}" "${optName}" ) 569 ENDIF() 570 ENDFOREACH(optName) 571 572 ## Sub-command 573 ZANATA_CLIENT_SUB_COMMAND(subCommandReal "${subCommand}") 574 LIST(APPEND result "${subCommandReal}") 575 576 ## Explicit Options 577 FOREACH(optName ${${optionMapVar}}) 578 IF(optName STREQUAL "BATCH") 579 ELSEIF(optName STREQUAL "DEBUG") 580 ELSEIF(optName STREQUAL "ERRORS") 581 ELSE() 582 IF(${optionMapVar}_${optName}) 583 IF(ZANATA_OPTION_NAME_${optName} EQUAL 1 AND "${${optionMapVar}_${optName}}" STREQUAL "1") 584 ZANATA_CLIENT_OPTNAME_LIST_APPEND(result "${subCommand}" "${optName}") 585 ELSE() 586 ZANATA_CLIENT_OPTNAME_LIST_APPEND(result "${subCommand}" "${optName}" "${${optionMapVar}_${optName}}") 587 ENDIF() 588 ENDIF() 589 ENDIF() 590 ENDFOREACH(optName) 591 592 ## Implied options: Mandatory options but not specified. 593 ZANATA_STRING_LOWERCASE_DASH_TO_UPPERCASE_UNDERSCORE(subCommandName "${subCommand}") 594 STRING(TOUPPER "${ZANATA_CLIENT_TYPE}" zanataClientTypeUpper) 595 596 IF(DEFINED ZANATA_${zanataClientTypeUpper}_${subCommandName}_MANDATORY_OPTIONS) 597 FOREACH(optName ${ZANATA_${zanataClientTypeUpper}_${subCommandName}_MANDATORY_OPTIONS}) 598 IF(DEFINED ZANATA_${optName}) 599 ## Implied options 600 IF("${${optionMapVar}_${optName}}" STREQUAL "") 601 ## Not yet append as exlicit options 602 ZANATA_CLIENT_OPTNAME_LIST_APPEND(result "${subCommand}" "${optName}" "${ZANATA_${optName}}") 603 ENDIF() 604 ENDIF() 605 ENDFOREACH(optName) 606 ENDIF() 607 608 SET(${cmdListVar} "${result}" PARENT_SCOPE) 609ENDFUNCTION(MANAGE_ZANATA_OBTAIN_REAL_COMMAND) 610 611####################################### 612# ZANATA Put_Version 613# 614 615# MANAGE_ZANATA_OBTAIN_PUT_VERSION_COMMAND(<cmdListVar> <optionMapVar>) 616FUNCTION(MANAGE_ZANATA_OBTAIN_PUT_VERSION_COMMAND cmdListVar optionMapVar) 617 ### zanata_put-version 618 MANAGE_ZANATA_OBTAIN_REAL_COMMAND(result put-version ${optionMapVar}) 619 SET(${cmdListVar} "${result}" PARENT_SCOPE) 620ENDFUNCTION(MANAGE_ZANATA_OBTAIN_PUT_VERSION_COMMAND) 621 622FUNCTION(MANAGE_ZANATA_PUT_VERSION_TARGETS cmdList) 623 ADD_CUSTOM_TARGET(zanata_put_version 624 COMMAND ${cmdList} 625 COMMENT "zanata_put-version: with ${cmdList}" 626 DEPENDS ${zanataXml} 627 ) 628ENDFUNCTION(MANAGE_ZANATA_PUT_VERSION_TARGETS) 629 630 631####################################### 632# ZANATA Push 633# 634 635# MANAGE_ZANATA_OBTAIN_PUSH_COMMAND(<cmdListVar> <optionMapVar>) 636FUNCTION(MANAGE_ZANATA_OBTAIN_PUSH_COMMAND cmdListVar optionMapVar) 637 ### zanata_push 638 MANAGE_ZANATA_OBTAIN_REAL_COMMAND(result push ${optionMapVar}) 639 SET(${cmdListVar} "${result}" PARENT_SCOPE) 640ENDFUNCTION(MANAGE_ZANATA_OBTAIN_PUSH_COMMAND) 641 642FUNCTION(MANAGE_ZANATA_PUSH_TARGETS cmdList) 643 ADD_CUSTOM_TARGET(zanata_push 644 COMMAND ${cmdList} 645 COMMENT "zanata_push: with ${cmdList}" 646 DEPENDS ${zanataXml} 647 ) 648 649 ### zanata_push_both 650 SET(extraOptions "") 651 ZANATA_CLIENT_OPTNAME_LIST_APPEND(extraOptions "PUSH_TYPE" "both") 652 ADD_CUSTOM_TARGET(zanata_push_both 653 COMMAND ${cmdList} ${extraOptions} 654 COMMENT "zanata_push: with ${cmdList} ${extraOptions}" 655 DEPENDS ${zanataXml} 656 ) 657 658 ### zanata_push_trans 659 SET(extraOptions "") 660 ZANATA_CLIENT_OPTNAME_LIST_APPEND(extraOptions "PUSH_TYPE" "trans") 661 ADD_CUSTOM_TARGET(zanata_push_trans 662 COMMAND ${cmdList} ${extraOptions} 663 COMMENT "zanata_push: with ${cmdList} ${extraOptions}" 664 DEPENDS ${zanataXml} 665 ) 666ENDFUNCTION(MANAGE_ZANATA_PUSH_TARGETS) 667 668####################################### 669# ZANATA Pull 670# 671 672# MANAGE_ZANATA_OBTAIN_PULL_COMMAND(<cmdListVar> <optionMapVar>) 673FUNCTION(MANAGE_ZANATA_OBTAIN_PULL_COMMAND cmdListVar optionMapVar) 674 ### zanata_pull 675 MANAGE_ZANATA_OBTAIN_REAL_COMMAND(result pull ${optionMapVar}) 676 SET(${cmdListVar} "${result}" PARENT_SCOPE) 677ENDFUNCTION(MANAGE_ZANATA_OBTAIN_PULL_COMMAND) 678 679FUNCTION(MANAGE_ZANATA_PULL_TARGETS cmdList) 680 ADD_CUSTOM_TARGET(zanata_pull 681 COMMAND ${cmdList} 682 COMMENT "zanata_pull: with ${cmdList}" 683 DEPENDS ${zanataXml} 684 ) 685 686 ### zanata_pull_both 687 SET(extraOptions "") 688 ZANATA_CLIENT_OPTNAME_LIST_APPEND(extraOptions "PULL_TYPE" "both") 689 ADD_CUSTOM_TARGET(zanata_pull_both 690 COMMAND ${cmdList} ${extraOptions} 691 COMMENT "zanata_pull: with ${cmdList} ${extraOptions}" 692 DEPENDS ${zanataXml} 693 ) 694 695ENDFUNCTION(MANAGE_ZANATA_PULL_TARGETS) 696 697####################################### 698# ZANATA Main 699# 700 701FUNCTION(MANAGE_ZANATA) 702 ZANATA_CMAKE_OPTIONS_PARSE_OPTIONS_MAP(_o ${ARGN}) 703 704 IF(_o_DEPENDENCIES_MISSING EQUAL 1) 705 RETURN() 706 ENDIF() 707 708 ### Common options 709 SET(zanataCommonOptions "") 710 FOREACH(optCName "URL" ${ZANATA_CLIENT_COMMON_VALID_OPTIONS}) 711 SET(value "${_o_${optCName}}") 712 IF(value) 713 ZANATA_CLIENT_OPTNAME_LIST_APPEND(zanataCommonOptions "${optCName}" "${value}") 714 ENDIF() 715 ENDFOREACH(optCName) 716 717 ### zanata_put_project 718 SET(exec "") 719 MANAGE_ZANATA_OBTAIN_REAL_COMMAND(exec put-project _o) 720 LIST(APPEND exec ${zanataCommonOptions}) 721 ADD_CUSTOM_TARGET(zanata_put_project 722 COMMAND ${exec} 723 COMMENT "zanata_put_project: with ${exec}" 724 ) 725 726 ### zanata_put_version 727 MANAGE_ZANATA_OBTAIN_PUT_VERSION_COMMAND(cmdPushList _o) 728 MANAGE_ZANATA_PUT_VERSION_TARGETS("${cmdPushList}") 729 730 ### zanata_push 731 MANAGE_ZANATA_OBTAIN_PUSH_COMMAND(cmdPushList _o) 732 MANAGE_ZANATA_PUSH_TARGETS("${cmdPushList}") 733 734 ### zanata_pull 735 MANAGE_ZANATA_OBTAIN_PULL_COMMAND(cmdPullList _o) 736 MANAGE_ZANATA_PULL_TARGETS("${cmdPullList}") 737ENDFUNCTION(MANAGE_ZANATA) 738 739####################################### 740# MANAGE_ZANATA_XML_MAKE 741# 742FUNCTION(ZANATA_LOCALE_COMPLETE var language script country modifier) 743 IF("${modifier}" STREQUAL "") 744 SET(sModifier "${ZANATA_SUGGEST_MODIFIER_${language}_${script}_}") 745 IF(NOT "${sModifier}" STREQUAL "") 746 SET(modifier "${sModifier}") 747 ENDIF() 748 ENDIF() 749 IF("${country}" STREQUAL "") 750 SET(sCountry "${ZANATA_SUGGEST_COUNTRY_${language}_${script}_}") 751 IF(NOT "${sCountry}" STREQUAL "") 752 SET(country "${sCountry}") 753 ENDIF() 754 ENDIF() 755 IF("${script}" STREQUAL "") 756 SET(sScript "${ZANATA_SUGGEST_SCRIPT_${language}_${country}_${modifier}}") 757 IF(NOT "${sScript}" STREQUAL "") 758 SET(script "${sScript}") 759 ENDIF() 760 ENDIF() 761 SET(${var} "${language}_${script}_${country}_${modifier}" PARENT_SCOPE) 762ENDFUNCTION(ZANATA_LOCALE_COMPLETE var locale) 763 764FUNCTION(ZANATA_JSON_GET_VALUE var key string) 765 STRING(REGEX REPLACE ".*[{,]\"${key}\":\"([^\"]*)\".*" "\\1" ret "${string}") 766 SET(${var} "${ret}" PARENT_SCOPE) 767ENDFUNCTION(ZANATA_JSON_GET_VALUE) 768 769FUNCTION(ZANATA_JSON_TO_ARRAY var string) 770 STRING(REGEX REPLACE "[[]\(.*\)[]]" "\\1" ret1 "${string}") 771 STRING(REGEX REPLACE "},{" "};{" ret "${ret1}") 772 SET(${var} "${ret}" PARENT_SCOPE) 773ENDFUNCTION(ZANATA_JSON_TO_ARRAY) 774 775FUNCTION(ZANATA_REST_GET_PROJECT_VERSION_TYPE var url project version) 776 SET(restUrl "${url}rest/projects/p/${project}/iterations/i/${version}") 777 EXECUTE_PROCESS(COMMAND curl -f -G -s -H "Content-Type:application/json" 778 -H "Accept:application/json" "${restUrl}" 779 RESULT_VARIABLE curlRet 780 OUTPUT_VARIABLE curlOut) 781 IF(NOT curlRet EQUAL 0) 782 M_MSG(${M_OFF} "Failed to get project type from project ${project} to ${version} with ${url}") 783 RETURN() 784 ENDIF() 785 ZANATA_JSON_GET_VALUE(ret "projectType" "${curlOut}") 786 SET(${var} "${ret}" PARENT_SCOPE) 787ENDFUNCTION(ZANATA_REST_GET_PROJECT_VERSION_TYPE) 788 789FUNCTION(ZANATA_REST_GET_PROJECT_VERSION_LOCALES var url project version) 790 SET(restUrl "${url}rest/projects/p/${project}/iterations/i/${version}/locales") 791 EXECUTE_PROCESS(COMMAND curl -f -G -s -H "Content-Type:application/json" 792 -H "Accept:application/json" "${restUrl}" 793 RESULT_VARIABLE curlRet 794 OUTPUT_VARIABLE curlOut) 795 IF(NOT curlRet EQUAL 0) 796 M_MSG(${M_OFF} "Failed to get project type from project ${project} to ${version} with ${url}") 797 RETURN() 798 ENDIF() 799 ZANATA_JSON_TO_ARRAY(nodeArray "${curlOut}") 800 SET(retArray "") 801 FOREACH(node ${nodeArray}) 802 ZANATA_JSON_GET_VALUE(l "localeId" "${node}") 803 LIST(APPEND retArray "${l}") 804 ENDFOREACH() 805 SET(${var} "${retArray}" PARENT_SCOPE) 806ENDFUNCTION(ZANATA_REST_GET_PROJECT_VERSION_LOCALES) 807 808FUNCTION(ZANATA_ZANATA_XML_DOWNLOAD zanataXml url project version) 809 GET_FILENAME_COMPONENT(zanataXmlDir "${zanataXml}" PATH) 810 IF(NOT zanataXmlDir) 811 SET(zanataXml "./${zanataXml}") 812 ENDIF() 813 814 ZANATA_REST_GET_PROJECT_VERSION_TYPE(pType "${url}" "${project}" "${version}") 815 MANAGE_ZANATA_XML_OBJECT_NEW(zObj "${url}" "${project}" "${version}" "${pType}") 816 MANAGE_ZANATA_XML_OBJECT_TO_STRING(buf zObj) 817 FILE(WRITE "${zanataXml}" "${buf}") 818ENDFUNCTION(ZANATA_ZANATA_XML_DOWNLOAD) 819 820FUNCTION(ZANATA_BEST_MATCH_LOCALES var serverLocales clientLocales) 821 ## Build "Client Hash" 822 SET(result "") 823 FOREACH(cL ${clientLocales}) 824 LOCALE_PARSE_STRING(cLang cScript cCountry cModifier "${cL}") 825 SET(_ZANATA_CLIENT_LOCALE_${cLang}_${cScript}_${cCountry}_${cModifier} "${cL}") 826 ZANATA_LOCALE_COMPLETE(cCLocale "${cLang}" "${cScript}" "${cCountry}" "${cModifier}") 827 SET(compKey "_ZANATA_CLIENT_COMPLETE_LOCALE_${cCLocale}") 828 IF("${${compKey}}" STREQUAL "") 829 SET("${compKey}" "${cL}") 830 ENDIF() 831 ENDFOREACH() 832 833 ## 1st pass: Exact match 834 FOREACH(sL ${serverLocales}) 835 LOCALE_PARSE_STRING(sLang sScript sCountry sModifier "${sL}") 836 SET(scKey "_ZANATA_CLIENT_LOCALE_${sLang}_${sScript}_${sCountry}_${sModifier}") 837 ## Exact match locale 838 SET(cLExact "${${scKey}}") 839 IF(NOT "${cLExact}" STREQUAL "") 840 SET(_ZANATA_SERVER_LOCALE_${sL} "${cLExact}") 841 SET(_ZANATA_CLIENT_LOCALE_${cLExact} "${sL}") 842 LIST(APPEND result "${sL},${cLExact}") 843 ENDIF() 844 ENDFOREACH() 845 846 ## 2nd pass: Find the next best match 847 FOREACH(sL ${serverLocales}) 848 IF("${_ZANATA_SERVER_LOCALE_${sL}}" STREQUAL "") 849 ## no exact match 850 LOCALE_PARSE_STRING(sLang sScript sCountry sModifier "${sL}") 851 852 ## Locale completion 853 ZANATA_LOCALE_COMPLETE(sCLocale "${sLang}" "${sScript}" "${sCountry}" "${sModifier}") 854 SET(sCompKey "_ZANATA_CLIENT_COMPLETE_LOCALE_${sCLocale}") 855 SET(bestMatch "") 856 857 ## Match client locale after Locale completion 858 SET(cLComp "${${sCompKey}}") 859 IF(NOT "${cLComp}" STREQUAL "") 860 ## And the client locale is not occupied 861 IF("${_ZANATA_CLIENT_LOCALE_${cLComp}}" STREQUAL "") 862 SET(_ZANATA_SERVER_LOCALE_${sL} "${cLComp}") 863 SET(_ZANATA_CLIENT_LOCALE_${cLComp} "${sL}") 864 SET(bestMatch "${cLComp}") 865 ENDIF() 866 ENDIF() 867 IF(bestMatch STREQUAL "") 868 ## No matched, use corrected sL 869 STRING(REPLACE "-" "_" bestMatch "${sL}") 870 IF("${bestMatch}" STREQUAL "${sL}") 871 M_MSG(${M_OFF} "${sL} does not have matched client locale, use as-is.") 872 ELSE() 873 M_MSG(${M_OFF} "${sL} does not have matched client locale, use ${bestMatch}.") 874 ENDIF() 875 ENDIF() 876 LIST(APPEND result "${sL},${bestMatch}") 877 ENDIF() 878 ENDFOREACH() 879 LIST(SORT result) 880 SET(${var} "${result}" PARENT_SCOPE) 881ENDFUNCTION(ZANATA_BEST_MATCH_LOCALES) 882 883FUNCTION(ZANATA_ZANATA_XML_MAP zanataXml zanataXmlIn workDir) 884 INCLUDE(ManageTranslation) 885 INCLUDE(ManageZanataSuggest) 886 FILE(STRINGS "${zanataXmlIn}" zanataXmlLines) 887 FILE(REMOVE ${zanataXml}) 888 889 ## Start parsing zanataXmlIn and gather serverLocales 890 SET(serverLocales "") 891 SET(srcDirOrig "") 892 SET(transDirOrig "") 893 FOREACH(line ${zanataXmlLines}) 894 IF("${line}" MATCHES "<locale>(.*)</locale>") 895 ## Is a locale string 896 SET(sL "${CMAKE_MATCH_1}") 897 LIST(APPEND serverLocales "${sL}") 898 ELSEIF("${line}" MATCHES "<src-dir>(.*)</src-dir>") 899 SET(srcDirOrig "${CMAKE_MATCH_1}") 900 ELSEIF("${line}" MATCHES "<trans-dir>(.*)</trans-dir>") 901 SET(transDirOrig "${CMAKE_MATCH_1}") 902 ELSEIF("${line}" MATCHES "<url>(.*)</url>") 903 SET(url "${CMAKE_MATCH_1}") 904 ELSEIF("${line}" MATCHES "<project>(.*)</project>") 905 SET(project "${CMAKE_MATCH_1}") 906 ELSEIF("${line}" MATCHES "<project-version>(.*)</project-version>") 907 SET(version "${CMAKE_MATCH_1}") 908 ELSEIF("${line}" MATCHES "<project-type>(.*)</project-type>") 909 SET(projectType "${CMAKE_MATCH_1}") 910 ELSE() 911 IF(zanataXmlIsHeader) 912 STRING_APPEND(zanataXmlHeader "${line}" "\n") 913 ELSE() 914 STRING_APPEND(zanataXmlFooter "${line}" "\n") 915 ENDIF() 916 ## Not a locale string, write as-is 917 ENDIF() 918 ENDFOREACH() 919 920 MANAGE_ZANATA_XML_OBJECT_NEW(zObj ${url} ${project} ${version} ${projectType}) 921 922 ## Build "Client Hash" 923 MANAGE_GETTEXT_LOCALES(clientLocales WORKING_DIRECTORY "${workDir}" DETECT_PO_DIR poDir ${ARGN}) 924 IF(NOT "${srcDirOrig}" STREQUAL "") 925 SET(poDir "${srcDirOrig}") 926 ELSEIF("${poDir}" STREQUAL "") 927 SET(poDir ".") 928 ENDIF() 929 930 IF(NOT "${transDirOrig}" STREQUAL "") 931 SET(potDir "${transDirOrig}") 932 ELSE() 933 MANAGE_GETTEXT_DETECT_POT_DIR(potDir WORKING_DIRECTORY "${workDir}") 934 IF("${potDir}" STREQUAL "NOTFOUND") 935 M_MSG(${M_ERROR} "ZANATA_ZANATA_XML_MAP: Failed to detect pot dir because .pot files are not found in ${workDir}") 936 ELSEIF("${potDir}" STREQUAL "") 937 SET(potDir ".") 938 ENDIF() 939 ENDIF() 940 MANAGE_ZANATA_XML_OBJECT_ADD_PROPERTY(zObj "src-dir" "${potDir}") 941 MANAGE_ZANATA_XML_OBJECT_ADD_PROPERTY(zObj "trans-dir" "${poDir}") 942 943 944 IF(NOT "${serverLocales}" STREQUAL "") 945 ## If server locales are available, then start matching the client and server locales 946 947 ## clientLocales if not specified 948 IF("${clientLocales}" STREQUAL "") 949 MANAGE_GETTEXT_LOCALES(clientLocales SYSTEM_LOCALES) 950 ENDIF() 951 M_MSG(${M_INFO3} "clientLocales=${clientLocales}") 952 953 LIST(SORT serverLocales) 954 ZANATA_BEST_MATCH_LOCALES(bestMatches "${serverLocales}" "${clientLocales}") 955 956 FOREACH(bM ${bestMatches}) 957 STRING_SPLIT(lA "," "${bM}") 958 LIST(GET lA 0 sLocale) 959 LIST(GET lA 1 cLocale) 960 LIST(APPEND zObj_locales "${sLocale}") 961 962 IF(NOT "${sLocale}" STREQUAL "${cLocale}") 963 SET(zObj_locales_${sLocale} "${cLocale}") 964 ENDIF() 965 ENDFOREACH(bM) 966 ENDIF(NOT "${serverLocales}" STREQUAL "") 967 968 MANAGE_ZANATA_XML_OBJECT_TO_STRING(outputBuf zObj) 969 FILE(WRITE "${zanataXml}" "${outputBuf}") 970ENDFUNCTION(ZANATA_ZANATA_XML_MAP) 971 972 973 974