diff options
| author | Karl Berry <karl@freefriends.org> | 2013-02-05 23:00:15 +0000 |
|---|---|---|
| committer | Karl Berry <karl@freefriends.org> | 2013-02-05 23:00:15 +0000 |
| commit | 5951dc20b924b01da871a6b772f7cd30f66e07fd (patch) | |
| tree | 6df25558e8efc9d7e28ce858f1ef7866bd567702 /Master/texmf-dist/source/support | |
| parent | b5620e0b06e34b0db7481f8b3c6417c6e8b13c1a (diff) | |
arara (6feb13)
git-svn-id: svn://tug.org/texlive/trunk@29036 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Master/texmf-dist/source/support')
35 files changed, 7168 insertions, 0 deletions
diff --git a/Master/texmf-dist/source/support/arara/pom.xml b/Master/texmf-dist/source/support/arara/pom.xml new file mode 100644 index 00000000000..ec01ed9c125 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/pom.xml @@ -0,0 +1,180 @@ + +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <groupId>com.github.arara</groupId> + <artifactId>arara</artifactId> + <version>3.0</version> + <packaging>jar</packaging> + + <name>arara</name> + <url>http://cereda.github.com/arara</url> + <description>The cool TeX automation tool</description> + <inceptionYear>2012</inceptionYear> + + <properties> + <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> + </properties> + + <issueManagement> + <system>GitHub</system> + <url>https://github.com/cereda/arara/issues</url> + </issueManagement> + + <licenses> + <license> + <name>New BSD License</name> + <url>http://www.opensource.org/licenses/bsd-license.php</url> + <distribution>repo</distribution> + <comments>New BSD License</comments> + </license> + </licenses> + + <scm> + <connection>scm:git:https://github.com/cereda/arara.git</connection> + <developerConnection>scm:git:https://github.com/cereda/arara.git</developerConnection> + <url>https://github.com/cereda/arara</url> + </scm> + + <developers> + <developer> + <name>Paulo Roberto Massa Cereda</name> + <email>cereda@users.sf.net</email> + <id>cereda</id> + <url>http://tex.stackexchange.com/users/3094</url> + <roles> + <role>Lead Developer</role> + <role>Creator</role> + </roles> + </developer> + <developer> + <name>Marco Daniel</name> + <email>marco.daniel@mada-nada.de</email> + <id>marcodaniel</id> + <url>http://tex.stackexchange.com/users/5239</url> + <roles> + <role>Contributor</role> + <role>Tester</role> + </roles> + </developer> + <developer> + <name>Brent Longborough</name> + <email>brent@longborough.org</email> + <id>brent</id> + <url>http://tex.stackexchange.com/users/344</url> + <roles> + <role>Developer</role> + <role>Contributor</role> + <role>Tester</role> + </roles> + </developer> + </developers> + + + <dependencies> + <dependency> + <groupId>junit</groupId> + <artifactId>junit</artifactId> + <version>4.10</version> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.yaml</groupId> + <artifactId>snakeyaml</artifactId> + <version>1.11</version> + </dependency> + <dependency> + <groupId>org.mvel</groupId> + <artifactId>mvel2</artifactId> + <version>2.0.19</version> + </dependency> + <dependency> + <groupId>commons-cli</groupId> + <artifactId>commons-cli</artifactId> + <version>1.2</version> + </dependency> + <dependency> + <groupId>org.apache.commons</groupId> + <artifactId>commons-lang3</artifactId> + <version>3.1</version> + </dependency> + <dependency> + <groupId>ch.qos.logback</groupId> + <artifactId>logback-classic</artifactId> + <version>1.0.1</version> + </dependency> + <dependency> + <groupId>ch.qos.logback</groupId> + <artifactId>logback-core</artifactId> + <version>1.0.1</version> + </dependency> + <dependency> + <groupId>org.slf4j</groupId> + <artifactId>slf4j-api</artifactId> + <version>1.6.4</version> + </dependency> + <dependency> + <groupId>org.apache.commons</groupId> + <artifactId>commons-exec</artifactId> + <version>1.1</version> + </dependency> + <dependency> + <groupId>commons-collections</groupId> + <artifactId>commons-collections</artifactId> + <version>3.2.1</version> + </dependency> + </dependencies> + + <build> + <finalName>arara-${project.version}</finalName> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-compiler-plugin</artifactId> + <version>2.5.1</version> + <configuration> + <source>1.5</source> + <target>1.5</target> + </configuration> + </plugin> + <plugin> + <artifactId>maven-assembly-plugin</artifactId> + <version>2.3</version> + <configuration> + <descriptorRefs> + <descriptorRef>jar-with-dependencies</descriptorRef> + </descriptorRefs> + <archive> + <manifest> + <mainClass>com.github.arara.Arara</mainClass> + </manifest> + </archive> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-javadoc-plugin</artifactId> + <version>2.7</version> + <configuration> + <show>public</show> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-jar-plugin</artifactId> + <version>2.4</version> + <configuration> + <archive> + <manifest> + <addClasspath>true</addClasspath> + <classpathPrefix>lib/</classpathPrefix> + <mainClass>com.github.arara.Arara</mainClass> + </manifest> + </archive> + </configuration> + </plugin> + </plugins> + </build> + +</project> diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/Arara.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/Arara.java new file mode 100644 index 00000000000..bbad5404845 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/Arara.java @@ -0,0 +1,196 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * Arara: The main class. Basically, this class will get the file name from the + * arguments list and call the proper methods from the other helper classes. + */ +// package definition +package com.github.arara; + +// needed imports +import com.github.arara.model.AraraDirective; +import com.github.arara.utils.*; +import java.io.File; +import java.util.List; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * The main arara class. The code logic is encapsulated in the helper class, so + * if something goes wrong, the generic exception catch here will simply print + * it. I tried to make the code as easier as possible. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 1.0 + */ +public class Arara { + + // the logger + final static Logger logger = LoggerFactory.getLogger(Arara.class); + // the localization class + final static AraraLocalization localization = AraraLocalization.getInstance(); + + /** + * The main method. The idea is to provide to arara only the supported file + * name and let it handle. The application will remove the file extension + * (if any) and call the other helper classes. + * + * @param args The command line arguments. In fact, arara supports a lot of + * flags, all listed in the CommandLineAnalyzer. + */ + public static void main(String[] args) { + + // the application status, zero for a normal execution, + // or nonzero for an abnormal execution + int exitStatus; + + // trying to have a normal execution + try { + + // print the application header + AraraUtils.printHeader(); + + // create a configuration instance and load + // the proper settings, if any + ConfigurationLoader configuration = new ConfigurationLoader(); + configuration.load(); + + // create a new analyzer + CommandLineAnalyzer commandLine = new CommandLineAnalyzer(args, configuration); + + // if the minimum parameters are not satisfied or it's a simple + // help or version request + if (!commandLine.parse()) { + + // simply return + exitStatus = 0; + + // exit right now, good job + System.exit(exitStatus); + } + + // it's a normal workflow, let's define the main file + File file; + + // create a new file reference + file = new File(commandLine.getFile()); + + // welcome message + logger.info(localization.getMessage("Log_WelcomeMessage")); + + // process file + logger.info(localization.getMessage("Log_ProcessingFile", file.getName())); + + // file exists, let's proceed with the directive extractor + DirectiveExtractor dirExtractor = new DirectiveExtractor(file, configuration); + + // extract all directives from the file + dirExtractor.extract(); + + // get all directives found + List<AraraDirective> directives = dirExtractor.getDirectives(); + + // set the overall result flag + boolean overallResult = true; + + // check if any directive was found + if (!directives.isEmpty()) { + + // now let's parse the directives + DirectiveParser dirParser = new DirectiveParser(directives); + + // set the file + dirParser.setFile(file); + + // parse the directives + TaskDeployer taskDeployer = new TaskDeployer(dirParser.parse(), configuration); + + // deploy the tasks through a command trigger + CommandTrigger commandTrigger = new CommandTrigger(taskDeployer.deploy()); + + // set verbose option, if enabled + commandTrigger.setVerbose(commandLine.isVerbose()); + + // set an execution timeout, if set + commandTrigger.setExecutionTimeout(commandLine.getExecutionTimeout()); + + // execute the tasks + overallResult = commandTrigger.execute(); + } + else { + + // no directives found, add message to the log + logger.info(localization.getMessage("Log_NoDirectivesFound", file.getName())); + + // print message + System.out.println(AraraUtils.wrap(localization.getMessage("Msg_NoDirectivesFound", file.getName()))); + } + + // final message + logger.info(localization.getMessage("Log_Done")); + + // if everything was ok, that is, every command in the command list + // returned with an exit status of zero + if (overallResult) { + + // everything fine + exitStatus = 0; + + } else { + + // something wrong happened, so let's consider the whole + // execution as abnormal + exitStatus = 1; + } + + } catch (Exception exception) { + + // something bad happened, print the error message + System.out.println(AraraUtils.wrap(exception.getMessage())); + + // catch error in the log + logger.error(localization.getMessage("Log_ExceptionRaised")); + logger.error(exception.getMessage()); + + // error, set status to an abnormal execution + exitStatus = 1; + + } + + // send the exit code to the terminal, and we are done + System.exit(exitStatus); + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/exception/AraraException.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/exception/AraraException.java new file mode 100644 index 00000000000..5f51a48e43f --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/exception/AraraException.java @@ -0,0 +1,87 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraException: This class aims at reducing every exception that happens in the + * whole application to a single self-contained exception. + */ +// package definition +package com.github.arara.exception; + +/** + * Aims at reducing every exception that happens in the whole application to a + * single self-contained exception. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class AraraException extends Exception { + + /** + * Constructor. + */ + public AraraException() { + super(); + } + + /** + * Constructor with a message. + * + * @param message A message containing the cause of the exception thrown. + */ + public AraraException(String message) { + super(message); + } + + /** + * Constructor with both message and the cause of the exception. + * + * @param message A message containing the cause of the exception thrown. + * @param cause The throwable cause. + */ + public AraraException(String message, Throwable cause) { + super(message, cause); + } + + /** + * Constructor with the cause of the exception. + * + * @param cause The throwable cause. + */ + public AraraException(Throwable cause) { + super(cause); + } + +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraCommand.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraCommand.java new file mode 100644 index 00000000000..5e065b49ab4 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraCommand.java @@ -0,0 +1,99 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraCommand: This class provides the model for commands to be executed by + * the runtime. It's a plain old Java object. + */ +// package definition +package com.github.arara.model; + +/** + * Provides the model for commands to be executed by the runtime. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 1.0 + */ +public class AraraCommand { + + // the name to be displayed in the command line + private String name; + // the command itself + private String command; + + /** + * Getter for command. + * + * @return The command to be executed by the runtime. + */ + public String getCommand() { + + // return it + return command; + } + + /** + * Setter for command. + * + * @param command The command, already expanded. + */ + public void setCommand(String command) { + + // set the command + this.command = command; + } + + /** + * Getter for the command name. + * + * @return The command name, provided by the rule. + */ + public String getName() { + + // return it + return name; + } + + /** + * Setter for the command name. + * + * @param name The command name. + */ + public void setName(String name) { + + // set the name + this.name = name; + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraConfiguration.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraConfiguration.java new file mode 100644 index 00000000000..7d783225a51 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraConfiguration.java @@ -0,0 +1,221 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraConfiguration: This class holds the model for the arara configuration + * file. + */ +// package definition +package com.github.arara.model; + +// needed imports +import com.github.arara.exception.AraraException; +import com.github.arara.utils.AraraUtils; +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import org.apache.commons.lang3.SystemUtils; +import org.mvel2.templates.TemplateRuntime; + +/** + * Holds the model for the arara configuration file. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class AraraConfiguration { + + // the application language + private String language; + // the list of search paths + private List<String> paths; + // the list of filetypes + private List<AraraFilePattern> filetypes; + // the path runtime exception + private RuntimeException pathRuntimeException; + // the path IO exception + private IOException pathIOException; + + /** + * Getter for the search paths. + * + * @return The search paths. + */ + public List<String> getPaths() { + return paths; + } + + /** + * Getter for the language. + * + * @return The language. + */ + public String getLanguage() { + return language; + } + + /** + * Setter for the language. + * + * @param language The language. + */ + public void setLanguage(String language) { + this.language = language; + } + + /** + * Setter for the search paths. + * + * @param rules The search paths. + */ + public void setPaths(List<String> rules) throws AraraException, Exception { + this.paths = rules; + + // refresh paths + refreshPaths(); + } + + /** + * Getter for the filetypes. + * + * @return The filetypes. + */ + public List<AraraFilePattern> getFiletypes() { + return filetypes; + } + + /** + * Setter for the filetypes. + * + * @param filetypes The filetypes. + */ + public void setFiletypes(List<AraraFilePattern> filetypes) { + this.filetypes = filetypes; + } + + /** + * Constructor. + */ + public AraraConfiguration() { + + // creates both lists + paths = new ArrayList<String>(); + filetypes = new ArrayList<AraraFilePattern>(); + pathRuntimeException = null; + } + + /** + * Refreshes all paths, replacing possible variables in the template + */ + private void refreshPaths() throws AraraException, Exception { + + // create a map + HashMap map = new HashMap(); + + // add the variables + map.put("userhome", SystemUtils.USER_HOME); + + // for every path in the list + for (int i = 0; i < paths.size(); i++) { + + try { + + // remove the keyword + String fullPath = AraraUtils.removeKeyword(paths.get(i)); + + // apply the template + fullPath = (String) TemplateRuntime.eval(fullPath, map); + + try { + + // attempt to create a file reference and + // get the canonical path, if the operation + // succeeds, it's a valid path + File validFile = new File(fullPath); + validFile.getCanonicalPath(); + + // sanitize the path in order to be displayed correctly + fullPath = new File(new File(fullPath).toURI()).getPath(); + + // set the path in the list + paths.set(i, fullPath); + + } catch (IOException ioException) { + + // the path is terribly invalid, get the exception, + // if null + if (pathIOException == null) { + + // set the path IO exception + pathIOException = ioException; + } + } + + } catch (RuntimeException runtimeException) { + + // an error has occurred, register the exception for + // later access + + // if there isn't an exception yet + if (pathRuntimeException == null) { + + // set the exception + pathRuntimeException = runtimeException; + } + + } + } + } + + /** + * Getter for the path runtime exception. + * + * @return The path runtime exception. + */ + public RuntimeException getPathRuntimeException() { + return pathRuntimeException; + } + + /** + * Getter for the path IO exception. + * + * @return The path IO exception. + */ + public IOException getPathIOException() { + return pathIOException; + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraDirective.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraDirective.java new file mode 100644 index 00000000000..d0ff90daf14 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraDirective.java @@ -0,0 +1,148 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraDirective: This class provides the model for representing the arara + * directives found in the source file. It's a plain old Java object. + */ +// package definition +package com.github.arara.model; + +// needed imports +import java.util.Map; + +/** + * Provides the model for representing the arara directives found in the source + * file. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 1.0 + */ +public class AraraDirective { + + // the directive name + private String name; + // the configuration + private Map config; + // the line number + private int lineNumber = 0; + + /** + * Constructor. + * + * @param name The directive name. + * @param config The configuration. + */ + public AraraDirective(String name, Map config) { + + // set the name + this.name = name; + + // set the configuration + this.config = config; + } + + /** + * Constructor. + */ + public AraraDirective() { + } + + /** + * Getter for configuration. + * + * @return The configuration. + */ + public Map getConfig() { + + // return it + return config; + } + + /** + * Setter for configuration. + * + * @param config The configuration. + */ + public void setConfig(Map config) { + + // set the configuration + this.config = config; + } + + /** + * Getter for the directive name. + * + * @return The directive name. + */ + public String getName() { + + // return it + return name; + } + + /** + * Setter for the directive name. + * + * @param name The directive name. + */ + public void setName(String name) { + + // set it + this.name = name; + } + + /** + * Getter for the line number. + * + * @return The line number. + */ + public int getLineNumber() { + + // return it + return lineNumber; + } + + /** + * Setter for the line number. + * + * @param lineNumber The line number. + */ + public void setLineNumber(int lineNumber) { + + // set it + this.lineNumber = lineNumber; + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraFilePattern.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraFilePattern.java new file mode 100644 index 00000000000..99035737134 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraFilePattern.java @@ -0,0 +1,93 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraFilePattern: This class maps the supported filetypes. + */ +// package definition +package com.github.arara.model; + +// needed imports +import com.github.arara.utils.AraraConstants; + +/** + * Maps the supported filetypes. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class AraraFilePattern { + + // file extension + private String extension; + // file pattern + private String pattern; + + /** + * Getter for the file extension. + * + * @return The file extension. + */ + public String getExtension() { + return extension; + } + + /** + * Setter for the file extension. + * + * @param extension The file extension. + */ + public void setExtension(String extension) { + this.extension = extension; + } + + /** + * Getter for the file pattern. + * + * @return The file pattern. + */ + public String getPattern() { + return pattern; + } + + /** + * Setter for the file pattern. + * + * @param pattern The file pattern. + */ + public void setPattern(String pattern) { + this.pattern = pattern.concat(AraraConstants.DIRECTIVEPREFIX); + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraLanguage.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraLanguage.java new file mode 100644 index 00000000000..dbcda5b1549 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraLanguage.java @@ -0,0 +1,137 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraLanguage: This class holds the data model for the arara language + * specification. + */ +// package definition. +package com.github.arara.model; + +// needed import +import java.util.Locale; + +/** + * Holds the data model for the arara language specification. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class AraraLanguage { + + // language name + private String name; + // language code + private String code; + // language locale + private Locale locale; + + /** + * Getter for the language name. + * + * @return The language name. + */ + public String getName() { + return name; + } + + /** + * Setter for the language name. + * + * @param name The language name. + */ + public void setName(String name) { + this.name = name; + } + + /** + * Getter for the language code. + * + * @return The language code. + */ + public String getCode() { + return code; + } + + /** + * Setter for the language code. + * + * @param code The language code. + */ + public void setCode(String code) { + this.code = code; + } + + /** + * Getter for the language locale. + * + * @return The language locale. + */ + public Locale getLocale() { + return locale; + } + + /** + * Setter for the language locale. + * + * @param locale The language locale. + */ + public void setLocale(Locale locale) { + this.locale = locale; + } + + /** + * Constructor. + * + * @param name The language name. + * @param code The language code. + * @param locale The language locale. + */ + public AraraLanguage(String name, String code, Locale locale) { + this.name = name; + this.code = code; + this.locale = locale; + } + + /** + * Returns a string representation of the object. + * + * @return The string representation of the object. + */ + @Override + public String toString() { + return name.concat(" [").concat(code).concat("]"); + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraRuleArgument.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraRuleArgument.java new file mode 100644 index 00000000000..ec7edf71e86 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraRuleArgument.java @@ -0,0 +1,124 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * PlainAraraRuleArgument: This class provides the model for representing a + * plain Arara rule argument based on the YAML files. It's a plain old Java + * object. + */ +// package definition +package com.github.arara.model; + +// needed import +import com.github.arara.utils.AraraUtils; + +/** + * Provides the model for representing a plain Arara rule argument based on the + * YAML files. This class will be used to map YAML rules into Java objects. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 1.0 + */ +public class AraraRuleArgument { + + // the rule argument identifier + private String identifier; + // the command flag + private String flag; + // the default value + private String defaultValue; + + /** + * Getter for the default value. + * + * @return The default value. + */ + public String getDefault() { + return defaultValue; + } + + /** + * Setter for the default value. + * + * @param defaultValue The default value. + */ + public void setDefault(String defaultValue) { + this.defaultValue = AraraUtils.removeKeyword(defaultValue); + } + + /** + * Getter for flag. + * + * @return The command flag. + */ + public String getFlag() { + + // return it + return flag; + } + + /** + * Setter for flag. + * + * @param flag The command flag. + */ + public void setFlag(String flag) { + + // set the flag + this.flag = AraraUtils.removeKeyword(flag); + } + + /** + * Getter for the argument identifier. + * + * @return The argument identifier. + */ + public String getIdentifier() { + + // return it + return identifier; + } + + /** + * Setter for the argument identifier. + * + * @param identifier The argument identifier. + */ + public void setIdentifier(String identifier) { + + // set the identifier + this.identifier = identifier; + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraRuleConfig.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraRuleConfig.java new file mode 100644 index 00000000000..172c899bf14 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraRuleConfig.java @@ -0,0 +1,223 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * PlainAraraRuleConfig: This class provides the model for representing a plain + * Arara rule configuration based on the YAML files. It's a plain old Java + * object. + */ +// package definition +package com.github.arara.model; + +// needed imports +import com.github.arara.utils.AraraUtils; +import java.util.ArrayList; +import java.util.List; + +/** + * Provides the model for representing a plain Arara rule configuration based on + * the YAML files. This class will be used to map YAML rules into Java objects. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 1.0 + */ +public class AraraRuleConfig { + + // the rule identifier + private String identifier; + // the rule name + private String name; + // the rule command + private String command; + // the rule commands + private List<String> commands; + // the arguments list + private List<AraraRuleArgument> arguments; + + public List<String> getCommands() { + return commands; + } + + /** + * Setter for the rule commands. + * + * @param commands A list containing the rule commands. + */ + public void setCommands(List<String> commands) { + this.commands = commands; + + // for every entry + for (int i = 0; i < commands.size(); i++) { + + // remove keyword and reinsert into the list + String currentCommand = AraraUtils.removeKeyword(commands.get(i)); + commands.set(i, currentCommand); + } + } + + /** + * Getter for the rule identifier. + * + * @return The rule identifier. + */ + public String getIdentifier() { + + // return it + return identifier; + } + + /** + * Setter for the rule identifier. + * + * @param identifier The rule identifier. + */ + public void setIdentifier(String identifier) { + + // set the identifier + this.identifier = identifier; + } + + /** + * Getter for the rule name. + * + * @return The rule name. + */ + public String getName() { + + // return it + return name; + } + + /** + * Setter for the rule name. + * + * @param name The rule name. + */ + public void setName(String name) { + + // set the rule name + this.name = name; + } + + /** + * Getter for the rule command. + * + * @return The rule command. + */ + public String getCommand() { + + // return it + return command; + } + + /** + * Setter for the rule command. + * + * @param command The rule command. + */ + public void setCommand(String command) { + + // set the command + this.command = AraraUtils.removeKeyword(command); + } + + /** + * Getter for the arguments list. + * + * @return The arguments list. + */ + public List<AraraRuleArgument> getArguments() { + + // return the list + return arguments; + } + + /** + * Setter for the arguments list. + * + * @param arguments The arguments list. + */ + public void setArguments(List<AraraRuleArgument> arguments) { + + // set the list + this.arguments = arguments; + } + + /** + * Returns a list containing all argument identifiers. + * + * @return A list containing all argument identifiers. + */ + public List<String> getIdentifiersList() { + + // create a new list + List<String> result = new ArrayList<String>(); + + // for every argument + for (AraraRuleArgument argument : getArguments()) { + + // add identifier + result.add(argument.getIdentifier()); + } + + // return list + return result; + } + + /** + * Returns the forbidden identifier, if any. + * + * @return The forbidden identifier, if any. + */ + public String checkForForbiddenIdentifiers() { + + // for every argument + for (AraraRuleArgument argument : getArguments()) { + + // get the current argument value + String value = argument.getIdentifier().toLowerCase(); + + // check if it's a forbidden argument identifier + if ((value.equals("file")) || (value.equals("files")) || (value.equals("item")) || (value.equals("items"))) { + + // return the value + return value; + } + } + + // nothing wrong was found + return null; + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraTask.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraTask.java new file mode 100644 index 00000000000..5bb679afdc1 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/model/AraraTask.java @@ -0,0 +1,109 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraTask: This class provides the model for representing the Arara tasks + * based on the directives and rules. It's a plain old Java object. + */ +// package definition +package com.github.arara.model; + +// needed import +import java.util.HashMap; + +/** + * Provides the model for representing the Arara tasks based on the directives + * and rules. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 1.0 + */ +public class AraraTask { + + // the task name + private String name; + // a map to hold the tasks parameters + private HashMap parameters; + + /** + * Empty constructor. + */ + public AraraTask() { + } + + /** + * Getter for name. + * + * @return The task name. + */ + public String getName() { + + // return it + return name; + } + + /** + * Setter for name. + * + * @param name The task name. + */ + public void setName(String name) { + + // set the name + this.name = name; + } + + /** + * Getter for parameters. + * + * @return A map containing all the task parameters. + */ + public HashMap getParameters() { + + // return it + return parameters; + } + + /** + * Setter for parameters. + * + * @param parameters The task parameters as a map. + */ + public void setParameters(HashMap parameters) { + + // set parameters + this.parameters = parameters; + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraConstants.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraConstants.java new file mode 100644 index 00000000000..5139bb7b884 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraConstants.java @@ -0,0 +1,96 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraConstants: This class contains all the constants used in the main + * application. + */ +// package definition +package com.github.arara.utils; + +/** + * Contains all the constants used in the main application. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class AraraConstants { + + /** + * The arara version. + */ + public static final String VERSION = "3.0"; + /** + * The number of characters per line in messages. + */ + public static final int WRAPLENGTH = 65; + /** + * The name of the default configuration file. + */ + public static final String ARARACONFIG = "araraconfig.yaml"; + /** + * The directive prefix for the pattern matching method. + */ + public static final String DIRECTIVEPREFIX = "arara:\\s"; + /** + * The rule pattern for string reference. + */ + public static final String RULEPATTERN = "^(\\s)*<arara>\\s"; + /** + * The name of the log file generated by arara. + */ + public static final String LOGNAME = "arara"; + /** + * The copyright year. + */ + public static final String COPYRIGHTYEAR = "2012"; + /** + * The variable exception matching pattern. + */ + public static final String VAREXCEPTIONPATTERN = "^\\[Error: could not access: (.*);"; + /** + * The method exception matching pattern. + */ + public static final String METHODEXCEPTIONPATTERN = "^\\[Error: unable to access property \\((.*)\\): (.*)\\]"; + /** + * The full directive matching pattern. + */ + public static final String FULLDIRECTIVEPATTERN = "^\\s*(\\w+)\\s*:\\s*\\{.*\\}\\s*$"; + /** + * The empty directive matching pattern. + */ + public static final String EMPTYDIRECTIVEPATTERN = "^\\s*(\\w+)\\s*$"; + +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraLocalization.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraLocalization.java new file mode 100644 index 00000000000..b3444f615bf --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraLocalization.java @@ -0,0 +1,126 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraLocalization: This class contains a few helper methods in order to ease + * the localization process during the execution. This class is a singleton + * reference. + */ +// package definition +package com.github.arara.utils; + +// needed imports +import java.text.MessageFormat; +import java.util.Locale; +import java.util.ResourceBundle; + +/** + * Contains a few helper methods in order to ease the localization process + * during the execution. This class is a singleton reference. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class AraraLocalization { + + // the singleton reference + private static AraraLocalization selfRef; + // the resource bundle for the whole application + private ResourceBundle resources; + + /** + * Constructs the singleton instance. + */ + private AraraLocalization() { + + // set the self-reference + selfRef = this; + + // instead of relying in the default locale from the + // operating system, always fallback to english + Locale.setDefault(Locale.ENGLISH); + + // get the resource bundle + resources = ResourceBundle.getBundle("com.github.arara.localization.Messages"); + } + + /** + * Provides reference to the singleton object. + * + * @return The singleton instance. + */ + public static final AraraLocalization getInstance() { + + // if there's no current object, call the private constructor + if (selfRef == null) { + selfRef = new AraraLocalization(); + } + + // return the actual object + return selfRef; + } + + /** + * Returns a simple message from the resource bundle. + * + * @param message The message identifier. + * @return A string from the resource bundle. + */ + public String getMessage(String message) { + return resources.getString(message); + } + + /** + * Returns a message containing parameters from the resource bundle. + * + * @param message The message identifier. + * @param parameters A list of parameters to be replaced in the message. + * @return A string from the resource bundle, with the correct parameters. + */ + public String getMessage(String message, Object... parameters) { + return MessageFormat.format(resources.getString(message), parameters); + } + + /** + * Refresh the resource bundle reference, if by any chance, the application + * language is changed in runtime. + */ + public void refresh() { + + // clear cache and reload the resource bundle + // ResourceBundle.clearCache(); // not supported by Java 5 + resources = ResourceBundle.getBundle("com.github.arara.localization.Messages"); + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraLogging.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraLogging.java new file mode 100644 index 00000000000..ad5cf19d861 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraLogging.java @@ -0,0 +1,82 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraLogging: This class configures the logging features. + */ +// package definition +package com.github.arara.utils; + +// needed imports +import ch.qos.logback.classic.LoggerContext; +import ch.qos.logback.classic.joran.JoranConfigurator; +import ch.qos.logback.core.joran.spi.JoranException; +import org.slf4j.LoggerFactory; + +/** + * Configures the logging features. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class AraraLogging { + + public static void enableLogging(boolean enable) { + + // get the context + LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory(); + + try { + + // create a new configurator + JoranConfigurator configurator = new JoranConfigurator(); + + // set context and reset it + configurator.setContext(loggerContext); + loggerContext.reset(); + + // if logging should be enabled + if (enable) { + + // add the correct properties and load the XML file + loggerContext.putProperty("araraLogName", AraraConstants.LOGNAME); + configurator.doConfigure(AraraLogging.class.getResourceAsStream("/com/github/arara/conf/logback.xml")); + } + + } catch (JoranException joranException) { + // do nothing + } + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraMethods.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraMethods.java new file mode 100644 index 00000000000..e7699c96d56 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraMethods.java @@ -0,0 +1,481 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraMethods: This class contains methods for the MVEL expression language to + * be used in the rules. + */ +// package definition +package com.github.arara.utils; + +// needed import +import java.io.File; +import org.apache.commons.lang3.SystemUtils; + +/** + * Contains methods for the MVEL expression language to be used in the rules. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class AraraMethods { + + /** + * Holds the original filename. + */ + private static String originalFile; + + /** + * Setter for the original filename. + * + * @param originalFile The original filename. + */ + public static void setOriginalFile(String originalFile) { + AraraMethods.originalFile = originalFile; + } + + /** + * Getter for the original filename. + * + * @return A string containing the original filename. + */ + public static String getOriginalFile() { + return originalFile; + } + + /** + * Checks if string is empty. + * + * @param string The string. + * @return A logical value according to the condition. + */ + public static boolean isEmpty(String string) { + return string.isEmpty(); + } + + /** + * Checks if string is not empty. + * + * @param string The string. + * @return A logical value according to the condition. + */ + public static boolean isNotEmpty(String string) { + return !string.isEmpty(); + } + + /** + * Checks if string is empty. + * + * @param string The string. + * @param ifTrue Value if true. + * @return A string according the condition. + */ + public static String isEmpty(String string, String ifTrue) { + return (string.isEmpty() ? ifTrue : string); + } + + /** + * Checks if string is not empty. + * + * @param string The string. + * @param ifTrue Value if true. + * @return A string according the condition. + */ + public static String isNotEmpty(String string, String ifTrue) { + return (!string.isEmpty() ? ifTrue : string); + } + + /** + * Checks if string is empty. + * + * @param string The string. + * @param ifTrue Value if true. + * @param ifFalse Value if false. + * @return A string according the condition. + */ + public static String isEmpty(String string, String ifTrue, String ifFalse) { + return (string.isEmpty() ? ifTrue : ifFalse); + } + + /** + * Checks if string is not empty. + * + * @param string The string. + * @param ifTrue Value if true. + * @param ifFalse Value if false. + * @return A string according the condition. + */ + public static String isNotEmpty(String string, String ifTrue, String ifFalse) { + return (!string.isEmpty() ? ifTrue : ifFalse); + } + + /** + * Checks if string resolves to a logic value representing true. + * + * @param string The string. + * @return A string according the condition. + */ + public static boolean isTrue(String string) { + string = string.toLowerCase(); + if ((string.equals("yes")) || (string.equals("on")) || (string.equals("true")) || (string.equals("y")) || (string.equals("1"))) { + return true; + } else { + return false; + } + } + + /** + * Checks if string resolves to a logic value representing false. + * + * @param string The string. + * @return A string according the condition. + */ + public static boolean isFalse(String string) { + string = string.toLowerCase(); + if ((string.equals("no")) || (string.equals("off")) || (string.equals("false")) || (string.equals("n")) || (string.equals("0"))) { + return true; + } else { + return false; + } + } + + /** + * Checks if string resolves to a logic value representing true. + * + * @param string The string. + * @param ifTrue Value if true. + * @return A string according the condition. + */ + public static String isTrue(String string, String ifTrue) { + return (isTrue(string) ? ifTrue : ""); + } + + /** + * Checks if string resolves to a logic value representing false. + * + * @param string The string. + * @param ifTrue Value if true. + * @return A string according the condition. + */ + public static String isFalse(String string, String ifTrue) { + return (isFalse(string) ? ifTrue : ""); + } + + /** + * Checks if string resolves to a logic value representing true. + * + * @param string The string. + * @param ifTrue Value if true. + * @param ifFalse Value if false. + * @return A string according the condition. + */ + public static String isTrue(String string, String ifTrue, String ifFalse) { + return (isTrue(string) ? ifTrue : ifFalse); + } + + /** + * Checks if string resolves to a logic value representing false. + * + * @param string The string. + * @param ifTrue Value if true. + * @param ifFalse Value if false. + * @return A string according the condition. + */ + public static String isFalse(String string, String ifTrue, String ifFalse) { + return (isFalse(string) ? ifTrue : ifFalse); + } + + /** + * Checks if string resolves to a logic value representing true. + * + * @param string The string. + * @param ifTrue Value if true. + * @param ifFalse Value if false. + * @param defaultValue Value if the string is neither true or false. + * @return A string according the condition. + */ + public static String isTrue(String string, String ifTrue, String ifFalse, String defaultValue) { + if (isTrue(string)) { + return ifTrue; + } + if (isFalse(string)) { + return ifFalse; + } + return defaultValue; + } + + /** + * Checks if string resolves to a logic value representing false. + * + * @param string The string. + * @param ifTrue Value if true. + * @param ifFalse Value if false. + * @param defaultValue Value if the string is neither true or false. + * @return A string according the condition. + */ + public static String isFalse(String string, String ifTrue, String ifFalse, String defaultValue) { + if (isFalse(string)) { + return ifTrue; + } + if (isTrue(string)) { + return ifFalse; + } + return defaultValue; + } + + /** + * Trim spaces from the string. + * + * @param string The string. + * @return The string with the trailing and leading spaces trimmed. + */ + public static String trimSpaces(String string) { + return string.trim(); + } + + /** + * Returns the filename. + * + * @param f The string. + * @return The filename. + */ + public static String getFilename(String f) { + try { + return (new File(f)).getName(); + } catch (Exception exception) { + return ""; + } + } + + /** + * Returns the base name. + * + * @param f The string. + * @return The base name. + */ + public static String getBasename(String f) { + try { + f = (new File(f)).getName(); + int i = f.lastIndexOf(".") != -1 ? f.lastIndexOf(".") : f.length(); + return f.substring(0, i); + } catch (Exception exception) { + return ""; + } + } + + /** + * Returns the filetype. + * + * @param f The string. + * @return The filetype. + */ + public static String getFiletype(String f) { + try { + f = (new File(f)).getName(); + if (f.lastIndexOf(".") != -1) { + return f.substring(f.lastIndexOf(".") + 1, f.length()); + } + return ""; + } catch (Exception exception) { + return ""; + } + } + + /** + * Returns the directory name. + * + * @param f The string. + * @return The directory name. + */ + public static String getDirname(String f) { + try { + return (new File(f)).getParent(); + } catch (Exception exception) { + return ""; + } + } + + /** + * Checks if the string is a valid existing file. + * + * @param f The string. + * @return A logic value indicating if the string is a valid existing file. + */ + public static boolean isFile(String f) { + try { + return (new File(f)).isFile(); + } catch (Exception exception) { + return false; + } + } + + /** + * Checks if the string is a valid existing directory. + * + * @param f The string. + * @return A logic value indicating if the string is a valid existing + * directory. + */ + public static boolean isDir(String f) { + try { + return (new File(f)).isDirectory(); + } catch (Exception exception) { + return false; + } + } + + /** + * Checks if the operating system is Windows. + * + * @param ifTrue The value if true. + * @param ifFalse The value if false. + * @return A string according the condition. + */ + public static String isWindows(String ifTrue, String ifFalse) { + if (SystemUtils.IS_OS_WINDOWS) { + return ifTrue; + } + else { + return ifFalse; + } + } + + /** + * Checks if the operating system is Linux. + * + * @param ifTrue The value if true. + * @param ifFalse The value if false. + * @return A string according the condition. + */ + public static String isLinux(String ifTrue, String ifFalse) { + if (SystemUtils.IS_OS_LINUX) { + return ifTrue; + } + else { + return ifFalse; + } + } + + /** + * Checks if the operating system is Unix. + * + * @param ifTrue The value if true. + * @param ifFalse The value if false. + * @return A string according the condition. + */ + public static String isUnix(String ifTrue, String ifFalse) { + if (SystemUtils.IS_OS_UNIX) { + return ifTrue; + } + else { + return ifFalse; + } + } + + /** + * Checks if the operating system is Mac. + * + * @param ifTrue The value if true. + * @param ifFalse The value if false. + * @return A string according the condition. + */ + public static String isMac(String ifTrue, String ifFalse) { + if (SystemUtils.IS_OS_MAC) { + return ifTrue; + } + else { + return ifFalse; + } + } + + /** + * Checks if the logic condition is true. + * + * @param value Logic condition to be evaluated. + * @param ifTrue The value if true. + * @return A string according the condition. + */ + public static String isTrue(boolean value, String ifTrue) { + if (value) { + return ifTrue; + } + return ""; + } + + /** + * Checks if the logic condition is true. + * + * @param value Logic condition to be evaluated. + * @param ifTrue The value if true. + * @param ifFalse The value if false. + * @return A string according the condition. + */ + public static String isTrue(boolean value, String ifTrue, String ifFalse) { + if (value) { + return ifTrue; + } + return ifFalse; + } + + /** + * Checks if the logic condition is false. + * + * @param value Logic condition to be evaluated. + * @param ifTrue The value if true. + * @return A string according the condition. + */ + public static String isFalse(boolean value, String ifTrue) { + if (!value) { + return ifTrue; + } + return ""; + } + + /** + * Checks if the logic condition is false. + * + * @param value Logic condition to be evaluated. + * @param ifTrue The value if true. + * @param ifFalse The value if false. + * @return A string according the condition. + */ + public static String isFalse(boolean value, String ifTrue, String ifFalse) { + if (!value) { + return ifTrue; + } + return ifFalse; + } + +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraResolver.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraResolver.java new file mode 100644 index 00000000000..54d280be2cb --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraResolver.java @@ -0,0 +1,74 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraResolver: This class extends a Resolver class to disable mapping of + * numeric times, as arara works better with text. + */ +// package definition +package com.github.arara.utils; + +// needed import +import org.yaml.snakeyaml.nodes.Tag; +import org.yaml.snakeyaml.resolver.Resolver; + +/** + * Extends a Resolver class to disable mapping of numeric times, as Arara works + * better with text. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 1.0 + */ +public class AraraResolver extends Resolver { + + /** + * Adds the implicit resolvers to the Yaml mechanism. + */ + @Override + protected void addImplicitResolvers() { + + // for merges + addImplicitResolver(Tag.MERGE, MERGE, "<"); + + // for null values + addImplicitResolver(Tag.NULL, NULL, "~nN\0"); + + // for empty values + addImplicitResolver(Tag.NULL, EMPTY, null); + + // for values + addImplicitResolver(Tag.VALUE, VALUE, "="); + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraUtils.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraUtils.java new file mode 100644 index 00000000000..2439cb70150 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/AraraUtils.java @@ -0,0 +1,224 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraUtils: This class contains some helper methods used for general purpose. + */ +// package definition +package com.github.arara.utils; + +// needed imports +import java.util.StringTokenizer; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import org.apache.commons.lang3.text.WordUtils; +import org.yaml.snakeyaml.error.MarkedYAMLException; + +/** + * Contains some helper methods used for general purpose. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class AraraUtils { + + // the localization class + final static AraraLocalization localization = AraraLocalization.getInstance(); + + /** + * Removes the reserved keyword in the strings to be analyzed by the MVEL + * template engine. The keyword is set in AraraConstants. + * + * @param line The line to be analyzed. + * @return The new line without the keyword. + */ + public static String removeKeyword(String line) { + + // set a new pattern and matcher + Pattern pattern = Pattern.compile(AraraConstants.RULEPATTERN); + Matcher matcher = pattern.matcher(line); + + // if the keyword is found + if (matcher.find()) { + + // remove the keyword + line = (line.substring(matcher.end(), line.length())).trim(); + } + + // and return it + return line; + } + + /** + * Prints the arara ASCII header. + */ + public static void printHeader() { + + // print the ASCII art + System.out.println(" __ _ _ __ __ _ _ __ __ _ "); + System.out.println(" / _` | '__/ _` | '__/ _` |"); + System.out.println("| (_| | | | (_| | | | (_| |"); + System.out.println(" \\__,_|_| \\__,_|_| \\__,_|\n"); + + } + + /** + * Wraps the string to several lines, according to the wrap length set in + * the AraraConstants class. + * + * @param message The message to be wrapped. + * @return A new message. + */ + public static String wrap(String message) { + + // create a new tokenizer in order to allow line breaks, so + // every line is processed individually + StringTokenizer tokens = new StringTokenizer(message, "\n", true); + String result = ""; + + // iterate through tokens + while (tokens.hasMoreTokens()) { + + // wrap line according to the wrap length + result = result.concat(WordUtils.wrap(tokens.nextToken(), AraraConstants.WRAPLENGTH)); + } + + // return the result + return result; + } + + /** + * Gets the variable reference from a RuntimeException object. + * @param runtimeException The RuntimeException object. + * + * @return The variable reference name. + */ + public static String getVariableFromException(RuntimeException runtimeException) { + + // set pattern and matcher + Pattern pattern = Pattern.compile(AraraConstants.VAREXCEPTIONPATTERN); + Matcher matcher = pattern.matcher(runtimeException.getMessage()); + + // if the variable is found + if (matcher.find()) { + + // check if it's a valid reference + if (matcher.groupCount() != 0) { + + // return the variable name + return matcher.group(1); + } + + } else { + + // maybe it's a method call, let's investigate + pattern = Pattern.compile(AraraConstants.METHODEXCEPTIONPATTERN); + matcher = pattern.matcher(runtimeException.getMessage()); + + if (matcher.find()) { + + // check if it's a valid reference + if (matcher.groupCount() > 1) { + + // return the method name + return matcher.group(2); + } + + } + + } + + // nothing is found, so return an unknown reference + return "<unknown>"; + } + + /** + * Extracts information from a MarkedYAMLException object. + * + * @param yamlException The exception object. + * @return A string containing all the available information from the + * exception object. + */ + public static String extractInformationFromYAMLException(MarkedYAMLException yamlException) { + StringBuilder stringBuilder = new StringBuilder(); + if (yamlException.getContext() != null) { + stringBuilder.append(localization.getMessage("YamlError_Context", yamlException.getContext())).append("\n"); + } + if (yamlException.getProblem() != null) { + stringBuilder.append(localization.getMessage("YamlError_Problem", yamlException.getProblem())).append("\n"); + } + if (yamlException.getProblemMark() != null) { + stringBuilder.append(localization.getMessage("YamlError_ErrorLocation", yamlException.getProblemMark().getLine(), yamlException.getProblemMark().getColumn())).append("\n"); + } + if (yamlException.getProblemMark().get_snippet() != null) { + stringBuilder.append(yamlException.getProblemMark().get_snippet()); + } + return stringBuilder.toString(); + } + + /** + * Checks if the line contains a valid full directive. + * + * @param line The current line. + * @return A logic value indicating if a valid directive was found. + */ + public static boolean checkForFullDirective(String line) { + Pattern pattern = Pattern.compile(AraraConstants.FULLDIRECTIVEPATTERN); + Matcher m = pattern.matcher(line); + if (m.find()) { + return true; + } + else { + return false; + } + } + + /** + * Checks if the line contains a valid empty directive. + * + * @param line The current line. + * @return A logic value indicating if a valid directive was found. + */ + public static boolean checkForEmptyDirective(String line) { + Pattern pattern = Pattern.compile(AraraConstants.EMPTYDIRECTIVEPATTERN); + Matcher m = pattern.matcher(line); + if (m.find()) { + return true; + } + else { + return false; + } + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/CommandLineAnalyzer.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/CommandLineAnalyzer.java new file mode 100644 index 00000000000..18257a3d532 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/CommandLineAnalyzer.java @@ -0,0 +1,488 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * CommandLineAnalyzer: This class implements a command line parser to provide + * better control of flags and files to process. + */ +// package definition +package com.github.arara.utils; + +// needed import +import java.io.File; +import org.apache.commons.cli.*; + +/** + * Implements a command line parser to provide better control of flags and files + * to process. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 1.0 + */ +public class CommandLineAnalyzer { + + // the file to process + private String theFile; + // the command line arguments + private String[] theArgs; + // the command line options + private Options commandLineOptions; + // the verbose option + private boolean showVerboseOutput; + // the execution timeout, + // in milliseconds + private long executionTimeout; + // the configuration + private ConfigurationLoader configuration; + // the localization class + final static AraraLocalization localization = AraraLocalization.getInstance(); + + /** + * Constructor. + * + * @param theArgs The command line arguments. + * @param configuration The current configuration. + */ + public CommandLineAnalyzer(String[] theArgs, ConfigurationLoader configuration) { + + // set the array + this.theArgs = theArgs; + + // set the configuration + this.configuration = configuration; + + // create new options + commandLineOptions = new Options(); + + // set the default value to the output + showVerboseOutput = false; + + } + + /** + * Parses the command line arguments and provides feedback to the main + * class. + * + * @return A boolean value if there is a file to be processed by Arara. + */ + public boolean parse() { + + // create the version option + Option optVersion = new Option("V", "version", false, localization.getMessage("Help_Version")); + + // create the help option + Option optHelp = new Option("h", "help", false, localization.getMessage("Help_Help")); + + // create the log option + Option optLog = new Option("l", "log", false, localization.getMessage("Help_Log")); + + // create the verbose option + Option optVerbose = new Option("v", "verbose", false, localization.getMessage("Help_Verbose")); + + // create the timeout option + Option optTimeout = new Option("t", "timeout", true, localization.getMessage("Help_Timeout")); + + // create the language option + Option optLanguage = new Option("L", "language", true, localization.getMessage("Help_Language")); + + // add version + commandLineOptions.addOption(optVersion); + + // add help + commandLineOptions.addOption(optHelp); + + // add log + commandLineOptions.addOption(optLog); + + // add verbose + commandLineOptions.addOption(optVerbose); + + // add timeout + commandLineOptions.addOption(optTimeout); + + // add language + commandLineOptions.addOption(optLanguage); + + // create a new basic parser + CommandLineParser parser = new BasicParser(); + + // lets try to parse everthing + try { + + // parse the arguments + CommandLine line = parser.parse(commandLineOptions, theArgs); + + // if -L or --language found + if (line.hasOption("language")) { + + // create a new language controler + LanguageController language = new LanguageController(); + + // if the attempt to set the language according to the command + // line has failed + if (!language.setLanguage(line.getOptionValue("language"))) { + + // print the list of available languages + language.printLanguageHelp(); + + // print the usage + printUsage(); + + // and simply return + return false; + } + else { + + // new language, refresh the options + optVersion.setDescription(localization.getMessage("Help_Version")); + optHelp.setDescription(localization.getMessage("Help_Help")); + optLog.setDescription(localization.getMessage("Help_Log")); + optVerbose.setDescription(localization.getMessage("Help_Verbose")); + optTimeout.setDescription(localization.getMessage("Help_Timeout")); + optLanguage.setDescription(localization.getMessage("Help_Language")); + } + } + + // if -h or --help found + if (line.hasOption("help")) { + + // print version + printVersion(); + + // and usage + printUsage(); + + // return + return false; + + } else { + + // if -v or --version found + if (line.hasOption("version")) { + + // print version + printVersion(); + + printSpecialThanks(); + + // and return + return false; + + } else { + + // get the list of files + String[] files = line.getArgs(); + + // we only expect one file + if (files.length != 1) { + + // print version + printVersion(); + + // usage + printUsage(); + + // and return + return false; + + } else { + + // if -t or --timeout found + if (line.hasOption("timeout")) { + + // try to convert the argument to a number + try { + + // parse the long value + executionTimeout = Long.parseLong(line.getOptionValue("timeout")); + + // if it's not a valid number + if (executionTimeout <= 0) { + + // print version + printVersion(); + + // usage + printUsage(); + + // and return + return false; + + } + } catch (NumberFormatException numberFormatException) { + + // we have a bad conversion + + // print version + printVersion(); + + // usage + printUsage(); + + // and return + return false; + } + } else { + + // fallback to the default value, that is, + // timeout is disabled + executionTimeout = 0; + } + + // active logging + AraraLogging.enableLogging(line.hasOption("log")); + + // set verbose flag + showVerboseOutput = line.hasOption("verbose"); + + // everything is fine, set + // the file + theFile = files[0]; + + // check if file exists + if (!checkFile(theFile, configuration.getValidExtensions())) { + + // file not found, return false + return false; + + } + + // and return + return true; + } + } + } + + } catch (ParseException parseException) { + + // something happened, in the last case print version + printVersion(); + + // and usage + printUsage(); + + // and simply return + return false; + + } + } + + /** + * Prints the usage message. + */ + private void printUsage() { + + // new formatter + HelpFormatter formatter = new HelpFormatter(); + + // add the text and print + formatter.printHelp("arara [file [--log] [--verbose] [--timeout N] [--language L] | --help | --version]", commandLineOptions); + } + + /** + * Prints the application version. + */ + private void printVersion() { + + // print the version + System.out.println("arara ".concat(AraraConstants.VERSION).concat(" - ").concat(localization.getMessage("Header_Slogan"))); + System.out.println("Copyright (c) ".concat(AraraConstants.COPYRIGHTYEAR).concat(", Paulo Roberto Massa Cereda")); + System.out.println(localization.getMessage("Header_AllRightsReserved").concat("\n")); + } + + /** + * Getter for file obtained from the command line. + * + * @return The file. + */ + public String getFile() { + + // return it + return theFile; + } + + /** + * Checks if file is valid. + * + * @param filename The file name. + * @param extensions A priority list of allowed extensions. + * @return A boolean value to determine if the file is valid. + */ + private boolean checkFile(String filename, String[] extensions) { + + // flag to indicate the file was found + boolean foundFile = false; + + // iterate through all the extensions + for (String currentExtension : extensions) { + + // check if the file has the current extension + if (filename.toLowerCase().endsWith(currentExtension)) { + + // set flag + foundFile = true; + + // set configuration + configuration.setChosenFilePattern(currentExtension); + + // break iteration + break; + } + } + + // create a new file status + File fileStatus = null; + + // check if a reference was found + if (foundFile) { + + // create new instance + fileStatus = new File(filename); + + // check if exists + if (fileStatus.exists()) { + + // add file + theFile = filename; + + // found it! + return true; + } else { + + // print message about it + System.out.println(localization.getMessage("Error_FileDoesNotExist", filename)); + + // not found + return false; + } + + } else { + + // there's no extension, we will add them and see if something + // is found + for (String currentExtension : extensions) { + + // new file with extension + fileStatus = new File(filename + currentExtension); + + // let's check it + if (fileStatus.exists()) { + + // add file + theFile = filename + currentExtension; + + // add reference + configuration.setChosenFilePattern(currentExtension); + + // found it! + return true; + + } + + } + + // print message about it + System.out.println(AraraUtils.wrap(localization.getMessage("Error_FileDoesNotExistWithExtensionsList", filename, getExtensionsList(extensions)))); + + // file not found + return false; + + } + + } + + /** + * Returns a string with the extensions list. + * + * @param extensions The extensions list. + * @return A string with the extensions list. + */ + private String getExtensionsList(String[] extensions) { + + // if it's an empty vector + if (extensions.length == 0) { + + // return an empty string + return ""; + + } else { + + // get first element + String result = "[".concat(extensions[0]); + + // iterate through the other values + for (int i = 1; i < extensions.length; i++) { + + // add the current extension + result = result.concat(", ").concat(extensions[i]); + } + + // close the list + result = result.concat("]"); + + // return it + return result; + } + } + + /** + * Checks if the output must be verbose. + * + * @return A boolean value. + */ + public boolean isVerbose() { + + // return it + return showVerboseOutput; + } + + /** + * Getter for the execution timeout. + * + * @return The execution timeout. + */ + public long getExecutionTimeout() { + + // return it + return executionTimeout; + } + + /** + * Prints the special thanks message. + */ + private void printSpecialThanks() { + System.out.println(AraraUtils.wrap(localization.getMessage("Msg_SpecialThanks"))); + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/CommandTrigger.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/CommandTrigger.java new file mode 100644 index 00000000000..2ab887c2883 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/CommandTrigger.java @@ -0,0 +1,285 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * CommandTrigger: This class is responsible for running the arara commands. + */ +// package definition +package com.github.arara.utils; + +// needed imports +import com.github.arara.exception.AraraException; +import com.github.arara.model.AraraCommand; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.util.List; +import org.apache.commons.exec.*; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Implements an environment for running the arara commands. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class CommandTrigger { + + // the logger + final static Logger logger = LoggerFactory.getLogger(CommandTrigger.class); + // the localization class + final static AraraLocalization localization = AraraLocalization.getInstance(); + // the commands list + private List<AraraCommand> commands; + // flag to determine verbose output + private boolean showVerboseOutput; + // value for the execution timeout + private long executionTimeout; + + /** + * Constructor. + * + * @param commands The commands list. + */ + public CommandTrigger(List<AraraCommand> commands) { + + // set the list + this.commands = commands; + } + + /** + * Setter for the execution timeout. + * + * @param executionTimeout The execution timeout. + */ + public void setExecutionTimeout(long executionTimeout) { + + // set the value + this.executionTimeout = executionTimeout; + } + + /** + * Setter for the verbose mode. + * + * @param verbose A flag to indicate the verbose mode. + */ + public void setVerbose(boolean verbose) { + + // set the flag + showVerboseOutput = verbose; + } + + /** + * Executes the arara commands provided in the list. + * + * @return A boolean value about the execution. To be honest, I don't think + * it's necessary to return an actual value, but I kept it for possible + * future use. + * @throws AraraException Raised when the command is not found in the + * underlying system. + */ + public boolean execute() throws AraraException { + + // log action + logger.info(localization.getMessage("Log_ReadyToRunCommands")); + + // for every command in the list + for (AraraCommand currentAraraCommand : commands) { + + // print a message + System.out.print(localization.getMessage("Msg_RunningCommand", currentAraraCommand.getName()).concat(" ")); + + // if verbose + if (showVerboseOutput) { + + // add two lines + System.out.println("\n"); + } + + // log action + logger.info(localization.getMessage("Log_CommandName", currentAraraCommand.getName())); + + // log command + logger.trace(localization.getMessage("Log_Command", currentAraraCommand.getCommand())); + + // if the execution was ok + //if (runCommand(currentAraraCommand)) { + if (runCommand(currentAraraCommand)) { + + // print a message + System.out.println(localization.getMessage("Msg_Success")); + + // log action + logger.info(localization.getMessage("Log_CommandSuccess", currentAraraCommand.getName())); + + } else { + + // something bad happened, print message + System.out.println(localization.getMessage("Msg_Failure")); + + // log action + logger.warn(localization.getMessage("Log_CommandFailure", currentAraraCommand.getName())); + + // and return false + return false; + + } + + // if verbose + if (showVerboseOutput) { + + // add one line to the output + System.out.println(""); + } + + } + + // log action + logger.info(localization.getMessage("Log_AllCommandsSuccess")); + + // everything went ok, simply return true + return true; + + } + + /** + * Run the arara command. + * + * @param command The Arara command. + * @return A boolean indicating if the execution was successful. + * @throws AraraException Throws an exception in case the command was not + * found. + */ + private boolean runCommand(AraraCommand command) throws AraraException { + + // create a new byte array for the output logger + ByteArrayOutputStream stringLogger = new ByteArrayOutputStream(); + + // let's try + try { + + // set a query + String query = command.getCommand(); + + // create a new command line from the query + CommandLine commandLine = CommandLine.parse(query); + + // create a new tee + TeeOutputStream tee; + + // create a new execution handler + PumpStreamHandler streamHandler; + + // if verbose + if (showVerboseOutput) { + + // the new tee should include the normal output + // and the log + tee = new TeeOutputStream(System.out, stringLogger); + + // verbose mode enables input mode as well + streamHandler = new PumpStreamHandler(tee, tee, System.in); + + } else { + + // no verbose, so include only the log output + tee = new TeeOutputStream(stringLogger); + + // define the handler only with the log output + streamHandler = new PumpStreamHandler(tee); + } + + // create a new executor + DefaultExecutor executor = new DefaultExecutor(); + + // set the handler + executor.setStreamHandler(streamHandler); + + // check if there should be an execution timeout + if (executionTimeout > 0) { + + // create a new watch dog + ExecuteWatchdog watchDog = new ExecuteWatchdog(executionTimeout); + + // add it to the execution + executor.setWatchdog(watchDog); + } + + // set the shutdown hook + ShutdownHookProcessDestroyer processDestroyer = new ShutdownHookProcessDestroyer(); + + // add it to the executor + executor.setProcessDestroyer(processDestroyer); + + // execute the command and get the exit code + int exitValue = executor.execute(commandLine); + + // if we are in verbose mode + if (showVerboseOutput) { + + // print the output status + System.out.print(localization.getMessage("Msg_Status").concat(" ")); + + } + + // add the output to the logger + logger.trace(localization.getMessage("Log_OutputLogging")); + logger.trace(stringLogger.toString()); + + // return the status as a boolean + return (exitValue == 0 ? true : false); + + } catch (ExecuteException executeException) { + + // in case of an error, or the watchdog in action, + // the logger addition is not reached, so we need + // to replicate it here + logger.trace(localization.getMessage("Log_OutputLogging")); + logger.trace(stringLogger.toString()); + + // something bad happened, return false + return false; + + } catch (IOException ioException) { + + // log error + logger.error(localization.getMessage("Log_CommandNotFound", command.getName(), command.getCommand())); + + // command not found, throw exception + throw new AraraException(localization.getMessage("Error_CommandNotFound", command.getName(), command.getCommand())); + + } + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/ConfigurationLoader.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/ConfigurationLoader.java new file mode 100644 index 00000000000..cb2b2a7705d --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/ConfigurationLoader.java @@ -0,0 +1,394 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * ConfigurationLoader: This class provides an object handler for the arara + * configuration file. + */ +// package definition +package com.github.arara.utils; + +// needed imports +import com.github.arara.Arara; +import com.github.arara.exception.AraraException; +import com.github.arara.model.AraraConfiguration; +import com.github.arara.model.AraraFilePattern; +import java.io.File; +import java.io.FileReader; +import java.net.URLDecoder; +import java.util.ArrayList; +import java.util.List; +import org.apache.commons.lang3.SystemUtils; +import org.yaml.snakeyaml.Yaml; +import org.yaml.snakeyaml.constructor.Constructor; +import org.yaml.snakeyaml.error.MarkedYAMLException; +import org.yaml.snakeyaml.nodes.Tag; +import org.yaml.snakeyaml.representer.Representer; + +/** + * Provides an object handler for the arara configuration file. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class ConfigurationLoader { + + // list of search paths + private List<String> paths; + // the application path, that is, where arara is located + private String applicationPath; + // list of file patterns + private List<AraraFilePattern> filePatterns; + // list of valid extensions + private String[] validExtensions; + // the chosen pattern + private AraraFilePattern chosenFilePattern; + // the localization class + final static AraraLocalization localization = AraraLocalization.getInstance(); + + /** + * Constructor. + */ + public ConfigurationLoader() { + + // create a new list of paths + paths = new ArrayList<String>(); + + // try to obtain the application path + try { + applicationPath = Arara.class.getProtectionDomain().getCodeSource().getLocation().getPath(); + applicationPath = URLDecoder.decode(applicationPath, "UTF-8"); + applicationPath = new File(applicationPath).getParentFile().getPath(); + } catch (Exception exception) { + applicationPath = ""; + } + } + + /** + * Loads the configuration settings, either the default setup or through the + * configuration file. + * + * @throws Exception An exception is thrown if something unexpected happens + * during the execution of this method. + */ + public void load() throws Exception { + + // create the default patterns + + // for .tex files + AraraFilePattern texPattern = new AraraFilePattern(); + texPattern.setExtension("tex"); + texPattern.setPattern("^(\\s)*%\\s+"); + + // for .dtx files + AraraFilePattern dtxPattern = new AraraFilePattern(); + dtxPattern.setExtension("dtx"); + dtxPattern.setPattern("^(\\s)*%\\s+"); + + // for .ltx files + AraraFilePattern ltxPattern = new AraraFilePattern(); + ltxPattern.setExtension("ltx"); + ltxPattern.setPattern("^(\\s)*%\\s+"); + + // create a list of default patterns + List<AraraFilePattern> defaultPatterns = new ArrayList<AraraFilePattern>(); + + // add the default ones + defaultPatterns.add(texPattern); + defaultPatterns.add(dtxPattern); + defaultPatterns.add(ltxPattern); + + // create a list of file patterns + filePatterns = new ArrayList<AraraFilePattern>(); + + // create a file reference + File configurationFile = new File(SystemUtils.USER_HOME + File.separator + AraraConstants.ARARACONFIG); + + // if there is not a configuration file + if (!configurationFile.exists()) { + + // there's only one path to look for rules + paths.add(applicationPath + File.separator + "rules"); + + // the only file patterns are the default ones + filePatterns.addAll(defaultPatterns); + + // create an array of valid extensions + validExtensions = new String[filePatterns.size()]; + + // add them according to the file patterns + for (int i = 0; i < filePatterns.size(); i++) { + validExtensions[i] = ".".concat(filePatterns.get(i).getExtension()); + } + + // simply return, there's nothing more to do + return; + } + + // create the YAML representer + Representer representer = new Representer(); + representer.addClassTag(AraraConfiguration.class, new Tag("!config")); + representer.addClassTag(AraraFilePattern.class, new Tag("!pattern")); + + // create the YAML parser + Yaml yaml = new Yaml(new Constructor(AraraConfiguration.class), representer); + + // create the file reader + FileReader fileReader = new FileReader(configurationFile); + + // set the new configuration object + AraraConfiguration configuration = null; + + try { + + // try to read the configuration object + configuration = (AraraConfiguration) yaml.load(fileReader); + + } catch (MarkedYAMLException yamlException) { + + // there's an error with the YAML file, so an exception is thrown + AraraLogging.enableLogging(false); + throw new AraraException(localization.getMessage("Error_InvalidYAMLConfigurationFile").concat("\n\n").concat(AraraUtils.extractInformationFromYAMLException(yamlException))); + } + catch (Exception e) { + System.out.println(e.getMessage()); + } + + // close the file reader + fileReader.close(); + + // check if the configuration is invalid + if (configuration == null) { + + // it's invalid, raise an exception + AraraLogging.enableLogging(false); + throw new AraraException(localization.getMessage("Error_InvalidConfigurationFile")); + } + + // check if there's an available language + if (configuration.getLanguage() != null) { + + // create a new language control + LanguageController languageController = new LanguageController(); + + // if the language is not valid + if (languageController.setLanguage(configuration.getLanguage()) == false) { + + // it's invalid, raise an exception + AraraLogging.enableLogging(false); + throw new AraraException(localization.getMessage("Error_InvalidLanguageConfigurationFile", languageController.getLanguagesList())); + } + } + + // check if there are new paths + if (configuration.getPaths() != null) { + + // a runtime exception happened when resolving some + // path names + if (configuration.getPathRuntimeException() != null) { + + // raise an exception + AraraLogging.enableLogging(false); + throw new AraraException(localization.getMessage("Error_PathRuntimeErrorConfigurationFile", AraraUtils.getVariableFromException(configuration.getPathRuntimeException()))); + } + + // a IO exception happened when checking if it was + // a valid path entry + if (configuration.getPathIOException() != null) { + + // raise an exception + AraraLogging.enableLogging(false); + throw new AraraException(localization.getMessage("Error_PathIOErrorConfigurationFile")); + } + + // for every path set + for (String currentPath : configuration.getPaths()) { + + // add it to the paths list + paths.add(currentPath); + } + } + + // the last path to be added is the application path + paths.add(applicationPath + File.separator + "rules"); + + // check if there are new file patterns + if (configuration.getFiletypes() != null) { + + // get all file patterns + List<AraraFilePattern> filetypes = configuration.getFiletypes(); + + // reorder the list of filetypes + for (int i = 0; i < defaultPatterns.size(); i++) { + + // if the filetype is not in the default list + if (!isAlreadyDefined(defaultPatterns.get(i), filetypes)) { + + // simply add it + filePatterns.add(defaultPatterns.get(i)); + } + } + + // merge the two lists + filePatterns.addAll(filetypes); + + // create a new array of valid extensions + validExtensions = new String[filePatterns.size()]; + int counter = 0; + + // sanity check, if there are valid extensions and patterns + for (AraraFilePattern currentPattern : filePatterns) { + + // check if either of those fields is missing + if ((currentPattern.getPattern() == null) || (currentPattern.getExtension() == null)) { + + // it's invalid, raise an exception + AraraLogging.enableLogging(false); + throw new AraraException(localization.getMessage("Error_InvalidFiletypesConfigurationFile")); + + } + + // add the dot to the extension + validExtensions[counter] = ".".concat(currentPattern.getExtension()); + counter++; + } + } else { + + // no new filetypes, simply merge the lists + filePatterns.addAll(defaultPatterns); + + // create a new array for extensions + validExtensions = new String[filePatterns.size()]; + + // iterate through all filetypes and add the extension to the array + for (int i = 0; i < filePatterns.size(); i++) { + validExtensions[i] = ".".concat(filePatterns.get(i).getExtension()); + } + } + + } + + /** + * Checks if the filetype is already defined in the list, and updates the + * latter if needed. + * + * @param filePattern The filetype object. + * @param list The list to be inspected. + * @return A boolean indicating if the filetype is already defined in the + * list. + */ + private boolean isAlreadyDefined(AraraFilePattern filePattern, List<AraraFilePattern> list) { + + // iterate through all elements + for (int i = 0; i < list.size(); i++) { + + // check if it already exists + if (filePattern.getExtension().equalsIgnoreCase(list.get(i).getExtension())) { + + // update the element if needed + if (list.get(i).getPattern() == null) { + list.set(i, filePattern); + } + + // already defined + return true; + } + } + + // not found + return false; + } + + /** + * Getter for the paths. + * + * @return The paths. + */ + public List<String> getPaths() { + return paths; + } + + /** + * Getter for the file patterns. + * + * @return The file patterns. + */ + public List<AraraFilePattern> getFilePatterns() { + return filePatterns; + } + + /** + * Getter for the valid extensions available. + * + * @return An array containing the valid extensions. + */ + public String[] getValidExtensions() { + return validExtensions; + } + + /** + * Setter for the chosen file pattern. + * + * @param extension A string containing a reference for the file extension. + */ + public void setChosenFilePattern(String extension) { + + // for every file pattern + for (AraraFilePattern currentPattern : filePatterns) { + + // if the extension matches + if (".".concat(currentPattern.getExtension()).equals(extension)) { + + // we found our pattern + chosenFilePattern = currentPattern; + + // return + return; + } + } + + // nothing found + chosenFilePattern = null; + } + + /** + * Getter for the chosen file pattern. + * + * @return The chosen file pattern. + */ + public AraraFilePattern getChosenFilePattern() { + return chosenFilePattern; + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/DirectiveExtractor.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/DirectiveExtractor.java new file mode 100644 index 00000000000..847fe933cef --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/DirectiveExtractor.java @@ -0,0 +1,287 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * DirectiveExtractor: This class reads the file and extracts all the directives + * it could find. + */ +// package definition +package com.github.arara.utils; + +// needed imports +import com.github.arara.exception.AraraException; +import com.github.arara.model.AraraDirective; +import java.io.*; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.yaml.snakeyaml.DumperOptions; +import org.yaml.snakeyaml.Yaml; +import org.yaml.snakeyaml.constructor.Constructor; +import org.yaml.snakeyaml.error.MarkedYAMLException; +import org.yaml.snakeyaml.representer.Representer; + +/** + * Reads the file and extracts all the directives it could find. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 1.0 + */ +public class DirectiveExtractor { + + // the logger + final static Logger logger = LoggerFactory.getLogger(DirectiveExtractor.class); + // the list of directives + private List<AraraDirective> directives; + // the file + private File file; + // the current line number + private int currentLineNumber; + // the configuration object + private ConfigurationLoader configuration; + // the localization class + final static AraraLocalization localization = AraraLocalization.getInstance(); + + /** + * Constructor. + */ + public DirectiveExtractor() { + + // create new list + directives = new ArrayList<AraraDirective>(); + + // set file to null + file = null; + } + + /** + * Constructor. + * + * @param file The file. + */ + public DirectiveExtractor(File file, ConfigurationLoader configuration) { + + // create a new list + directives = new ArrayList<AraraDirective>(); + + this.configuration = configuration; + + // set file + this.file = file; + } + + /** + * Setter for file. + * + * @param file The file. + */ + public void setFile(File file) { + + // set the file + this.file = file; + } + + /** + * Getter for Arara directives. + * + * @return A list containing all Arara directives. + */ + public List<AraraDirective> getDirectives() { + + // return the list + return directives; + } + + /** + * Extracts the directives from the file. + * + * @throws FileNotFoundException Raised when file not found. + * @throws IOException Raised when an IO error happened. + * @throws AraraException Raised when there's a problem with the directive. + */ + public void extract() throws FileNotFoundException, IOException, AraraException { + + // create a new file reader + FileReader fileReader = new FileReader(file); + + // create a new buffer + BufferedReader bufferedReader = new BufferedReader(fileReader); + + // variable to hold the current line + String currentLine; + + // the line count + currentLineNumber = 0; + + // log directives + logger.info("Reading directives from {}.", file.getName()); + + // while not EOF + while ((currentLine = bufferedReader.readLine()) != null) { + + // increment the current line number + currentLineNumber++; + + // extract directive + extractDirective(currentLine); + } + + // close the buffer + bufferedReader.close(); + + // close the reader + fileReader.close(); + + } + + /** + * Extracts the Arara directives from the current line. + * + * @param currentLine The current line. + * @throws AraraException Raised when there is a problem with the directive. + */ + private void extractDirective(String currentLine) throws AraraException { + + // get the pattern for the chosen filetype + Pattern linePattern = Pattern.compile(configuration.getChosenFilePattern().getPattern()); + + // create the matcher according to the pattern + Matcher matcher = linePattern.matcher(currentLine); + + // if the pattern is found + if (matcher.find()) { + + // get the substring + currentLine = (currentLine.substring(matcher.end(), currentLine.length())).trim(); + + // there is actually something after the keyword + if (!currentLine.isEmpty()) { + + // log directive + logger.trace(localization.getMessage("Log_DirectiveFound", currentLineNumber, currentLine)); + + // look for a full directive + if (AraraUtils.checkForFullDirective(currentLine)) { + + // add it + addAraraDirective(currentLine); + } + else { + + // look for an empty directive + if (AraraUtils.checkForEmptyDirective(currentLine)) { + + // add it + addEmptyAraraDirective(currentLine.trim()); + } + else { + + // an invalid directive was found, throw error + throw new AraraException(localization.getMessage("Error_InvalidDirective", currentLineNumber)); + } + } + + } + } + } + + /** + * Extracts an empty Arara directive. + * + * @param currentLine The current line. + */ + private void addEmptyAraraDirective(String currentLine) { + + // create a new directive + AraraDirective araraDirective = new AraraDirective(); + + // set the name + araraDirective.setName(currentLine); + + // set the config + araraDirective.setConfig(new HashMap()); + + // set the line number, in case of error + araraDirective.setLineNumber(currentLineNumber); + + // add the directive to the list + directives.add(araraDirective); + + } + + /** + * Extracts am Arara directive. + * + * @param currentLine The current line. + * @throws AraraException Raised when there is a problem with the directive. + */ + private void addAraraDirective(String currentLine) throws AraraException { + + // lets try + try { + + // create a new YAML parser + Yaml yaml = new Yaml(new Constructor(), new Representer(), new DumperOptions(), new AraraResolver()); + + // create a new map and load the current line + Map config = (Map) yaml.load(currentLine); + + // create a new directive + AraraDirective ad = new AraraDirective(); + + // set the name + ad.setName(currentLine); + + // set the config + ad.setConfig(config); + + // set line number. in case of error + ad.setLineNumber(currentLineNumber); + + // add the directive to the list + directives.add(ad); + + } catch (MarkedYAMLException yamlException) { + + // malformed directive, throw exception + throw new AraraException(localization.getMessage("Error_InvalidYAMLDirective", currentLineNumber).concat("\n\n").concat(AraraUtils.extractInformationFromYAMLException(yamlException))); + } + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/DirectiveParser.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/DirectiveParser.java new file mode 100644 index 00000000000..7c547be1a07 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/DirectiveParser.java @@ -0,0 +1,321 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * DirectiveParser: This class analyzes the list of directives and converts them + * to a list of arara tasks. + */ +// package definition +package com.github.arara.utils; + +// needed imports +import com.github.arara.exception.AraraException; +import com.github.arara.model.AraraDirective; +import com.github.arara.model.AraraTask; +import java.io.File; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Analyzes the list of directives and converts them to a list of arara tasks. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 1.0 + */ +public class DirectiveParser { + + // the logger + final static Logger logger = LoggerFactory.getLogger(DirectiveParser.class); + // the list of directives + private List<AraraDirective> directives; + // the list of tasks + private List<AraraTask> tasks; + // the list of file names, to use as a temporary variable + private List<String> fileNames; + // the list of items + private List<String> items; + // the current file reference + private File file; + // the localization class + final static AraraLocalization localization = AraraLocalization.getInstance(); + + /** + * Constructor + */ + public DirectiveParser() { + } + + /** + * Constructor. + * + * @param directives The Arara directives. + */ + public DirectiveParser(List<AraraDirective> directives) { + + // set the directives + this.directives = directives; + + // create a new list of tasks + this.tasks = new ArrayList<AraraTask>(); + + // create a new list of file names + this.fileNames = new ArrayList<String>(); + + // create a new list of items + this.items = new ArrayList<String>(); + } + + /** + * Setter for file. + * + * @param file The file. + */ + public void setFile(File file) { + + // set the file + this.file = file; + } + + /** + * Setter for the list of Arara directives. + * + * @param directives The list of Arara directives. + */ + public void setDirectives(List<AraraDirective> directives) { + + // set the list + this.directives = directives; + } + + /** + * Parses the list of Arara directives. + * + * @return A list of Arara tasks based on the directives. + * @throws AraraMalformedDirective Raised when a malformed directive is + * found. + */ + public List<AraraTask> parse() throws AraraException { + + // log message + logger.info("Parsing directives."); + + // for every directive + for (AraraDirective currentDirective : directives) { + + // clear the list of files + fileNames.clear(); + + // clear the task name + String taskName = ""; + + // create a new map + Map taskConfig = new HashMap(); + + // if there's no configuration + if (currentDirective.getConfig().isEmpty()) { + + // set the name + taskName = currentDirective.getName(); + + } else { + + // get the current config + Map currentConfig = currentDirective.getConfig(); + + // and get the directive name + String directiveName = (String) currentConfig.keySet().iterator().next(); + + // set the name to the task + taskName = directiveName; + + // get the parameters + Object currentConfigParameters = currentConfig.get(directiveName); + + // if it is a map + if (currentConfigParameters instanceof Map) { + + // get the map + Map currentParameters = (Map) currentConfigParameters; + + // if it is empty, error + if (currentParameters.isEmpty()) { + + // raise an error + throw new AraraException(localization.getMessage("Error_DirectiveEmptyCurlyBrackets", directiveName, currentDirective.getLineNumber())); + + } else { + + // for every parameter + for (Object currentParameterKey : currentParameters.keySet()) { + + // if the parameter is a string + if (currentParameters.get(currentParameterKey) instanceof String) { + + // if it is a file reference, error + if (((String) currentParameterKey).equals("files")) { + + // raise an error + throw new AraraException(localization.getMessage("Error_DirectiveInvalidArgumentList", directiveName, currentDirective.getLineNumber(), "files")); + } + + if (((String) currentParameterKey).equals("items")) { + + // raise an error + throw new AraraException(localization.getMessage("Error_DirectiveInvalidArgumentList", directiveName, currentDirective.getLineNumber(), "items")); + } + + // if it is a file reference, error + if (((String) currentParameterKey).equals("file")) { + + // raise an error + throw new AraraException(localization.getMessage("Error_DirectiveReservedKeyword", directiveName, currentDirective.getLineNumber(), "file", "files")); + } + + if (((String) currentParameterKey).equals("item")) { + + // raise an error + throw new AraraException(localization.getMessage("Error_DirectiveReservedKeyword", directiveName, currentDirective.getLineNumber(), "item", "items")); + } + + + // add the parameter to the configuration + taskConfig.put(currentParameterKey, (String) currentParameters.get(currentParameterKey)); + + } else { + + // if it is a list + if (currentParameters.get(currentParameterKey) instanceof List) { + + // if it is a file reference + if (((String) currentParameterKey).equals("files")) { + + // get the list + for (Object currentListValue : ((List) currentParameters.get(currentParameterKey))) { + + // add the file names + fileNames.add(currentListValue.toString()); + } + } else { + + if (((String) currentParameterKey).equals("items")) { + + // get the list + for (Object currentListValue : ((List) currentParameters.get(currentParameterKey))) { + + // add the file names + items.add(currentListValue.toString()); + } + } else { + + // raise error + throw new AraraException(localization.getMessage("Error_DirectiveListError", directiveName, currentDirective.getLineNumber())); + } + } + } else { + + // raise error + throw new AraraException(localization.getMessage("Error_DirectiveGenericError", directiveName, currentDirective.getLineNumber())); + } + } + } + } + } else { + + // raise error + throw new AraraException(localization.getMessage("Error_DirectiveGenericError", directiveName, currentDirective.getLineNumber())); + } + } + + // set original file name + AraraMethods.setOriginalFile(file.getName()); + + // if there is not a list of filenames + if (fileNames.isEmpty()) { + + // add the only filename available + fileNames.add(file.getName()); + } + + // if there are no items available + if (items.isEmpty()) { + + // simply add an empty entry + items.add(""); + } + + // for every filename + for (String filename : fileNames) { + + // and for every item + for (String item : items) { + + // create a new task + AraraTask araraTask = new AraraTask(); + + // set the name + araraTask.setName(taskName); + + // create a new map based on the current configuration + HashMap currentTaskConfig = new HashMap(taskConfig); + + // add the current file + currentTaskConfig.put("file", filename); + currentTaskConfig.put("item", item); + + // set the parameters + araraTask.setParameters(currentTaskConfig); + + // and add the task to the list + tasks.add(araraTask); + + // the current task is now null + araraTask = null; + } + } + + // clear the list of files and items + fileNames.clear(); + items.clear(); + + } + + // return the list of tasks + return tasks; + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/LanguageController.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/LanguageController.java new file mode 100644 index 00000000000..9595479933c --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/LanguageController.java @@ -0,0 +1,159 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * LanguageController: This class holds the language model controller for arara. + */ +// package definition +package com.github.arara.utils; + +// needed imports +import com.github.arara.model.AraraLanguage; +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; + +/** + * Holds the language model controller for arara. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class LanguageController { + + // list of available languages + private List<AraraLanguage> languages; + // the localization singleton instance + final static AraraLocalization localization = AraraLocalization.getInstance(); + + /** + * Constructor. + */ + public LanguageController() { + + // create a new list of languages + languages = new ArrayList<AraraLanguage>(); + + // add the resources + languages.add(new AraraLanguage("English", "en", new Locale("en"))); + languages.add(new AraraLanguage("Brazilian Portuguese", "ptbr", new Locale("pt", "BR"))); + languages.add(new AraraLanguage("Italian", "it", new Locale("it"))); + languages.add(new AraraLanguage("French", "fr", new Locale("fr"))); + languages.add(new AraraLanguage("Spanish", "es", new Locale("es"))); + languages.add(new AraraLanguage("German", "de", new Locale("de"))); + languages.add(new AraraLanguage("Turkish", "tr", new Locale("tr", "TR"))); + languages.add(new AraraLanguage("Russian", "ru", new Locale("ru"))); + + } + + /** + * Sets the current language according to the provided country code. + * + * @param code The country code. + * @return A boolean value indicating if the new language was properly + * applied. + */ + public boolean setLanguage(String code) { + + // get the index of the language + int i = getIndex(code); + + // if it's valid + if (i != -1) { + + // set locale and refresh the resource bundle + Locale.setDefault(languages.get(i).getLocale()); + localization.refresh(); + + // everything went fine + return true; + } + + // the country code is invalid + return false; + } + + /** + * Returns a string containing the list of available languages. + * + * @return A string containing the list of available languages. + */ + public String getLanguagesList() { + + // get the first one in the list + String result = languages.get(0).toString(); + + // iterate through the rest + for (int i = 1; i < languages.size(); i++) { + + // separate them by commas + result = result.concat(", ").concat(languages.get(i).toString()); + } + + // return the string + return result; + } + + /** + * Prints the language help. + */ + public void printLanguageHelp() { + + // print message + System.out.println(AraraUtils.wrap(localization.getMessage("Error_InvalidLanguage").concat("\n\n").concat(getLanguagesList()).concat("\n"))); + } + + /** + * Gets the index for the country code. + * @param code The country code. + * @return An integer representing the index. + */ + private int getIndex(String code) { + + // for every language + for (int i = 0; i < languages.size(); i++) { + + // if the codes are equal + if (languages.get(i).getCode().equalsIgnoreCase(code)) { + + // return the current counter + return i; + } + } + + // nothing was found, return a negative value + return -1; + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/TaskDeployer.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/TaskDeployer.java new file mode 100644 index 00000000000..bba0fa377ff --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/TaskDeployer.java @@ -0,0 +1,532 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * TaskDeployer: This class is responsible for taking the tasks and turning them + * into rara commands. + */ +// package definition +package com.github.arara.utils; + +// needed imports +import com.github.arara.exception.AraraException; +import com.github.arara.model.AraraCommand; +import com.github.arara.model.AraraRuleArgument; +import com.github.arara.model.AraraRuleConfig; +import com.github.arara.model.AraraTask; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.util.*; +import org.apache.commons.collections.CollectionUtils; +import org.apache.commons.lang3.SystemUtils; +import org.mvel2.templates.TemplateRuntime; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.yaml.snakeyaml.Yaml; +import org.yaml.snakeyaml.constructor.Constructor; +import org.yaml.snakeyaml.error.MarkedYAMLException; +import org.yaml.snakeyaml.nodes.Tag; +import org.yaml.snakeyaml.representer.Representer; + +/** + * Class responsible for taking the tasks and turning them into Arara commands. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 1.0 + */ +public class TaskDeployer { + + // the logger + final static Logger logger = LoggerFactory.getLogger(TaskDeployer.class); + // the localization class + final static AraraLocalization localization = AraraLocalization.getInstance(); + // the tasks list + private List<AraraTask> tasks; + //the output list with the proper commands + private List<AraraCommand> commands; + // the configuration + private ConfigurationLoader configuration; + + /** + * Constructor. + * + * @param tasks The Arara tasks. + */ + public TaskDeployer(List<AraraTask> tasks, ConfigurationLoader configuration) { + + // set everything + this.tasks = tasks; + + // set the configuration + this.configuration = configuration; + + // create the list + commands = new ArrayList<AraraCommand>(); + + } + + /** + * Deploys the tasks and returns the commands list. + * + * @return The Arara commands list. + * @throws Exception Raised if something bad happened. + */ + public List<AraraCommand> deploy() throws Exception { + + // log message + logger.info("Deploying tasks into commands."); + + // for each task + for (AraraTask currentTask : tasks) { + + // get the index where the rule is located + int pathIndex = findRule(currentTask); + + // if it's not a negative index, that is, the rule was found + if (pathIndex != -1) { + + // deploy plain rule + deployRule(currentTask, pathIndex); + + } else { + + // not found, throw exception + throw new AraraException(localization.getMessage("Error_RuleNotFound", currentTask.getName())); + } + } + + // return the commands + return commands; + + } + + /** + * Finds the rule in the rules directory. + * + * @param task The task to find. + * @return The rule location. + */ + private int findRule(AraraTask task) { + + // get the search path + List<String> paths = configuration.getPaths(); + + // for every entry in the search path + for (int i = 0; i < paths.size(); i++) { + + // if the current task is found in the current path + if (new File(paths.get(i).concat(File.separator).concat(task.getName()).concat(".yaml")).exists()) { + + // add an entry to the logger + logger.trace(localization.getMessage("Log_RuleFound", task.getName(), paths.get(i))); + + // return the index of the current path + return i; + } + } + + // nothing was found, return a negative value + return -1; + + } + + /** + * Deploys plain rule. + * + * @param task The task. + * @throws Exception The rule has a bad definition. + */ + private void deployRule(AraraTask task, int pathIndex) throws Exception { + + // create a representer + Representer representer = new Representer(); + + // add a class tag + representer.addClassTag(AraraRuleConfig.class, new Tag("!config")); + representer.addClassTag(AraraRuleArgument.class, new Tag("!argument")); + + // create a new YAML parser + Yaml yaml = new Yaml(new Constructor(AraraRuleConfig.class), representer); + + FileReader fileReader = null; + + // new file reader + fileReader = new FileReader(configuration.getPaths().get(pathIndex).concat(File.separator).concat(task.getName()).concat(".yaml")); + + // load rule + AraraRuleConfig plainRule = null; + + try { + + // try to load the rule + plainRule = (AraraRuleConfig) yaml.load(fileReader); + + } catch (MarkedYAMLException yamlException) { + + // YAML syntax error, throw exception + throw new AraraException(localization.getMessage("Error_InvalidYAMLRule", task.getName(), configuration.getPaths().get(pathIndex)).concat("\n\n").concat(AraraUtils.extractInformationFromYAMLException(yamlException))); + } + + try { + + // close reader + fileReader.close(); + + } catch (IOException ioException) { + // do nothing here + } + + // check if the rule is invalid + if (plainRule == null) { + + // raise an error + throw new AraraException(localization.getMessage("Error_InvalidRule", task.getName(), configuration.getPaths().get(pathIndex))); + } + + // verify if the identifier is empty + if (plainRule.getIdentifier() == null) { + + // raise error + throw new AraraException(localization.getMessage("Error_EmptyIdentifierRule", task.getName(), configuration.getPaths().get(pathIndex))); + + } else { + + // check if the rule has a proper name + if (plainRule.getName() == null) { + + // raise error + throw new AraraException(localization.getMessage("Error_EmptyNameRule", task.getName(), configuration.getPaths().get(pathIndex))); + + } else { + + // check if the rule has a proper list of arguments + if (plainRule.getArguments() == null) { + + // raise error + throw new AraraException(localization.getMessage("Error_EmptyArgumentsListRule", task.getName(), configuration.getPaths().get(pathIndex))); + + } + } + } + + // if the rule name doesn't match with the file name + if (!task.getName().equals(plainRule.getIdentifier())) { + + // throw exception + throw new AraraException(localization.getMessage("Error_WrongIdentifierRule", task.getName(), configuration.getPaths().get(pathIndex), plainRule.getIdentifier())); + } + + // check if the rule has any forbidden identifier + if (plainRule.checkForForbiddenIdentifiers() != null) { + + // raise error + throw new AraraException(localization.getMessage("Error_ForbiddenIdentifierRule", task.getName(), configuration.getPaths().get(pathIndex), plainRule.checkForForbiddenIdentifiers())); + } + + // get the list of all arguments available in the rule + List<String> availableArgumentsInRule = plainRule.getIdentifiersList(); + + // add the two reserved keywords + availableArgumentsInRule.add("file"); + availableArgumentsInRule.add("item"); + + // get the parameters for the task + HashMap directiveMap = task.getParameters(); + + // for every entry in the parameters map of the task, add it to the + // list of available parameters in the directive + List<String> availableArgumentsInDirective = new ArrayList<String>(); + for (Object theKey : directiveMap.keySet()) { + availableArgumentsInDirective.add((String) theKey); + } + + // find out which arguments are not defined in the directive and in + // the rule + List<String> argumentsNotDefinedInDirective = (List<String>) CollectionUtils.subtract(availableArgumentsInRule, availableArgumentsInDirective); + List<String> argumentsNotDefinedInRule = (List<String>) CollectionUtils.subtract(availableArgumentsInDirective, availableArgumentsInRule); + + // if there are invalid arguments in the directive + if (!argumentsNotDefinedInRule.isEmpty()) { + + // raise error + throw new AraraException(localization.getMessage("Error_ArgumentsNotDefinedInRule", task.getName(), configuration.getPaths().get(pathIndex), argumentsNotDefinedInRule.toString())); + } + + // for all arguments in the rule not mapped in the directive, set + // their default value to an empty string + for (String currentKey : argumentsNotDefinedInDirective) { + directiveMap.put(currentKey, ""); + } + + // add entries in the arguments map + HashMap argumentMap = new HashMap(); + argumentMap.put("file", directiveMap.get("file")); + argumentMap.put("item", directiveMap.get("item")); + directiveMap.remove("file"); + directiveMap.remove("item"); + argumentMap.put("parameters", directiveMap); + + // helper functions added + argumentMap.put("SystemUtils", SystemUtils.class); + argumentMap.put("isEmpty", AraraMethods.class.getMethod("isEmpty", String.class)); + argumentMap.put("isNotEmpty", AraraMethods.class.getMethod("isNotEmpty", String.class)); + argumentMap.put("isEmpty", AraraMethods.class.getMethod("isEmpty", String.class, String.class)); + argumentMap.put("isNotEmpty", AraraMethods.class.getMethod("isNotEmpty", String.class, String.class)); + argumentMap.put("isEmpty", AraraMethods.class.getMethod("isEmpty", String.class, String.class, String.class)); + argumentMap.put("isNotEmpty", AraraMethods.class.getMethod("isNotEmpty", String.class, String.class, String.class)); + argumentMap.put("isTrue", AraraMethods.class.getMethod("isTrue", String.class)); + argumentMap.put("isFalse", AraraMethods.class.getMethod("isFalse", String.class)); + argumentMap.put("isTrue", AraraMethods.class.getMethod("isTrue", String.class, String.class)); + argumentMap.put("isFalse", AraraMethods.class.getMethod("isFalse", String.class, String.class)); + argumentMap.put("isTrue", AraraMethods.class.getMethod("isTrue", String.class, String.class, String.class)); + argumentMap.put("isFalse", AraraMethods.class.getMethod("isFalse", String.class, String.class, String.class)); + argumentMap.put("isTrue", AraraMethods.class.getMethod("isTrue", String.class, String.class, String.class, String.class)); + argumentMap.put("isFalse", AraraMethods.class.getMethod("isFalse", String.class, String.class, String.class, String.class)); + argumentMap.put("trimSpaces", AraraMethods.class.getMethod("trimSpaces", String.class)); + argumentMap.put("getFilename", AraraMethods.class.getMethod("getFilename", String.class)); + argumentMap.put("getBasename", AraraMethods.class.getMethod("getBasename", String.class)); + argumentMap.put("getFiletype", AraraMethods.class.getMethod("getFiletype", String.class)); + argumentMap.put("getDirname", AraraMethods.class.getMethod("getDirname", String.class)); + argumentMap.put("isFile", AraraMethods.class.getMethod("isFile", String.class)); + argumentMap.put("isDir", AraraMethods.class.getMethod("isDir", String.class)); + argumentMap.put("isWindows", AraraMethods.class.getMethod("isWindows", String.class, String.class)); + argumentMap.put("isLinux", AraraMethods.class.getMethod("isLinux", String.class, String.class)); + argumentMap.put("isUnix", AraraMethods.class.getMethod("isUnix", String.class, String.class)); + argumentMap.put("isMac", AraraMethods.class.getMethod("isMac", String.class, String.class)); + + argumentMap.put("isTrue", AraraMethods.class.getMethod("isTrue", boolean.class, String.class)); + argumentMap.put("isTrue", AraraMethods.class.getMethod("isTrue", boolean.class, String.class, String.class)); + argumentMap.put("isFalse", AraraMethods.class.getMethod("isFalse", boolean.class, String.class)); + argumentMap.put("isFalse", AraraMethods.class.getMethod("isFalse", boolean.class, String.class, String.class)); + + argumentMap.put("getOriginalFile", AraraMethods.class.getMethod("getOriginalFile")); + + // create a rule map + HashMap ruleMap = new HashMap(); + + // for every argument in the rule + for (AraraRuleArgument currentArgument : plainRule.getArguments()) { + + // if there's not a default value + if (currentArgument.getDefault() == null) { + + // set the default to an empty string + ruleMap.put(currentArgument.getIdentifier(), ""); + + } else { + + // there's actually a default value + try { + + // get the default value and apply the template + String defaultValue = (String) TemplateRuntime.eval(currentArgument.getDefault(), argumentMap); + + // put the new default value into the rule map + ruleMap.put(currentArgument.getIdentifier(), defaultValue); + + } catch (RuntimeException runtimeException) { + + // an error occurred, throw exception + throw new AraraException(localization.getMessage("Error_DefaultValueRuntimeErrorRule", currentArgument.getIdentifier(), task.getName(), configuration.getPaths().get(pathIndex), AraraUtils.getVariableFromException(runtimeException))); + + } + } + } + + // after setting the default values into the rule map, let's add + // the directive parameters and both file and item references + ruleMap.put("parameters", directiveMap); + ruleMap.put("file", argumentMap.get("file")); + ruleMap.put("item", argumentMap.get("item")); + + // helper classes + ruleMap.put("SystemUtils", SystemUtils.class); + ruleMap.put("isEmpty", AraraMethods.class.getMethod("isEmpty", String.class)); + ruleMap.put("isNotEmpty", AraraMethods.class.getMethod("isNotEmpty", String.class)); + ruleMap.put("isEmpty", AraraMethods.class.getMethod("isEmpty", String.class, String.class)); + ruleMap.put("isNotEmpty", AraraMethods.class.getMethod("isNotEmpty", String.class, String.class)); + ruleMap.put("isEmpty", AraraMethods.class.getMethod("isEmpty", String.class, String.class, String.class)); + ruleMap.put("isNotEmpty", AraraMethods.class.getMethod("isNotEmpty", String.class, String.class, String.class)); + ruleMap.put("isTrue", AraraMethods.class.getMethod("isTrue", String.class)); + ruleMap.put("isFalse", AraraMethods.class.getMethod("isFalse", String.class)); + ruleMap.put("isTrue", AraraMethods.class.getMethod("isTrue", String.class, String.class)); + ruleMap.put("isFalse", AraraMethods.class.getMethod("isFalse", String.class, String.class)); + ruleMap.put("isTrue", AraraMethods.class.getMethod("isTrue", String.class, String.class, String.class)); + ruleMap.put("isFalse", AraraMethods.class.getMethod("isFalse", String.class, String.class, String.class)); + ruleMap.put("isTrue", AraraMethods.class.getMethod("isTrue", String.class, String.class, String.class, String.class)); + ruleMap.put("isFalse", AraraMethods.class.getMethod("isFalse", String.class, String.class, String.class, String.class)); + ruleMap.put("trimSpaces", AraraMethods.class.getMethod("trimSpaces", String.class)); + ruleMap.put("getFilename", AraraMethods.class.getMethod("getFilename", String.class)); + ruleMap.put("getBasename", AraraMethods.class.getMethod("getBasename", String.class)); + ruleMap.put("getFiletype", AraraMethods.class.getMethod("getFiletype", String.class)); + ruleMap.put("getDirname", AraraMethods.class.getMethod("getDirname", String.class)); + ruleMap.put("isFile", AraraMethods.class.getMethod("isFile", String.class)); + ruleMap.put("isDir", AraraMethods.class.getMethod("isDir", String.class)); + ruleMap.put("isWindows", AraraMethods.class.getMethod("isWindows", String.class, String.class)); + ruleMap.put("isLinux", AraraMethods.class.getMethod("isLinux", String.class, String.class)); + ruleMap.put("isUnix", AraraMethods.class.getMethod("isUnix", String.class, String.class)); + ruleMap.put("isMac", AraraMethods.class.getMethod("isMac", String.class, String.class)); + + ruleMap.put("isTrue", AraraMethods.class.getMethod("isTrue", boolean.class, String.class)); + ruleMap.put("isTrue", AraraMethods.class.getMethod("isTrue", boolean.class, String.class, String.class)); + ruleMap.put("isFalse", AraraMethods.class.getMethod("isFalse", boolean.class, String.class)); + ruleMap.put("isFalse", AraraMethods.class.getMethod("isFalse", boolean.class, String.class, String.class)); + + ruleMap.put("getOriginalFile", AraraMethods.class.getMethod("getOriginalFile")); + + // remove references to file and item + availableArgumentsInDirective.remove("file"); + availableArgumentsInDirective.remove("item"); + + // for all arguments in the rule + for (AraraRuleArgument currentArgument : plainRule.getArguments()) { + + // if the current argument is defined in the directive + if (isArgumentDefinedInDirective(availableArgumentsInDirective, currentArgument)) { + + // if there is a valid flag + if (currentArgument.getFlag() != null) { + + try { + + // get the flag and apply template + String defaultFlag = (String) TemplateRuntime.eval(currentArgument.getFlag(), ruleMap); + + // put the new flag reference into the rule map + ruleMap.put(currentArgument.getIdentifier(), defaultFlag); + } catch (RuntimeException runtimeException) { + + // an error occurred, throw exception + throw new AraraException(localization.getMessage("Error_FlagRuntimeErrorRule", currentArgument.getIdentifier(), task.getName(), configuration.getPaths().get(pathIndex), AraraUtils.getVariableFromException(runtimeException))); + + } + } + } + } + + // create a new list of commands to be executed by the current task + List<String> commandsList = new ArrayList<String>(); + + // if there is a command element in the rule + if (plainRule.getCommand() != null) { + + // and if there isn't a list of commands + if (plainRule.getCommands() == null) { + + // add the current command to the list of commands to + // be executed + commandsList.add(plainRule.getCommand()); + + } else { + + // both are defined, throw an error + throw new AraraException(localization.getMessage("Error_DuplicatedCommandElementsRule", task.getName(), configuration.getPaths().get(pathIndex))); + + } + } else { + + // none of the fields is defined + if (plainRule.getCommands() == null) { + + // neither of the elements is defined, throw an error + throw new AraraException(localization.getMessage("Error_MissingCommandElementsRule", task.getName(), configuration.getPaths().get(pathIndex))); + + } else { + + // there's a list of commands, add them to the list + commandsList.addAll(plainRule.getCommands()); + } + } + + // for every command to be processed + for (String commandTemplate : commandsList) { + + try { + // get the current command and apply template + commandTemplate = (String) TemplateRuntime.eval(commandTemplate, ruleMap); + + } catch (RuntimeException runtimeException) { + + // an error occurred, throw exception + throw new AraraException(localization.getMessage("Error_CommandRuntimeErrorRule", task.getName(), configuration.getPaths().get(pathIndex), AraraUtils.getVariableFromException(runtimeException))); + + } + + // check if it's a valid command + if (!commandTemplate.trim().isEmpty()) { + + // create a new command + AraraCommand araraCommand = new AraraCommand(); + + // add the command + araraCommand.setCommand(commandTemplate); + + // add the name + araraCommand.setName(plainRule.getName()); + + // add to the list + commands.add(araraCommand); + + } + } + } + + /** + * Checks if the current argument is included in the list of arguments from + * the directive. + * + * @param arguments List of arguments from the directive. + * @param argument The current argument to be analyzed. + * @return A logic value indicating if the current argument is included in + * the list of arguments from the directive. + */ + private boolean isArgumentDefinedInDirective(List<String> arguments, AraraRuleArgument argument) { + + // for every argument in the list + for (String current : arguments) { + + // if the identifiers match + if (current.equalsIgnoreCase(argument.getIdentifier())) { + + // found it + return true; + } + } + + // not found + return false; + } +} diff --git a/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/TeeOutputStream.java b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/TeeOutputStream.java new file mode 100644 index 00000000000..95aa32e6f30 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/java/com/github/arara/utils/TeeOutputStream.java @@ -0,0 +1,155 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * TeeOutputStream: This class implements an output stream that handles other + * streams, so the flow is propagated to all of them in an easy way. + */ +// package definition +package com.github.arara.utils; + +// needed importa +import java.io.IOException; +import java.io.OutputStream; + +/** + * Implements an output stream that handles other streams, so the flow is + * propagated to all of them in an easy way. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 2.0 + */ +public class TeeOutputStream extends OutputStream { + + // the list of the output streams + private final OutputStream[] streams; + + /** + * Constructor. + * + * @param outputStreams An array containing the output streams. + */ + public TeeOutputStream(OutputStream... outputStreams) { + + // set the array + streams = outputStreams; + } + + /** + * Writes the byte to all the output streams. + * + * @param b The byte to write. + * @throws IOException Exception if an error ocurred. + */ + @Override + public void write(int b) throws IOException { + + // for every stream + for (OutputStream ostream : streams) { + + // write the byte + ostream.write(b); + } + } + + /** + * Writes an array of bytes to all the output streams. + * + * @param b The bytes to write. + * @param offset The offset. + * @param length Number of bytes. + * @throws IOException Exception if an error ocurred. + */ + @Override + public void write(byte[] b, int offset, int length) throws IOException { + + // for every stream + for (OutputStream ostream : streams) { + + // write the array + ostream.write(b, offset, length); + } + } + + /** + * Flushes the stream. + * + * @throws IOException Exception if an error ocurred. + */ + @Override + public void flush() throws IOException { + + // for every stream + for (OutputStream ostream : streams) { + + // flush the stream + ostream.flush(); + } + } + + /** + * Closes the stream. + * + * @throws IOException Exception if an error ocurred. + */ + @Override + public void close() throws IOException { + + // for every stream + for (OutputStream ostream : streams) { + + // try to close the stream + forceClose(ostream); + } + } + + /** + * Forces the stream to close without raising exceptions. + * + * @param ostream The stream. + */ + private void forceClose(OutputStream ostream) { + + // try to close + try { + + // close it + ostream.close(); + + } catch (IOException exception) { + // do nothing + } + } +}
\ No newline at end of file diff --git a/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/conf/logback.xml b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/conf/logback.xml new file mode 100644 index 00000000000..22f73680d00 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/conf/logback.xml @@ -0,0 +1,13 @@ +<configuration> + <appender name="FILE" class="ch.qos.logback.core.FileAppender"> + <file>${araraLogName}.log</file> + <append>false</append> + <encoder> + <charset>UTF-8</charset> + <pattern>%date{dd MMM yyyy HH:mm:ss.SSS} %-5level %logger{0} - %msg%n</pattern> + </encoder> + </appender> + <root level="ALL"> + <appender-ref ref="FILE" /> + </root> +</configuration>
\ No newline at end of file diff --git a/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages.properties b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages.properties new file mode 100644 index 00000000000..dbcde45e7f8 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages.properties @@ -0,0 +1,163 @@ +# Arara -- the cool TeX automation tool +# Copyright (c) 2012, Paulo Roberto Massa Cereda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the project's author nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY +# WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +# Messages: This file holds the default messages for arara. +# +# author: Paulo Roberto Massa Cereda +# e-mail: cereda@users.sf.net + +Log_WelcomeMessage = Welcome to arara! + +Log_ProcessingFile = Processing file ''{0}'', please wait. + +Log_Done = Done. + +Log_ExceptionRaised = Arara raised an exception with the following message: + +Log_ReadyToRunCommands = Ready to run commands. + +Log_CommandName = Running ''{0}''. + +Log_Command = Command: {0} + +Log_CommandSuccess = ''{0}'' was successfully executed. + +Log_CommandFailure = ''{0}'' returned an error status. + +Log_AllCommandsSuccess = All commands were successfully executed. + +Log_OutputLogging = Output logging: + +Log_CommandNotFound = ''{0}'' was not found in the path. Execution attempt: {1} + +Log_DirectiveFound = Directive found in line {0} with {1}. + +Log_RuleFound = Task ''{0}'' found in ''{1}''. + +Log_NoDirectivesFound = No directives found in ''{0}''. + +Help_Version = print the application version + +Help_Help = print the help message + +Help_Log = generate a log output + +Help_Verbose = print the command output + +Help_Timeout = set the execution timeout (in milliseconds) + +Help_Language = set the application language + +Header_Slogan = The cool TeX automation tool + +Header_AllRightsReserved = All rights reserved. + +Msg_NoDirectivesFound = I didn''t find any directives in ''{0}'', and so didn''t do anything. Is that what you really wanted? + +Msg_SpecialThanks = A special thanks goes to Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz, and many others for making this humble tool possible. + +Msg_RunningCommand = Running {0}... + +Msg_Success = SUCCESS + +Msg_Failure = FAILURE + +Msg_Status = Status: + +YamlError_Context = Context: {0} + +YamlError_Problem = Problem: {0} + +YamlError_ErrorLocation = Error found in line {0}, column {1}. + +Error_FileDoesNotExistWithExtensionsList = I''m sorry, but the file ''{0} {1}'' does not exist. Note that when you provide only the basename (i.e, the filename without the extension) or with an unknown extension, arara will try to look for files ending with the predefined extensions {1} in that order. You can override the order, the search pattern or even add support for new extensions through the configuration file. Please refer to the arara manual to learn more about this feature. + +Error_FileDoesNotExist = File ''{0}'' does not exist. + +Error_CommandNotFound = \nI''m sorry, but the command from the ''{0}'' task could not be found. Are you sure the command ''{1}'' is correct, or even accessible from the system path? + +Error_InvalidYAMLConfigurationFile = I'm sorry, but apparently your arara configuration file is invalid, that is, it has invalid or missing YAML entries. Unfortunately, arara cannot proceed until the error is fixed. I tried my best to dump the error message, so here it is: + +Error_InvalidConfigurationFile = Uh-oh, the configuration file appears to be invalid. Are you sure it's a proper YAML file? Unfortunately, arara cannot proceed until a proper configuration file is provided. + +Error_InvalidLanguageConfigurationFile = Houston, we have a problem. Sadly, the language set in the configuration file is not valid. Currently, arara can provide support for the following languages: {0}. Make sure to choose a valid language or remove the entry from the configuration file (the field is optional), otherwise arara cannot proceed. + +Error_InvalidFiletypesConfigurationFile = I'm sorry, but it seems your configuration file has customized filetypes with neither the extension or pattern defined. Both are required in order to continue. Please fix this error in your configuration file and try again. + +Error_PathRuntimeErrorConfigurationFile = I''m sorry, but one of the entries of the search path in your configuration file has an unavailable variable in the path context: ''{0}'' + +Error_PathIOErrorConfigurationFile = I'm sorry, but one of the entries of the search path in your configuration file has a malformed directory structure. Could you take a look at it? + +Error_InvalidYAMLDirective = It appears there is a malformed directive found at line {0}, that is, a directive that might have a YAML syntax error or an invalid field. I tried my best to dump the error message, so here it is: + +Error_DirectiveEmptyCurlyBrackets = Directive ''{0}'' at line {1} has empty curly brackets. Note that arara opts for a cleaner syntax when a directive has no parameters. To fix it, it''s enough to either remove the curly brackets or provide the arguments for the directive. + +Error_DirectiveInvalidArgumentList = Directive ''{0}'' at line {1} has an invalid argument type. The argument ''{2}'' is a reserved arara keyword and always requires a list. + +Error_DirectiveReservedKeyword = Directive ''{0}'' at line {1} has an invalid argument name. The name ''{2}'' is a reserved arara keyword representing every element in the ''{3}'' list. Please, pick another name for that argument. + +Error_DirectiveListError = Directive ''{0}'' at line {1} has an invalid argument type. Only the arguments ''files'' and ''items'' can have a list. Both are reserved arara keywords. + +Error_InvalidDirective = Apparently, there''s an invalid directive at line {0}. Please take a look and fix it. + +Error_DirectiveGenericError = Directive ''{0}'' at line {1} seems to be malformed. It might be a YAML syntax error or a wrong mapping. + +Error_InvalidLanguage = I'm sorry, but the language code you chose is invalid. Currently, the following languages are supported: + +Error_RuleNotFound = Uh-oh, I could not find the ''{0}'' rule in the search path. Could you take a look if the rule name is correct and if the rule is accessible through the search path? + +Error_InvalidYAMLRule = It appears that the ''{0}'' task has a YAML syntax error or an invalid field. Could you take a look at the ''{0}.yaml'' file located at ''{1}''. I tried my best to dump the error message, so here it is: + +Error_InvalidRule = Uh-oh, the ''{0}'' task appears to be invalid. Are you sure the ''{0}.yaml'' file located at ''{1}'' is a proper YAML file? + +Error_EmptyIdentifierRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid identifier. Could you fix it? + +Error_EmptyNameRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid name. Could you fix it? + +Error_ForbiddenIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an invalid argument identifier. ''{2}'' is a reserved keyword, so it cannot be used. Could you use another name? + +Error_EmptyArgumentsListRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid list of arguments. Could you fix it? Note that the list of arguments can also be empty, but it is still necessary to define it explicitly (with ''arguments: []''). + +Error_WrongIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has the wrong identifier - ''{0}'' was expected, rather than ''{2}''. Could you fix it? + +Error_ArgumentsNotDefinedInRule = Oh no, there are arguments used in the diretive ''{0}'' which are not defined in the ''{0}.yaml'' rule located at ''{1}''. You can either remove them from the ''{0}'' directive or add them to the list of arguments in the ''{0}.yaml'' rule. Here they are: {2} + +Error_DefaultValueRuntimeErrorRule = I''m sorry, but the default value set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' + +Error_FlagRuntimeErrorRule = I''m sorry, but the flag set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' + +Error_DuplicatedCommandElementsRule = Uh-oh, both ''command'' and ''commands'' fields are set in the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}''). You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. + +Error_MissingCommandElementsRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') does not have either the ''command'' or ''commands'' elements. You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. + +Error_CommandRuntimeErrorRule = I''m sorry, but the command set for the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an unavailable variable/method in the rule context: ''{2}'' + diff --git a/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_de.properties b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_de.properties new file mode 100644 index 00000000000..e0183983cf8 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_de.properties @@ -0,0 +1,226 @@ +# Arara -- the cool TeX automation tool +# Copyright (c) 2012, Paulo Roberto Massa Cereda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the project's author nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY +# WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +# Messages_de: Diese Datei beinhalted alle Meldungen f\u00fcr arara in Deutsch. +# +# translator: Marco Daniel +# e-mail: marco.daniel@mada-nada.de + +# Log_WelcomeMessage = Welcome to arara! +Log_WelcomeMessage = Willkommen zu arara! + +# Log_ProcessingFile = Processing file ''{0}'', please wait. +Log_ProcessingFile = Bearbeitung der Datei ''{0}'', bitte warten. + +# Log_Done = Done. +Log_Done = Fertig. + +# Log_ExceptionRaised = Arara raised an exception with the following message: +Log_ExceptionRaised = Eine Ausnahme mit folgender Nachricht ist durch arara ausgel\u00f6st worden: + +# Log_ReadyToRunCommands = Ready to run commands. +Log_ReadyToRunCommands = Bereit zum Start der Anweisungen. + +# Log_CommandName = Running ''{0}''. +Log_CommandName = Verarbeitung von: ''{0}''. + +# Log_Command = Command: {0} +Log_Command = Anweisung: {0} + +# Log_CommandSuccess = ''{0}'' was successfully executed. +Log_CommandSuccess = ''{0}'' wurde erfolgreich ausgef\u00fchrt. + +# Log_CommandFailure = ''{0}'' returned an error status. +Log_CommandFailure = ''{0}'' gibt einen Fehlerwert zur\u00fcck. + +# Log_AllCommandsSuccess = All commands were successfully executed. +Log_AllCommandsSuccess = Alle Anweisungen wurden erfolgreich ausgef\u00fchrt. + +# Log_OutputLogging = Output logging: +Log_OutputLogging = Ausgabe des Protokolls: + +# Log_CommandNotFound = ''{0}'' was not found in the path. Execution attempt: {1} +Log_CommandNotFound = ''{0}'' wurde nicht im Suchpfad gefunden. Ausf\u00fchrungsversuch: {1} + +# Log_DirectiveFound = Directive found in line {0} with {1}. +Log_DirectiveFound = Anweisung in Zeile {0} mit {1} gefunden. + +# Log_RuleFound = Task ''{0}'' found in ''{1}''. +Log_RuleFound = Aufgabe ''{0}'' gefunden in ''{1}''. + +# Log_NoDirectivesFound = No directives found in ''{0}''. +Log_NoDirectivesFound = Keine Anweisungen in ''{0}'' gefunden. + +# Help_Version = print the application version +Help_Version = Ausgabe der Version. + +# Help_Help = print the help message +Help_Help = Ausgabe der Hilfe. + +# Help_Log = generate a log output +Help_Log = Erstelle eine Protokolldatei (.log-Datei). + +# Help_Verbose = print the command output +Help_Verbose = Zeige das Protokoll der Anweisungen im Terminal an. + +# Help_Timeout = set the execution timeout (in milliseconds) +Help_Timeout = Deklariere die Zeitbeschr\u00e4nkung je Anweisung (in Millisekunden). + +# Help_Language = set the application language +Help_Language = Lege die Sprache der Anwendung fest. + +# Header_Slogan = The cool TeX automation tool +Header_Slogan = Das coole TeX Automatisierungstool + +# Header_AllRightsReserved = All rights reserved. +Header_AllRightsReserved = Alle Rechte vorbehalten! + +# Msg_NoDirectivesFound = I didn''t find any directives in ''{0}'', and so didn''t do anything. Is that what you really wanted? +Msg_NoDirectivesFound = Ich habe keine Anweisungen in ''{0}'' gefunden und daher nichts getan. Ist es das, was du wirklich wolltest. + +# Msg_SpecialThanks = A special thanks goes to Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz, and many others for making this humble tool possible. +Msg_SpecialThanks = Ein besonderes Danke geht an Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz und viele andere, die dieses bescheidene Tool erm\u00f6glichten. + +# Msg_RunningCommand = Running {0}... +Msg_RunningCommand = Verarbeite {0}... + +# Msg_Success = SUCCESS +Msg_Success = ERFOLGREICH + +# Msg_Failure = FAILURE +Msg_Failure = FEHLERHAFT + +# Msg_Status = Status: +Msg_Status = Status: + +# YamlError_Context = Context: {0} +YamlError_Context = Kontext: {0} + +# YamlError_Problem = Problem: {0} +YamlError_Problem = Problem: {0} + +# YamlError_ErrorLocation = Error found in line {0}, column {1}. +YamlError_ErrorLocation = Fehler in Zeile {0}, Spalte {1}. + +# Error_FileDoesNotExistWithExtensionsList = I''m sorry, but the file ''{0} {1}'' does not exist. Note that when you provide only the basename (i.e, the filename without the extension) or with an unknown extension, arara will try to look for files ending with the predefined extensions {1} in that order. You can override the order, the search pattern or even add support for new extensions through the configuration file. Please refer to the arara manual to learn more about this feature. +Error_FileDoesNotExistWithExtensionsList = Es tut mir Leid, aber die Datei ''{0} {1}'' existiert nicht. Beachte bitte, dass wenn du nur den Dateinamen (ohne Endung) oder eine unbekannte Dateiendung angegeben hast, arara stets versucht nach unterst\u00fctzten Dateiendungen in der Reihenfolge {1} zu suchen. Du kannst die Reihenfolge bzw. das Suchmuster \u00e4ndern oder sogar neue Dateiendung hinzuf\u00fcgen. Bitte konsolidiere die Dokumentation, um mehr \u00fcber dieses und andere Features zu erfahren. + +# Error_FileDoesNotExist = File ''{0}'' does not exist. +Error_FileDoesNotExist = Datei ''{0}'' existiert nicht. + +# Error_CommandNotFound = \nI''m sorry, but the command from the ''{0}'' task could not be found. Are you sure the command ''{1}'' is correct, or even accessible from the system path? +Error_CommandNotFound = Es tut mir Leid, aber die Anweisung der Aufgabe ''{0}'' konnte nicht gefunden werden. Bist du dir sicher, dass die Anweisung ''{1}'' korrekt oder \u00fcber die Systempfade zug\u00e4nglich ist? + +# Error_InvalidYAMLConfigurationFile = I'm sorry, but apparently your arara configuration file is invalid, that is, it has invalid or missing YAML entries. Unfortunately, arara cannot proceed until the error is fixed. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLConfigurationFile = Es tut mir Leid, aber deine arara Konfigurationsdatei ist unzul\u00e4ssig. Dies kann aus einem unzul\u00e4ssigen oder fehlenden YAML Eintrag resultieren. + +# Error_InvalidConfigurationFile = Uh-oh, the configuration file appears to be invalid. Are you sure it's a proper YAML file? Unfortunately, arara cannot proceed until a proper configuration file is provided. +Error_InvalidConfigurationFile = Uh-oh, die Konfigurationsdatei scheint unzul\u00e4ssig zu sein. Bist du dir sicher, dass es sich um eine korrekt erstellte YAML-Datei handelt? Leider kann arara nicht fortsetzen, bis eine passende Konfigurationsdatei bereitgestellt wird. + +# Error_InvalidLanguageConfigurationFile = Houston, we have a problem. Sadly, the language set in the configuration file is not valid. Currently, arara can provide support for the following languages: {0}. Make sure to choose a valid language or remove the entry from the configuration file (the field is optional), otherwise arara cannot proceed. +Error_InvalidLanguageConfigurationFile = Housten, wir haben ein Problem. Leider ist die in der Konfigurationsdatei spezifizierte Sprache nicht zul\u00e4ssig. Momentan kann arara die folgenden Sprachen unterst\u00fctzen: {0}. Stelle sicher, dass eine g\u00fcltige Sprache gew\u00e4hlt wird oder entferne den Eintrag aus deiner Konfigurationsdatei (der Sprachschl\u00fcssel ist optional), ansonsten kann arara nicht ausgef\u00fchrt werden. + +# Error_InvalidFiletypesConfigurationFile = I'm sorry, but it seems your configuration file has customized filetypes with neither the extension or pattern defined. Both are required in order to continue. Please fix this error in your configuration file and try again. +Error_InvalidFiletypesConfigurationFile = Es tut mir Leid, aber es scheint, dass du eine benutzerdefinierte Konfigurationsdatei nutzt, bei der weder die Dateiendung noch das Muster definiert wurde. Beides wird zum Fortfahren ben\u00f6tigt. Bitte behebe diesen Fehler in deiner Konfigurationsdatei und versuche es erneut. + +# Error_PathRuntimeErrorConfigurationFile = I''m sorry, but one of the entries of the search path in your configuration file has an unavailable variable in the path context: ''{0}'' +Error_PathRuntimeErrorConfigurationFile = Es tut mir Leid, aber einer der Eintr\u00e4ge des Suchpfades in deiner Konfigurationsdatei hat eine nicht verf\u00fcgbare Variable im Zusammenhang mit dem Pfad: {0} + +# Error_PathIOErrorConfigurationFile = I'm sorry, but one of the entries of the search path in your configuration file has a malformed directory structure. Could you take a look at it? +Error_PathIOErrorConfigurationFile = Es tut mir Leid, aber einer der Eintr\u00e4ge des Suchpfades in deiner Konfigurationsdatei hat eine ung\u00fcltige Verzeichnisstruktur. Kannst du einen Blick drauf werfen? + +# Error_InvalidYAMLDirective = It appears there is a malformed directive found at line {0}, that is, a directive that might have a YAML syntax error or an invalid field. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLDirective = Es scheint, als g\u00e4be es eine deformierte Anweisung in der Zeile {0}. Die Anweisung kann einen Fehler in der YAML-Syntax aufweisen bzw. einen ung\u00fcltiger Eintrag haben. + +# Error_DirectiveEmptyCurlyBrackets = Directive ''{0}'' at line {1} has empty curly brackets. Note that arara opts for a cleaner syntax when a directive has no parameters. To fix it, it''s enough to either remove the curly brackets or provide the arguments for the directive. +Error_DirectiveEmptyCurlyBrackets = Die Anweisung {0} in Zeile {1} hat ein leeres geschweiftes Klammerpaar. Beachte bitte, dass arara f\u00fcr eine klare Syntax optimiert ist, wenn kein Parameter \u00fcbergeben wird, sollte auch keine Klammer angegeben werden. Um den Fehler zu beseitigen, reicht es aus, die geschweiften Klammern zu entfernen oder ein Argument f\u00fcr die Anweisung zu \u00fcbergeben. + +# Error_DirectiveInvalidArgumentList = Directive ''{0}'' at line {1} has an invalid argument type. The argument ''{2}'' is a reserved arara keyword and always requires a list. +Error_DirectiveInvalidArgumentList = Die Anweisung {0} in Zeile {1} hat einen unzul\u00e4ssigen Argumenttypen. Das Argument {2} ist ein reserviertes Schl\u00fcsselwort von arara und verlangt stets eine Liste. + +# Error_DirectiveReservedKeyword = Directive ''{0}'' at line {1} has an invalid argument name. The name ''{2}'' is a reserved arara keyword representing every element in the ''{3}'' list. Please, pick another name for that argument. +Error_DirectiveReservedKeyword = Die Anweisung {0} in Zeile {1} hat einen unzul\u00e4ssigen Argumentnamen. Der Name {2} ist ein reserviertes Schl\u00fcsselwort von arara und repr\u00e4sentiert jedes Element in der Liste {3}. Bitte w\u00e4hle einen anderen Namen als Argument. + +# Error_DirectiveListError = Directive ''{0}'' at line {1} has an invalid argument type. Only the arguments ''files'' and ''items'' can have a list. Both are reserved arara keywords. +Error_DirectiveListError = Die Anweisung ''{0}'' in Zeile ''{1}'' hat einen unzul\u00e4ssigen Argumenttypen. Nur die Argumente ''files'' und ''items'' k\u00f6nnen eine liste haben. Beides sind reservierte Schl\u00fcsselw\u00f6rter von arara. + +# Error_InvalidDirective = Apparently, there''s an invalid directive at line {0}. Please take a look and fix it. +Error_InvalidDirective = Anscheinend gibt es eine ung\u00fcltige Direktive in der Zeile {0}. Bitte pr\u00fcfe es. + +# Error_DirectiveGenericError = Directive ''{0}'' at line {1} seems to be malformed. It might be a YAML syntax error or a wrong mapping. +Error_DirectiveGenericError = Die Anweisung ''{0}'' in Zeile ''{1}'' scheint deformiert zu sein. Es kann ein Fehler in der YAML-Syntax oder eine falsche Zuordnung sein. + +# Error_InvalidLanguage = I'm sorry, but the language code you chose is invalid. Currently, the following languages are supported: +Error_InvalidLanguage = Es tut mir Leid, aber die gew\u00e4hlte Sprache ist nicht verf\u00fcgbar. Im Moment werden folgende Sprachen unterst\u00fctzt: + +# Error_RuleNotFound = Uh-oh, I could not find the ''{0}'' rule in the search path. Could you take a look if the rule name is correct and if the rule is accessible through the search path? +Error_RuleNotFound = Uh-oh, Ich konnte die Regel ''{0}'' im Suchpfad nicht finden. Kannst du bitte pr\u00fcfen, ob der Regelname korrekt ist und die Regel durch den Suchpfad gefunden wird. + +# Error_InvalidYAMLRule = It appears that the ''{0}'' task has a YAML syntax error or an invalid field. Could you take a look at the ''{0}.yaml'' file located at ''{1}''. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLRule = Es scheint, dass die Aufgabe ''{0}'' einen Fehler in der YAML-Syntax hat oder einen ung\u00fcltiges Feld nutzt. Kannst du einen Blick auf die Datei ''{0}.yaml'' im Pfad ''{1}'' werfen. I versuchte mein Bestes, um die Fehlermeldung auszuwerfen, daher hier ist sie: + +# Error_InvalidRule = Uh-oh, the ''{0}'' task appears to be invalid. Are you sure the ''{0}.yaml'' file located at ''{1}'' is a proper YAML file? +Error_InvalidRule = Uh-oh, Die Aufgabe ''{0}'' scheint ung\u00fcltig zu sein. Bist du dir sicher, dass die Datei ''{0}.yaml'' im Pfad ''{1}'' eine g\u00fcltige YAML file ist? + +# Error_EmptyIdentifierRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid identifier. Could you fix it? +Error_EmptyIdentifierRule = Ein Problem in der Aufgabe ''{0}'' wurde festgestellt. Die Datei ''{0}.yaml'' im Pfad ''{1}'' verlangt einen g\u00fcltigen Bezeichner (identifier). Siehst du den Fehler? + +# Error_EmptyNameRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid name. Could you fix it? +Error_EmptyNameRule = Ein Problem in der Aufgabe ''{0}'' wurde festgestellt. Die Datei ''{0}.yaml'' im Pfad ''{1}'' verlangt einen g\u00fcltigen Dateinamen. Kannst du es beheben? + +# Error_ForbiddenIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an invalid argument identifier. ''{2}'' is a reserved keyword, so it cannot be used. Could you use another name? +Error_ForbiddenIdentifierRule = Uh-oh, die Aufgabe ''{0}'' (Referenzierung auf Datei ''{0}.yaml'' im Pfad ''{1}'') hat einen ung\u00fcltigen Argumenteinbezeichner. ''{2}'' ist ein reserviertes Schl\u00fcsselwort und kann daher nicht genutzt werden. Kannst du einen anderen nutzen? + +# Error_EmptyArgumentsListRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid list of arguments. Could you fix it? Note that the list of arguments can also be empty, but it is still necessary to define it explicitly (with ''arguments: []''). +Error_EmptyArgumentsListRule = Ein Problem wurde in der Aufgabe ''{0}'' festgestellt. Die Datei ''{0}.yaml'' im Pfad ''{1}'' verlangt eine validierte Liste an Argumenten. Kannst du es beheben? Beachte, dass die Liste der Argumente auch leer sein kann. Es ist aber unbedingt notwendig, dass das Argument explizit angeben wird: ''arguments: []''. + +# Error_WrongIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has the wrong identifier - ''{0}'' was expected, rather than ''{2}''. Could you fix it? +Error_WrongIdentifierRule = Uh-oh, die Aufgabe ''{0}'' (Referenzierung auf Datei ''{0}.yaml'' im Pfad ''{1}'') hat einen falschen ''identifier'' - es wurde ''{0}'' anstelle von ''{2}'' erwartet. Kannst du es beheben? + +# Error_ArgumentsNotDefinedInRule = Oh no, there are arguments used in the diretive ''{0}'' which are not defined in the ''{0}.yaml'' rule located at ''{1}''. You can either remove them from the ''{0}'' directive or add them to the list of arguments in the ''{0}.yaml'' rule. Here they are: {2} +Error_ArgumentsNotDefinedInRule = Oh nein, es gibt Argumente in der Anweisung ''{0}'', welche nicht in der Regel ''{0}.yaml'' im Pfad ''{1}'' definiert wurden. Du kannst sie aus der Anweisung ''{0}'' entfernen oder als Liste von Argumenten in der Regel ''{0}.yaml'' erg\u00e4nzen. Hier sind sie: {2} + +# Error_DefaultValueRuntimeErrorRule = I''m sorry, but the default value set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_DefaultValueRuntimeErrorRule = Es tut mir Leid, aber der Defaultwert f\u00fcr das Argument ''{0}'' der Aufgabe ''{1}'' (Referenzierung auf Datei ''{0}.yaml'' im Pfad ''{1}'') hat eine ung\u00fcltige Variable/Methode im Regelkontext: ''{3}'' + +# Error_FlagRuntimeErrorRule = I''m sorry, but the flag set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_FlagRuntimeErrorRule = Es tut mir Leid, aber der Flag f\u00fcr das Argument ''{0}'' der Aufgabe ''{1}'' (Referenzierung auf Datei ''{0}.yaml'' im Pfad ''{1}'') hat eine ung\u00fcltige Variable/Methode im Regelkontext: ''{3}'' + +# Error_DuplicatedCommandElementsRule = Uh-oh, both ''command'' and ''commands'' fields are set in the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}''). You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_DuplicatedCommandElementsRule = Uh-oh, in der Aufgabe ''{0}'' werden beide Felder ''command'' und ''commands'' verwendet (Referenzierung auf Datei ''{0}.yaml'' im Pfad ''{1}''). Du kannst nur eine der Anweisungen ausw\u00e4hlen. Sollte deine Aufgabe von einem einzelnen Kommando abh\u00e4ngen, kannst du ''command'' optimieren. Sollte deine Regel mehrere Anweisungen ben\u00f6tigen, k\u00f6nnte das Feld ''commands'' geeignet sein. + +# Error_MissingCommandElementsRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') does not have either the ''command'' or ''commands'' elements. You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_MissingCommandElementsRule = Uh-oh, die Aufgabe ''{0}'' (Referenzierung auf Datei ''{0}.yaml'' im Pfad ''{1}'') hat weder 'command'' noch 'commands'' Elemente. Du musst nur eine der Anweisungen ausw\u00e4hlen. Sollte deine Aufgabe von einem einzelnen Kommando abh\u00e4ngen, kannst du ''command'' optimieren. Sollte deine Regel mehrere Anweisungen ben\u00f6tigen, k\u00f6nnte das Feld ''commands'' geeignet sein. + +# Error_CommandRuntimeErrorRule = I''m sorry, but the command set for the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an unavailable variable/method in the rule context: ''{2}'' +Error_CommandRuntimeErrorRule = Es tut mir Leid, aber das Kommando, welches in der Aufgabe ''{0}'' (Referenzierung auf Datei ''{0}.yaml'' im Pfad ''{1}'') genutzt wird, hat eine ung\u00fcltige Variable/Methode im Regelsinn: ''{2}'' + diff --git a/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_es.properties b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_es.properties new file mode 100644 index 00000000000..f48535fe9ce --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_es.properties @@ -0,0 +1,226 @@ +# Arara -- the cool TeX automation tool +# Copyright (c) 2012, Paulo Roberto Massa Cereda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the project's author nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY +# WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +# Messages: This file holds the default Spanish messages for arara. +# +# author: Gonzalo Medina +# e-mail: gmedinaar@unal.edu.co + +# Log_WelcomeMessage = Welcome to arara! +Log_WelcomeMessage = \u00a1Bienvenido a arara! + +# Log_ProcessingFile = Processing file ''{0}'', please wait. +Log_ProcessingFile = Procesando el archivo ''{0}'', por favor espere. + +# Log_Done = Done. +Log_Done = Listo. + +# Log_ExceptionRaised = Arara raised an exception with the following message: +Log_ExceptionRaised = Arara gener\u00f3 una excepci\u00f3n con el siguiente mensaje: + +# Log_ReadyToRunCommands = Ready to run commands. +Log_ReadyToRunCommands = Listo para ejecutar comandos. + +# Log_CommandName = Running ''{0}''. +Log_CommandName = Ejecutando ''{0}''. + +# Log_Command = Command: {0} +Log_Command = Comando: {0} + +# Log_CommandSuccess = ''{0}'' was successfully executed. +Log_CommandSuccess = ''{0}'' se ejecut\u00f3 de manera exitosa. + +# Log_CommandFailure = ''{0}'' returned an error status. +Log_CommandFailure = ''{0}'' emiti\u00f3 un estado de error. + +# Log_AllCommandsSuccess = All commands were successfully executed. +Log_AllCommandsSuccess = Todos los comandos han sido ejecutados de manera exitosa. + +# Log_OutputLogging = Output logging: +Log_OutputLogging = Recuento de la salida: + +# Log_CommandNotFound = ''{0}'' was not found in the path. Execution attempt: {1} +Log_CommandNotFound = ''{0}'' no se encontr\u00f3 en la ruta. Tentativa de ejecuci\u00f3n: {1} + +# Log_DirectiveFound = Directive found in line {0} with {1}. +Log_DirectiveFound = Directiva encontrada en la l\u00ednea {0} con {1}. + +# Log_RuleFound = Task ''{0}'' found in ''{1}''. +Log_RuleFound = Tarea ''{0}'' encontrada en ''{1}''. + +# Log_NoDirectivesFound = No directives found in ''{0}''. +Log_NoDirectivesFound = No se encontraron directivas en ''{0}''. + +# Help_Version = print the application version +Help_Version = imprime la versi\u00f3n de la aplicaci\u00f3n + +# Help_Help = print the help message +Help_Help = imprime el mensaje de ayuda + +# Help_Log = generate a log output +Help_Log = genera el registro de la salida + +# Help_Verbose = print the command output +Help_Verbose = imprime la salida del comando + +# Help_Timeout = set the execution timeout (in milliseconds) +Help_Timeout = configura el 'timeout' de la ejecuci\u00f3n (en milisegundos) + +# Help_Language = set the application language +Help_Language = configura el idioma de la aplicaci\u00f3n + +# Header_Slogan = The cool TeX automation tool +Header_Slogan = The cool TeX automation tool + +# Header_AllRightsReserved = All rights reserved. +Header_AllRightsReserved = Todos los derechos reservados. + +# Msg_NoDirectivesFound = I didn''t find any directives in ''{0}'', and so didn''t do anything. Is that what you really wanted? +Msg_NoDirectivesFound = No encontr\u00e9 directivas en ''{0}'', por lo que no ejecut\u00e9 ninguna acci\u00f3n. \u00bfEra esto lo que realmente deseaba? + +# Msg_SpecialThanks = A special thanks goes to Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz, and many others for making this humble tool possible. +Msg_SpecialThanks = Un agradecimiento especial a Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz, y a muchos otros por hacer posible esta herramienta. + +# Msg_RunningCommand = Running {0}... +Msg_RunningCommand = Ejecutando {0}... + +# Msg_Success = SUCCESS +Msg_Success = \u00c9XITO + +# Msg_Failure = FAILURE +Msg_Failure = FALLO + +# Msg_Status = Status: +Msg_Status = Estado: + +# YamlError_Context = Context: {0} +YamlError_Context = Contexto: {0} + +# YamlError_Problem = Problem: {0} +YamlError_Problem = Problema: {0} + +# YamlError_ErrorLocation = Error found in line {0}, column {1}. +YamlError_ErrorLocation = Error encontrado en la l\u00ednea {0}, columna {1}. + +# Error_FileDoesNotExistWithExtensionsList = I''m sorry, but the file ''{0} {1}'' does not exist. Note that when you provide only the basename (i.e, the filename without the extension) or with an unknown extension, arara will try to look for files ending with the predefined extensions {1} in that order. You can override the order, the search pattern or even add support for new extensions through the configuration file. Please refer to the arara manual to learn more about this feature. +Error_FileDoesNotExistWithExtensionsList = Lo siento, pero el archivo ''{0} {1}'' no existe. Note que cuando \u00fanicamente se utiliza el nombre base (es decir, el nombre del archivo sin la extensi\u00f3n) o cuando se usa una extansi\u00f3n desconocida, arara intentar\u00e1 buscar los archivos terminados en las extensiones predefinidas {1} en ese orden. El orden y los patrones de b\u00fasqueda se pueden modificar, incluso se puede agregar soporte para nuevas extensiones, utilizando el archivo de configuraci\u00f3n. Por favor consulte el manual de arara para mayor informaci\u00f3n. + +# Error_FileDoesNotExist = File ''{0}'' does not exist. +Error_FileDoesNotExist = El archivo ''{0}'' no existe. + +# Error_CommandNotFound = \nI''m sorry, but the command from the ''{0}'' task could not be found. Are you sure the command ''{1}'' is correct, or even accessible from the system path? +Error_CommandNotFound = \nLo siento, pero el comando para la tarea ''{0}'' no se encontr\u00f3. Aseg\u00farese de que el comando ''{1}'' sea correcto y accesible desde la ruta (''path'') del sistema. + +# Error_InvalidYAMLConfigurationFile = I'm sorry, but apparently your arara configuration file is invalid, that is, it has invalid or missing YAML entries. Unfortunately, arara cannot proceed until the error is fixed. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLConfigurationFile = Lo siento, pero aparentemente su archivo de configuraci\u00f3n de arara no es v\u00e1lido; es decir, algunas entradas YAML hacen falta o son no v\u00e1lidas. Desafortunadamente, arara no puede seguir adelante hasta que se corrija el error. Hice mi mejor esfuerzo registrando el mensaje de error, que es el siguiente: + +# Error_InvalidConfigurationFile = Uh-oh, the configuration file appears to be invalid. Are you sure it's a proper YAML file? Unfortunately, arara cannot proceed until a proper configuration file is provided. +Error_InvalidConfigurationFile = \u00a10h, oh! El archivo de configuraci\u00f3n parece no ser v\u00e1lido. Aseg\u00farese de que sea un archivo YAML correcto. Desafortunadamente, arara no puede continuar a menos que el archivo de configuraci\u00f3n sea correcto. + +# Error_InvalidLanguageConfigurationFile = Houston, we have a problem. Sadly, the language set in the configuration file is not valid. Currently, arara can provide support for the following languages: {0}. Make sure to choose a valid language or remove the entry from the configuration file (the field is optional), otherwise arara cannot proceed. +Error_InvalidLanguageConfigurationFile = !Houston, tenemos un problema! Lamentablemente, el idioma configurado en el archivo de configuraci\u00f3n no es v\u00e1lido. Actualemente arara soporta los siguientes idiomas: {0}. Aseg\u00farese de escoger un idioma v\u00e1lido o suprima la entrada del archivo de configuraci\u00f3n (el campo es opcional), de lo contrario, arara no podr\u00e1 continuar. + +# Error_InvalidFiletypesConfigurationFile = I'm sorry, but it seems your configuration file has customized filetypes with neither the extension or pattern defined. Both are required in order to continue. Please fix this error in your configuration file and try again. +Error_InvalidFiletypesConfigurationFile = Lo siento, pero parece que el archivo de configuraci\u00f3n contiene tipos de archivo para los cuales no se ha definido una extensi\u00f3n o un patr\u00f3n. Los dos son necesarios para continuar. Por favor, corrija este error en el archivo de configuraci\u00f3n e intente nuevamente. + +# Error_PathRuntimeErrorConfigurationFile = I''m sorry, but one of the entries of the search path in your configuration file has an unavailable variable in the path context: ''{0}'' +Error_PathRuntimeErrorConfigurationFile = Lo siento, pero una de las entradas de la ruta de b\u00fasqueda en el archivo de configuraci\u00f3n contiene una variable no disponible en este contexto: ''{0}'' + +# Error_PathIOErrorConfigurationFile = I'm sorry, but one of the entries of the search path in your configuration file has a malformed directory structure. Could you take a look at it? +Error_PathIOErrorConfigurationFile = Lo siento, pero una de las entradas de la ruta de b\u00fasqueda en el archivo de configuraci\u00f3n tiene una estructura jer\u00e1rquica mal formada. \u00bfPodr\u00eda por favor revisar las entradas? + +# Error_InvalidYAMLDirective = It appears there is a malformed directive found at line {0}, that is, a directive that might have a YAML syntax error or an invalid field. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLDirective = Parece que hay una directiva mal formada en la l\u00ednea {0}; es decir, una directiva con un error de sintaxis YAML o con un campo inv\u00e1lido. Hice mi mejor esfuerzo registrando el mensaje de error, que es el siguiente: + +# Error_DirectiveEmptyCurlyBrackets = Directive ''{0}'' at line {1} has empty curly brackets. Note that arara opts for a cleaner syntax when a directive has no parameters. To fix it, it''s enough to either remove the curly brackets or provide the arguments for the directive. +Error_DirectiveEmptyCurlyBrackets = La directiva ''{0}'' en la l\u00ednea {1} no tiene contenido entre un par de llaves. Note que arara utiliza una sintaxis m\u00e1s simple cuando una directiva no tiene par\u00e1metros. Para corregir este error, es suficiente remover las llaves o insertar un argumento en la directiva. + +# Error_DirectiveInvalidArgumentList = Directive ''{0}'' at line {1} has an invalid argument type. The argument ''{2}'' is a reserved arara keyword and always requires a list. +Error_DirectiveInvalidArgumentList = La directiva ''{0}'' en la l\u00ednea {1} tiene un tipo de argumento no v\u00e1lido. El argumento ''{2}'' es una palabra clave reservada de arara que siempre requiere de una lista. + +# Error_DirectiveReservedKeyword = Directive ''{0}'' at line {1} has an invalid argument name. The name ''{2}'' is a reserved arara keyword representing every element in the ''{3}'' list. Please, pick another name for that argument. +Error_DirectiveReservedKeyword = La directiva ''{0}'' en la l\u00ednea {1} tiene un nombre de argumento no v\u00e1lido. El nombre ''{2}'' es una palabra clave reservada de arara que representa todos los elementos de la lista ''{3}''. Por favor, escoja otro nombre para el argumento. + +# Error_DirectiveListError = Directive ''{0}'' at line {1} has an invalid argument type. Only the arguments ''files'' and ''items'' can have a list. Both are reserved arara keywords. +Error_DirectiveListError = La directiva ''{0}'' en la l\u00ednea {1} tiene un tipo de argumento no v\u00e1lido. \u00danicamente los argumentos ''files'' e ''items'' pueden contener una lista; los dos son palabras claves reservadas de arara. + +# Error_InvalidDirective = Apparently, there''s an invalid directive at line {0}. Please take a look and fix it. +Error_InvalidDirective = Aparentemente, hay una directiva no v\u00e1lida en la l\u00ednea {0}. Por favor rev\u00edsela y haga las correcciones necesarias. + +# Error_DirectiveGenericError = Directive ''{0}'' at line {1} seems to be malformed. It might be a YAML syntax error or a wrong mapping. +Error_DirectiveGenericError = La directiva ''{0}'' en la l\u00ednea {1} est\u00e1 mal formada. Podr\u00eda tratarse de un error de sintaxis YAML o de una asignaci\u00f3n incorrecta. + +# Error_InvalidLanguage = I'm sorry, but the language code you chose is invalid. Currently, the following languages are supported: +Error_InvalidLanguage = Lo siento, pero el c\u00f3digo de idioma escogido es inv\u00e1lido. Actualmente, arara soporta los siguientes idiomas: + +# Error_RuleNotFound = Uh-oh, I could not find the ''{0}'' rule in the search path. Could you take a look if the rule name is correct and if the rule is accessible through the search path? +Error_RuleNotFound = \u00a1Oh, oh! No se pudo hallar la regla ''{0}'' en la ruta de b\u00fasqueda. Revise que el nombre de la regla sea el corrceto y que la regla sea accesible usando la ruta de b\u00fasqueda. + +# Error_InvalidYAMLRule = It appears that the ''{0}'' task has a YAML syntax error or an invalid field. Could you take a look at the ''{0}.yaml'' file located at ''{1}''. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLRule = Aparentemente la tarea ''{0}'' contiene un error de sintaxis YAML o un campo incorrecto. Por favor revise el archivo ''{0}.yaml'' localizado en ''{1}''. Hice mi mejor esfuerzo registrando el mensaje de error, que es el siguiente: + +# Error_InvalidRule = Uh-oh, the ''{0}'' task appears to be invalid. Are you sure the ''{0}.yaml'' file located at ''{1}'' is a proper YAML file? +Error_InvalidRule = !Oh, oh! Parece que la tarea ''{0}'' es inv\u00e1lida. Aseg\u00farese de que el archivo ''{0}.yaml'' localizado en ''{1}'' sea un archivo YAML correcto. + +# Error_EmptyIdentifierRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid identifier. Could you fix it? +Error_EmptyIdentifierRule = Se detect\u00f3 un problema en la tarea ''{0}''. El archivo ''{0}.yaml'' localizado en ''{1}'' necesita un identificador v\u00e1lido. \u00bfPodr\u00eda, por favor, corregirlo? + +# Error_EmptyNameRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid name. Could you fix it? +Error_EmptyNameRule = Se detect\u00f3 un problema en la tarea ''{0}''. El archivo ''{0}.yaml'' localizado en ''{1}'' necesita un nombre v\u00e1lido. \u00bfPodr\u00eda, por favor, corregirlo? + +# Error_ForbiddenIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an invalid argument identifier. ''{2}'' is a reserved keyword, so it cannot be used. Could you use another name? +Error_ForbiddenIdentifierRule = !Oh, oh! La tarea ''{0}'' (que hace referencia al archivo ''{0}.yaml'' localizado en ''{1}'') contiene un identificador de argumentos inv\u00e1lido. ''{2}'' es una palabra reservada y no puede ser utilizada. Por favor, utilice otro nombre. + +# Error_EmptyArgumentsListRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid list of arguments. Could you fix it? Note that the list of arguments can also be empty, but it is still necessary to define it explicitly (with ''arguments: []''). +Error_EmptyArgumentsListRule = Se detect\u00f3 un problema en la tarea ''{0}''. El archivo ''{0}.yaml'' localizado en ''{1}'' necesita una lista valida de argumentos. Por favor, corr\u00edjala. Note que la lista de argumentos puede ser vac\u00eda, pero esto debe declararse expl\u00edcitamente (utilizando ''arguments: []''). + +# Error_WrongIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has the wrong identifier - ''{0}'' was expected, rather than ''{2}''. Could you fix it? +Error_WrongIdentifierRule = \u00a1Oh, oh! La tarea ''{0}'' (que hace referencia al archivo ''{0}.yaml'' localizado en ''{1}'') tiene un identificadoe err\u00f3neo - Se esperaba ''{0}'' y no ''{2}''. Por favor, corr\u00edjalo. + +# Error_ArgumentsNotDefinedInRule = Oh no, there are arguments used in the diretive ''{0}'' which are not defined in the ''{0}.yaml'' rule located at ''{1}''. You can either remove them from the ''{0}'' directive or add them to the list of arguments in the ''{0}.yaml'' rule. Here they are: {2} +Error_ArgumentsNotDefinedInRule = \u00a1Oh, no! En la directiva ''{0}'' se usan argumentos que no est\u00e1n definidos en la regla ''{0}.yaml'' localizada en ''{1}''. Puede o bien removerlos de la directiva ''{0}'' o bien agregarlos a la lista de argumentos en la regla ''{0}.yaml''. Estos son: {2} + +# Error_DefaultValueRuntimeErrorRule = I''m sorry, but the default value set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_DefaultValueRuntimeErrorRule = Lo siento, pero el valor por defecto asignado al argumento ''{0}'' de la tarea ''{1}'' (que hace referencia al archivo ''{1}.yaml'' localizado en ''{2}'') contiene una variable o un m\u00e9todo no v\u00e1lido en el contexto de la regla: ''{3}'' + +# Error_FlagRuntimeErrorRule = I''m sorry, but the flag set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_FlagRuntimeErrorRule = Lo siento, pero la se\u00f1al (''flag'') asignada al argumento ''{0}'' de la tarea ''{1}'' (que hace referencia al archivo ''{1}.yaml'' localizado en ''{2}'') contiene una variable o un m\u00e9todo no v\u00e1lido en el contexto de la regla: ''{3}'' + +# Error_DuplicatedCommandElementsRule = Uh-oh, both ''command'' and ''commands'' fields are set in the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}''). You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_DuplicatedCommandElementsRule = \u00a1Oh, oh! Los dos campos ''command'' y ''commands'' fueron simult\u00e1neamente asignados en la tarea ''{0}'' (que hace referencia al archivo ''{0}.yaml'' localizado en ''{1}''). Es necesario escoger \u00fanicamente uno de los dos. Si la tarea tan solo requiere un \u00fanico comando, puede usar ''command''; si la regla requiere un conjunto de comandos, quiz\u00e1 sea preferible utilizar el campo ''commands''. + +# Error_MissingCommandElementsRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') does not have either the ''command'' or ''commands'' elements. You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_MissingCommandElementsRule = \u00a1Oh, oh! En la tarea ''{0}'' (que hace referencia al archivo ''{0}.yaml'' localizado en ''{1}'') hace falta o bien ''command'' o bien ''commands''. Es necesario utilizar uno de ellos. Si la tarea tan solo requiere un \u00fanico comando, puede usar ''command''; si la regla requiere de un conjunto de comandos, quiz\u00e1 sea preferible utilizar el campo ''commands''. + +# Error_CommandRuntimeErrorRule = I''m sorry, but the command set for the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an unavailable variable/method in the rule context: ''{2}'' +Error_CommandRuntimeErrorRule = Lo siento, pero el comando asignado a la tarea ''{0}'' (que hace referencia al archivo ''{0}.yaml'' localizado en ''{1}'') contiene una variable o un m\u00e9todo no v\u00e1lido en el contexto de la regla: ''{2}'' + diff --git a/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_fr.properties b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_fr.properties new file mode 100644 index 00000000000..8796caa1817 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_fr.properties @@ -0,0 +1,226 @@ +# Arara -- the cool TeX automation tool +# Copyright (c) 2012, Paulo Roberto Massa Cereda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the project's author nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY +# WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +# Messages_fr: This file holds the French language messages for arara. +# +# translator: Mika\u00ebl Maunier +# e-mail: mmaunier2001@yahoo.fr + +# Log_WelcomeMessage = Welcome to arara! +Log_WelcomeMessage = Arara vous souhaite la bienvenue ! + +# Log_ProcessingFile = Processing file ''{0}'', please wait. +Log_ProcessingFile = Traitement du fichier ''{0}'', veuillez patienter. + +# Log_Done = Done. +Log_Done = Termin\u00e9. + +# Log_ExceptionRaised = Arara raised an exception with the following message: +Log_ExceptionRaised = Arara a g\u00e9n\u00e9r\u00e9 une erreur avec le message suivant : + +# Log_ReadyToRunCommands = Ready to run commands. +Log_ReadyToRunCommands = Pr\u00eat \u00e0 executer des commandes. + +# Log_CommandName = Running ''{0}''. +Log_CommandName = Execution de ''{0}''. + +# Log_Command = Command: {0} +Log_Command = Commande : {0} + +# Log_CommandSuccess = ''{0}'' was successfully executed. +Log_CommandSuccess = ''{0}'' ex\u00e9cut\u00e9 avec succ\u00e8s. + +# Log_CommandFailure = ''{0}'' returned an error status. +Log_CommandFailure = ''{0}'' a renvoy\u00e9 une erreur. + +# Log_AllCommandsSuccess = All commands were successfully executed. +Log_AllCommandsSuccess = Toutes les commandes ont \u00e9t\u00e9 correctement ex\u00e9cut\u00e9es. + +# Log_OutputLogging = Output logging: +Log_OutputLogging = Journal de sortie: + +# Log_CommandNotFound = ''{0}'' was not found in the path. Execution attempt: {1} +Log_CommandNotFound = ''{0}'' non trouv\u00e9(e) dans le PATH. Tentative d''execution : {1} + +# Log_DirectiveFound = Directive found in line {0} with {1}. +Log_DirectiveFound = Instruction trouv\u00e9e \u00e0 la ligne {0} avec {1}. + +# Log_RuleFound = Task ''{0}'' found in ''{1}''. +Log_RuleFound = T\u00e2che ''{0}'' trouv\u00e9e dans ''{1}''. + +# Log_NoDirectivesFound = No directives found in ''{0}''. +Log_NoDirectivesFound = Aucune instructions trouv\u00e9es dans ''{0}''. + +# Help_Version = print the application version +Help_Version = affiche la version de l'application + +# Help_Help = print the help message +Help_Help = affiche le message d'aide + +# Help_Log = generate a log output +Help_Log = g\u00e9n\u00e8re un journal de sortie + +# Help_Verbose = print the command output +Help_Verbose = affiche la sortie de la commande. + +# Help_Timeout = set the execution timeout (in milliseconds) +Help_Timeout = d\u00e9finit le temps d'execution (en millisecondes) + +# Help_Language = set the application language +Help_Language = d\u00e9finit la langue de l'application + +# Header_Slogan = The cool TeX automation tool +Header_Slogan = L'outil de traitement TeX vraiment cool + +# Header_AllRightsReserved = All rights reserved. +Header_AllRightsReserved = Tous droits r\u00e9serv\u00e9s. + +# Msg_NoDirectivesFound = I didn''t find any directives in ''{0}'', and so didn''t do anything. Is that what you really wanted? +Msg_NoDirectivesFound = Je n''ai trouv\u00e9 aucunes instructions dans ''{0}'', aussi n''ai-je rien fait. Est-ce r\u00e9ellment ce que vous vouliez ? + +# Msg_SpecialThanks = A special thanks goes to Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz, and many others for making this humble tool possible. +Msg_SpecialThanks = Un remerciement sp\u00e9cial pour Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz, et de nombreux autres qui ont rendu possible la cr\u00e9ation de cet humble outil. + +# Msg_RunningCommand = Running {0}... +Msg_RunningCommand = Execution de {0}... + +# Msg_Success = SUCCESS +Msg_Success = SUCC\u00c8S + +# Msg_Failure = FAILURE +Msg_Failure = \u00c9CHEC + +# Msg_Status = Status: +Msg_Status = Status : + +# YamlError_Context = Context: {0} +YamlError_Context = Contexte : {0} + +# YamlError_Problem = Problem: {0} +YamlError_Problem = Probl\u00e8me: {0} + +# YamlError_ErrorLocation = Error found in line {0}, column {1}. +YamlError_ErrorLocation = Erreur trouv\u00e9e \u00e0 la ligne {0}, colonne {1}. + +# Error_FileDoesNotExistWithExtensionsList = I''m sorry, but the file ''{0} {1}'' does not exist. Note that when you provide only the basename (i.e, the filename without the extension) or with an unknown extension, arara will try to look for files ending with the predefined extensions {1} in that order. You can override the order, the search pattern or even add support for new extensions through the configuration file. Please refer to the arara manual to learn more about this feature. +Error_FileDoesNotExistWithExtensionsList = Je suis d\u00e9sol\u00e9 mais le fichier ''{0} {1}'' n''existe pas. Notez qu''en ne fournissant que le nom de base (i.e, le nom sans l''extension) ou bien une extension inconnue, arara essaiera de chercher des fichiers se terminant par les extensions pr\u00e9d\u00e9finies {1} dans cet ordre. Vous pouvez modifier l''ordre, le motif pour la recherche ou m\u00eame ajouter de nouvelles extensions par le biais du fichier de configuration. Merci de vous r\u00e9f\u00e9rer au manuel d'arara pour en apprendre plus sur cette caract\u00e9ristique. + +# Error_FileDoesNotExist = File ''{0}'' does not exist. +Error_FileDoesNotExist = Le fichier ''{0}'' n''existe pas. + +# Error_CommandNotFound = \nI''m sorry, but the command from the ''{0}'' task could not be found. Are you sure the command ''{1}'' is correct, or even accessible from the system path? +Error_CommandNotFound = \nJe suis navr\u00e9, mais la commande en provenance de la t\u00e2che ''{0}'' n''a pas \u00e9t\u00e9 trouv\u00e9e. \u00cates-vous sur(e) que la commande ''{1}'' est correcte et accessible depuis le PATH ? + +# Error_InvalidYAMLConfigurationFile = I'm sorry, but apparently your arara configuration file is invalid, that is, it has invalid or missing YAML entries. Unfortunately, arara cannot proceed until the error is fixed. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLConfigurationFile = Je suis d\u00e9sol\u00e9, apparemment votre fichier de configuration d'arara est invalide ; il contient des entr\u00e9es YAML invalides ou certaines sont manquantes. Malheureusement, arara ne peut pas continuer tant que l'erreur n'est pas r\u00e9par\u00e9e. J'ai fait de mon mieux pour r\u00e9cup\u00e9rer le message d'erreur, le voici : + +# Error_InvalidConfigurationFile = Uh-oh, the configuration file appears to be invalid. Are you sure it's a proper YAML file? Unfortunately, arara cannot proceed until a proper configuration file is provided. +Error_InvalidConfigurationFile = Oh-oh, le fichier de configuration est invalide. \u00cates-vous sur(e) qu'il s'agit d'un fichier YAML correct ? Malheureusement, arara ne pourra pas continuer tant qu'un fichier de configuration correct ne sera pas disponible. + +# Error_InvalidLanguageConfigurationFile = Houston, we have a problem. Sadly, the language set in the configuration file is not valid. Currently, arara can provide support for the following languages: {0}. Make sure to choose a valid language or remove the entry from the configuration file (the field is optional), otherwise arara cannot proceed. +Error_InvalidLanguageConfigurationFile = Houston, nous avons un probl\u00e8me. C''est triste \u00e0 dire mais le langage d\u00e9finit dans le fichier de configuration est incorrect. Pour l''instant, arara supporte les langages suivants : {0}. Soyez sur(e) de choisir un langage correct ou de retirer l''entr\u00e9e du fichier de configuration (le champ est optionnel), sinon arara ne pourra pas continuer. + +# Error_InvalidFiletypesConfigurationFile = I'm sorry, but it seems your configuration file has customized filetypes with neither the extension or pattern defined. Both are required in order to continue. Please fix this error in your configuration file and try again. +Error_InvalidFiletypesConfigurationFile = Je suis navr\u00e9 mais il semble que votre fichier de configuration contient des extensions de fichiers personnalis\u00e9es dont ni l'extension ni le motif ne sont d\u00e9finis. Les deux sont requis pour pouvoir continuer. Veuillez r\u00e9gler ce probl\u00e8me dans votre fichier de configuration puis essayer \u00e0 nouveau. + +# Error_PathRuntimeErrorConfigurationFile = I''m sorry, but one of the entries of the search path in your configuration file has an unavailable variable in the path context: ''{0}'' +Error_PathRuntimeErrorConfigurationFile = Je suis d\u00e9sol\u00e9 mais une des entr\u00e9es du chemin de recherche dans votre fichier de configuration contient une variable non disponible dans le contexte du PATH : ''{0}'' + +# Error_PathIOErrorConfigurationFile = I'm sorry, but one of the entries of the search path in your configuration file has a malformed directory structure. Could you take a look at it? +Error_PathIOErrorConfigurationFile = D\u00e9sol\u00e9. Une des entr\u00e9es du chemin de recherche dans votre fichier de configuration contient une structure de r\u00e9pertoire incorrecte. Pourriez vous y jetez un coup d'oeil ? + +# Error_InvalidYAMLDirective = It appears there is a malformed directive found at line {0}, that is, a directive that might have a YAML syntax error or an invalid field. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLDirective = Il semble qu''il y ait une intruction mal \u00e9crite \u00e0 la ligne {0}. Il est possible que ce soit une instruction qui contiennent une erreur de syntaxe YAML ou un champ invalide. J''ai fait de mon mieux pour r\u00e9cup\u00e9rer le message d''erreur, le voici : + +# Error_DirectiveEmptyCurlyBrackets = Directive ''{0}'' at line {1} has empty curly brackets. Note that arara opts for a cleaner syntax when a directive has no parameters. To fix it, it''s enough to either remove the curly brackets or provide the arguments for the directive. +Error_DirectiveEmptyCurlyBrackets = L''instruction ''{0}'' \u00e0 la ligne {1} a des accolades vides. Notez qu''arara opte pour une syntaxe plus \u00e9pur\u00e9e quand une instruction n''a pas de param\u00e8tres. Pour r\u00e9gler le probl\u00e8me, il suffit soit d''enlever les accolades soit de fournir les arguments pour la commande. + +# Error_DirectiveInvalidArgumentList = Directive ''{0}'' at line {1} has an invalid argument type. The argument ''{2}'' is a reserved arara keyword and always requires a list. +Error_DirectiveInvalidArgumentList = L''instruction ''{0}'' \u00e0 la ligne {1} a un type d''argument incorrect. L''argument ''{2}'' est un mot-cl\u00e9 pour arara et requiert obligatoirement une liste. + +# Error_DirectiveReservedKeyword = Directive ''{0}'' at line {1} has an invalid argument name. The name ''{2}'' is a reserved arara keyword representing every element in the ''{3}'' list. Please, pick another name for that argument. +Error_DirectiveReservedKeyword = L''instruction ''{0}'' \u00e0 la ligne {1} a un nom d''argument incorrect. Le nom ''{2}'' est un mot-cl\u00e9 pour arara qui repr\u00e9sente tous les \u00e9l\u00e9ments dans la liste ''{3}''. Veuillez choisir un autre nom pour cet argument. + +# Error_DirectiveListError = Directive ''{0}'' at line {1} has an invalid argument type. Only the arguments ''files'' and ''items'' can have a list. Both are reserved arara keywords. +Error_DirectiveListError = L''instruction ''{0}'' \u00e0 la ligne {1} a type d''argument incorrect. Seul les arguments ''files'' et ''items'' peuvent avoir une liste. Les deux sont des mots-cl\u00e9s r\u00e9serv\u00e9s pour arara. + +# Error_InvalidDirective = Apparently, there''s an invalid directive at line {0}. Please take a look and fix it. +Error_InvalidDirective = Apparemment, il y a une commande invalide \u00e0 la ligne {0}. S''il vous pla\u00eet, veuillez y jeter un oeil et r\u00e9gler le probl\u00e8me. + +# Error_DirectiveGenericError = Directive ''{0}'' at line {1} seems to be malformed. It might be a YAML syntax error or a wrong mapping. +Error_DirectiveGenericError = L''instruction ''{0}'' \u00e0 la ligne {1} semble malform\u00e9e. Cela pourrait \u00eatre une erreur de syntaxe YAML ou un mauvais mapping. + +# Error_InvalidLanguage = I'm sorry, but the language code you chose is invalid. Currently, the following languages are supported: +Error_InvalidLanguage = Je suis d\u00e9sol\u00e9 mais la langue choisie est incorrecte. Pour l'instant, seuls les langages suivants sont support\u00e9s : + +# Error_RuleNotFound = Uh-oh, I could not find the ''{0}'' rule in the search path. Could you take a look if the rule name is correct and if the rule is accessible through the search path? +Error_RuleNotFound = Oh-oh, Je n''ai pas trouv\u00e9 la r\u00e8gle ''{0}'' dans le chemin de recherche. Pourriez-vous v\u00e9rifier si le nom de la r\u00e8gle est correct et si celle-ci est accessible dans le chemin de recherche ? + +# Error_InvalidYAMLRule = It appears that the ''{0}'' task has a YAML syntax error or an invalid field. Could you take a look at the ''{0}.yaml'' file located at ''{1}''. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLRule = Il semble que la t\u00e2che ''{0}'' contienne une erreur de syntaxe YAML ou un champ invalide. Pourriez-vous v\u00e9rifier le fichier ''{0}.yaml'' situ\u00e9 dans ''{1}''. J''ai fait de mon mieux pour r\u00e9cup\u00e9rer le message d'erreur, le voici : + +# Error_InvalidRule = Uh-oh, the ''{0}'' task appears to be invalid. Are you sure the ''{0}.yaml'' file located at ''{1}'' is a proper YAML file? +Error_InvalidRule = Oh-oh, la t\u00e2che ''{0}'' semble invalide. \u00cates vous sur(e) que le fichier ''{0}.yaml'' situ\u00e9 dans ''{1}'' est un fichier YAML valide ? + +# Error_EmptyIdentifierRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid identifier. Could you fix it? +Error_EmptyIdentifierRule = Un probl\u00e8me a \u00e9t\u00e9 d\u00e9tect\u00e9 dans la t\u00e2che ''{0}''. Le fichier ''{0}.yaml'' situ\u00e9 dans ''{1}'' requiert un identifiant valide. Pouvez-vous r\u00e9gler \u00e7a ? + +# Error_EmptyNameRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid name. Could you fix it? +Error_EmptyNameRule = Un probl\u00e8me a \u00e9t\u00e9 d\u00e9tect\u00e9 dans la t\u00e2che ''{0}''. Le fichier ''{0}.yaml'' situ\u00e9 dans ''{1}'' requiert un nom valide. Pouvez-vous r\u00e9gler \u00e7a ? + +# Error_ForbiddenIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an invalid argument identifier. ''{2}'' is a reserved keyword, so it cannot be used. Could you use another name? +Error_ForbiddenIdentifierRule = Oh-oh, la t\u00e2che ''{0}'' (qui fait r\u00e9f\u00e9rence au fichier ''{0}.yaml'' situ\u00e9 dans ''{1}'') a un identifiant d''argument invalide. ''{2}'' est un mot-cl\u00e9 r\u00e9serv\u00e9, aussi il ne peut pas \u00eatre utilis\u00e9. Pouvez-vous utiliser un autre nom ? + +# Error_EmptyArgumentsListRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid list of arguments. Could you fix it? Note that the list of arguments can also be empty, but it is still necessary to define it explicitly (with ''arguments: []''). +Error_EmptyArgumentsListRule = Un probl\u00e8me a \u00e9t\u00e9 d\u00e9tect\u00e9 dans la t\u00e2che ''{0}''. Le fichier ''{0}.yaml'' situ\u00e9 dans ''{1}'' requiert une liste d''arguments valide. Pourriez-vous r\u00e9gler cela ? Notez que la liste d''arguments peut aussi \u00eatre vide, mais il sera toujours n\u00e9cessaire de la d\u00e9finir explicitement (avec ''arguments: []''). + +# Error_WrongIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has the wrong identifier - ''{0}'' was expected, rather than ''{2}''. Could you fix it? +Error_WrongIdentifierRule = Oh-oh, la t\u00e2che ''{0}'' (faisant r\u00e9f\u00e9rence au fichier ''{0}.yaml'' situ\u00e9 dans ''{1}'') a un mauvais identifiant - ''{0}'' \u00e9tait attendu, au lieu de ''{2}''. Pourriez-vous r\u00e9gler cela ? + +# Error_ArgumentsNotDefinedInRule = Oh no, there are arguments used in the diretive ''{0}'' which are not defined in the ''{0}.yaml'' rule located at ''{1}''. You can either remove them from the ''{0}'' directive or add them to the list of arguments in the ''{0}.yaml'' rule. Here they are: {2} +Error_ArgumentsNotDefinedInRule = Oh, non ! Il y a des arguments utilis\u00e9s dans l''instruction ''{0}'' qui ne sont pas d\u00e9finis dans la r\u00e8gle ''{0}.yaml'' situ\u00e9 dans ''{1}''. Vous pouvez soit les enlever de la commande ''{0}'' ou les ajouter \u00e0 la liste des arguments de la r\u00e8gle ''{0}.yaml''. Les voil\u00e0 : {2} + +# Error_DefaultValueRuntimeErrorRule = I''m sorry, but the default value set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_DefaultValueRuntimeErrorRule = D\u00e9sol\u00e9, mais la valeur par d\u00e9faut d\u00e9finie pour l''agument ''{0}'' de la r\u00e8gle ''{1}'' (qui fait r\u00e9f\u00e9rence au fichier ''{0}.yaml'' situ\u00e9 dans ''{2}'') a une variable/m\u00e9thode incorrecte dans le contexte de la r\u00e8gle : ''{3}'' + +# Error_FlagRuntimeErrorRule = I''m sorry, but the flag set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_FlagRuntimeErrorRule = Je suis d\u00e9sol\u00e9 mais le drapeau d\u00e9finit par l''argument ''{0}'' de la t\u00e2che ''{1}'' (qui fait r\u00e9f\u00e9rence au fichier ''{0}.yaml'' situ\u00e9 dans ''{2}'') a une variable/m\u00e9thode incorrecte dans le contexte de la r\u00e8gle : ''{3}'' + +# Error_DuplicatedCommandElementsRule = Uh-oh, both ''command'' and ''commands'' fields are set in the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}''). You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_DuplicatedCommandElementsRule = Oh-oh, les 2 champs ''command'' et ''commands'' sont simultan\u00e9ment d\u00e9finis dans la t\u00e2che ''{0}'' (qui fait r\u00e9f\u00e9rence au fichier ''{0}.yaml'' situ\u00e9 dans ''{1}''). Vous ne devez en choisir qu''un des deux. Si votre t\u00e2che n''a besoin que d''une seule commande, vous pouvez choisir ''command''; s''il s''agit d''une succession de commandes, peut-\u00eatre que le champ ''commands'' serait plus avis\u00e9. + +# Error_MissingCommandElementsRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') does not have either the ''command'' or ''commands'' elements. You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_MissingCommandElementsRule = Oh-oh, la t\u00e2che ''{0}'' (qui fait r\u00e9f\u00e9rence au fichier ''{0}.yaml'' situ\u00e9 dans ''{1}'') ne contient ni l''\u00e9l\u00e9ment ''command'' ni l''\u00e9l\u00e9ment ''commands''. Vous devez en choisir un des deux. Si votre t\u00e2che n''a besoin que d''une seule commande, vous pouvez choisir ''command''; s''il s''agit d''une succession de commandes, peut-\u00eatre que le champ ''commands'' serait plus avis\u00e9. + +# Error_CommandRuntimeErrorRule = I''m sorry, but the command set for the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an unavailable variable/method in the rule context: ''{2}'' +Error_CommandRuntimeErrorRule = Je suis d\u00e9sol\u00e9, mais la commande d\u00e9finie pour la t\u00e2che ''{0}'' (qui fait r\u00e9f\u00e9rence au fichier ''{0}.yaml'' situ\u00e9 dans ''{1}'') contient une variable/m\u00e9thode non disponible dans le contexte de la r\u00e8gle : ''{2}'' + diff --git a/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_it.properties b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_it.properties new file mode 100644 index 00000000000..e851d9eef11 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_it.properties @@ -0,0 +1,226 @@ +# Arara -- the cool TeX automation tool +# Copyright (c) 2012, Paulo Roberto Massa Cereda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the project's author nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY +# WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +# Messages: This file holds the default Italian language messages for arara. +# +# translator: Enrico Gregorio +# e-mail: Enrico.Gregorio@univr.it + +# Log_WelcomeMessage = Welcome to arara! +Log_WelcomeMessage = arara ti d\u00e0 il benvenuto! + +# Log_ProcessingFile = Processing file ''{0}'', please wait. +Log_ProcessingFile = Sto elaborando il file ''{0}'', attendi. + +# Log_Done = Done. +Log_Done = Done. + +# Log_ExceptionRaised = Arara raised an exception with the following message: +Log_ExceptionRaised = Arara ha sollevato un'eccezione con il seguente messaggio: + +# Log_ReadyToRunCommands = Ready to run commands. +Log_ReadyToRunCommands = Pronto a eseguire comandi. + +# Log_CommandName = Running ''{0}''. +Log_CommandName = Sto eseguendo ''{0}''. + +# Log_Command = Command: {0} +Log_Command = Comando: {0} + +# Log_CommandSuccess = ''{0}'' was successfully executed. +Log_CommandSuccess = ''{0}'' \u00e8 stato eseguito con successo. + +# Log_CommandFailure = ''{0}'' returned an error status. +Log_CommandFailure = ''{0}'' ha emesso uno stato di errore. + +# Log_AllCommandsSuccess = All commands were successfully executed. +Log_AllCommandsSuccess = Tutti i comandi sono stati eseguiti con successo. + +# Log_OutputLogging = Output logging: +Log_OutputLogging = Resoconto dell'output: + +# Log_CommandNotFound = ''{0}'' was not found in the path. Execution attempt: {1} +Log_CommandNotFound = ''{0}'' non \u00e8 stato trovato nel ''path''. Tentativo di esecuzione: {1} + +# Log_DirectiveFound = Directive found in line {0} with {1}. +Log_DirectiveFound = Direttiva trovata alla riga {0} con {1}. + +# Log_RuleFound = Task ''{0}'' found in ''{1}''. +Log_RuleFound = Compito ''{0}'' trovato in ''{1}''. + +# Log_NoDirectivesFound = No directives found in ''{0}''. +Log_NoDirectivesFound = Non ho trovato direttive in ''{0}''. + +# Help_Version = print the application version +Help_Version = stampa la versione dell'applicazione + +# Help_Help = print the help message +Help_Help = stampa il messaggio di aiuto + +# Help_Log = generate a log output +Help_Log = genera un resoconto dell'output + +# Help_Verbose = print the command output +Help_Verbose = stampa l'output del comando + +# Help_Timeout = set the execution timeout (in milliseconds) +Help_Timeout = imposta il 'timeout' dell'esecuzione (in millisecondi) + +# Help_Language = set the application language +Help_Language = imposta la lingua dell'applicazione + +# Header_Slogan = The cool TeX automation tool +Header_Slogan = The cool TeX automation tool + +# Header_AllRightsReserved = All rights reserved. +Header_AllRightsReserved = Tutti i diritti riservati. + +# Msg_NoDirectivesFound = I didn''t find any directives in ''{0}'', and so didn''t do anything. Is that what you really wanted? +Msg_NoDirectivesFound = Non ho trovato direttive in ''{0}'', cos\u00ec non ho fatto niente. \u00c8 proprio quello che volevi? + +# Msg_SpecialThanks = A special thanks goes to Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz, and many others for making this humble tool possible. +Msg_SpecialThanks = Un ringraziamento speciale va a Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz e molti altri che hanno reso possibile la realizzazione di questo umile strumento. + +# Msg_RunningCommand = Running {0}... +Msg_RunningCommand = Sto eseguendo {0}... + +# Msg_Success = SUCCESS +Msg_Success = SUCCESSO + +# Msg_Failure = FAILURE +Msg_Failure = FALLIMENTO + +# Msg_Status = Status: +Msg_Status = Stato: + +# YamlError_Context = Context: {0} +YamlError_Context = Contesto: {0} + +# YamlError_Problem = Problem: {0} +YamlError_Problem = Problema: {0} + +# YamlError_ErrorLocation = Error found in line {0}, column {1}. +YamlError_ErrorLocation = Ho trovato un errore alla riga {0}, colonna {1}. + +# Error_FileDoesNotExistWithExtensionsList = I''m sorry, but the file ''{0} {1}'' does not exist. Note that when you provide only the basename (i.e, the filename without the extension) or with an unknown extension, arara will try to look for files ending with the predefined extensions {1} in that order. You can override the order, the search pattern or even add support for new extensions through the configuration file. Please refer to the arara manual to learn more about this feature. +Error_FileDoesNotExistWithExtensionsList = Splacente, ma il file ''{0} {1}'' non esiste. Osserva che quando inserisci solo il nome proprio (cio\u00e8 il nome del file senza estensione) o il nome con un''estensione sconosciuta, arara cercher\u00e0 un file che termini con le estensioni predefinite {1} in quest''ordine. \u00c8 possibile modificare l''ordine, lo schema di ricerca e anche abilitare nuove estensioni agendo sul file di configurazione. Consulta il manuale di arara per saperne di pi\u00f9. + +# Error_FileDoesNotExist = File ''{0}'' does not exist. +Error_FileDoesNotExist = Il file ''{0}'' non esiste. + +# Error_CommandNotFound = \nI''m sorry, but the command from the ''{0}'' task could not be found. Are you sure the command ''{1}'' is correct, or even accessible from the system path? +Error_CommandNotFound = \nMi dispiace, ma il comando chiesto dal compito ''{0}'' non \u00e8 stato trovato. Assicurati che il comando ''{1}'' sia corretto e accessibile dal ''path'' di sistema. + +# Error_InvalidYAMLConfigurationFile = I'm sorry, but apparently your arara configuration file is invalid, that is, it has invalid or missing YAML entries. Unfortunately, arara cannot proceed until the error is fixed. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLConfigurationFile = Mi dispiace, ma sembra che il file di configurazione di arara non sia valido, cio\u00e8 che abbia istruzioni YAML mancanti o scorrette. Sfortunatamente arara non pu\u00f2 andare oltre finch\u00e9 l'errore non viene corretto. Ho fatto del mio meglio registrando il messaggio di errore che \u00e8 questo: + +# Error_InvalidConfigurationFile = Uh-oh, the configuration file appears to be invalid. Are you sure it's a proper YAML file? Unfortunately, arara cannot proceed until a proper configuration file is provided. +Error_InvalidConfigurationFile = Oh, oh! Il file di configurazione non sembra valido. Assicurati che sia un file YAML corretto. Sfortunatamente arara non pu\u00f2 andare oltre finch\u00e9 non trova un file di configurazione corretto. + +# Error_InvalidLanguageConfigurationFile = Houston, we have a problem. Sadly, the language set in the configuration file is not valid. Currently, arara can provide support for the following languages: {0}. Make sure to choose a valid language or remove the entry from the configuration file (the field is optional), otherwise arara cannot proceed. +Error_InvalidLanguageConfigurationFile = Houston, abbiamo un problema. Spiacente, la lingua impostata nel file di configurazione non \u00e8 valida. Attualmente arara comprende le seguenti lingue: {0}. Assicurati di scegliere una lingua della lista o togli quella sbagliata dal file di configurazione (la lingua \u00e8 facoltativa), altrimenti arara non pu\u00f2 andare oltre. + +# Error_InvalidFiletypesConfigurationFile = I'm sorry, but it seems your configuration file has customized filetypes with neither the extension or pattern defined. Both are required in order to continue. Please fix this error in your configuration file and try again. +Error_InvalidFiletypesConfigurationFile = Spiacente, ma sembra che il file di configurazione abbia tipi di file personalizzati senza che siano stati definiti un'estensione o uno schema: entrambi sono richiesti per poter continuare. Per favore, correggi l'errore nel file di configurazione e riprova. + +# Error_PathRuntimeErrorConfigurationFile = I''m sorry, but one of the entries of the search path in your configuration file has an unavailable variable in the path context: ''{0}'' +Error_PathRuntimeErrorConfigurationFile = Spiacente, ma uno degli elementi nel percorso di ricerca indicato nel file di configurazione usa una variabile non disponibile in questo contesto: ''{0}'' + +# Error_PathIOErrorConfigurationFile = I'm sorry, but one of the entries of the search path in your configuration file has a malformed directory structure. Could you take a look at it? +Error_PathIOErrorConfigurationFile = Spiacente, ma uno degli elementi nel percorso di ricerca indicato nel file di configurazione ha una struttura gerarchica malformata. Puoi darci un'occhiata? + +# Error_InvalidYAMLDirective = It appears there is a malformed directive found at line {0}, that is, a directive that might have a YAML syntax error or an invalid field. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLDirective = Sembra che ci sia una direttiva malformata alla riga {0}, cio\u00e8 una direttiva con un errore di sintassi YAML oppure un campo non valido. Ho fatto del mio meglio registrando il messaggio di errore che \u00e8 questo: + +# Error_DirectiveEmptyCurlyBrackets = Directive ''{0}'' at line {1} has empty curly brackets. Note that arara opts for a cleaner syntax when a directive has no parameters. To fix it, it''s enough to either remove the curly brackets or provide the arguments for the directive. +Error_DirectiveEmptyCurlyBrackets = La direttiva ''{0}'' alla riga {1} non ha nulla tra le graffe. Osserva che arara preferisce una sintassi pi\u00f9 snella quando una direttiva non ha parametri. Per correggere, \u00e8 sufficiente togliere le graffe o inserire un argomento per la direttiva. + +# Error_DirectiveInvalidArgumentList = Directive ''{0}'' at line {1} has an invalid argument type. The argument ''{2}'' is a reserved arara keyword and always requires a list. +Error_DirectiveInvalidArgumentList = La direttiva ''{0}'' alla riga {1} ha un argomento di tipo non valido. L''argomento ''{2}'' \u00e8 una parola chiave riservata di arara che richiede sempre una lista. + +# Error_DirectiveReservedKeyword = Directive ''{0}'' at line {1} has an invalid argument name. The name ''{2}'' is a reserved arara keyword representing every element in the ''{3}'' list. Please, pick another name for that argument. +Error_DirectiveReservedKeyword = La direttiva ''{0}'' alla riga {1} ha un nome di argomento non valido. Il nome ''{2}'' \u00e8 una parola chiave riservata di arara che rappresenta tutti gli elementi della lista ''{3}''. Per favore, scegli un nome diverso per quell''argomento. + +# Error_DirectiveListError = Directive ''{0}'' at line {1} has an invalid argument type. Only the arguments ''files'' and ''items'' can have a list. Both are reserved arara keywords. +Error_DirectiveListError = La direttiva ''{0}'' alla riga {1} ha un tipo di argomento non valido. Solo gli argomenti ''files'' e ''items'' possono contenere una lista. Entrambi sono parole chiave riservate di arara. + +# Error_InvalidDirective = Apparently, there''s an invalid directive at line {0}. Please take a look and fix it. +Error_InvalidDirective = Sembra che ci sia una direttiva non valida alla riga {0}. Dacci un''occhiata e correggi. + +# Error_DirectiveGenericError = Directive ''{0}'' at line {1} seems to be malformed. It might be a YAML syntax error or a wrong mapping. +Error_DirectiveGenericError = La direttiva ''{0}'' alla riga {1} sembra malformata. Potrebbe essere un errore di sintassi YAML o un''assegnazione sbagliata. + +# Error_InvalidLanguage = I'm sorry, but the language code you chose is invalid. Currently, the following languages are supported: +Error_InvalidLanguage = Spiacente, ma questo codice di lingua non \u00e8 valido. Attualmente arara comprende le seguenti lingue: + +# Error_RuleNotFound = Uh-oh, I could not find the ''{0}'' rule in the search path. Could you take a look if the rule name is correct and if the rule is accessible through the search path? +Error_RuleNotFound = Oh, oh! Non sono riuscito a trovare la regola ''{0}'' nel percorso di ricerca. Puoi controllare che il nome della regola sia giusto e che la regola sia accessibile nel percorso di ricerca? + +# Error_InvalidYAMLRule = It appears that the ''{0}'' task has a YAML syntax error or an invalid field. Could you take a look at the ''{0}.yaml'' file located at ''{1}''. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLRule = Sembra che il compito ''{0}'' abbia un errore di sintassi YAML o un campo non valido. Puoi dare un''occhiata al file ''{0}.yaml'' che si trova in ''{1}''? Ho fatto del mio meglio registrando il messaggio di errore che \u00e8 questo: + +# Error_InvalidRule = Uh-oh, the ''{0}'' task appears to be invalid. Are you sure the ''{0}.yaml'' file located at ''{1}'' is a proper YAML file? +Error_InvalidRule = Oh, oh! Il compito ''{0}'' sembra non valido. Assicurati che il file ''{0}.yaml'' che si trova in ''{1}'' sia un file YAML corretto. + +# Error_EmptyIdentifierRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid identifier. Could you fix it? +Error_EmptyIdentifierRule = C''\u00e8 un problema nell''eseguire ''{0}''. Il file ''{0}.yaml'' che si trova in ''{1}'' richiede un identificatore valido. Puoi correggerlo? + +# Error_EmptyNameRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid name. Could you fix it? +Error_EmptyNameRule = C''\u00e8 un problema nell''eseguire ''{0}''. Il file ''{0}.yaml'' che si trova in ''{1}'' richede un nome valido. Puoi correggerlo? + +# Error_ForbiddenIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an invalid argument identifier. ''{2}'' is a reserved keyword, so it cannot be used. Could you use another name? +Error_ForbiddenIdentifierRule = Oh, oh! Il compito ''{0}'' (riferito al file ''{0}.yaml'' che si trova in ''{1}'') ha un identificatore di argomento non valido. ''{2}'' \u00e8 una parola chiave riservata e non pu\u00f2 essere usato. Puoi scegliere un altro nome? + +# Error_EmptyArgumentsListRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid list of arguments. Could you fix it? Note that the list of arguments can also be empty, but it is still necessary to define it explicitly (with ''arguments: []''). +Error_EmptyArgumentsListRule = C''\u00e8 un problame nell''eseguire ''{0}''. Il file ''{0}.yaml'' che si trova in ''{1}'' richiede una lista di argomenti valida. Puoi correggerlo? Nota che la lista di argomenti pu\u00f2 anche essere vuota, ma \u00e8 comunque necessario definirla esplicitamente (con ''arguments: []''). + +# Error_WrongIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has the wrong identifier - ''{0}'' was expected, rather than ''{2}''. Could you fix it? +Error_WrongIdentifierRule = Oh, oh! Il compito ''{0}'' (riferito al file ''{0}.yaml'' che si trova in ''{1}'') ha un identificatore sbagliato; mi aspettavo ''{0}'' e non ''{2}''. Puoi correggerlo? + +# Error_ArgumentsNotDefinedInRule = Oh no, there are arguments used in the diretive ''{0}'' which are not defined in the ''{0}.yaml'' rule located at ''{1}''. You can either remove them from the ''{0}'' directive or add them to the list of arguments in the ''{0}.yaml'' rule. Here they are: {2} +Error_ArgumentsNotDefinedInRule = Oh, no! Alcuni argomenti usati nella direttiva ''{0}'' non sono definiti nella regola ''{0}.yaml'' che si trova in ''{1}''. Puoi rimuoverli dalla direttiva ''{0}'' oppure aggiungerli alla lista di argomenti nella regola ''{0}.yaml''. Eccoli: {2} + +# Error_DefaultValueRuntimeErrorRule = I''m sorry, but the default value set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_DefaultValueRuntimeErrorRule = Spiacente, ma il valore di default impostato per l''argomento ''{0}'' del compito ''{1}'' (riferito al file ''{1}.yaml'' che si trova in ''{2}'') usa un metodo o una variabile che non \u00e8 disponibile nel contesto della regola: ''{3}'' + +# Error_FlagRuntimeErrorRule = I''m sorry, but the flag set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_FlagRuntimeErrorRule = Spiacente, ma il segnale (flag) impostato per l''argomento ''{0}'' del compito ''{1}'' (riferito al file ''{1}.yaml'' che si trova in ''{2}'') vuole un metodo o una variabile che non \u00e8 disponibile nel contesto della regola: ''{3}'' + +# Error_DuplicatedCommandElementsRule = Uh-oh, both ''command'' and ''commands'' fields are set in the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}''). You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_DuplicatedCommandElementsRule = Oh, oh! Entrambi i campi ''command'' e ''commands'' sono impostati per il compito ''{0}'' (riferito al file ''{0}.yaml'' che si trova in ''{1}''). Si pu\u00f2 adoperarne solo uno. Se il compito richiede a un solo comando, scegli ''command''; se la regola richiede pi\u00f9 comandi, forse il campo ''commands'' \u00e8 pi\u00f9 adatto. + +# Error_MissingCommandElementsRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') does not have either the ''command'' or ''commands'' elements. You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_MissingCommandElementsRule = Oh, oh! Il compito ''{0}'' (riferito al file ''{0}.yaml'' che si trova in ''{1}'') non ha n\u00e9 il campo ''command'' n\u00e9 ''commands''. Occorre usare uno (solo) di essi. Se il compito richiede un solo comando, scegli ''command''; se la regola richiede pi\u00f9 comandi, forse il campo ''commands'' \u00e8 pi\u00f9 adatto. + +# Error_CommandRuntimeErrorRule = I''m sorry, but the command set for the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an unavailable variable/method in the rule context: ''{2}'' +Error_CommandRuntimeErrorRule = Spiacente, ma il comando impostato per il compito ''{0}'' task (riferito al file ''{0}.yaml'' che si trova in ''{1}'') usa un metodo o una variabile non disponibile nel contesto della regola: ''{2}'' + diff --git a/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_pt_BR.properties b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_pt_BR.properties new file mode 100644 index 00000000000..f41c27490cb --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_pt_BR.properties @@ -0,0 +1,226 @@ +# Arara -- the cool TeX automation tool +# Copyright (c) 2012, Paulo Roberto Massa Cereda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the project's author nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY +# WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +# Messages: This file holds the default Brazilian Portuguese messages for arara. +# +# author: Paulo Roberto Massa Cereda +# e-mail: cereda@users.sf.net + +# Log_WelcomeMessage = Welcome to arara! +Log_WelcomeMessage = Bem-vindo ao arara! + +# Log_ProcessingFile = Processing file ''{0}'', please wait. +Log_ProcessingFile = Processando o arquivo ''{0}''; por favor, aguarde. + +# Log_Done = Done. +Log_Done = Conclu\u00eddo. + +# Log_ExceptionRaised = Arara raised an exception with the following message: +Log_ExceptionRaised = Arara gerou uma exce\u00e7\u00e3o com a seguinte mensagem: + +# Log_ReadyToRunCommands = Ready to run commands. +Log_ReadyToRunCommands = Pronto para executar comandos. + +# Log_CommandName = Running ''{0}''. +Log_CommandName = Executando ''{0}''. + +# Log_Command = Command: {0} +Log_Command = Comando: {0} + +# Log_CommandSuccess = ''{0}'' was successfully executed. +Log_CommandSuccess = ''{0}'' foi executado com sucesso. + +# Log_CommandFailure = ''{0}'' returned an error status. +Log_CommandFailure = ''{0}'' retornou um status de erro. + +# Log_AllCommandsSuccess = All commands were successfully executed. +Log_AllCommandsSuccess = Todos os comandos foram executados com sucesso. + +# Log_OutputLogging = Output logging: +Log_OutputLogging = Registro de sa\u00edda: + +# Log_CommandNotFound = ''{0}'' was not found in the path. Execution attempt: {1} +Log_CommandNotFound = ''{0}'' n\u00e3o foi encontrado no caminho do sistema. Tentativa de execu\u00e7\u00e3o: {1} + +# Log_DirectiveFound = Directive found in line {0} with {1}. +Log_DirectiveFound = Diretiva encontrada na linha {0} com {1}. + +# Log_RuleFound = Task ''{0}'' found in ''{1}''. +Log_RuleFound = Tarefa ''{0}'' encontrada em ''{1}''. + +# Log_NoDirectivesFound = No directives found in ''{0}''. +Log_NoDirectivesFound = Nenhuma diretiva foi encontrada em ''{0}''. + +# Help_Version = print the application version +Help_Version = imprime a vers\u00e3o da aplica\u00e7\u00e3o + +# Help_Help = print the help message +Help_Help = imprime a mensagem de ajuda + +# Help_Log = generate a log output +Help_Log = gera uma sa\u00edda para registro + +# Help_Verbose = print the command output +Help_Verbose = imprime a sa\u00edda do comando + +# Help_Timeout = set the execution timeout (in milliseconds) +Help_Timeout = define o timeout de execu\u00e7\u00e3o (em milissegundos) + +# Help_Language = set the application language +Help_Language = define o idioma da aplica\u00e7\u00e3o + +# Header_Slogan = The cool TeX automation tool +Header_Slogan = A ferramenta legal de automa\u00e7\u00e3o TeX + +# Header_AllRightsReserved = All rights reserved. +Header_AllRightsReserved = Todos os direitos reservados. + +# Msg_NoDirectivesFound = I didn''t find any directives in ''{0}'', and so didn''t do anything. Is that what you really wanted? +Msg_NoDirectivesFound = Eu n\u00e3o encontrei nenhuma diretiva em ''{0}'', e ent\u00e3o n\u00e3o fiz absolutamente nada. \u00c9 isso que voc\u00ea realmente queria? + +# Msg_SpecialThanks = A special thanks goes to Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz, and many others for making this humble tool possible. +Msg_SpecialThanks = Um agradecimento especial aos amigos Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz, e muitos outros por tornar poss\u00edvel esta humilde ferramenta. + +# Msg_RunningCommand = Running {0}... +Msg_RunningCommand = Executando {0}... + +# Msg_Success = SUCCESS +Msg_Success = SUCESSO + +# Msg_Failure = FAILURE +Msg_Failure = FRACASSO + +# Msg_Status = Status: +Msg_Status = Status: + +# YamlError_Context = Context: {0} +YamlError_Context = Contexto: {0} + +# YamlError_Problem = Problem: {0} +YamlError_Problem = Problema: {0} + +# YamlError_ErrorLocation = Error found in line {0}, column {1}. +YamlError_ErrorLocation = Erro encontrado na linha {0}, coluna {1}. + +# Error_FileDoesNotExistWithExtensionsList = I''m sorry, but the file ''{0} {1}'' does not exist. Note that when you provide only the basename (i.e, the filename without the extension) or with an unknown extension, arara will try to look for files ending with the predefined extensions {1} in that order. You can override the order, the search pattern or even add support for new extensions through the configuration file. Please refer to the arara manual to learn more about this feature. +Error_FileDoesNotExistWithExtensionsList = Sinto muito, mas o arquivo ''{0} {1}'' n\u00e3o existe. Observe que se voc\u00ea fornecer apenas o nome base (isto \u00e9, o nome do arquivo sem a extens\u00e3o) ou com uma extens\u00e3o desconhecida, arara tentar\u00e1 encontrar arquivos terminados com as extens\u00f5es predefinidas {1} nesta ordem. Voc\u00ea pode alterar a ordem, o padr\u00e3o de busca ou mesmo adicionar suporte para novas extens\u00f5es atrav\u00e9s do arquivo de configura\u00e7\u00e3o. Por favor, verifique o manual para aprender mais sobre essa funcionalidade. + +# Error_FileDoesNotExist = File ''{0}'' does not exist. +Error_FileDoesNotExist = O arquivo ''{0}'' n\u00e3o existe. + +# Error_CommandNotFound = \nI''m sorry, but the command from the ''{0}'' task could not be found. Are you sure the command ''{1}'' is correct, or even accessible from the system path? +Error_CommandNotFound = \nSinto muito, mas o comando da tarefa ''{0}'' n\u00e3o foi encontrado. Voc\u00ea tem certeza de que ''{1}'' est\u00e1 correto, ou mesmo acess\u00edvel a partir do caminho do sistema? + +# Error_InvalidYAMLConfigurationFile = I'm sorry, but apparently your arara configuration file is invalid, that is, it has invalid or missing YAML entries. Unfortunately, arara cannot proceed until the error is fixed. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLConfigurationFile = Sinto muito, mas aparentemente o seu arquivo de configura\u00e7\u00e3o arara \u00e9 inv\u00e1lido, isto \u00e9, cont\u00e9m entradas YAML inv\u00e1lidas ou inexistentes. Infelizmente, arara n\u00e3o pode prosseguir at\u00e9 que o erro seja reparado. Fiz o meu melhor para exibir a mensagem de erro; aqui est\u00e1: + +# Error_InvalidConfigurationFile = Uh-oh, the configuration file appears to be invalid. Are you sure it's a proper YAML file? Unfortunately, arara cannot proceed until a proper configuration file is provided. +Error_InvalidConfigurationFile = Uh-oh, o arquivo de configura\u00e7\u00e3o parece ser inv\u00e1lido. Voc\u00ea tem certeza de que ele \u00e9 um arquivo YAML adequado? Infelizmente, arara n\u00e3o pode prosseguir at\u00e9 que um arquivo de configura\u00e7\u00e3o v\u00e1lido seja fornecido. + +# Error_InvalidLanguageConfigurationFile = Houston, we have a problem. Sadly, the language set in the configuration file is not valid. Currently, arara can provide support for the following languages: {0}. Make sure to choose a valid language or remove the entry from the configuration file (the field is optional), otherwise arara cannot proceed. +Error_InvalidLanguageConfigurationFile = Houston, temos um problema. Infelizmente, o idioma definido no arquivo de configura\u00e7\u00e3o n\u00e3o \u00e9 v\u00e1lido. No momento, arara oferece suporte para os seguintes idiomas: {0}. Certifique-se de ter escolhido um idioma v\u00e1lido, ou remova a entrada do arquivo de configura\u00e7\u00e3o (o campo \u00e9 opcional). Caso contr\u00e1rio arara n\u00e3o poder\u00e1 prosseguir. + +# Error_InvalidFiletypesConfigurationFile = I'm sorry, but it seems your configuration file has customized filetypes with neither the extension or pattern defined. Both are required in order to continue. Please fix this error in your configuration file and try again. +Error_InvalidFiletypesConfigurationFile = Sinto muito, mas parece que o seu arquivo de configura\u00e7\u00e3o tem tipos de arquivos personalizados sem a extens\u00e3o ou o padr\u00e3o de busca definidos. Ambos s\u00e3o requeridos para que arara prossiga. Por favor, conserte o erro no seu arquivo de configura\u00e7\u00e3o e tente novamente. + +# Error_PathRuntimeErrorConfigurationFile = I''m sorry, but one of the entries of the search path in your configuration file has an unavailable variable in the path context: ''{0}'' +Error_PathRuntimeErrorConfigurationFile = Sinto muito, mas uma das entradas do caminho de busca no seu arquivo de configura\u00e7\u00e3o tem uma vari\u00e1vel n\u00e3o resolvida no contexto do caminho: ''{0}'' + +# Error_PathIOErrorConfigurationFile = I'm sorry, but one of the entries of the search path in your configuration file has a malformed directory structure. Could you take a look at it? + Error_PathIOErrorConfigurationFile = Sinto muito, mas uma das entradas do caminho de busca no seu arquivo de configura\u00e7\u00e3o tem uma estrutura de diret\u00f3rio malformada. Voc\u00ea poderia dar uma olhadinha? + +# Error_InvalidYAMLDirective = It appears there is a malformed directive found at line {0}, that is, a directive that might have a YAML syntax error or an invalid field. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLDirective = Parece que existe uma diretiva malformada encontrada na linha {0}, isto \u00e9, uma diretiva que pode ter um erro na sintaxe YAML ou um campo inv\u00e1lido. Fiz o meu melhor para exibir a mensagem de erro; aqui est\u00e1: + +# Error_DirectiveEmptyCurlyBrackets = Directive ''{0}'' at line {1} has empty curly brackets. Note that arara opts for a cleaner syntax when a directive has no parameters. To fix it, it''s enough to either remove the curly brackets or provide the arguments for the directive. +Error_DirectiveEmptyCurlyBrackets = A diretiva ''{0}'' na linha {1} tem chaves vazias. Observe que arara opta por uma sintaxe mais limpa quando uma diretiva n\u00e3o tem par\u00e2metros. Para repar\u00e1-la, \u00e9 suficiente remover as chaves ou fornecer os argumentos para a diretiva. + +# Error_DirectiveInvalidArgumentList = Directive ''{0}'' at line {1} has an invalid argument type. The argument ''{2}'' is a reserved arara keyword and always requires a list. +Error_DirectiveInvalidArgumentList = A diretiva ''{0}'' na linha {1} tem um tipo de argumento inv\u00e1lido. O argumento ''{2}'' \u00e9 uma palavra reservada arara e sempre requer uma lista. + +# Error_DirectiveReservedKeyword = Directive ''{0}'' at line {1} has an invalid argument name. The name ''{2}'' is a reserved arara keyword representing every element in the ''{3}'' list. Please, pick another name for that argument. +Error_DirectiveReservedKeyword = A diretiva ''{0}'' na linha {1} tem um nome de argumento inv\u00e1lido. O nome ''{2}'' \u00e9 uma palavra reservada arara representando cada elemento na lista ''{3}''. Por favor, escolha um outro nome para esse argumento. + +# Error_DirectiveListError = Directive ''{0}'' at line {1} has an invalid argument type. Only the arguments ''files'' and ''items'' can have a list. Both are reserved arara keywords. +Error_DirectiveListError = A diretiva ''{0}'' na linha {1} tem um tipo de argumento inv\u00e1lido. Apenas os argumentos ''files'' e ''items'' podem conter uma lista. Ambos s\u00e3o palavras reservadas arara. + +# Error_InvalidDirective = Apparently, there''s an invalid directive at line {0}. Please take a look and fix it. +Error_InvalidDirective = Aparentemente, existe uma diretiva inv\u00e1lida na linha {0}. Por favor, d\u00ea uma olhadinha e conserte a diretiva. + +# Error_DirectiveGenericError = Directive ''{0}'' at line {1} seems to be malformed. It might be a YAML syntax error or a wrong mapping. +Error_DirectiveGenericError = A diretiva ''{0}'' na linha {1} parece ser malformada. Pode ser um erro na sintaxe YAML ou um mapeamento incorreto. + +# Error_InvalidLanguage = I'm sorry, but the language code you chose is invalid. Currently, the following languages are supported: +Error_InvalidLanguage = Sinto muito, mas o c\u00f3digo de idioma que voc\u00ea escolheu \u00e9 inv\u00e1lido. No momento, os seguintes idiomas s\u00e3o suportados: + +# Error_RuleNotFound = Uh-oh, I could not find the ''{0}'' rule in the search path. Could you take a look if the rule name is correct and if the rule is accessible through the search path? +Error_RuleNotFound = Uh-oh, eu n\u00e3o consegui encontrar a regra ''{0}'' no caminho de busca. Voc\u00ea poderia conferir se o nome da regra est\u00e1 correto e se a regra \u00e9 acess\u00edvel a partir do caminho de busca? + +# Error_InvalidYAMLRule = It appears that the ''{0}'' task has a YAML syntax error or an invalid field. Could you take a look at the ''{0}.yaml'' file located at ''{1}''. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLRule = Parece que a tarefa ''{0}'' tem um erro na sintaxe YAML ou um campo inv\u00e1lido. Voc\u00ea poderia dar uma olhadinha no arquivo ''{0}.yaml'' localizado em ''{1}''? Fiz o meu melhor para exibir a mensagem de erro; aqui est\u00e1: + +# Error_InvalidRule = Uh-oh, the ''{0}'' task appears to be invalid. Are you sure the ''{0}.yaml'' file located at ''{1}'' is a proper YAML file? +Error_InvalidRule = Uh-oh, a tarefa ''{0}'' parece ser inv\u00e1lida. Voc\u00ea tem certeza de que o arquivo ''{0}.yaml'' localizado em ''{1}'' \u00e9 um arquivo YAML apropriado? + +# Error_EmptyIdentifierRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid identifier. Could you fix it? +Error_EmptyIdentifierRule = Um problema foi detectado na tarefa ''{0}''. O arquivo ''{0}.yaml'' localizado em ''{1}'' requer um identificador v\u00e1lido. Voc\u00ea pode consert\u00e1-lo? + +# Error_EmptyNameRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid name. Could you fix it? +Error_EmptyNameRule = Um problema foi detectado na tarefa ''{0}''. O arquivo ''{0}.yaml'' localizado em ''{1}'' requer um nome v\u00e1lido. Voc\u00ea pode consert\u00e1-lo? + +# Error_ForbiddenIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an invalid argument identifier. ''{2}'' is a reserved keyword, so it cannot be used. Could you use another name? +Error_ForbiddenIdentifierRule = Uh-oh, a tarefa ''{0}'' (referenciando o arquivo ''{0}.yaml'' localizado em ''{1}'') tem um identificador de argumento inv\u00e1lido. ''{2}'' \u00e9 uma palavra reservada, portanto n\u00e3o pode ser utilizada. Voc\u00ea poderia utilizar outro nome? + +# Error_EmptyArgumentsListRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid list of arguments. Could you fix it? Note that the list of arguments can also be empty, but it is still necessary to define it explicitly (with ''arguments: []''). +Error_EmptyArgumentsListRule = Um problema foi detectado na tarefa ''{0}''. O arquivo ''{0}.yaml'' localizado em ''{1}'' requer uma lista v\u00e1lida de argumentos. Voc\u00ea pode consert\u00e1-lo? Observe que a lista de argumentos tamb\u00e9m pode ser vazia, mas mesmo assim \u00e9 necess\u00e1rio defin\u00ed-la explicitamente (com ''arguments: []''). + +# Error_WrongIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has the wrong identifier - ''{0}'' was expected, rather than ''{2}''. Could you fix it? +Error_WrongIdentifierRule = Uh-oh, a tarefa ''{0}'' (referenciando o arquivo ''{0}.yaml'' localizado em ''{1}'') tem o identificador incorreto - era esperado ''{0}'', ao inv\u00e9s de ''{2}''. Voc\u00ea pode consert\u00e1-lo? + +# Error_ArgumentsNotDefinedInRule = Oh no, there are arguments used in the diretive ''{0}'' which are not defined in the ''{0}.yaml'' rule located at ''{1}''. You can either remove them from the ''{0}'' directive or add them to the list of arguments in the ''{0}.yaml'' rule. Here they are: {2} +Error_ArgumentsNotDefinedInRule = Uh-oh, existem argumentos utilizados na diretiva ''{0}'' que n\u00e3o est\u00e3o definidos na regra ''{0}.yaml'' localizada em ''{1}''. Voc\u00ea pode remover esses argumentos inexistentes da diretiva ''{0}'' ou adicion\u00e1-los \u00e0 lista de argumentos na regra ''{0}.yaml''. Aqui est\u00e3o eles: {2} + +# Error_DefaultValueRuntimeErrorRule = I''m sorry, but the default value set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_DefaultValueRuntimeErrorRule = Sinto muito, mas o valor padr\u00e3o definido para o argumento ''{0}'' da tarefa ''{1}'' (referenciando o arquivo ''{1}.yaml'' localizado em ''{2}'') tem uma vari\u00e1vel ou m\u00e9todo indispon\u00edvel no contexto da regra: ''{3}'' + +# Error_FlagRuntimeErrorRule = I''m sorry, but the flag set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_FlagRuntimeErrorRule = Sinto muito, mas a flag definida para o argumento ''{0}'' da tarefa ''{1}'' (referenciando o arquivo ''{1}.yaml'' localizado em ''{2}'') tem uma vari\u00e1vel ou m\u00e9todo indispon\u00edvel no contexto da regra: ''{3}'' + +# Error_DuplicatedCommandElementsRule = Uh-oh, both ''command'' and ''commands'' fields are set in the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}''). You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_DuplicatedCommandElementsRule = Uh-oh, os campos ''command'' e ''commands'' est\u00e3o definidos ao mesmo tempo na tarefa ''{0}'' (referenciando o arquivo ''{0}.yaml'' localizado em ''{1}''). Voc\u00ea precisa escolher apenas um deles. Se a sua regra precisa de apenas um comando, voc\u00ea pode optar por ''command''; se a sua regra requer um conjunto de comandos, talvez o campo ''commands'' seja mais adequado. + +# Error_MissingCommandElementsRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') does not have either the ''command'' or ''commands'' elements. You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_MissingCommandElementsRule = Uh-oh, a tarefa ''{0}'' (referenciando o arquivo ''{0}.yaml'' localizado em ''{1}'') n\u00e3o possui o elemento ''command'' ou ''commands''. Voc\u00ea precisa escolher um deles. Se a sua regra precisa de apenas um comando, voc\u00ea pode optar por ''command''; se a sua regra requer um conjunto de comandos, talvez o campo ''commands'' seja mais adequado. + +# Error_CommandRuntimeErrorRule = I''m sorry, but the command set for the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an unavailable variable/method in the rule context: ''{2}'' +Error_CommandRuntimeErrorRule = Sinto muito, mas o conjunto de comandos da tarefa ''{0}'' (referenciando o arquivo ''{0}.yaml'' localizado em ''{1}'') tem uma vari\u00e1vel ou m\u00e9todo indispon\u00edvel no contexto da regra: ''{2}'' + diff --git a/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_ru.properties b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_ru.properties new file mode 100644 index 00000000000..0e2278ae4dd --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_ru.properties @@ -0,0 +1,226 @@ +# Arara -- the cool TeX automation tool +# Copyright (c) 2012, Paulo Roberto Massa Cereda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the project's author nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY +# WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +# Messages: This file holds the default Russian language messages for arara. +# +# author: Sergey Ulyanov +# e-mail: ulyanov.sergey@gmail.com + +# Log_WelcomeMessage = Welcome to arara! +Log_WelcomeMessage = \u0414\u043e\u0431\u0440\u043e \u043f\u043e\u0436\u0430\u043b\u043e\u0432\u0430\u0442\u044c \u0432 arara! + +# Log_ProcessingFile = Processing file ''{0}'', please wait. +Log_ProcessingFile = \u041e\u0431\u0440\u0430\u0431\u043e\u0442\u043a\u0430 \u0444\u0430\u0439\u043b\u0430 ''{0}'', \u043f\u043e\u0436\u0430\u043b\u0443\u0439\u0441\u0442\u0430, \u043f\u043e\u0434\u043e\u0436\u0434\u0438\u0442\u0435. + +# Log_Done = Done. +Log_Done = \u0417\u0430\u0432\u0435\u0440\u0448\u0435\u043d\u043e. + +# Log_ExceptionRaised = Arara raised an exception with the following message: +Log_ExceptionRaised = Arara \u0432\u044b\u0434\u0430\u043b\u0430 \u0438\u0441\u043a\u043b\u044e\u0447\u0435\u043d\u0438\u0435 \u0441\u043e \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u043c \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u0435\u043c: + +# Log_ReadyToRunCommands = Ready to run commands. +Log_ReadyToRunCommands = \u0413\u043e\u0442\u043e\u0432 \u043a \u0437\u0430\u043f\u0443\u0441\u043a\u0443 \u043a\u043e\u043c\u0430\u043d\u0434. + +# Log_CommandName = Running ''{0}''. +Log_CommandName = \u0412\u044b\u043f\u043e\u043b\u043d\u0435\u043d\u0438\u0435 ''{0}''. + +# Log_Command = Command: {0} +Log_Command = \u041a\u043e\u043c\u0430\u043d\u0434\u0430: {0} + +# Log_CommandSuccess = ''{0}'' was successfully executed. +Log_CommandSuccess = ''{0}'' \u0431\u044b\u043b\u0430 \u0443\u0441\u043f\u0435\u0448\u043d\u043e \u0432\u044b\u043f\u043e\u043b\u043d\u0435\u043d\u0430. + +# Log_CommandFailure = ''{0}'' returned an error status. +Log_CommandFailure = ''{0}'' \u0437\u0430\u0432\u0435\u0440\u0448\u0438\u043b\u0430\u0441\u044c \u043d\u0435\u0443\u0434\u0430\u0447\u0435\u0439. + +# Log_AllCommandsSuccess = All commands were successfully executed. +Log_AllCommandsSuccess = \u0412\u0441\u0435 \u043a\u043e\u043c\u0430\u043d\u0434\u044b \u0431\u044b\u043b\u0438 \u0443\u0441\u043f\u0435\u0448\u043d\u043e \u0432\u044b\u043f\u043e\u043b\u043d\u0435\u043d\u044b. + +# Log_OutputLogging = Output logging: +Log_OutputLogging = \u0416\u0443\u0440\u043d\u0430\u043b \u0432\u044b\u0432\u043e\u0434\u0430: + +# Log_CommandNotFound = ''{0}'' was not found in the path. Execution attempt: {1} +Log_CommandNotFound = ''{0}'' \u043d\u0435 \u043d\u0430\u0439\u0434\u0435\u043d\u0430 \u0432 \u043f\u0443\u0442\u0438. \u041f\u043e\u043f\u044b\u0442\u043a\u0430 \u0432\u044b\u043f\u043e\u043b\u043d\u0435\u043d\u0438\u044f: {1} + +# Log_DirectiveFound = Directive found in line {0} with {1}. +Log_DirectiveFound = \u0414\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u0430 \u043d\u0430\u0439\u0434\u0435\u043d\u0430 \u0432 \u0441\u0442\u0440\u043e\u043a\u0435 {0} \u0441 {1}. + +# Log_RuleFound = Task ''{0}'' found in ''{1}''. +Log_RuleFound = \u0417\u0430\u0434\u0430\u0447\u0430 ''{0}'' \u043d\u0430\u0439\u0434\u0435\u043d\u0430 \u0432 ''{1}''. + +# Log_NoDirectivesFound = No directives found in ''{0}''. +Log_NoDirectivesFound = \u041d\u0438 \u043e\u0434\u043d\u043e\u0439 \u0434\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u044b \u043d\u0435 \u043d\u0430\u0439\u0434\u0435\u043d\u043e \u0432 ''{0}''. + +# Help_Version = print the application version +Help_Version = \u043f\u043e\u043a\u0430\u0437\u0430\u0442\u044c \u0432\u0435\u0440\u0441\u0438\u044e \u043f\u0440\u0438\u043b\u043e\u0436\u0435\u043d\u0438\u044f + +# Help_Help = print the help message +Help_Help = \u043f\u043e\u043a\u0430\u0437\u0430\u0442\u044c \u0441\u043f\u0440\u0430\u0432\u043e\u0447\u043d\u043e\u0435 \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u0435 + +# Help_Log = generate a log output +Help_Log = \u0432\u0435\u0441\u0442\u0438 \u0436\u0443\u0440\u043d\u0430\u043b \u0432\u044b\u0432\u043e\u0434\u0430 + +# Help_Verbose = print the command output +Help_Verbose = \u043f\u043e\u043a\u0430\u0437\u0430\u0442\u044c \u0432\u044b\u0432\u043e\u0434 \u043a\u043e\u043c\u0430\u043d\u0434 + +# Help_Timeout = set the execution timeout (in milliseconds) +Help_Timeout = \u0443\u0441\u0442\u0430\u043d\u043e\u0432\u0438\u0442\u044c \u0432\u0440\u0435\u043c\u044f \u043e\u0436\u0438\u0434\u0430\u043d\u0438\u044f \u0432\u044b\u043f\u043e\u043b\u043d\u0435\u043d\u0438\u044f (\u0432 \u043c\u0438\u043b\u0438\u0441\u0435\u043a\u0443\u043d\u0434\u0430\u0445) + +# Help_Language = set the application language +Help_Language = \u0443\u0441\u0442\u0430\u043d\u043e\u0432\u0438\u0442\u044c \u044f\u0437\u044b\u043a \u043f\u0440\u0438\u043b\u043e\u0436\u0435\u043d\u0438\u044f + +# Header_Slogan = The cool TeX automation tool +Header_Slogan = \u041a\u0440\u0443\u0442\u043e\u0439 \u0438\u043d\u0441\u0442\u0440\u0443\u043c\u0435\u043d\u0442 \u0430\u0432\u0442\u043e\u043c\u0430\u0442\u0438\u0437\u0430\u0446\u0438\u0438 TeX + +# Header_AllRightsReserved = All rights reserved. +Header_AllRightsReserved = \u0412\u0441\u0435 \u043f\u0440\u0430\u0432\u0430 \u0437\u0430\u0449\u0438\u0449\u0435\u043d\u044b. + +# Msg_NoDirectivesFound = I didn''t find any directives in ''{0}'', and so didn''t do anything. Is that what you really wanted? +Msg_NoDirectivesFound = \u042f \u043d\u0435 \u043c\u043e\u0433\u0443 \u043d\u0430\u0439\u0442\u0438 \u043d\u0438 \u043e\u0434\u043d\u043e\u0439 \u0434\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u044b \u0432 ''{0}'', \u0438 \u043f\u043e\u044d\u0442\u043e\u043c\u0443 \u043d\u0435 \u043c\u043e\u0433\u0443 \u043d\u0438\u0447\u0435\u0433\u043e \u0432\u044b\u043f\u043e\u043b\u043d\u0438\u0442\u044c. \u042d\u0442\u043e \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u0442\u0435\u043b\u044c\u043d\u043e \u0442\u043e, \u0447\u0442\u043e \u0432\u044b \u0445\u043e\u0442\u0435\u043b\u0438? + +# Msg_SpecialThanks = A special thanks goes to Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz, and many others for making this humble tool possible. +Msg_SpecialThanks = \u041e\u0441\u043e\u0431\u0430\u044f \u0431\u043b\u0430\u0433\u043e\u0434\u0430\u0440\u043d\u043e\u0441\u0442\u044c \u0432\u044b\u0440\u0430\u0436\u0430\u0435\u0442\u0441\u044f Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz \u0438 \u043c\u043d\u043e\u0433\u0438\u043c \u0434\u0440\u0443\u0433\u0438\u043c, \u0431\u043b\u0430\u0433\u043e\u0434\u0430\u0440\u044f \u043a\u043e\u043c\u0443 \u0441\u0442\u0430\u043b\u043e \u0432\u043e\u0437\u043c\u043e\u0436\u043d\u044b\u043c \u0441\u043e\u0437\u0434\u0430\u043d\u0438\u0435 \u044d\u0442\u043e\u0433\u043e \u0441\u043a\u0440\u043e\u043c\u043d\u043e\u0433\u043e \u0438\u043d\u0441\u0442\u0440\u0443\u043c\u0435\u043d\u0442\u0430. + +# Msg_RunningCommand = Running {0}... +Msg_RunningCommand = \u0412\u044b\u043f\u043e\u043b\u043d\u0435\u043d\u0438\u0435 {0}... + +# Msg_Success = SUCCESS +Msg_Success = \u0423\u0421\u041f\u0415\u0428\u041d\u041e + +# Msg_Failure = FAILURE +Msg_Failure = \u041d\u0415\u0423\u0414\u0410\u0427\u0410 + +# Msg_Status = Status: +Msg_Status = \u0421\u0442\u0430\u0442\u0443\u0441: + +# YamlError_Context = Context: {0} +YamlError_Context = \u041a\u043e\u043d\u0442\u0435\u043a\u0441\u0442: {0} + +# YamlError_Problem = Problem: {0} +YamlError_Problem = \u041f\u0440\u043e\u0431\u043b\u0435\u043c\u0430: {0} + +# YamlError_ErrorLocation = Error found in line {0}, column {1}. +YamlError_ErrorLocation = \u041e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0441\u0442\u0440\u043e\u043a\u0435 {0} \u043f\u043e\u0437\u0438\u0446\u0438\u0438 {1}. + +# Error_FileDoesNotExistWithExtensionsList = I''m sorry, but the file ''{0} {1}'' does not exist. Note that when you provide only the basename (i.e, the filename without the extension) or with an unknown extension, arara will try to look for files ending with the predefined extensions {1} in that order. You can override the order, the search pattern or even add support for new extensions through the configuration file. Please refer to the arara manual to learn more about this feature. +Error_FileDoesNotExistWithExtensionsList = \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u0444\u0430\u0439\u043b ''{0} {1}'' \u043d\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442. \u041e\u0431\u0440\u0430\u0442\u0438\u0442\u0435 \u0432\u043d\u0438\u043c\u0430\u043d\u0438\u0435, \u0447\u0442\u043e \u043a\u043e\u0433\u0434\u0430 \u0432\u044b \u0443\u043a\u0430\u0437\u044b\u0432\u0430\u0435\u0442\u0435 \u0442\u043e\u043b\u044c\u043a\u043e \u0431\u0430\u0437\u043e\u0432\u043e\u0435 \u0438\u043c\u044f (\u0442.\u0435., \u0438\u043c\u044f \u0444\u0430\u0439\u043b\u0430 \u0431\u0435\u0437 \u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043d\u0438\u044f) \u0438\u043b\u0438 \u0438\u043c\u044f \u0441 \u043d\u0435\u0438\u0437\u0432\u0435\u0441\u0442\u043d\u044b\u043c \u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043d\u0438\u0435\u043c, arara \u043f\u044b\u0442\u0430\u0435\u0442\u0441\u044f \u043d\u0430\u0439\u0442\u0438 \u0444\u0430\u0439\u043b\u044b \u0441 \u043f\u0440\u0435\u0434\u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0435\u043d\u043d\u044b\u043c\u0438 \u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043d\u0438\u044f\u043c\u0438 {1} \u0432 \u044d\u0442\u043e\u043c \u043f\u043e\u0440\u044f\u0434\u043a\u0435. \u0412\u044b \u043c\u043e\u0436\u0435\u0442\u0435 \u043f\u0435\u0440\u0435\u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0438\u0442\u044c \u043f\u043e\u0440\u044f\u0434\u043e\u043a, \u043e\u0431\u0440\u0430\u0437\u0435\u0446 \u043f\u043e\u0438\u0441\u043a\u0430 \u0438\u043b\u0438 \u0434\u0430\u0436\u0435 \u0434\u043e\u0431\u0430\u0432\u0438\u0442\u044c \u043f\u043e\u0434\u0434\u0435\u0440\u0436\u043a\u0443 \u043d\u043e\u0432\u044b\u0445 \u0440\u0430\u0441\u0449\u0438\u0440\u0435\u043d\u0438\u0439 \u0447\u0435\u0440\u0435\u0437 \u0444\u0430\u0439\u043b \u043a\u043e\u043d\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u0438. \u041f\u043e\u0436\u0430\u043b\u0443\u0439\u0441\u0442\u0430, \u043e\u0431\u0440\u0430\u0442\u0438\u0442\u0435\u0441\u044c \u043a \u0440\u0443\u043a\u043e\u0432\u043e\u0434\u0441\u0442\u0432\u0443 arara, \u0447\u0442\u043e \u0431\u044b \u0443\u0437\u043d\u0430\u0442\u044c \u0431\u043e\u043b\u044c\u0448\u0435 \u043e\u0431 \u044d\u0442\u043e\u0439 \u0432\u043e\u0437\u043c\u043e\u0436\u043d\u043e\u0441\u0442\u0438. + +# Error_FileDoesNotExist = File ''{0}'' does not exist. +Error_FileDoesNotExist = \u0424\u0430\u0439\u043b ''{0}'' \u043d\u0435 \u0441\u0443\u0449\u0435\u0441\u0442\u0432\u0443\u0435\u0442. + +# Error_CommandNotFound = \nI''m sorry, but the command from the ''{0}'' task could not be found. Are you sure the command ''{1}'' is correct, or even accessible from the system path? +Error_CommandNotFound = = \n\u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u043a\u043e\u043c\u0430\u043d\u0434\u0430 \u0438\u0437 \u0437\u0430\u0434\u0430\u0447\u0438 ''{0}'' \u043d\u0435 \u043d\u0430\u0439\u0434\u0435\u043d\u0430. \u0412\u044b \u0443\u0432\u0435\u0440\u0435\u043d\u044b, \u0447\u0442\u043e \u043a\u043e\u043c\u0430\u043d\u0434\u0430 ''{1}'' \u043a\u043e\u0440\u0440\u0435\u043a\u0442\u043d\u0430 \u0438\u043b\u0438 \u0436\u0435 \u0434\u043e\u0441\u0442\u0443\u043f\u043d\u0430 \u0438\u0437 \u0441\u0438\u0441\u0442\u0435\u043c\u043d\u043e\u0433\u043e \u043f\u0443\u0442\u0438? + +# Error_InvalidYAMLConfigurationFile = I'm sorry, but apparently your arara configuration file is invalid, that is, it has invalid or missing YAML entries. Unfortunately, arara cannot proceed until the error is fixed. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLConfigurationFile = \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u0432\u0430\u0448 \u0444\u0430\u0439\u043b \u043a\u043e\u043d\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u0438 arara, \u043f\u043e \u0432\u0441\u0435\u0439 \u0432\u0438\u0434\u0438\u043c\u043e\u0441\u0442\u0438, \u043d\u0435\u0432\u0435\u0440\u0435\u043d, \u0442\u043e \u0435\u0441\u0442\u044c \u0432 \u043d\u0435\u043c \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u0441\u044f \u043d\u0435\u0434\u043e\u043f\u0443\u0441\u0442\u0438\u043c\u044b\u0435 \u0438\u043b\u0438 \u043f\u0440\u043e\u043f\u0443\u0449\u0435\u043d\u043d\u044b\u0435 \u0437\u0430\u043f\u0438\u0441\u0438 YAML. \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, arara \u043d\u0435 \u043c\u043e\u0436\u0435\u0442 \u043f\u0440\u043e\u0434\u043e\u043b\u0436\u0438\u0442\u044c \u0440\u0430\u0431\u043e\u0442\u0443, \u043f\u043e\u043a\u0430 \u043e\u0448\u0438\u0431\u043a\u0430 \u043d\u0435 \u0431\u0443\u0434\u0435\u0442 \u0438\u0441\u043f\u0440\u0430\u0432\u043b\u0435\u043d\u0430\u200b\u200b. \u042f \u0441\u0442\u0430\u0440\u0430\u043b\u0441\u044f \u0438\u0437\u043e \u0432\u0441\u0435\u0445 \u0441\u0438\u043b, \u0447\u0442\u043e\u0431\u044b \u043f\u043e\u043b\u0443\u0447\u0438\u0442\u044c \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u0435 \u043e\u0431 \u043e\u0448\u0438\u0431\u043a\u0435, \u0438\u0442\u0430\u043a, \u0432\u043e\u0442 \u043e\u043d\u043e: + +# Error_InvalidConfigurationFile = Uh-oh, the configuration file appears to be invalid. Are you sure it's a proper YAML file? Unfortunately, arara cannot proceed until a proper configuration file is provided. +Error_InvalidConfigurationFile = \u041e\u0439-\u043e\u0439, \u043a\u043e\u043d\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u043e\u043d\u043d\u044b\u0439 \u0444\u0430\u0439\u043b, \u043a\u0430\u0436\u0435\u0442\u0441\u044f, \u043d\u0435\u0432\u0435\u0440\u0435\u043d. \u0412\u044b \u0443\u0432\u0435\u0440\u0435\u043d\u044b, \u0447\u0442\u043e \u044d\u0442\u043e \u043f\u0440\u0430\u0432\u0438\u043b\u044c\u043d\u044b\u0439 \u0444\u0430\u0439\u043b YAML? \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, arara \u043d\u0435 \u043c\u043e\u0436\u0435\u0442 \u043f\u0440\u043e\u0434\u043e\u043b\u0436\u0438\u0442\u044c \u0440\u0430\u0431\u043e\u0442\u0443, \u043f\u043e\u043a\u0430 \u043d\u0435 \u0431\u0443\u0434\u0435\u0442 \u043f\u0440\u0435\u0434\u043e\u0441\u0442\u0430\u0432\u043b\u0435\u043d \u043a\u043e\u0440\u0440\u0435\u043a\u0442\u043d\u044b\u0439 \u0444\u0430\u0439\u043b \u043a\u043e\u043d\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u0438. + +# Error_InvalidLanguageConfigurationFile = Houston, we have a problem. Sadly, the language set in the configuration file is not valid. Currently, arara can provide support for the following languages: {0}. Make sure to choose a valid language or remove the entry from the configuration file (the field is optional), otherwise arara cannot proceed. +Error_InvalidLanguageConfigurationFile = \u0425\u044c\u044e\u0441\u0442\u043e\u043d, \u0443 \u043d\u0430\u0441 \u043f\u0440\u043e\u0431\u043b\u0435\u043c\u0430. \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u044f\u0437\u044b\u043a, \u0443\u0441\u0442\u0430\u043d\u043e\u0432\u043b\u0435\u043d\u043d\u044b\u0439 \u0432 \u0444\u0430\u0439\u043b\u0435 \u043a\u043e\u043d\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u0438 \u043d\u0435 \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u0434\u043e\u043f\u0443\u0441\u0442\u0438\u043c\u044b\u043c. \u0412 \u043d\u0430\u0441\u0442\u043e\u044f\u0449\u0435\u0435 \u0432\u0440\u0435\u043c\u044f arara \u043c\u043e\u0436\u0435\u0442 \u043f\u0440\u0435\u0434\u043e\u0441\u0442\u0430\u0432\u0438\u0442\u044c \u043f\u043e\u0434\u0434\u0435\u0440\u0436\u043a\u0443 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0445 \u044f\u0437\u044b\u043a\u043e\u0432: {0}. \u0423\u0434\u043e\u0441\u0442\u043e\u0432\u0435\u0440\u044c\u0442\u0435\u0441\u044c, \u0447\u0442\u043e \u0432\u044b\u0431\u0440\u0430\u043d \u0434\u043e\u043f\u0443\u0441\u0442\u0438\u043c\u044b\u0439 \u044f\u0437\u044b\u043a \u0438\u043b\u0438 \u0437\u0430\u043f\u0438\u0441\u044c \u0443\u0434\u0430\u043b\u0435\u043d\u0430 \u0438\u0437 \u043a\u043e\u043d\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u043e\u043d\u043d\u043e\u0433\u043e \u0444\u0430\u0439\u043b\u0430 (\u043f\u043e\u043b\u0435 \u043d\u0435 \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u043e\u0431\u044f\u0437\u0430\u0442\u0435\u043b\u044c\u043d\u044b\u043c), \u0432 \u043f\u0440\u043e\u0442\u0438\u0432\u043d\u043e\u043c \u0441\u043b\u0443\u0447\u0430\u0435 arara \u043d\u0435 \u0441\u043c\u043e\u0436\u0435\u0442 \u043f\u0440\u043e\u0434\u043e\u043b\u0436\u0438\u0442\u044c \u0440\u0430\u0431\u043e\u0442\u0443. + +# Error_InvalidFiletypesConfigurationFile = I'm sorry, but it seems your configuration file has customized filetypes with neither the extension or pattern defined. Both are required in order to continue. Please fix this error in your configuration file and try again. +Error_InvalidFiletypesConfigurationFile = \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u0432\u0438\u0434\u0438\u043c\u043e, \u0432 \u0432\u0430\u0448\u0435\u043c \u0444\u0430\u0439\u043b\u0435 \u043a\u043e\u043d\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u0438 \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u0441\u044f \u0441\u043f\u0435\u0446\u0438\u0430\u043b\u0438\u0437\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u0435 \u0442\u0438\u043f\u044b \u0444\u0430\u0439\u043b\u043e\u0432 \u0431\u0435\u0437 \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0435\u043d\u0438\u044f \u0440\u0430\u0441\u0448\u0438\u0440\u0435\u043d\u0438\u044f \u0438 \u043e\u0431\u0440\u0430\u0437\u0446\u0430. \u0418 \u0442\u043e \u0438 \u0434\u0440\u0443\u0433\u043e\u0435 \u043d\u0435\u043e\u0431\u0445\u043e\u0434\u0438\u043c\u043e \u0434\u043b\u044f \u043f\u0440\u043e\u0434\u043e\u043b\u0436\u0435\u043d\u0438\u044f \u0440\u0430\u0431\u043e\u0442\u044b. \u041f\u043e\u0436\u0430\u043b\u0443\u0439\u0441\u0442\u0430, \u0438\u0441\u043f\u0440\u0430\u0432\u044c\u0442\u0435 \u044d\u0442\u0443 \u043e\u0448\u0438\u0431\u043a\u0443 \u0432 \u0432\u0430\u0448\u0435\u043c \u0444\u0430\u0439\u043b\u0435 \u043a\u043e\u043d\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u0438 \u0438 \u043f\u043e\u0432\u0442\u043e\u0440\u0438\u0442\u0435 \u043f\u043e\u043f\u044b\u0442\u043a\u0443. + +# Error_PathRuntimeErrorConfigurationFile = I''m sorry, but one of the entries of the search path in your configuration file has an unavailable variable in the path context: ''{0}'' +Error_PathRuntimeErrorConfigurationFile = \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u043e\u0434\u0438\u043d \u0438\u0437 \u044d\u043b\u0435\u043c\u0435\u043d\u0442\u043e\u0432 \u043f\u0443\u0442\u0438 \u043f\u043e\u0438\u0441\u043a\u0430 \u0432 \u0432\u0430\u0448\u0435\u043c \u0444\u0430\u0439\u043b\u0435 \u043a\u043e\u043d\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u0438 \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043d\u0435\u0434\u043e\u0441\u0442\u0443\u043f\u043d\u0443\u044e \u043f\u0435\u0440\u0435\u043c\u0435\u043d\u043d\u0443\u044e \u0432 \u043a\u043e\u043d\u0442\u0435\u043a\u0441\u0442\u0435 \u043f\u0443\u0442\u0438: ''{0}'' + +# Error_PathIOErrorConfigurationFile = I'm sorry, but one of the entries of the search path in your configuration file has a malformed directory structure. Could you take a look at it? +Error_PathIOErrorConfigurationFile = \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u043e\u0434\u0438\u043d \u0438\u0437 \u044d\u043b\u0435\u043c\u0435\u043d\u0442\u043e\u0432 \u043f\u0443\u0442\u0438 \u043f\u043e\u0438\u0441\u043a\u0430 \u0432 \u0432\u0430\u0448\u0435\u043c \u0444\u0430\u0439\u043b\u0435 \u043a\u043e\u043d\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u0438 \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043d\u0435\u043f\u0440\u0430\u0432\u0438\u043b\u044c\u043d\u0443\u044e \u0441\u0442\u0440\u0443\u043a\u0442\u0443\u0440\u0443 \u043a\u0430\u0442\u0430\u043b\u043e\u0433\u043e\u0432. \u041d\u0435 \u043c\u043e\u0433\u043b\u0438 \u0431\u044b \u0432\u044b \u0432\u0437\u0433\u043b\u044f\u043d\u0443\u0442\u044c \u043d\u0430 \u044d\u0442\u043e? + +# Error_InvalidYAMLDirective = It appears there is a malformed directive found at line {0}, that is, a directive that might have a YAML syntax error or an invalid field. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLDirective = \u041f\u043e\u0445\u043e\u0436\u0435, \u0432 \u0441\u0442\u0440\u043e\u043a\u0435 {0} \u043d\u0430\u0439\u0434\u0435\u043d\u0430 \u043d\u0435\u043a\u043e\u0440\u0440\u0435\u043a\u0442\u043d\u0430\u044f \u0434\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u0430, \u044d\u0442\u043e \u0437\u043d\u0430\u0447\u0438\u0442, \u0447\u0442\u043e \u0434\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u0430 \u043c\u043e\u0436\u0435\u0442 \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u044c \u0441\u0438\u043d\u0442\u0430\u043a\u0441\u0438\u0447\u0435\u0441\u043a\u0443\u044e \u043e\u0448\u0438\u0431\u043a\u0443 YAML \u0438\u043b\u0438 \u043d\u0435\u0432\u0435\u0440\u043d\u043e\u0435 \u043f\u043e\u043b\u0435. \u042f \u0441\u0442\u0430\u0440\u0430\u043b\u0441\u044f \u0438\u0437\u043e \u0432\u0441\u0435\u0445 \u0441\u0438\u043b, \u0447\u0442\u043e\u0431\u044b \u043f\u043e\u043b\u0443\u0447\u0438\u0442\u044c \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u0435 \u043e\u0431 \u043e\u0448\u0438\u0431\u043a\u0435, \u0438\u0442\u0430\u043a, \u0432\u043e\u0442 \u043e\u043d\u043e: + +# Error_DirectiveEmptyCurlyBrackets = Directive ''{0}'' at line {1} has empty curly brackets. Note that arara opts for a cleaner syntax when a directive has no parameters. To fix it, it''s enough to either remove the curly brackets or provide the arguments for the directive. +Error_DirectiveEmptyCurlyBrackets = \u0414\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u0430 ''{0}'' \u0432 \u0441\u0442\u0440\u043e\u043a\u0435 {1} \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043f\u0443\u0441\u0442\u044b\u0435 \u0444\u0438\u0433\u0443\u0440\u043d\u044b\u0435 \u0441\u043a\u043e\u0431\u043a\u0438. \u041e\u0431\u0440\u0430\u0442\u0438\u0442\u0435 \u0432\u043d\u0438\u043c\u0430\u043d\u0438\u0435 \u043d\u0430 \u0442\u043e, \u0447\u0442\u043e arara \u0432\u044b\u0431\u0438\u0440\u0430\u0435\u0442 \u0431\u043e\u043b\u0435\u0435 \u043f\u0440\u043e\u0441\u0442\u043e\u0439 \u0441\u0438\u043d\u0442\u0430\u043a\u0441\u0438\u0441, \u043a\u043e\u0433\u0434\u0430 \u0443 \u0434\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u044b \u043e\u0442\u0441\u0443\u0442\u0441\u0442\u0432\u0443\u044e\u0442 \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u044b. \u0427\u0442\u043e\u0431\u044b \u0438\u0441\u043f\u0440\u0430\u0432\u0438\u0442\u044c \u044d\u0442\u043e, \u0434\u043e\u0441\u0442\u0430\u0442\u043e\u0447\u043d\u043e \u043b\u0438\u0431\u043e \u0443\u0434\u0430\u043b\u0438\u0442\u044c \u0444\u0438\u0433\u0443\u0440\u043d\u044b\u0435 \u0441\u043a\u043e\u0431\u043a\u0438, \u043b\u0438\u0431\u043e \u043f\u0440\u0435\u0434\u043e\u0441\u0442\u0430\u0432\u0438\u0442\u044c \u0434\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u0435 \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u044b. + +# Error_DirectiveInvalidArgumentList = Directive ''{0}'' at line {1} has an invalid argument type. The argument ''{2}'' is a reserved arara keyword and always requires a list. +Error_DirectiveInvalidArgumentList = \u0414\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u0430 ''{0}'' \u0432 \u0441\u0442\u0440\u043e\u043a\u0435 {1} \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043d\u0435\u0432\u0435\u0440\u043d\u044b\u0439 \u0442\u0438\u043f \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u0430. \u0410\u0440\u0433\u0443\u043c\u0435\u043d\u0442 ''{2}'' \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u0437\u0430\u0440\u0435\u0437\u0435\u0440\u0432\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u043c \u043a\u043b\u044e\u0447\u0435\u0432\u044b\u043c \u0441\u043b\u043e\u0432\u043e\u043c arara \u0438 \u0432\u0441\u0435\u0433\u0434\u0430 \u0434\u043e\u043b\u0436\u0435\u043d \u0431\u044b\u0442\u044c \u0441\u043f\u0438\u0441\u043a\u043e\u043c. + +# Error_DirectiveReservedKeyword = Directive ''{0}'' at line {1} has an invalid argument name. The name ''{2}'' is a reserved arara keyword representing every element in the ''{3}'' list. Please, pick another name for that argument. +Error_DirectiveReservedKeyword = \u0414\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u0430 ''{0}'' \u0432 \u0441\u0442\u0440\u043e\u043a\u0435 {1} \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043d\u0435\u0432\u0435\u0440\u043d\u043e\u0435 \u0438\u043c\u044f \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u0430. \u0418\u043c\u044f ''{2}'' \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u0437\u0430\u0440\u0435\u0437\u0435\u0440\u0432\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u043c \u043a\u043b\u044e\u0447\u0435\u0432\u044b\u043c \u0441\u043b\u043e\u0432\u043e\u043c arara, \u043f\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043b\u044f\u044e\u0449\u0435\u0435 \u044d\u043b\u0435\u043c\u0435\u043d\u0442 \u0432 \u0441\u043f\u0438\u0441\u043a\u0435 ''{3}''. \u041f\u043e\u0436\u0430\u043b\u0443\u0439\u0441\u0442\u0430, \u0432\u044b\u0431\u0435\u0440\u0438\u0442\u0435 \u0434\u0440\u0443\u0433\u043e\u0435 \u0438\u043c\u044f \u0434\u043b\u044f \u044d\u0442\u043e\u0433\u043e \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u0430. + +# Error_DirectiveListError = Directive ''{0}'' at line {1} has an invalid argument type. Only the arguments ''files'' and ''items'' can have a list. Both are reserved arara keywords. +Error_DirectiveListError = \u0414\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u0430 ''{0}'' \u0432 \u0441\u0442\u0440\u043e\u043a\u0435 {1} \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043d\u0435\u0432\u0435\u0440\u043d\u044b\u0439 \u0442\u0438\u043f \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u0430. \u0422\u043e\u043b\u044c\u043a\u043e \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u044b ''files'' \u0438 ''items'' \u043c\u043e\u0433\u0443\u0442 \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u0442\u044c \u0441\u043f\u0438\u0441\u043a\u0438. \u041e\u0431\u0430 \u044f\u0432\u043b\u044f\u044e\u0442\u0441\u044f \u0437\u0430\u0440\u0435\u0437\u0435\u0440\u0432\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u043c\u0438 \u043a\u043b\u044e\u0447\u0435\u0432\u044b\u043c\u0438 \u0441\u043b\u043e\u0432\u043e\u043c\u0438 arara. + +# Error_InvalidDirective = Apparently, there''s an invalid directive at line {0}. Please take a look and fix it. +Error_InvalidDirective = \u0412\u0438\u0434\u0438\u043c\u043e, \u0432 \u0441\u0442\u0440\u043e\u043a\u0435 {0} \u043d\u0435\u0432\u0435\u0440\u043d\u0430\u044f \u0434\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u0430. \u041f\u043e\u0436\u0430\u043b\u0443\u0439\u0441\u0442\u0430, \u043e\u0431\u0440\u0430\u0442\u0438\u0442\u0435 \u0432\u043d\u0438\u043c\u0430\u043d\u0438\u0435 \u0438 \u0438\u0441\u043f\u0440\u0430\u0432\u044c\u0442\u0435 \u0435\u0435. + +# Error_DirectiveGenericError = Directive ''{0}'' at line {1} seems to be malformed. It might be a YAML syntax error or a wrong mapping. +Error_DirectiveGenericError = \u0414\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u0430 ''{0}'' \u0432 \u0441\u0442\u0440\u043e\u043a\u0435 {1}, \u043a\u0430\u0436\u0435\u0442\u0441\u044f, \u0438\u043c\u0435\u0435\u0442 \u043d\u0435\u0432\u0435\u0440\u043d\u044b\u0439 \u0444\u043e\u0440\u043c\u0430\u0442. \u042d\u0442\u043e \u043c\u043e\u0436\u0435\u0442 \u0431\u044b\u0442\u044c \u0441\u043b\u0435\u0434\u0441\u0442\u0432\u0438\u0435\u043c \u0441\u0438\u043d\u0442\u0430\u043a\u0441\u0438\u0447\u0435\u0441\u043a\u043e\u0439 \u043e\u0448\u0438\u0431\u043a\u0438 YAML \u0438\u043b\u0438 \u043d\u0435\u043f\u0440\u0430\u0432\u0438\u043b\u044c\u043d\u043e\u0433\u043e \u043e\u0442\u043e\u0431\u0440\u0430\u0436\u0435\u043d\u0438\u044f. + +# Error_InvalidLanguage = I'm sorry, but the language code you chose is invalid. Currently, the following languages are supported: +Error_InvalidLanguage = \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u0432\u044b\u0431\u0440\u0430\u043d\u043d\u044b\u0439 \u0432\u0430\u043c\u0438 \u043a\u043e\u0434 \u044f\u0437\u044b\u043a\u0430 \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u043d\u0435\u0432\u0435\u0440\u043d\u044b\u043c. \u0412 \u043d\u0430\u0441\u0442\u043e\u044f\u0449\u0435\u0435 \u0432\u0440\u0435\u043c\u044f \u043f\u043e\u0434\u0434\u0435\u0440\u0436\u0438\u0432\u0430\u044e\u0442\u0441\u044f \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0435 \u044f\u0437\u044b\u043a\u0438: + +# Error_RuleNotFound = Uh-oh, I could not find the ''{0}'' rule in the search path. Could you take a look if the rule name is correct and if the rule is accessible through the search path? +Error_RuleNotFound = \u041e\u0439-\u043e\u0439, \u044f \u043d\u0435 \u0441\u043c\u043e\u0433 \u043d\u0430\u0439\u0442\u0438 ''{0}'' \u043f\u0440\u0430\u0432\u0438\u043b\u043e \u0432 \u043a\u0430\u0442\u0430\u043b\u043e\u0433\u0435 \u043f\u043e\u0438\u0441\u043a\u0430. \u041d\u0435 \u043c\u043e\u0433\u043b\u0438 \u0431\u044b \u0432\u044b \u043f\u0440\u043e\u0432\u0435\u0440\u0438\u0442\u044c, \u0432\u0435\u0440\u043d\u043e \u043b\u0438 \u0437\u0430\u0434\u0430\u043d\u043e \u0438\u043c\u044f \u043f\u0440\u0430\u0432\u0438\u043b\u0430 \u0438 \u0434\u043e\u0441\u0442\u0443\u043f\u043d\u043e \u043b\u0438 \u043e\u043d\u043e \u0432 \u043a\u0430\u0442\u0430\u043b\u043e\u0433\u0435 \u043f\u043e\u0438\u0441\u043a\u0430? + +# Error_InvalidYAMLRule = It appears that the ''{0}'' task has a YAML syntax error or an invalid field. Could you take a look at the ''{0}.yaml'' file located at ''{1}''. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLRule = \u041f\u043e\u0445\u043e\u0436\u0435, \u0437\u0430\u0434\u0430\u0447\u0430 ''{0}'' \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u0441\u0438\u043d\u0442\u0430\u043a\u0441\u0438\u0447\u0435\u0441\u043a\u0443\u044e \u043e\u0448\u0438\u0431\u043a\u0443 YAML \u0438\u043b\u0438 \u043d\u0435\u0432\u0435\u0440\u043d\u043e\u0435 \u043f\u043e\u043b\u0435. \u041d\u0435 \u043c\u043e\u0433\u043b\u0438 \u0431\u044b \u0432\u044b \u0432\u0437\u0433\u043b\u044f\u043d\u0443\u0442\u044c \u043d\u0430 \u0444\u0430\u0439\u043b ''{0}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u044b\u0439 \u0432 ''{1}''. \u042f \u0441\u0442\u0430\u0440\u0430\u043b\u0441\u044f \u0438\u0437\u043e \u0432\u0441\u0435\u0445 \u0441\u0438\u043b, \u0447\u0442\u043e\u0431\u044b \u043f\u043e\u043b\u0443\u0447\u0438\u0442\u044c \u0441\u043e\u043e\u0431\u0449\u0435\u043d\u0438\u0435 \u043e\u0431 \u043e\u0448\u0438\u0431\u043a\u0435, \u0438\u0442\u0430\u043a, \u0432\u043e\u0442 \u043e\u043d\u043e: + +# Error_InvalidRule = Uh-oh, the ''{0}'' task appears to be invalid. Are you sure the ''{0}.yaml'' file located at ''{1}'' is a proper YAML file? +Error_InvalidRule = \u041e\u0439-\u043e\u0439, \u043f\u043e\u0445\u043e\u0436\u0435, \u0437\u0430\u0434\u0430\u0447\u0430 ''{0}'' \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u043d\u0435\u0432\u0435\u0440\u043d\u043e\u0439. \u0412\u044b \u0443\u0432\u0435\u0440\u0435\u043d\u044b, \u0447\u0442\u043e \u0444\u0430\u0439\u043b ''{0}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u044b\u0439 \u0432 ''{1}'', \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u043f\u0440\u0430\u0432\u0438\u043b\u044c\u043d\u044b\u043c YAML \u0444\u0430\u0439\u043b\u043e\u043c? + +# Error_EmptyIdentifierRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid identifier. Could you fix it? +Error_EmptyIdentifierRule = \u0412 \u0437\u0430\u0434\u0430\u0447\u0435 ''{0}'' \u0431\u044b\u043b\u0430 \u043e\u0431\u043d\u0430\u0440\u0443\u0436\u0435\u043d\u0430 \u043f\u0440\u043e\u0431\u043b\u0435\u043c\u0430. \u0412 \u0444\u0430\u0439\u043b\u0435 ''{0}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u043e\u043c \u0432 ''{1}'', \u0442\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044f \u0432\u0435\u0440\u043d\u044b\u0439 \u0438\u0434\u0435\u043d\u0442\u0438\u0444\u0438\u043a\u0430\u0442\u043e\u0440. \u041d\u0435 \u043c\u043e\u0433\u043b\u0438 \u0431\u044b \u0432\u044b \u044d\u0442\u043e \u0438\u0441\u043f\u0440\u0430\u0432\u0438\u0442\u044c? + +# Error_EmptyNameRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid name. Could you fix it? +Error_EmptyNameRule = \u0412 \u0437\u0430\u0434\u0430\u0447\u0435 ''{0}'' \u0431\u044b\u043b\u0430 \u043e\u0431\u043d\u0430\u0440\u0443\u0436\u0435\u043d\u0430 \u043f\u0440\u043e\u0431\u043b\u0435\u043c\u0430. \u0412 \u0444\u0430\u0439\u043b\u0435 ''{0}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u043e\u043c \u0432 ''{1}'', \u0442\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044f \u0432\u0435\u0440\u043d\u043e\u0435 \u0438\u043c\u044f. \u041d\u0435 \u043c\u043e\u0433\u043b\u0438 \u0431\u044b \u0432\u044b \u044d\u0442\u043e \u0438\u0441\u043f\u0440\u0430\u0432\u0438\u0442\u044c? + +# Error_ForbiddenIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an invalid argument identifier. ''{2}'' is a reserved keyword, so it cannot be used. Could you use another name? +Error_ForbiddenIdentifierRule = \u041e\u0439-\u043e\u0439, \u0432 \u0437\u0430\u0434\u0430\u0447\u0435 ''{0}'' (\u0441\u0441\u044b\u043b\u0430\u044e\u0449\u0435\u0439\u0441\u044f \u043d\u0430 \u0444\u0430\u0439\u043b ''{0}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u044b\u0439 \u0432 ''{1}'') \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442\u0441\u044f \u043d\u0435\u043f\u0440\u0430\u0432\u0438\u043b\u044c\u043d\u044b\u0439 \u0438\u0434\u0435\u043d\u0442\u0438\u0444\u0438\u043a\u0430\u0442\u043e\u0440 \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u0430. \u0418\u0434\u0435\u043d\u0442\u0438\u0444\u0438\u043a\u0430\u0442\u043e\u0440 ''{2}'' \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f \u0437\u0430\u0440\u0435\u0437\u0435\u0440\u0432\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u044b\u043c \u043a\u043b\u044e\u0447\u0435\u0432\u044b\u043c \u0441\u043b\u043e\u0432\u043e\u043c, \u043f\u043e\u044d\u0442\u043e\u043c\u0443 \u043d\u0435 \u043c\u043e\u0436\u0435\u0442 \u0431\u044b\u0442\u044c \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u043d. \u041d\u0435 \u043c\u043e\u0433\u043b\u0438 \u0431\u044b \u0432\u044b \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u044c \u0434\u0440\u0443\u0433\u043e\u0435 \u0438\u043c\u044f? + +# Error_EmptyArgumentsListRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid list of arguments. Could you fix it? Note that the list of arguments can also be empty, but it is still necessary to define it explicitly (with ''arguments: []''). +Error_EmptyArgumentsListRule = \u0412 \u0437\u0430\u0434\u0430\u0447\u0435 ''{0}'' \u0431\u044b\u043b\u0430 \u043e\u0431\u043d\u0430\u0440\u0443\u0436\u0435\u043d\u0430 \u043f\u0440\u043e\u0431\u043b\u0435\u043c\u0430. \u0412 \u0444\u0430\u0439\u043b\u0435 ''{0}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u043e\u043c \u0432 ''{1}'', \u0442\u0440\u0435\u0431\u0443\u0435\u0442\u0441\u044f \u0432\u0435\u0440\u043d\u044b\u0439 \u0441\u043f\u0438\u0441\u043e\u043a \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u043e\u0432. \u041d\u0435 \u043c\u043e\u0433\u043b\u0438 \u0431\u044b \u0432\u044b \u044d\u0442\u043e \u0438\u0441\u043f\u0440\u0430\u0432\u0438\u0442\u044c? \u041e\u0431\u0440\u0430\u0442\u0438\u0442\u0435 \u0432\u043d\u0438\u043c\u0430\u043d\u0438\u0435, \u0447\u0442\u043e \u0441\u043f\u0438\u0441\u043e\u043a \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u043e\u0432 \u0442\u0430\u043a\u0436\u0435 \u043c\u043e\u0436\u0435\u0442 \u0431\u044b\u0442\u044c \u043f\u0443\u0441\u0442\u044b\u043c, \u043d\u043e \u0434\u043b\u044f \u044d\u0442\u043e\u0433\u043e \u043d\u0435\u043e\u0431\u0445\u043e\u0434\u0438\u043c\u043e \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0438\u0442\u044c \u0435\u0433\u043e \u044f\u0432\u043d\u043e (\u0441 \u043f\u043e\u043c\u043e\u0449\u044c\u044e ''arguments: []''). + +# Error_WrongIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has the wrong identifier - ''{0}'' was expected, rather than ''{2}''. Could you fix it? +Error_WrongIdentifierRule = \u041e\u0439-\u043e\u0439, \u0432 \u0437\u0430\u0434\u0430\u0447\u0435 ''{0}'' (\u0441\u0441\u044b\u043b\u0430\u044e\u0449\u0435\u0439\u0441\u044f \u043d\u0430 \u0444\u0430\u0439\u043b ''{0}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u044b\u0439 \u0432 ''{1}'') \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442\u0441\u044f \u043d\u0435\u043f\u0440\u0430\u0432\u0438\u043b\u044c\u043d\u044b\u0439 \u0438\u0434\u0435\u043d\u0442\u0438\u0444\u0438\u043a\u0430\u0442\u043e\u0440 - ''{0}'' \u043e\u0436\u0438\u0434\u0430\u043b\u043e\u0441\u044c, \u0430 \u043d\u0435 ''{2}''. \u041d\u0435 \u043c\u043e\u0433\u043b\u0438 \u0431\u044b \u0432\u044b \u044d\u0442\u043e \u0438\u0441\u043f\u0440\u0430\u0432\u0438\u0442\u044c? + +# Error_ArgumentsNotDefinedInRule = Oh no, there are arguments used in the diretive ''{0}'' which are not defined in the ''{0}.yaml'' rule located at ''{1}''. You can either remove them from the ''{0}'' directive or add them to the list of arguments in the ''{0}.yaml'' rule. Here they are: {2} +Error_ArgumentsNotDefinedInRule = \u041e \u043d\u0435\u0442, \u043d\u0435\u043a\u043e\u0442\u043e\u0440\u044b\u0435 \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u044b, \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u0435\u043c\u044b\u0435 \u0432 \u0434\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u0435 ''{0}'', \u043d\u0435 \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0435\u043d\u044b \u0432 \u043f\u0440\u0430\u0432\u0438\u043b\u0435 ''{0}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u043e\u043c \u0432 ''{1}''. \u0412\u044b \u043c\u043e\u0436\u0435\u0442\u0435 \u0438\u043b\u0438 \u0443\u0434\u0430\u043b\u0438\u0442\u044c \u0438\u0445 \u0438\u0437 \u0434\u0438\u0440\u0435\u043a\u0442\u0438\u0432\u044b ''{0}'', \u0438\u043b\u0438 \u0434\u043e\u0431\u0430\u0432\u0438\u0442\u044c \u0432 \u0441\u043f\u0438\u0441\u043e\u043a \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u043e\u0432 \u043f\u0440\u0430\u0432\u0438\u043b\u0430 ''{0}.yaml''. \u0412\u043e\u0442 \u043e\u043d\u0438: {2} + +# Error_DefaultValueRuntimeErrorRule = I''m sorry, but the default value set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_DefaultValueRuntimeErrorRule = \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435 \u043f\u043e \u0443\u043c\u043e\u043b\u0447\u0430\u043d\u0438\u044e, \u0443\u0441\u0442\u0430\u043d\u043e\u0432\u043b\u0435\u043d\u043d\u043e\u0435 \u0434\u043b\u044f \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u0430 ''{0}'' \u0437\u0430\u0434\u0430\u0447\u0438 ''{1}'' (\u0441\u0441\u044b\u043b\u0430\u044e\u0449\u0435\u0439\u0441\u044f \u043d\u0430 \u0444\u0430\u0439\u043b ''{1}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u044b\u0439 \u0432 ''{2}'') \u0438\u043c\u0435\u0435\u0442 \u043d\u0435\u0434\u043e\u0441\u0442\u0443\u043f\u043d\u0443\u044e \u043f\u0435\u0440\u0435\u043c\u0435\u043d\u043d\u0443\u044e / \u043c\u0435\u0442\u043e\u0434 \u0432 \u043a\u043e\u043d\u0442\u0435\u043a\u0441\u0442\u0435 \u043f\u0440\u0430\u0432\u0438\u043b\u0430: ''{3}'' + +# Error_FlagRuntimeErrorRule = I''m sorry, but the flag set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_FlagRuntimeErrorRule = \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u0444\u043b\u0430\u0433, \u0443\u0441\u0442\u0430\u043d\u043e\u0432\u043b\u0435\u043d\u043d\u044b\u0439 \u0434\u043b\u044f \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u0430 ''{0}'' \u0437\u0430\u0434\u0430\u0447\u0438 ''{1}'' (\u0441\u0441\u044b\u043b\u0430\u044e\u0449\u0435\u0439\u0441\u044f \u043d\u0430 \u0444\u0430\u0439\u043b ''{1}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u044b\u0439 \u0432 ''{2}'') \u0438\u043c\u0435\u0435\u0442 \u043d\u0435\u0434\u043e\u0441\u0442\u0443\u043f\u043d\u0443\u044e \u043f\u0435\u0440\u0435\u043c\u0435\u043d\u043d\u0443\u044e / \u043c\u0435\u0442\u043e\u0434 \u0432 \u043a\u043e\u043d\u0442\u0435\u043a\u0441\u0442\u0435 \u043f\u0440\u0430\u0432\u0438\u043b\u0430: ''{3}'' + +# Error_DuplicatedCommandElementsRule = Uh-oh, both ''command'' and ''commands'' fields are set in the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}''). You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_DuplicatedCommandElementsRule = \u041e\u0439-\u043e\u0439, \u043e\u0431\u0430 \u043f\u043e\u043b\u044f ''command'' \u0438 ''commands'' \u0443\u0441\u0442\u0430\u043d\u043e\u0432\u043b\u0435\u043d\u044b \u0432 \u0437\u0430\u0434\u0430\u0447\u0435 ''{0}'' (\u0441\u0441\u044b\u043b\u0430\u044e\u0449\u0435\u0439\u0441\u044f \u043d\u0430 \u0444\u0430\u0439\u043b ''{0}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u044b\u0439 \u0432 ''{1}''). \u0412\u044b \u0434\u043e\u043b\u0436\u043d\u044b \u0432\u044b\u0431\u0440\u0430\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u043e\u0434\u043d\u043e \u0438\u0437 \u043d\u0438\u0445. \u0415\u0441\u043b\u0438 \u0432\u0430\u0448\u0430 \u0437\u0430\u0434\u0430\u0447\u0430 \u043f\u043e\u043b\u0430\u0433\u0430\u0435\u0442\u0441\u044f \u0442\u043e\u043b\u044c\u043a\u043e \u043d\u0430 \u043e\u0434\u043d\u0443 \u043a\u043e\u043c\u0430\u043d\u0434\u0443, \u0432\u044b \u043c\u043e\u0436\u0435\u0442\u0435 \u0432\u044b\u0431\u0440\u0430\u0442\u044c ''command'', \u0435\u0441\u043b\u0438 \u0432\u0430\u0448\u0435 \u043f\u0440\u0430\u0432\u0438\u043b\u043e \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u043d\u0430\u0431\u043e\u0440\u0430 \u043a\u043e\u043c\u0430\u043d\u0434, \u043f\u043e\u043b\u0435 ''commands'' \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f, \u043c\u043e\u0436\u0435\u0442 \u0431\u044b\u0442\u044c, \u0431\u043e\u043b\u0435\u0435 \u043f\u043e\u0434\u0445\u043e\u0434\u044f\u0449\u0438\u043c. + +# Error_MissingCommandElementsRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') does not have either the ''command'' or ''commands'' elements. You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_MissingCommandElementsRule = \u041e\u0439-\u043e\u0439, \u0432 \u0437\u0430\u0434\u0430\u0447\u0435 ''{0}'' (\u0441\u0441\u044b\u043b\u0430\u044e\u0449\u0435\u0439\u0441\u044f \u043d\u0430 \u0444\u0430\u0439\u043b ''{0}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u044b\u0439 \u0432 ''{1}'') \u043d\u0438 \u043e\u0434\u0438\u043d \u0438\u0437 \u044d\u043b\u0435\u043c\u0435\u043d\u0442\u043e\u0432 ''command'' \u0438\u043b\u0438 ''commands'' \u043d\u0435 \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0435\u043d. \u0412\u044b \u0434\u043e\u043b\u0436\u043d\u044b \u0432\u044b\u0431\u0440\u0430\u0442\u044c \u0442\u043e\u043b\u044c\u043a\u043e \u043e\u0434\u0438\u043d \u0438\u0437 \u043d\u0438\u0445. \u0415\u0441\u043b\u0438 \u0432\u0430\u0448\u0430 \u0437\u0430\u0434\u0430\u0447\u0430 \u043f\u043e\u043b\u0430\u0433\u0430\u0435\u0442\u0441\u044f \u0442\u043e\u043b\u044c\u043a\u043e \u043d\u0430 \u043e\u0434\u043d\u0443 \u043a\u043e\u043c\u0430\u043d\u0434\u0443, \u0432\u044b \u043c\u043e\u0436\u0435\u0442\u0435 \u0432\u044b\u0431\u0440\u0430\u0442\u044c ''command'', \u0435\u0441\u043b\u0438 \u0432\u0430\u0448\u0435 \u043f\u0440\u0430\u0432\u0438\u043b\u043e \u0442\u0440\u0435\u0431\u0443\u0435\u0442 \u043d\u0430\u0431\u043e\u0440\u0430 \u043a\u043e\u043c\u0430\u043d\u0434, \u043f\u043e\u043b\u0435 ''commands'' \u044f\u0432\u043b\u044f\u0435\u0442\u0441\u044f, \u043c\u043e\u0436\u0435\u0442 \u0431\u044b\u0442\u044c, \u0431\u043e\u043b\u0435\u0435 \u043f\u043e\u0434\u0445\u043e\u0434\u044f\u0449\u0438\u043c. + +# Error_CommandRuntimeErrorRule = I''m sorry, but the command set for the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an unavailable variable/method in the rule context: ''{2}'' +Error_CommandRuntimeErrorRule = \u041a \u0441\u043e\u0436\u0430\u043b\u0435\u043d\u0438\u044e, \u043a\u043e\u043c\u0430\u043d\u0434\u0430, \u0443\u0441\u0442\u0430\u043d\u043e\u0432\u043b\u0435\u043d\u043d\u0430\u044f \u0434\u043b\u044f \u0437\u0430\u0434\u0430\u0447\u0438 ''{0}'' (\u0441\u0441\u044b\u043b\u0430\u044e\u0449\u0435\u0439\u0441\u044f \u043d\u0430 \u0444\u0430\u0439\u043b ''{0}.yaml'', \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0436\u0435\u043d\u043d\u044b\u0439 \u0432 ''{1}'') \u0438\u043c\u0435\u0435\u0442 \u043d\u0435\u0434\u043e\u0441\u0442\u0443\u043f\u043d\u0443\u044e \u043f\u0435\u0440\u0435\u043c\u0435\u043d\u043d\u0443\u044e / \u043c\u0435\u0442\u043e\u0434 \u0432 \u043a\u043e\u043d\u0442\u0435\u043a\u0441\u0442\u0435 \u043f\u0440\u0430\u0432\u0438\u043b\u0430: ''{2}'' + diff --git a/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_tr.properties b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_tr.properties new file mode 100644 index 00000000000..f7fbb2423ab --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/main/resources/com/github/arara/localization/Messages_tr.properties @@ -0,0 +1,228 @@ +\ufeff# Arara -- the cool TeX automation tool +# Copyright (c) 2012, Paulo Roberto Massa Cereda +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the project's author nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY +# WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +# Messages_tr: This file holds the Turkish language messages for arara. +# +# initially translated by: Brent Longborough (Obviously not a fluent Turkish speaker!) +# e-mail: brent@longborough.org +# enjoyed and revised by: \u0130lhan Polat (Brent is just humble, he is wonderful) +# e-mail: i.polat@tudelft.nl + +# Log_WelcomeMessage = Welcome to arara! +Log_WelcomeMessage = arara'ya ho\u015fgeldin + +# Log_ProcessingFile = Processing file ''{0}'', please wait. +Log_ProcessingFile = Dosya ''{0}'' i\u015fleniyor, biraz bekletecegim. + +# Log_Done = Done. +Log_Done = Haz\u0131r. + +# Log_ExceptionRaised = Arara raised an exception with the following message: +Log_ExceptionRaised = arara bir istisna farketti ve \u015f\u00f6yle dedi: + +# Log_ReadyToRunCommands = Ready to run commands. +Log_ReadyToRunCommands = Komutlar icin beklemede. + +# Log_CommandName = Running ''{0}''. +Log_CommandName = ''{0}'' komutu yerine getiriliyor. + +# Log_Command = Command: {0} +Log_Command = Komut: {0} + +# Log_CommandSuccess = ''{0}'' was successfully executed. +Log_CommandSuccess = ''{0}'' ba\u015far\u0131yla yerine getirildi. + +# Log_CommandFailure = ''{0}'' returned an error status. +Log_CommandFailure = ''{0}'' hata durumu bildirdi. + +# Log_AllCommandsSuccess = All commands were successfully executed. +Log_AllCommandsSuccess = T\u00fcm komutlar ba\u015far\u0131yla yerine getirildi. + +# Log_OutputLogging = Output logging: +Log_OutputLogging = Kay\u0131t \u00c7\u0131kt\u0131s\u0131: + +# Log_CommandNotFound = ''{0}'' was not found in the path. Execution attempt: {1} +Log_CommandNotFound = ''{0}'' komutuna giden uygun bir yol bulunamad\u0131. Deneme: {1} + +# Log_DirectiveFound = Directive found in line {0} with {1}. +Log_DirectiveFound = Sat\u0131r {1} \u00fczerinde {0} y\u00f6nergesi bulundu. + +# Log_RuleFound = Task ''{0}'' found in ''{1}''. +Log_RuleFound = ''{1}'' de/da ''{0}'' g\u00f6revi bulundu. + +# Log_NoDirectivesFound = No directives found in ''{0}''. +Log_NoDirectivesFound = ''{0}'' dosyas\u0131nda hi\u00e7bir y\u00f6nerge bulunamad\u0131. + +# Help_Version = print the application version +Help_Version = uygulama s\u00fcr\u00fcm\u00fcn\u00fc yazd\u0131r\u0131r + +# Help_Help = print the help message +Help_Help = yard\u0131m iletisini yazd\u0131r\u0131r + +# Help_Log = generate a log output +Help_Log = kay\u0131t \u00e7\u0131kt\u0131s\u0131 \u00fcretir + +# Help_Verbose = print the command output +Help_Verbose = komut \u00e7\u0131kt\u0131s\u0131 yazd\u0131r\u0131r + +# Help_Timeout = set the execution timeout (in milliseconds) +Help_Timeout = y\u00fcr\u00fctme zaman a\u015f\u0131m\u0131n\u0131 (milisaniye cinsinden) ayarlar + +# Help_Language = set the application language +Help_Language = uygulama dilini ayarlar + +# Header_Slogan = The cool TeX automation tool +Header_Slogan = \u015eahane TeX otomasyon arac\u0131 + +# Header_AllRightsReserved = All rights reserved. +Header_AllRightsReserved = T\u00fcm haklar\u0131 sakl\u0131d\u0131r. + +# Msg_NoDirectivesFound = I didn''t find any directives in ''{0}'', and so didn''t do anything. Is that what you really wanted? +Msg_NoDirectivesFound = Ben ''{0}'' dosyas\u0131nda hi\u00e7bir y\u00f6nerge bulamad\u0131m, nedenle bir \u015fey yapmad\u0131m. Ger\u00e7ekten istedi\u011fin bu mu? + +# Msg_SpecialThanks = A special thanks goes to Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz, and many others for making this humble tool possible. +Msg_SpecialThanks = Alan Munn, Andrew Stacey, Brent Longborough, Clemens Niederberger, David Carlisle, Enrico Gregorio, Francesco Endrici, Gonzalo Medina, Harish Kumar, \u0130lhan Polat, Joseph Wright, Marco Daniel, Mika\u00ebl Maunier, Patrick Gundlach, Rasmus Roulund, Sergey Ulyanov, Stefan Kottwitz, ve di\u011ferlerine bu m\u00fctevazi arac\u0131 m\u00fcmk\u00fcn k\u0131ld\u0131klar\u0131 i\u00e7in \u00e7ok te\u015fekk\u00fcrler. + +# Msg_RunningCommand = Running {0}... +Msg_RunningCommand = {0} yerine getiriliyor... + +# Msg_Success = SUCCESS +Msg_Success = BA\u015eARILI + +# Msg_Failure = FAILURE +Msg_Failure = BA\u015eARISIZ + +# Msg_Status = Status: +Msg_Status = Durum: + +# YamlError_Context = Context: {0} +YamlError_Context = Ba\u011flam: {0} + +# YamlError_Problem = Problem: {0} +YamlError_Problem = Sorun: {0} + +# YamlError_ErrorLocation = Error found in line {0}, column {1}. +YamlError_ErrorLocation = {0}. sat\u0131r, {1}. s\u00fctunda hata bulundu. + +# Error_FileDoesNotExistWithExtensionsList = I''m sorry, but the file ''{0} {1}'' does not exist. Note that when you provide only the basename (i.e, the filename without the extension) or with an unknown extension, arara will try to look for files ending with the predefined extensions {1} in that order. You can override the order, the search pattern or even add support for new extensions through the configuration file. Please refer to the arara manual to learn more about this feature. +Error_FileDoesNotExistWithExtensionsList = \u00dczg\u00fcn\u00fcm ama ''{0} {1}'' diye bir dosya yok. Ancak, uzant\u0131s\u0131 olmayan (veya bilinmeyen bir uzant\u0131s\u0131 olan) dosya ad\u0131n\u0131 girdi\u011finde, arara s\u0131ras\u0131yla {1} uzant\u0131lar\u0131n\u0131 bulmay\u0131 dener. Elbette bu s\u0131ray\u0131 ge\u00e7ersiz k\u0131lmak, de\u011fi\u015ftirmek hatta yeni uzant\u0131lar ekleyebilmek m\u00fcmk\u00fcn. Bu \u00f6zellik hakk\u0131nda daha fazla bilgi edinmek i\u00e7in arara k\u0131lavuzuna bak\u0131n. + +# Error_FileDoesNotExist = File ''{0}'' does not exist. +Error_FileDoesNotExist = ''{0}'' diye bir dosya yok. + +# Error_CommandNotFound = \nI''m sorry, but the command from the ''{0}'' task could not be found. Are you sure the command ''{1}'' is correct, or even accessible from the system path? +Error_CommandNotFound = \n\u00dczg\u00fcn\u00fcm ama ''{0}'' g\u00f6revindeki komutu bulunamad\u0131. ''{1}'' komutunun do\u011fru veya sistem yolu ile eri\u015filebilir oldu\u011fundan emin misin? + +# Error_InvalidYAMLConfigurationFile = I'm sorry, but apparently your arara configuration file is invalid, that is, it has invalid or missing YAML entries. Unfortunately, arara cannot proceed until the error is fixed. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLConfigurationFile = \u00dczg\u00fcn\u00fcm, ama g\u00f6r\u00fcn\u00fc\u015fe g\u00f6re arara yap\u0131land\u0131rma dosyas\u0131 ge\u00e7ersiz, daha do\u011frusu ge\u00e7ersiz veya eksik YAML giri\u015fleri bar\u0131nd\u0131r\u0131yor. Maalesef, arara bu hata giderilene kadar devam edemeyecek. Elimden geldi\u011fince, \u015f\u00f6yle bir hata d\u00f6k\u00fcm\u00fc \u00e7\u0131kartt\u0131m: + +# Error_InvalidConfigurationFile = Uh-oh, the configuration file appears to be invalid. Are you sure it's a proper YAML file? Unfortunately, arara cannot proceed until a proper configuration file is provided. +Error_InvalidConfigurationFile = T\u00fch, yap\u0131land\u0131rma dosyas\u0131 ge\u00e7ersiz g\u00f6r\u00fcn\u00fcyor. Uygun bir YAML dosyas\u0131 oldu\u011fundan emin misin? Uygun bir yap\u0131land\u0131rma dosyas\u0131 girilene kadar maalesef arara devam edemeyecek. + +# Error_InvalidLanguageConfigurationFile = Houston, we have a problem. Sadly, the language set in the configuration file is not valid. Currently, arara can provide support for the following languages: {0}. Make sure to choose a valid language or remove the entry from the configuration file (the field is optional), otherwise arara cannot proceed. +Error_InvalidLanguageConfigurationFile = Houston, bir sorun var. Ne yaz\u0131k ki, yap\u0131land\u0131rma dosyas\u0131nda ayarlanan dil ge\u00e7erli de\u011fil. \u015eu anda, arara \u015fu dilleri destekliyor: {0}. Anlayabildi\u011fim bir dil se\u00e7in ya da yap\u0131land\u0131rma dosyas\u0131ndan bu (iste\u011fe ba\u011fl\u0131) giri\u015fi kald\u0131r\u0131n, aksi takdirde arara devam edemeyecek. + +# Error_InvalidFiletypesConfigurationFile = I'm sorry, but it seems your configuration file has customized filetypes with neither the extension or pattern defined. Both are required in order to continue. Please fix this error in your configuration file and try again. +Error_InvalidFiletypesConfigurationFile = \u00dczg\u00fcn\u00fcm ama g\u00f6r\u00fcn\u00fc\u015fe g\u00f6re yap\u0131land\u0131rma dosyas\u0131nda ne desen tan\u0131m\u0131 olan ne de uzant\u0131s\u0131 bilinen \u00f6zelle\u015ftirilmi\u015f dosya tipleri var. Her iki bilgininde sa\u011flanm\u0131\u015f olmas\u0131 devam edebilmek i\u00e7in gerekli. Yap\u0131land\u0131rma dosyas\u0131ndaki bu hatay\u0131 d\u00fczeltin, ve tekrar deneyin. + +# Error_PathRuntimeErrorConfigurationFile = I''m sorry, but one of the entries of the search path in your configuration file has an unavailable variable in the path context: ''{0}'' +Error_PathRuntimeErrorConfigurationFile = \u00dczg\u00fcn\u00fcm ama yap\u0131land\u0131rma dosyas\u0131nda arama yolu girdilerinden birinde kullan\u0131lamayacak bir de\u011fi\u015fken var: ''{0}'' + +# Error_PathIOErrorConfigurationFile = I'm sorry, but one of the entries of the search path in your configuration file has a malformed directory structure. Could you take a look at it? +Error_PathIOErrorConfigurationFile = \u00dczg\u00fcn\u00fcm ama yap\u0131land\u0131rma dosyas\u0131nda arama yoluna girdilerinden birini hatal\u0131 bi\u00e7imlendirilmi\u015f bir dizin yap\u0131s\u0131 vard\u0131r. Benim i\u00e7in bir bakabilir misin? + +# Error_InvalidYAMLDirective = It appears there is a malformed directive found at line {0}, that is, a directive that might have a YAML syntax error or an invalid field. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLDirective = Sat\u0131r {0} \u00fczerinde bozuk, yani, YAML s\u00f6zdizimi hatas\u0131 veya ge\u00e7ersiz bir alan\u0131 olabilecek bir y\u00f6nerge var gibi duruyor. Elimden geldi\u011fince, \u015f\u00f6yle bir hata d\u00f6k\u00fcm\u00fc \u00e7\u0131kartt\u0131m: + +# Error_DirectiveEmptyCurlyBrackets = Directive ''{0}'' at line {1} has empty curly brackets. Note that arara opts for a cleaner syntax when a directive has no parameters. To fix it, it''s enough to either remove the curly brackets or provide the arguments for the directive. +Error_DirectiveEmptyCurlyBrackets = Sat\u0131r {1} \u00fczerindeki ''{0}'' y\u00f6nergesinde bo\u015f k\u00fcme parantezleri buldum. arara y\u00f6nergenin arg\u00fcmanlar\u0131 yoksa sade bir s\u00f6zdizimi yap\u0131s\u0131n\u0131 tercih eder. Bunu d\u00fczeltmek i\u00e7in, bo\u015f k\u00fcme parantezlerini kald\u0131rmak veya y\u00f6nerge i\u00e7in arg\u00fcmanlar sunmak yeterli. + +# Error_DirectiveInvalidArgumentList = Directive ''{0}'' at line {1} has an invalid argument type. The argument ''{2}'' is a reserved arara keyword and always requires a list. +Error_DirectiveInvalidArgumentList = Sat\u0131r {1} \u00fczerinde ''{0}'' y\u00f6nergesi i\u00e7in ge\u00e7ersiz bir arg\u00fcman t\u00fcr\u00fc var. ''{2}'' arg\u00fcman\u0131 arara''ya \u00f6zeldir her zaman bir liste gerektirir. + +# Error_DirectiveReservedKeyword = Directive ''{0}'' at line {1} has an invalid argument name. The name ''{2}'' is a reserved arara keyword representing every element in the ''{3}'' list. Please, pick another name for that argument. +Error_DirectiveReservedKeyword = Sat\u0131r {1} \u00fczerinde ''{0}'' y\u00f6nergesi i\u00e7in ge\u00e7ersiz bir arg\u00fcman t\u00fcr\u00fc var. ''{2}'' kelimesi arara''ya ait ''{3}'' listesinde her elementi temsil eden \u00f6zel bir kelimedir. L\u00fctfen, ba\u015fka bir kelime se\u00e7in. + +# Error_DirectiveListError = Directive ''{0}'' at line {1} has an invalid argument type. Only the arguments ''files'' and ''items'' can have a list. Both are reserved arara keywords. +Error_DirectiveListError = Sat\u0131r {1} \u00fczerinde ''{0}'' y\u00f6nergesi i\u00e7in ge\u00e7ersiz bir arg\u00fcman t\u00fcr\u00fc var. Sadece ''file'' ve ''items'' arg\u00fcmanlar\u0131 bir liste olabilir. Her ikisi de arara''ya ait \u00f6zel kelimelerdir. + +# Error_InvalidDirective = Apparently, there''s an invalid directive at line {0}. Please take a look and fix it. +Error_InvalidDirective = G\u00f6r\u00fcn\u00fc\u015fe g\u00f6re, {0}. sat\u0131rda ge\u00e7ersiz bir y\u00f6nerge var. Bir g\u00f6z at\u0131p d\u00fczeltin l\u00fctfen. + +# Error_DirectiveGenericError = Directive ''{0}'' at line {1} seems to be malformed. It might be a YAML syntax error or a wrong mapping. +Error_DirectiveGenericError = Sat\u0131r {1} \u00fczerinde ''{0}'' y\u00f6nergesi bozuk gibi. YAML s\u00f6zdizimi hatas\u0131 ya da yanl\u0131\u015f bir e\u015fleme olabilir. + +# Error_InvalidLanguage = I'm sorry, but the language code you chose is invalid. Currently, the following languages are supported: +Error_InvalidLanguage = \u00dczg\u00fcn\u00fcm, ama se\u00e7ti\u011fin dil kodu ge\u00e7ersiz. \u015eimdilik a\u015fa\u011f\u0131daki dilleri konu\u015fabiliyorum: + +# Error_RuleNotFound = Uh-oh, I could not find the ''{0}'' rule in the search path. Could you take a look if the rule name is correct and if the rule is accessible through the search path? +Error_RuleNotFound = T\u00fch, arama yolunda ''{0}'' kural\u0131n\u0131 bulamad\u0131m. Kural arama yolu \u00fczerinden eri\u015filebilir ise kural ad\u0131n\u0131n do\u011fru oldu\u011funa bakar m\u0131s\u0131n? + +# Error_InvalidYAMLRule = It appears that the ''{0}'' task has a YAML syntax error or an invalid field. Could you take a look at the ''{0}.yaml'' file located at ''{1}''. I tried my best to dump the error message, so here it is: +Error_InvalidYAMLRule = ''{0}'' g\u00f6revi bir YAML s\u00f6zdizimi hatas\u0131 veya ge\u00e7ersiz bir alan i\u00e7eriyor gibi g\u00f6r\u00fcn\u00fcyor. ''{1}'' rdeki ''{0}.yaml'' dosyas\u0131na bir bakar m\u0131s\u0131n? Elimden geldi\u011fince, \u015f\u00f6yle bir hata d\u00f6k\u00fcm\u00fc \u00e7\u0131kartt\u0131m: + +# Error_InvalidRule = Uh-oh, the ''{0}'' task appears to be invalid. Are you sure the ''{0}.yaml'' file located at ''{1}'' is a proper YAML file? +Error_InvalidRule = T\u00fch, ''{0}'' g\u00f6revi ge\u00e7ersiz g\u00f6r\u00fcn\u00fcyor. ''{1}'' de bulunan ''{0}.yaml'' uygun bir YAML dosyas\u0131 oldu\u011fundan emin misin? + +# Error_EmptyIdentifierRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid identifier. Could you fix it? +Error_EmptyIdentifierRule = ''{0}'' g\u00f6revinde bir sorun var. ''{1}'' deki ''{0}.yaml'' dosyas\u0131 i\u00e7in ge\u00e7erli bir tan\u0131mlay\u0131c\u0131 gerek. D\u00fczeltebilir misin? + +# Error_EmptyNameRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid name. Could you fix it? +Error_EmptyNameRule = ''{0}'' g\u00f6revinde bir sorun var. ''{1}'' yer ''{0}.yaml'' dosyas\u0131 i\u00e7in ge\u00e7erli bir isim gerek. D\u00fczeltebilir misin? + +# Error_ForbiddenIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an invalid argument identifier. ''{2}'' is a reserved keyword, so it cannot be used. Could you use another name? +Error_ForbiddenIdentifierRule = T\u00fch, ''{0}'' g\u00f6revi (''{1}'' deki ''{0}.yaml'' dosyas\u0131na atfen) ge\u00e7ersiz bir arg\u00fcman tan\u0131mlay\u0131c\u0131s\u0131 i\u00e7eriyor. ''{2}'' \u00f6zel bir kelime, bu nedenle kullan\u0131lamaz. Ba\u015fka bir isim kullanabilir misin? + +# Error_EmptyArgumentsListRule = A problem was detected in the ''{0}'' task. The ''{0}.yaml'' file located at ''{1}'' requires a valid list of arguments. Could you fix it? Note that the list of arguments can also be empty, but it is still necessary to define it explicitly (with ''arguments: []''). +Error_EmptyArgumentsListRule = ''{0}'' g\u00f6revinde bir sorun var. ''{1}'' deki ''{0}.yaml'' dosyas\u0131 i\u00e7in ge\u00e7erli bir arg\u00fcman listesi gerek. Bunu d\u00fczeltebilir misin? Bu arada, arg\u00fcmanlar listesi bo\u015f dahi olabilir, ama yine de ''arguments: []'' ile belirtmek gerekiyor. + +# Error_WrongIdentifierRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has the wrong identifier - ''{0}'' was expected, rather than ''{2}''. Could you fix it? +Error_WrongIdentifierRule = T\u00fch, ''{0}'' g\u00f6revi (''{1}'' deki ''{0}.yaml'' dosyas\u0131na atfen) yanl\u0131\u015f bir tan\u0131mlay\u0131c\u0131s\u0131 i\u00e7eriyor - ''{0}}'' yerine ''{2}'' bekliyordum. Bunu d\u00fczeltebilir misin? + +# Error_ArgumentsNotDefinedInRule = Oh no, there are arguments used in the diretive ''{0}'' which are not defined in the ''{0}.yaml'' rule located at ''{1}''. You can either remove them from the ''{0}'' directive or add them to the list of arguments in the ''{0}.yaml'' rule. Here they are: {2} +Error_ArgumentsNotDefinedInRule = ''{0}'' y\u00f6nergesinde, ''{1}'' deki ''{0}.yaml'' kural\u0131 taraf\u0131ndan tan\u0131mlanmam\u0131\u015f arg\u00fcmanlar\u0131 kullan\u0131yor. Bunlar\u0131 ya ''{0}'' y\u00f6nergesinden kald\u0131rabilirsin ya da ''{0}.yaml'' kural\u0131 arg\u00fcman listesine ekleyebilirsin. Bahsetti\u011fim arg\u00fcmanlar \u015funlar: {2} + +# Error_DefaultValueRuntimeErrorRule = I''m sorry, but the default value set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_DefaultValueRuntimeErrorRule = \u00dczg\u00fcn\u00fcm ama ''{1}'' g\u00f6revinin ''{0}'' arg\u00fcman\u0131n\u0131n varsay\u0131lan de\u011feri (''{2}'' deki ''{1}.yaml'' dosyas\u0131na atfen) kullan\u0131lamayan bir de\u011fi\u015fken/y\u00f6ntem i\u00e7eriyor: ''{3}'' + +# Error_FlagRuntimeErrorRule = I''m sorry, but the flag set for the argument ''{0}'' of the ''{1}'' task (referencing the ''{1}.yaml'' file located at ''{2}'') has an unavailable variable/method in the rule context: ''{3}'' +Error_FlagRuntimeErrorRule = \u00dczg\u00fcn\u00fcm ama ''{1}'' g\u00f6revinin ''{0}'' arg\u00fcman imlecinde (''{2}'' deki ''{1}.yaml'' dosyas\u0131na atfen) bu kural i\u00e7in kullan\u0131lamayan bir de\u011fi\u015fken/y\u00f6ntem var: ''{3}'' + +# Error_DuplicatedCommandElementsRule = Uh-oh, both ''command'' and ''commands'' fields are set in the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}''). You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_DuplicatedCommandElementsRule = T\u00fch, her iki ''command'' ve ''commands'' alan\u0131 da ''{0}'' g\u00f6revinde (''{1}'' deki ''{0}.yaml'' dosyas\u0131na atfen) kullan\u0131lmaya ayarlanm\u0131\u015f. Sadece birinin se\u00e7ilmi\u015f olmas\u0131 gerekiyor. E\u011fer i\u015flenecek g\u00f6rev sadece bir komut i\u00e7eriyorsa, ''command'' kullanabilirsin; birden fazla komut kullan\u0131m\u0131 i\u00e7in ''commands'' daha uygun olacakt\u0131r. + +# Error_MissingCommandElementsRule = Uh-oh, the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') does not have either the ''command'' or ''commands'' elements. You need to pick only one of them. If your task only relies on a single command, you can opt for ''command''; if your rule requires a set of commands, maybe the ''commands'' field is more suitable. +Error_MissingCommandElementsRule = her iki ''command'' ve ''commands'' alan\u0131 da ''{0}'' g\u00f6revinde (''{1}'' deki ''{0}.yaml'' dosyas\u0131na atfen) kullan\u0131lmaya ayarlanm\u0131\u015f. \u0130kisinden birinin kullan\u0131l\u0131yor olmas\u0131 gerekiyor. E\u011fer i\u015flenecek g\u00f6rev sadece bir komut i\u00e7eriyorsa, ''command'' kullanabilirsin; birden fazla komut kullan\u0131m\u0131 i\u00e7in ''commands'' daha uygun olacakt\u0131r. + +# Error_CommandRuntimeErrorRule = I''m sorry, but the command set for the ''{0}'' task (referencing the ''{0}.yaml'' file located at ''{1}'') has an unavailable variable/method in the rule context: ''{2}'' +Error_CommandRuntimeErrorRule = \u00dczg\u00fcn\u00fcm ama ''{0}'' g\u00f6revi i\u00e7in belirlenmi\u015f komut (''{1}'' deki ''{0}.yaml'' dosyas\u0131na atfen) bu kural i\u00e7in kullan\u0131lamayacak bir de\u011fi\u015fken/y\u00f6ntem i\u00e7eriyor: ''{2}'' + diff --git a/Master/texmf-dist/source/support/arara/src/test/java/com/github/arara/AraraTest.java b/Master/texmf-dist/source/support/arara/src/test/java/com/github/arara/AraraTest.java new file mode 100644 index 00000000000..4e779f9c247 --- /dev/null +++ b/Master/texmf-dist/source/support/arara/src/test/java/com/github/arara/AraraTest.java @@ -0,0 +1,87 @@ +/** + * \cond LICENSE + * Arara -- the cool TeX automation tool + * Copyright (c) 2012, Paulo Roberto Massa Cereda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * 3. Neither the name of the project's author nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY + * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * \endcond + * + * AraraTest: This class checks if the localization files are in place in order + * to Maven correctly build the application. + */ +// package definition +package com.github.arara; + +// needed imports +import java.net.URL; +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +/** + * Checks if the localization files are in place in order to Maven correctly + * build the application. + * + * @author Paulo Roberto Massa Cereda + * @version 3.0 + * @since 3.0 + */ +public class AraraTest extends TestCase { + + /** + * Create the test case. + * + * @param testName The name of the test case. + */ + public AraraTest(String testName) { + super(testName); + } + + /** + * @return The suite of tests being tested. + */ + public static Test suite() { + return new TestSuite(AraraTest.class); + } + + /** + * Checks if the localization resource exists. + */ + public void testLocalizationFile() { + URL url = Arara.class.getResource("/com/github/arara/localization/Messages.properties"); + if (url == null) { + fail("arara requires at least the default localization file Messages.properties " + + "located at the translations/ directory in the project repository. Rename " + + "Messages.input to Messages.properties and copy the new file to the src/ " + + "directory, under com/github/arara/localization, and build arara again."); + + } + } +} |