emmanuel/gclc-core
emmanuel/gclc-core
1
0
Fork 0
Code Issues 2 Pull Requests Projects 1 Releases Wiki Activity

Reorganize code to avoid cyclic dependencies.

Browse Source 
Signed-off-by: Emmanuel Bigeon <emmanuel@bigeon.fr>
This commit is contained in:
Emmanuel Bigeon 2018-10-08 11:49:14 -04:00
parent c8745e00a9
commit d99d97b9d5
75 changed files with 12705 additions and 10120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

517
gclc/LICENSE.txt Normal file
View File

@ -0,0 +1,517 @@
CeCILL FREE SOFTWARE LICENSE AGREEMENT
Version 2.1 dated 2013-06-21
Notice
This Agreement is a Free Software license agreement that is the result
of discussions between its authors in order to ensure compliance with
the two main principles guiding its drafting:
* firstly, compliance with the principles governing the distribution
of Free Software: access to source code, broad rights granted to users,
* secondly, the election of a governing law, French law, with which it
is conformant, both as regards the law of torts and intellectual
property law, and the protection that it offers to both authors and
holders of the economic rights over software.
The authors of the CeCILL (for Ce[a] C[nrs] I[nria] L[ogiciel] L[ibre])
license are:
Commissariat à l'énergie atomique et aux énergies alternatives - CEA, a
public scientific, technical and industrial research establishment,
having its principal place of business at 25 rue Leblanc, immeuble Le
Ponant D, 75015 Paris, France.
Centre National de la Recherche Scientifique - CNRS, a public scientific
and technological establishment, having its principal place of business
at 3 rue Michel-Ange, 75794 Paris cedex 16, France.
Institut National de Recherche en Informatique et en Automatique -
Inria, a public scientific and technological establishment, having its
principal place of business at Domaine de Voluceau, Rocquencourt, BP
105, 78153 Le Chesnay cedex, France.
Preamble
The purpose of this Free Software license agreement is to grant users
the right to modify and redistribute the software governed by this
license within the framework of an open source distribution model.
The exercising of this right is conditional upon certain obligations for
users so as to preserve this status for all subsequent redistributions.
In consideration of access to the source code and the rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors only have limited liability.
In this respect, the risks associated with loading, using, modifying
and/or developing or reproducing the software by the user are brought to
the user's attention, given its Free Software status, which may make it
complicated to use, with the result that its use is reserved for
developers and experienced professionals having in-depth computer
knowledge. Users are therefore encouraged to load and test the
suitability of the software as regards their requirements in conditions
enabling the security of their systems and/or data to be ensured and,
more generally, to use and operate it in the same conditions of
security. This Agreement may be freely reproduced and published,
provided it is not altered, and that no provisions are either added or
removed herefrom.
This Agreement may apply to any or all software for which the holder of
the economic rights decides to submit the use thereof to its provisions.
Frequently asked questions can be found on the official website of the
CeCILL licenses family (http://www.cecill.info/index.en.html) for any
necessary clarification.
Article 1 - DEFINITIONS
For the purpose of this Agreement, when the following expressions
commence with a capital letter, they shall have the following meaning:
Agreement: means this license agreement, and its possible subsequent
versions and annexes.
Software: means the software in its Object Code and/or Source Code form
and, where applicable, its documentation, "as is" when the Licensee
accepts the Agreement.
Initial Software: means the Software in its Source Code and possibly its
Object Code form and, where applicable, its documentation, "as is" when
it is first distributed under the terms and conditions of the Agreement.
Modified Software: means the Software modified by at least one
Contribution.
Source Code: means all the Software's instructions and program lines to
which access is required so as to modify the Software.
Object Code: means the binary files originating from the compilation of
the Source Code.
Holder: means the holder(s) of the economic rights over the Initial
Software.
Licensee: means the Software user(s) having accepted the Agreement.
Contributor: means a Licensee having made at least one Contribution.
Licensor: means the Holder, or any other individual or legal entity, who
distributes the Software under the Agreement.
Contribution: means any or all modifications, corrections, translations,
adaptations and/or new functions integrated into the Software by any or
all Contributors, as well as any or all Internal Modules.
Module: means a set of sources files including their documentation that
enables supplementary functions or services in addition to those offered
by the Software.
External Module: means any or all Modules, not derived from the
Software, so that this Module and the Software run in separate address
spaces, with one calling the other when they are run.
Internal Module: means any or all Module, connected to the Software so
that they both execute in the same address space.
GNU GPL: means the GNU General Public License version 2 or any
subsequent version, as published by the Free Software Foundation Inc.
GNU Affero GPL: means the GNU Affero General Public License version 3 or
any subsequent version, as published by the Free Software Foundation Inc.
EUPL: means the European Union Public License version 1.1 or any
subsequent version, as published by the European Commission.
Parties: mean both the Licensee and the Licensor.
These expressions may be used both in singular and plural form.
Article 2 - PURPOSE
The purpose of the Agreement is the grant by the Licensor to the
Licensee of a non-exclusive, transferable and worldwide license for the
Software as set forth in Article 5 <#scope> hereinafter for the whole
term of the protection granted by the rights over said Software.
Article 3 - ACCEPTANCE
3.1 The Licensee shall be deemed as having accepted the terms and
conditions of this Agreement upon the occurrence of the first of the
following events:
* (i) loading the Software by any or all means, notably, by
downloading from a remote server, or by loading from a physical medium;
* (ii) the first time the Licensee exercises any of the rights granted
hereunder.
3.2 One copy of the Agreement, containing a notice relating to the
characteristics of the Software, to the limited warranty, and to the
fact that its use is restricted to experienced users has been provided
to the Licensee prior to its acceptance as set forth in Article 3.1
<#accepting> hereinabove, and the Licensee hereby acknowledges that it
has read and understood it.
Article 4 - EFFECTIVE DATE AND TERM
4.1 EFFECTIVE DATE
The Agreement shall become effective on the date when it is accepted by
the Licensee as set forth in Article 3.1 <#accepting>.
4.2 TERM
The Agreement shall remain in force for the entire legal term of
protection of the economic rights over the Software.
Article 5 - SCOPE OF RIGHTS GRANTED
The Licensor hereby grants to the Licensee, who accepts, the following
rights over the Software for any or all use, and for the term of the
Agreement, on the basis of the terms and conditions set forth hereinafter.
Besides, if the Licensor owns or comes to own one or more patents
protecting all or part of the functions of the Software or of its
components, the Licensor undertakes not to enforce the rights granted by
these patents against successive Licensees using, exploiting or
modifying the Software. If these patents are transferred, the Licensor
undertakes to have the transferees subscribe to the obligations set
forth in this paragraph.
5.1 RIGHT OF USE
The Licensee is authorized to use the Software, without any limitation
as to its fields of application, with it being hereinafter specified
that this comprises:
1. permanent or temporary reproduction of all or part of the Software
by any or all means and in any or all form.
2. loading, displaying, running, or storing the Software on any or all
medium.
3. entitlement to observe, study or test its operation so as to
determine the ideas and principles behind any or all constituent
elements of said Software. This shall apply when the Licensee
carries out any or all loading, displaying, running, transmission or
storage operation as regards the Software, that it is entitled to
carry out hereunder.
5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS
The right to make Contributions includes the right to translate, adapt,
arrange, or make any or all modifications to the Software, and the right
to reproduce the resulting software.
The Licensee is authorized to make any or all Contributions to the
Software provided that it includes an explicit notice that it is the
author of said Contribution and indicates the date of the creation thereof.
5.3 RIGHT OF DISTRIBUTION
In particular, the right of distribution includes the right to publish,
transmit and communicate the Software to the general public on any or
all medium, and by any or all means, and the right to market, either in
consideration of a fee, or free of charge, one or more copies of the
Software by any means.
The Licensee is further authorized to distribute copies of the modified
or unmodified Software to third parties according to the terms and
conditions set forth hereinafter.
5.3.1 DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION
The Licensee is authorized to distribute true copies of the Software in
Source Code or Object Code form, provided that said distribution
complies with all the provisions of the Agreement and is accompanied by:
1. a copy of the Agreement,
2. a notice relating to the limitation of both the Licensor's warranty
and liability as set forth in Articles 8 and 9,
and that, in the event that only the Object Code of the Software is
redistributed, the Licensee allows effective access to the full Source
Code of the Software for a period of at least three years from the
distribution of the Software, it being understood that the additional
acquisition cost of the Source Code shall not exceed the cost of the
data transfer.
5.3.2 DISTRIBUTION OF MODIFIED SOFTWARE
When the Licensee makes a Contribution to the Software, the terms and
conditions for the distribution of the resulting Modified Software
become subject to all the provisions of this Agreement.
The Licensee is authorized to distribute the Modified Software, in
source code or object code form, provided that said distribution
complies with all the provisions of the Agreement and is accompanied by:
1. a copy of the Agreement,
2. a notice relating to the limitation of both the Licensor's warranty
and liability as set forth in Articles 8 and 9,
and, in the event that only the object code of the Modified Software is
redistributed,
3. a note stating the conditions of effective access to the full source
code of the Modified Software for a period of at least three years
from the distribution of the Modified Software, it being understood
that the additional acquisition cost of the source code shall not
exceed the cost of the data transfer.
5.3.3 DISTRIBUTION OF EXTERNAL MODULES
When the Licensee has developed an External Module, the terms and
conditions of this Agreement do not apply to said External Module, that
may be distributed under a separate license agreement.
5.3.4 COMPATIBILITY WITH OTHER LICENSES
The Licensee can include a code that is subject to the provisions of one
of the versions of the GNU GPL, GNU Affero GPL and/or EUPL in the
Modified or unmodified Software, and distribute that entire code under
the terms of the same version of the GNU GPL, GNU Affero GPL and/or EUPL.
The Licensee can include the Modified or unmodified Software in a code
that is subject to the provisions of one of the versions of the GNU GPL,
GNU Affero GPL and/or EUPL and distribute that entire code under the
terms of the same version of the GNU GPL, GNU Affero GPL and/or EUPL.
Article 6 - INTELLECTUAL PROPERTY
6.1 OVER THE INITIAL SOFTWARE
The Holder owns the economic rights over the Initial Software. Any or
all use of the Initial Software is subject to compliance with the terms
and conditions under which the Holder has elected to distribute its work
and no one shall be entitled to modify the terms and conditions for the
distribution of said Initial Software.
The Holder undertakes that the Initial Software will remain ruled at
least by this Agreement, for the duration set forth in Article 4.2 <#term>.
6.2 OVER THE CONTRIBUTIONS
The Licensee who develops a Contribution is the owner of the
intellectual property rights over this Contribution as defined by
applicable law.
6.3 OVER THE EXTERNAL MODULES
The Licensee who develops an External Module is the owner of the
intellectual property rights over this External Module as defined by
applicable law and is free to choose the type of agreement that shall
govern its distribution.
6.4 JOINT PROVISIONS
The Licensee expressly undertakes:
1. not to remove, or modify, in any manner, the intellectual property
notices attached to the Software;
2. to reproduce said notices, in an identical manner, in the copies of
the Software modified or not.
The Licensee undertakes not to directly or indirectly infringe the
intellectual property rights on the Software of the Holder and/or
Contributors, and to take, where applicable, vis-à-vis its staff, any
and all measures required to ensure respect of said intellectual
property rights of the Holder and/or Contributors.
Article 7 - RELATED SERVICES
7.1 Under no circumstances shall the Agreement oblige the Licensor to
provide technical assistance or maintenance services for the Software.
However, the Licensor is entitled to offer this type of services. The
terms and conditions of such technical assistance, and/or such
maintenance, shall be set forth in a separate instrument. Only the
Licensor offering said maintenance and/or technical assistance services
shall incur liability therefor.
7.2 Similarly, any Licensor is entitled to offer to its licensees, under
its sole responsibility, a warranty, that shall only be binding upon
itself, for the redistribution of the Software and/or the Modified
Software, under terms and conditions that it is free to decide. Said
warranty, and the financial terms and conditions of its application,
shall be subject of a separate instrument executed between the Licensor
and the Licensee.
Article 8 - LIABILITY
8.1 Subject to the provisions of Article 8.2, the Licensee shall be
entitled to claim compensation for any direct loss it may have suffered
from the Software as a result of a fault on the part of the relevant
Licensor, subject to providing evidence thereof.
8.2 The Licensor's liability is limited to the commitments made under
this Agreement and shall not be incurred as a result of in particular:
(i) loss due the Licensee's total or partial failure to fulfill its
obligations, (ii) direct or consequential loss that is suffered by the
Licensee due to the use or performance of the Software, and (iii) more
generally, any consequential loss. In particular the Parties expressly
agree that any or all pecuniary or business loss (i.e. loss of data,
loss of profits, operating loss, loss of customers or orders,
opportunity cost, any disturbance to business activities) or any or all
legal proceedings instituted against the Licensee by a third party,
shall constitute consequential loss and shall not provide entitlement to
any or all compensation from the Licensor.
Article 9 - WARRANTY
9.1 The Licensee acknowledges that the scientific and technical
state-of-the-art when the Software was distributed did not enable all
possible uses to be tested and verified, nor for the presence of
possible defects to be detected. In this respect, the Licensee's
attention has been drawn to the risks associated with loading, using,
modifying and/or developing and reproducing the Software which are
reserved for experienced users.
The Licensee shall be responsible for verifying, by any or all means,
the suitability of the product for its requirements, its good working
order, and for ensuring that it shall not cause damage to either persons
or properties.
9.2 The Licensor hereby represents, in good faith, that it is entitled
to grant all the rights over the Software (including in particular the
rights set forth in Article 5 <#scope>).
9.3 The Licensee acknowledges that the Software is supplied "as is" by
the Licensor without any other express or tacit warranty, other than
that provided for in Article 9.2 <#good-faith> and, in particular,
without any warranty as to its commercial value, its secured, safe,
innovative or relevant nature.
Specifically, the Licensor does not warrant that the Software is free
from any error, that it will operate without interruption, that it will
be compatible with the Licensee's own equipment and software
configuration, nor that it will meet the Licensee's requirements.
9.4 The Licensor does not either expressly or tacitly warrant that the
Software does not infringe any third party intellectual property right
relating to a patent, software or any other property right. Therefore,
the Licensor disclaims any and all liability towards the Licensee
arising out of any or all proceedings for infringement that may be
instituted in respect of the use, modification and redistribution of the
Software. Nevertheless, should such proceedings be instituted against
the Licensee, the Licensor shall provide it with technical and legal
expertise for its defense. Such technical and legal expertise shall be
decided on a case-by-case basis between the relevant Licensor and the
Licensee pursuant to a memorandum of understanding. The Licensor
disclaims any and all liability as regards the Licensee's use of the
name of the Software. No warranty is given as regards the existence of
prior rights over the name of the Software or as regards the existence
of a trademark.
Article 10 - TERMINATION
10.1 In the event of a breach by the Licensee of its obligations
hereunder, the Licensor may automatically terminate this Agreement
thirty (30) days after notice has been sent to the Licensee and has
remained ineffective.
10.2 A Licensee whose Agreement is terminated shall no longer be
authorized to use, modify or distribute the Software. However, any
licenses that it may have granted prior to termination of the Agreement
shall remain valid subject to their having been granted in compliance
with the terms and conditions hereof.
Article 11 - MISCELLANEOUS
11.1 EXCUSABLE EVENTS
Neither Party shall be liable for any or all delay, or failure to
perform the Agreement, that may be attributable to an event of force
majeure, an act of God or an outside cause, such as defective
functioning or interruptions of the electricity or telecommunications
networks, network paralysis following a virus attack, intervention by
government authorities, natural disasters, water damage, earthquakes,
fire, explosions, strikes and labor unrest, war, etc.
11.2 Any failure by either Party, on one or more occasions, to invoke
one or more of the provisions hereof, shall under no circumstances be
interpreted as being a waiver by the interested Party of its right to
invoke said provision(s) subsequently.
11.3 The Agreement cancels and replaces any or all previous agreements,
whether written or oral, between the Parties and having the same
purpose, and constitutes the entirety of the agreement between said
Parties concerning said purpose. No supplement or modification to the
terms and conditions hereof shall be effective as between the Parties
unless it is made in writing and signed by their duly authorized
representatives.
11.4 In the event that one or more of the provisions hereof were to
conflict with a current or future applicable act or legislative text,
said act or legislative text shall prevail, and the Parties shall make
the necessary amendments so as to comply with said act or legislative
text. All other provisions shall remain effective. Similarly, invalidity
of a provision of the Agreement, for any reason whatsoever, shall not
cause the Agreement as a whole to be invalid.
11.5 LANGUAGE
The Agreement is drafted in both French and English and both versions
are deemed authentic.
Article 12 - NEW VERSIONS OF THE AGREEMENT
12.1 Any person is authorized to duplicate and distribute copies of this
Agreement.
12.2 So as to ensure coherence, the wording of this Agreement is
protected and may only be modified by the authors of the License, who
reserve the right to periodically publish updates or new versions of the
Agreement, each with a separate number. These subsequent versions may
address new issues encountered by Free Software.
12.3 Any Software distributed under a given version of the Agreement may
only be subsequently distributed under the same version of the Agreement
or a subsequent version, subject to the provisions of Article 5.3.4
<#compatibility>.
Article 13 - GOVERNING LAW AND JURISDICTION
13.1 The Agreement is governed by French law. The Parties agree to
endeavor to seek an amicable solution to any disagreements or disputes
that may arise during the performance of the Agreement.
13.2 Failing an amicable solution within two (2) months as from their
occurrence, and unless emergency proceedings are necessary, the
disagreements or disputes shall be referred to the Paris Courts having
jurisdiction, by the more diligent Party.

170
gclc/pom.xml
View File

@ -1,88 +1,82 @@
<!-- Copyright Bigeon Emmanuel (2014) --> <project xmlns="http://maven.apache.org/POM/4.0.0"
<!-- --> xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
<!-- emmanuel@bigeon.fr --> xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<!-- --> <modelVersion>4.0.0</modelVersion>
<!-- This software is a computer program whose purpose is to --> <artifactId>gclc</artifactId>
<!-- provide a generic framework for console applications. --> <version>2.0.6-SNAPSHOT</version>
<!-- --> <packaging>jar</packaging>
<!-- This software is governed by the CeCILL license under French law and --> <url>http://www.bigeon.fr/emmanuel</url>
<!-- abiding by the rules of distribution of free software. You can use, --> <properties>
<!-- modify and/or redistribute the software under the terms of the CeCILL --> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!-- license as circulated by CEA, CNRS and INRIA at the following URL --> <project.scm.id>git.bigeon.net</project.scm.id>
<!-- "http://www.cecill.info". --> <copyright.email>emmanuel@bigeon.fr</copyright.email>
<!-- --> <license.licenseName>cecill_2.1</license.licenseName>
<!-- As a counterpart to the access to the source code and rights to copy, --> </properties>
<!-- modify and redistribute granted by the license, users are provided only --> <dependencies>
<!-- with a limited warranty and the software's author, the holder of the --> <dependency>
<!-- economic rights, and the successive licensors have only limited --> <groupId>junit</groupId>
<!-- liability. --> <artifactId>junit</artifactId>
<!-- --> <version>4.11</version>
<!-- In this respect, the user's attention is drawn to the risks associated --> <scope>test</scope>
<!-- with loading, using, modifying and/or developing or reproducing the --> </dependency>
<!-- software by the user in light of its specific status of free software, --> </dependencies>
<!-- that may mean that it is complicated to manipulate, and that also --> <parent>
<!-- therefore means that it is reserved for developers and experienced --> <groupId>net.bigeon.config</groupId>
<!-- professionals having in-depth computer knowledge. Users are therefore --> <artifactId>ebigeon-config</artifactId>
<!-- encouraged to load and test the software's suitability as regards their --> <version>1.8.3</version>
<!-- requirements in conditions enabling the security of their systems and/or --> </parent>
<!-- data to be ensured and, more generally, to use and operate it in the --> <build>
<!-- same conditions as regards security. --> <plugins>
<!-- --> <plugin>
<!-- The fact that you are presently reading this means that you have had --> <groupId>org.codehaus.mojo</groupId>
<!-- knowledge of the CeCILL license and that you accept its terms. --> <artifactId>license-maven-plugin</artifactId>
<configuration>
<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/maven-v4_0_0.xsd"> <extraExtensions>
<modelVersion>4.0.0</modelVersion> <gclc>properties</gclc>
<artifactId>gclc</artifactId> <txt>properties</txt>
<version>2.0.6-SNAPSHOT</version> </extraExtensions>
<packaging>jar</packaging> </configuration>
<url>http://www.bigeon.fr/emmanuel</url> </plugin>
<properties> </plugins>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </build>
<project.scm.id>git.bigeon.net</project.scm.id> <licenses>
</properties> <license>
<dependencies> <distribution>manual</distribution>
<dependency> <name>CeCILL 2.1</name>
<groupId>junit</groupId> <url>https://cecill.info/licences/Licence_CeCILL_V2.1-en.html</url>
<artifactId>junit</artifactId> </license>
<version>4.11</version> </licenses>
<scope>test</scope> <reporting>
</dependency> <plugins>
</dependencies> <plugin>
<parent> <groupId>org.apache.maven.plugins</groupId>
<groupId>fr.bigeon</groupId> <artifactId>maven-javadoc-plugin</artifactId>
<artifactId>ebigeon-config</artifactId> <version>2.10.3</version>
<version>1.7.1</version> </plugin>
</parent> <plugin>
<build> <groupId>com.github.sevntu-checkstyle</groupId>
<plugins> <artifactId>dsm-maven-plugin</artifactId>
<plugin> <version>2.2.0</version>
<groupId>com.mycila</groupId> </plugin>
<artifactId>license-maven-plugin</artifactId> </plugins>
<configuration> </reporting>
<header>fr/bigeon/gclc/licensing/cecill/CeCILL-header.txt</header> <developers>
<properties> <developer>
<owner>Bigeon Emmanuel</owner> <email>emmanuel@bigeon.fr</email>
<email>emmanuel@bigeon.fr</email> <name>Emmanuel Bigeon</name>
</properties> <url>bigeon.net</url>
</configuration> <roles>
<executions> <role>PM</role>
<execution> </roles>
<goals> </developer>
<goal>check</goal> </developers>
</goals> <inceptionYear>2014</inceptionYear>
</execution> <name>Generic Command Ligne console</name>
</executions> <description>A generic framework for console applications, with customized command input and output streams.</description>
</plugin> <scm>
</plugins>
</build> <developerConnection>scm:git:gogs@git.code.bigeon.net:emmanuel/gclc.git</developerConnection>
<inceptionYear>2014</inceptionYear> </scm>
<name>Generic Command Ligne console</name> <groupId>net.bigeon</groupId>
<description>provide a generic framework for console applications</description> </project>
<scm>
<developerConnection>scm:git:gogs@git.code.bigeon.net:emmanuel/gclc.git</developerConnection>
<tag>gclc-1.3.5</tag>
</scm>
</project>

117
gclc/src/main/java/fr/bigeon/gclc/ApplicationAttachement.java
View File

@ -1,59 +1,58 @@
/* /**
* Copyright Bigeon Emmanuel (2014) * gclc:fr.bigeon.gclc.ApplicationAttachement.java
* * Created on: Apr 19, 2017
* emmanuel@bigeon.fr */
* package fr.bigeon.gclc;
* This software is a computer program whose purpose is to
* provide a generic framework for console applications. /*-
* * #%L
* This software is governed by the CeCILL license under French law and * Generic Command Ligne console
* abiding by the rules of distribution of free software. You can use, * %%
* modify and/or redistribute the software under the terms of the CeCILL * Copyright (C) 2014 - 2018 bigeon.fr
* license as circulated by CEA, CNRS and INRIA at the following URL * %%
* "http://www.cecill.info". * This software is governed by the CeCILL license under French law and
* * abiding by the rules of distribution of free software. You can use,
* As a counterpart to the access to the source code and rights to copy, * modify and/ or redistribute the software under the terms of the CeCILL
* modify and redistribute granted by the license, users are provided only * license as circulated by CEA, CNRS and INRIA at the following URL
* with a limited warranty and the software's author, the holder of the * "http://www.cecill.info".
* economic rights, and the successive licensors have only limited *
* liability. * As a counterpart to the access to the source code and rights to copy,
* * modify and redistribute granted by the license, users are provided only
* In this respect, the user's attention is drawn to the risks associated * with a limited warranty and the software's author, the holder of the
* with loading, using, modifying and/or developing or reproducing the * economic rights, and the successive licensors have only limited
* software by the user in light of its specific status of free software, * liability.
* that may mean that it is complicated to manipulate, and that also *
* therefore means that it is reserved for developers and experienced * In this respect, the user's attention is drawn to the risks associated
* professionals having in-depth computer knowledge. Users are therefore * with loading, using, modifying and/or developing or reproducing the
* encouraged to load and test the software's suitability as regards their * software by the user in light of its specific status of free software,
* requirements in conditions enabling the security of their systems and/or * that may mean that it is complicated to manipulate, and that also
* data to be ensured and, more generally, to use and operate it in the * therefore means that it is reserved for developers and experienced
* same conditions as regards security. * professionals having in-depth computer knowledge. Users are therefore
* * encouraged to load and test the software's suitability as regards their
* The fact that you are presently reading this means that you have had * requirements in conditions enabling the security of their systems and/or
* knowledge of the CeCILL license and that you accept its terms. * data to be ensured and, more generally, to use and operate it in the
*/ * same conditions as regards security.
/** *
* gclc:fr.bigeon.gclc.ApplicationAttachement.java * The fact that you are presently reading this means that you have had
* Created on: Apr 19, 2017 * knowledge of the CeCILL license and that you accept its terms.
*/ * #L%
package fr.bigeon.gclc; */
import fr.bigeon.gclc.command.ICommandProvider;
import fr.bigeon.gclc.command.ICommandProvider; import fr.bigeon.gclc.exception.InvalidCommandName;
import fr.bigeon.gclc.exception.InvalidCommandName;
/** Represent a functionnality set that can be added to a console application.
/** Represent a functionnality set that can be added to a console application. *
* * @author Emmanuel Bigeon */
* @author Emmanuel Bigeon */ public interface ApplicationAttachement {
public interface ApplicationAttachement { /** Attach this object to a console application.
/** Attach this object to a console application. * <p>
* <p> * The attaching usually consist in the addition of commands in the console
* The attaching usually consist in the addition of commands in the console * application. The attached command should be specific to the attachement
* application. The attached command should be specific to the attachement * (typically, the generic help command or the script command should not be
* (typically, the generic help command or the script command should not be * added through this mechanism).
* added through this mechanism). *
* * @param application the application
* @param application the application * @throws InvalidCommandName if a command name is invalid for the
* @throws InvalidCommandName if a command name is invalid for the * application. */
* application. */ void attach(ICommandProvider application) throws InvalidCommandName;
void attach(ICommandProvider application) throws InvalidCommandName; }
}

99
gclc/src/main/java/fr/bigeon/gclc/CommandRequestListener.java
View File

@ -1,50 +1,49 @@
/* /**
* Copyright Bigeon Emmanuel (2014) * gclc:fr.bigeon.gclc.CommandRequestListener.java
* * Created on: Mar 19, 2015
* emmanuel@bigeon.fr */
* package fr.bigeon.gclc;
* This software is a computer program whose purpose is to
* provide a generic framework for console applications. /*-
* * #%L
* This software is governed by the CeCILL license under French law and * Generic Command Ligne console
* abiding by the rules of distribution of free software. You can use, * %%
* modify and/or redistribute the software under the terms of the CeCILL * Copyright (C) 2014 - 2018 bigeon.fr
* license as circulated by CEA, CNRS and INRIA at the following URL * %%
* "http://www.cecill.info". * This software is governed by the CeCILL license under French law and
* * abiding by the rules of distribution of free software. You can use,
* As a counterpart to the access to the source code and rights to copy, * modify and/ or redistribute the software under the terms of the CeCILL
* modify and redistribute granted by the license, users are provided only * license as circulated by CEA, CNRS and INRIA at the following URL
* with a limited warranty and the software's author, the holder of the * "http://www.cecill.info".
* economic rights, and the successive licensors have only limited *
* liability. * As a counterpart to the access to the source code and rights to copy,
* * modify and redistribute granted by the license, users are provided only
* In this respect, the user's attention is drawn to the risks associated * with a limited warranty and the software's author, the holder of the
* with loading, using, modifying and/or developing or reproducing the * economic rights, and the successive licensors have only limited
* software by the user in light of its specific status of free software, * liability.
* that may mean that it is complicated to manipulate, and that also *
* therefore means that it is reserved for developers and experienced * In this respect, the user's attention is drawn to the risks associated
* professionals having in-depth computer knowledge. Users are therefore * with loading, using, modifying and/or developing or reproducing the
* encouraged to load and test the software's suitability as regards their * software by the user in light of its specific status of free software,
* requirements in conditions enabling the security of their systems and/or * that may mean that it is complicated to manipulate, and that also
* data to be ensured and, more generally, to use and operate it in the * therefore means that it is reserved for developers and experienced
* same conditions as regards security. * professionals having in-depth computer knowledge. Users are therefore
* * encouraged to load and test the software's suitability as regards their
* The fact that you are presently reading this means that you have had * requirements in conditions enabling the security of their systems and/or
* knowledge of the CeCILL license and that you accept its terms. * data to be ensured and, more generally, to use and operate it in the
*/ * same conditions as regards security.
/** *
* gclc:fr.bigeon.gclc.CommandRequestListener.java * The fact that you are presently reading this means that you have had
* Created on: Mar 19, 2015 * knowledge of the CeCILL license and that you accept its terms.
*/ * #L%
package fr.bigeon.gclc; */
/** Command Request Listeners are listeners that are notified before a command
/** Command Request Listeners are listeners that are notified before a command * is executed by the ConsoleApplication.
* is executed by the ConsoleApplication. *
* * @author Emmanuel Bigeon */
* @author Emmanuel Bigeon */ public interface CommandRequestListener {
public interface CommandRequestListener { /** Indicates that the given command was requested to the application.
/** Indicates that the given command was requested to the application. *
* * @param command the command */
* @param command the command */ void commandRequest(String command);
void commandRequest(String command); }
}

555
gclc/src/main/java/fr/bigeon/gclc/ConsoleApplication.java
View File

@ -1,261 +1,294 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** gclc:fr.bigeon.gclc.ConsoleApplication.java /** gclc:fr.bigeon.gclc.ConsoleApplication.java
* Created on: Sep 6, 2014 */ * Created on: Sep 6, 2014 */
package fr.bigeon.gclc; package fr.bigeon.gclc;
import java.io.IOException; /*-
import java.io.InterruptedIOException; * #%L
import java.util.ArrayList; * Generic Command Ligne console
import java.util.Arrays; * %%
import java.util.List; * Copyright (C) 2014 - 2018 bigeon.fr
import java.util.logging.Level; * %%
import java.util.logging.Logger; * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
import fr.bigeon.gclc.command.ICommand; * modify and/ or redistribute the software under the terms of the CeCILL
import fr.bigeon.gclc.command.ICommandProvider; * license as circulated by CEA, CNRS and INRIA at the following URL
import fr.bigeon.gclc.command.SubedCommand; * "http://www.cecill.info".
import fr.bigeon.gclc.exception.CommandParsingException; *
import fr.bigeon.gclc.exception.CommandRunException; * As a counterpart to the access to the source code and rights to copy,
import fr.bigeon.gclc.exception.CommandRunExceptionType; * modify and redistribute granted by the license, users are provided only
import fr.bigeon.gclc.exception.InvalidCommandName; * with a limited warranty and the software's author, the holder of the
import fr.bigeon.gclc.i18n.Messages; * economic rights, and the successive licensors have only limited
import fr.bigeon.gclc.manager.ConsoleInput; * liability.
import fr.bigeon.gclc.manager.ConsoleOutput; *
* In this respect, the user's attention is drawn to the risks associated
/** * with loading, using, modifying and/or developing or reproducing the
* A {@link ConsoleApplication} is an application that require the user to input * software by the user in light of its specific status of free software,
* commands. * that may mean that it is complicated to manipulate, and that also
* <p> * therefore means that it is reserved for developers and experienced
* A typical use case is the following: * professionals having in-depth computer knowledge. Users are therefore
* * encouraged to load and test the software's suitability as regards their
* <pre> * requirements in conditions enabling the security of their systems and/or
* {@link ConsoleOutput} out = new {@link fr.bigeon.gclc.manager.StreamConsoleOutput StreamConsoleOutput}(); * data to be ensured and, more generally, to use and operate it in the
* {@link ConsoleInput} in = new {@link fr.bigeon.gclc.manager.StreamConsoleInput StreamConsoleInput}(); * same conditions as regards security.
* {@link ConsoleApplication} app = new {@link ConsoleApplication}(out, in, "welcome", "see you latter")}; *
* app.{@link ConsoleApplication#add(ICommand) add}("my_command", new {@link ICommand MyCommand()}); * The fact that you are presently reading this means that you have had
* app.{@link ConsoleApplication#start() start()}; * knowledge of the CeCILL license and that you accept its terms.
* </pre> * #L%
* <p> */
* That will launch in the console application that will display "welcome", import java.io.IOException;
* return a line and prompt the user for the command until he inputs the import java.io.InterruptedIOException;
* <code>exit</code> command. Then it will print "see you latter" and exit the import java.util.ArrayList;
* start method. import java.util.Arrays;
* import java.util.List;
* @author Emmanuel BIGEON */ import java.util.logging.Level;
public final class ConsoleApplication implements ICommandProvider { import java.util.logging.Logger;
/** The class logger. */ import fr.bigeon.gclc.command.ICommand;
private static final Logger LOGGER = Logger import fr.bigeon.gclc.command.ICommandProvider;
.getLogger(ConsoleApplication.class.getName()); import fr.bigeon.gclc.command.SubedCommand;
/** The welcome message. */ import fr.bigeon.gclc.exception.CommandParsingException;
public final String header; import fr.bigeon.gclc.exception.CommandRunException;
/** The good bye message. */ import fr.bigeon.gclc.exception.CommandRunExceptionType;
public final String footer; import fr.bigeon.gclc.exception.InvalidCommandName;
/** The standard output for the application. */ import fr.bigeon.gclc.i18n.Messages;
private final ConsoleOutput out; import fr.bigeon.gclc.manager.ConsoleInput;
/** The standard input for the application. */ import fr.bigeon.gclc.manager.ConsoleOutput;
private final ConsoleInput in;
/** The container of commands. */ /**
public final SubedCommand root; * A {@link ConsoleApplication} is an application that require the user to input
/** The state of this application. */ * commands.
private boolean running; * <p>
/** The listeners. */ * A typical use case is the following:
private final List<CommandRequestListener> listeners = new ArrayList<>(); *
* <pre>
/** Create a console application. * {@link ConsoleOutput} out = new {@link fr.bigeon.gclc.utils.StreamConsoleOutput StreamConsoleOutput}();
* * {@link ConsoleInput} in = new {@link fr.bigeon.gclc.utils.StreamConsoleInput StreamConsoleInput}();
* @param out the output * {@link ConsoleApplication} app = new {@link ConsoleApplication}(out, in, "welcome", "see you latter")};
* @param in the input * app.{@link ConsoleApplication#add(ICommand) add}("my_command", new {@link ICommand MyCommand()});
* @param welcome the welcoming message * app.{@link ConsoleApplication#start() start()};
* @param goodbye the goodbye message */ * </pre>
public ConsoleApplication(final ConsoleOutput out, final ConsoleInput in, * <p>
final String welcome, * That will launch in the console application that will display "welcome",
final String goodbye) { * return a line and prompt the user for the command until he inputs the
header = welcome; * <code>exit</code> command. Then it will print "see you latter" and exit the
footer = goodbye; * start method.
this.in = in; *
this.out = out; * @author Emmanuel BIGEON */
root = new SubedCommand(""); //$NON-NLS-1$ public final class ConsoleApplication implements ICommandProvider {
}
/** The class logger. */
@Override private static final Logger LOGGER = Logger
public boolean add(final ICommand cmd) throws InvalidCommandName { .getLogger(ConsoleApplication.class.getName());
return root.add(cmd); /** The welcome message. */
} public final String header;
/** The good bye message. */
/** Add a listener for command requests. public final String footer;
* /** The standard output for the application. */
* @param listener the command listener */ private final ConsoleOutput out;
public void addListener(final CommandRequestListener listener) { /** The standard input for the application. */
listeners.add(listener); private final ConsoleInput in;
} /** The container of commands. */
public final SubedCommand root;
/* (non-Javadoc) /** The state of this application. */
* @see fr.bigeon.gclc.command.ICommandProvider#executeSub(java.lang.String, private boolean running;
* java.lang.String[]) */ /** The listeners. */
@Override private final List<CommandRequestListener> listeners = new ArrayList<>();
public void executeSub(final ConsoleOutput output, final ConsoleInput input,
final String command, /** Create a console application.
final String... args) throws CommandRunException { *
root.executeSub(output, input, command, args); * @param out the output
} * @param in the input
* @param welcome the welcoming message
/** Signify to the application that no command should be inputed anymore. */ * @param goodbye the goodbye message */
public void exit() { public ConsoleApplication(final ConsoleOutput out, final ConsoleInput in,
LOGGER.fine("Request exiting application..."); //$NON-NLS-1$ final String welcome,
running = false; final String goodbye) {
in.interruptPrompt(); header = welcome;
} footer = goodbye;
this.in = in;
/* (non-Javadoc) this.out = out;
* @see fr.bigeon.gclc.command.ICommandProvider#get(java.lang.String) */ root = new SubedCommand(""); //$NON-NLS-1$
@Override }
public ICommand get(final String command) {
return root.get(command); @Override
} public boolean add(final ICommand cmd) throws InvalidCommandName {
return root.add(cmd);
/** Interpret a command line. }
* <p>
* This method will split the command in its part and execute the command /** Add a listener for command requests.
* with {@link #executeSub(ConsoleOutput, ConsoleInput, String, String...)}. *
* * @param listener the command listener */
* @param cmd the command public void addListener(final CommandRequestListener listener) {
* @throws IOException if the command could not be parsed */ listeners.add(listener);
public void interpretCommand(final String cmd) throws IOException { }
List<String> args;
try { /* (non-Javadoc)
args = GCLCConstants.splitCommand(cmd); * @see fr.bigeon.gclc.command.ICommandProvider#executeSub(java.lang.String,
} catch (final CommandParsingException e1) { * java.lang.String[]) */
out.println("Command line cannot be parsed"); //$NON-NLS-1$ @Override
LOGGER.log(Level.FINE, "Invalid user command " + cmd, e1); //$NON-NLS-1$ public void executeSub(final ConsoleOutput output, final ConsoleInput input,
return; final String command,
} final String... args) throws CommandRunException {
if (!args.isEmpty()) { root.executeSub(output, input, command, args);
try { }
executeSub(out, in, args.get(0), Arrays.copyOfRange(
args.toArray(new String[0]), 1, args.size())); /** Signify to the application that no command should be inputed anymore. */
} catch (final CommandRunException e) { public void exit() {
LOGGER.log(Level.FINE, "Command failed: " + cmd, e); //$NON-NLS-1$ LOGGER.fine("Request exiting application..."); //$NON-NLS-1$
out.println(Messages running = false;
.getString("ConsoleApplication.cmd.failed", cmd)); //$NON-NLS-1$ in.interruptPrompt();
out.println(e.getLocalizedMessage()); }
if (e.getType() == CommandRunExceptionType.USAGE) {
e.getSource().help(out); /* (non-Javadoc)
} * @see fr.bigeon.gclc.command.ICommandProvider#get(java.lang.String) */
} @Override
} public ICommand get(final String command) {
} return root.get(command);
}
/** Test if the application is running.
* /** Interpret a command line.
* @return the running status */ * <p>
public boolean isRunning() { * This method will split the command in its part and execute the command
return running; * with {@link #executeSub(ConsoleOutput, ConsoleInput, String, String...)}.
} *
* @param cmd the command
/** Remove a listener from this application. * @throws IOException if the command could not be parsed */
* public void interpretCommand(final String cmd) throws IOException {
* @param listener the command listener to remove */ List<String> args;
public void removeListener(final CommandRequestListener listener) { try {
listeners.remove(listener); args = GCLCConstants.splitCommand(cmd);
} } catch (final CommandParsingException e1) {
out.println("Command line cannot be parsed"); //$NON-NLS-1$
/** The running loop content. LOGGER.log(Level.FINE, "Invalid user command " + cmd, e1); //$NON-NLS-1$
* <p> return;
* This consisting in getting the command, executing it and exiting }
* (restarting the loop). */ if (!args.isEmpty()) {
private void runLoop() { try {
try { executeSub(out, in, args.get(0), Arrays.copyOfRange(
final String cmd = in.prompt(); args.toArray(new String[0]), 1, args.size()));
if (cmd == null || cmd.isEmpty()) { } catch (final CommandRunException e) {
return; LOGGER.log(Level.FINE, "Command failed: " + cmd, e); //$NON-NLS-1$
} out.println(Messages
for (final CommandRequestListener listener : listeners) { .getString("ConsoleApplication.cmd.failed", cmd)); //$NON-NLS-1$
listener.commandRequest(cmd); out.println(e.getLocalizedMessage());
} if (e.getType() == CommandRunExceptionType.USAGE) {
interpretCommand(cmd); get(args.get(0)).help(out);
} catch (final InterruptedIOException e) { }
LOGGER.info( }
"Prompt interrupted. It is likely the application is closing."); //$NON-NLS-1$ }
LOGGER.log(Level.FINER, "Interruption of the prompt.", //$NON-NLS-1$ }
e);
} catch (final IOException e) { /** Test if the application is running.
// The manager was closed *
running = false; * @return the running status */
LOGGER.warning( public boolean isRunning() {
"The console manager was closed. Closing the application as no one can reach it."); //$NON-NLS-1$ return running;
LOGGER.log(Level.FINE, }
"An exception caused the closing of the application", //$NON-NLS-1$
e); /** Remove a listener from this application.
} *
} * @param listener the command listener to remove */
public void removeListener(final CommandRequestListener listener) {
/** Start the application. */ listeners.remove(listener);
public void start() { }
try {
running = true; /** The running loop content.
if (header != null) { * <p>
out.println(header); * This consisting in getting the command, executing it and exiting
} * (restarting the loop). */
} catch (final IOException e) { private void runLoop() {
// The manager was closed try {
running = false; final String cmd = in.prompt();
LOGGER.warning( if (cmd == null || cmd.isEmpty()) {
"The console manager was closed. Closing the application as no one can reach it."); //$NON-NLS-1$ return;
LOGGER.log(Level.FINE, }
"An exception caused the closing of the application", //$NON-NLS-1$ for (final CommandRequestListener listener : listeners) {
e); listener.commandRequest(cmd);
return; }
} interpretCommand(cmd);
do { } catch (final InterruptedIOException e) {
runLoop(); LOGGER.info(
} while (running); "Prompt interrupted. It is likely the application is closing."); //$NON-NLS-1$
if (footer != null) { LOGGER.log(Level.FINER, "Interruption of the prompt.", //$NON-NLS-1$
try { e);
out.println(footer); } catch (final IOException e) {
} catch (final IOException e) { // The manager was closed
// The manager was closed running = false;
running = false; LOGGER.warning(
LOGGER.warning("Console manager alreaady closed."); //$NON-NLS-1$ "The console manager was closed. Closing the application as no one can reach it."); //$NON-NLS-1$
LOGGER.log(Level.FINE, LOGGER.log(Level.FINE,
"Exception raised by goodbye message printing... Application will still close.", //$NON-NLS-1$ "An exception caused the closing of the application", //$NON-NLS-1$
e); e);
} }
} }
running = false;
LOGGER.fine("Exiting application."); //$NON-NLS-1$ /** Start the application. */
} public void start() {
} try {
running = true;
if (header != null) {
out.println(header);
}
} catch (final IOException e) {
// The manager was closed
running = false;
LOGGER.warning(
"The console manager was closed. Closing the application as no one can reach it."); //$NON-NLS-1$
LOGGER.log(Level.FINE,
"An exception caused the closing of the application", //$NON-NLS-1$
e);
return;
}
do {
runLoop();
} while (running);
if (footer != null) {
try {
out.println(footer);
} catch (final IOException e) {
// The manager was closed
running = false;
LOGGER.warning("Console manager alreaady closed."); //$NON-NLS-1$
LOGGER.log(Level.FINE,
"Exception raised by goodbye message printing... Application will still close.", //$NON-NLS-1$
e);
}
}
running = false;
LOGGER.fine("Exiting application."); //$NON-NLS-1$
}
}

319
gclc/src/main/java/fr/bigeon/gclc/GCLCConstants.java
View File

@ -1,143 +1,176 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.GCLCConstants.java * gclc:fr.bigeon.gclc.GCLCConstants.java
* Created on: Jun 8, 2016 * Created on: Jun 8, 2016
*/ */
package fr.bigeon.gclc; package fr.bigeon.gclc;
import java.util.ArrayList; /*-
import java.util.List; * #%L
* Generic Command Ligne console
import fr.bigeon.gclc.exception.CommandParsingException; * %%
* Copyright (C) 2014 - 2018 bigeon.fr
/** A Utility class for GCLC * %%
* <p> * This software is governed by the CeCILL license under French law and
* This class offers a method to split a line or arguments into the list of * abiding by the rules of distribution of free software. You can use,
* arguments. * modify and/ or redistribute the software under the terms of the CeCILL
* * license as circulated by CEA, CNRS and INRIA at the following URL
* @author Emmanuel Bigeon */ * "http://www.cecill.info".
public final class GCLCConstants { *
* As a counterpart to the access to the source code and rights to copy,
/** The escaping character. */ * modify and redistribute granted by the license, users are provided only
private static final char ESCAPING_CHAR = getSystemEscapingChar(); * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
/** Hide utility class constructor. */ * liability.
private GCLCConstants() { *
// utility class * In this respect, the user's attention is drawn to the risks associated
} * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
/** Get the end of a string argument. * that may mean that it is complicated to manipulate, and that also
* * therefore means that it is reserved for developers and experienced
* @param cmd the command to parse * professionals having in-depth computer knowledge. Users are therefore
* @param startIndex the starting point of the parsing * encouraged to load and test the software's suitability as regards their
* @param index the index of the current position * requirements in conditions enabling the security of their systems and/or
* @return the argument * data to be ensured and, more generally, to use and operate it in the
* @throws CommandParsingException if the end of string does not mark end of * same conditions as regards security.
* command and is not followed by a space */ *
private static String endOfString(final String cmd, final int startIndex, * The fact that you are presently reading this means that you have had
final int index) throws CommandParsingException { * knowledge of the CeCILL license and that you accept its terms.
if (index < cmd.length() && cmd.charAt(index) != ' ') { * #L%
throw new CommandParsingException("Misplaced quote"); //$NON-NLS-1$ */
} import java.util.ArrayList;
return cmd.substring(startIndex + 1, index - 1); import java.util.List;
}
import fr.bigeon.gclc.exception.CommandParsingException;
/** Get the excaping character.
* /** A Utility class for GCLC
* @return the escaping character */ * <p>
private static char getSystemEscapingChar() { * This class offers a method to split a line or arguments into the list of
return '\\'; * arguments.
} *
* @author Emmanuel Bigeon */
/** Remove escaping characters from the string. public final class GCLCConstants {
*
* @param arg the string to remove excaping character from /** The escaping character. */
* @return the string without escape character */ private static final char ESCAPING_CHAR = getSystemEscapingChar();
private static String removeEscaped(final String arg) {
final StringBuilder builder = new StringBuilder(); /** Hide utility class constructor. */
int index = 0; private GCLCConstants() {
int endIndex = arg.indexOf(ESCAPING_CHAR); // utility class
while (endIndex != -1) { }
builder.append(arg.subSequence(index, endIndex));
index = endIndex + 1; /** Get the end of a string argument.
endIndex = arg.indexOf(ESCAPING_CHAR, index + 1); *
} * @param cmd the command to parse
builder.append(arg.substring(index)); * @param startIndex the starting point of the parsing
return builder.toString(); * @param index the index of the current position
} * @return the argument
* @throws CommandParsingException if the end of string does not mark end of
/** Splits a command in the diferrent arguments. * command and is not followed by a space */
* private static String endOfString(final String cmd, final int startIndex,
* @param cmd the command to split in its parts final int index) throws CommandParsingException {
* @return the list of argument preceded by the command name if (index < cmd.length() && cmd.charAt(index) != ' ') {
* @throws CommandParsingException if the parsing of the command failed */ throw new CommandParsingException("Misplaced quote"); //$NON-NLS-1$
public static List<String> splitCommand(final String cmd) throws CommandParsingException { }
final List<String> args = new ArrayList<>(); return cmd.substring(startIndex + 1, index - 1);
// parse the string to separate arguments }
int index = 0;
int startIndex = 0; /** Get the excaping character.
boolean escaped = false; *
boolean inString = false; * @return the escaping character */
while (index < cmd.length()) { private static char getSystemEscapingChar() {
final char c = cmd.charAt(index); return '\\';
index++; }
if (escaped || c == ESCAPING_CHAR) {
escaped = !escaped; /** Remove escaping characters from the string.
continue; *
} * @param arg the string to remove excaping character from
if (c == ' ' && !inString) { * @return the string without escape character */
final String arg = cmd.substring(startIndex, index - 1); private static String removeEscaped(final String arg) {
if (!arg.isEmpty()) { final StringBuilder builder = new StringBuilder();
args.add(removeEscaped(arg)); int index = 0;
} int endIndex = arg.indexOf(ESCAPING_CHAR);
startIndex = index; while (endIndex != -1) {
} else if (c == '"') { builder.append(arg.subSequence(index, endIndex));
if (inString) { index = endIndex + 1;
args.add(endOfString(cmd, startIndex, index)); endIndex = arg.indexOf(ESCAPING_CHAR, index + 1);
index++; }
startIndex = index; builder.append(arg.substring(index));
} return builder.toString();
inString = startIndex == index - 1; }
}
} /** Splits a command in the diferrent arguments.
if (startIndex < cmd.length()) { *
final String arg = cmd.substring(startIndex, cmd.length()); * @param cmd the command to split in its parts
args.add(arg); * @return the list of argument preceded by the command name
} * @throws CommandParsingException if the parsing of the command failed */
return args; public static List<String> splitCommand(final String cmd) throws CommandParsingException {
} final List<String> args = new ArrayList<>();
// parse the string to separate arguments
} int index = 0;
int startIndex = 0;
boolean escaped = false;
boolean inString = false;
while (index < cmd.length()) {
final char c = cmd.charAt(index);
index++;
if (escaped || c == ESCAPING_CHAR) {
escaped = !escaped;
continue;
}
if (c == ' ' && !inString) {
final String arg = cmd.substring(startIndex, index - 1);
if (!arg.isEmpty()) {
args.add(removeEscaped(arg));
}
startIndex = index;
} else if (c == '"') {
if (inString) {
args.add(endOfString(cmd, startIndex, index));
index++;
startIndex = index;
}
inString = startIndex == index - 1;
}
}
if (startIndex < cmd.length()) {
final String arg = cmd.substring(startIndex, cmd.length());
args.add(arg);
}
return args;
}
}

297
gclc/src/main/java/fr/bigeon/gclc/command/Command.java
View File

@ -1,149 +1,148 @@
/* /**
* Copyright Bigeon Emmanuel (2014) * acide:fr.bigeon.acide.Command.java
* * Created on: Jul 31, 2014
* emmanuel@bigeon.fr */
* package fr.bigeon.gclc.command;
* This software is a computer program whose purpose is to
* provide a generic framework for console applications. /*-
* * #%L
* This software is governed by the CeCILL license under French law and * Generic Command Ligne console
* abiding by the rules of distribution of free software. You can use, * %%
* modify and/or redistribute the software under the terms of the CeCILL * Copyright (C) 2014 - 2018 bigeon.fr
* license as circulated by CEA, CNRS and INRIA at the following URL * %%
* "http://www.cecill.info". * This software is governed by the CeCILL license under French law and
* * abiding by the rules of distribution of free software. You can use,
* As a counterpart to the access to the source code and rights to copy, * modify and/ or redistribute the software under the terms of the CeCILL
* modify and redistribute granted by the license, users are provided only * license as circulated by CEA, CNRS and INRIA at the following URL
* with a limited warranty and the software's author, the holder of the * "http://www.cecill.info".
* economic rights, and the successive licensors have only limited *
* liability. * As a counterpart to the access to the source code and rights to copy,
* * modify and redistribute granted by the license, users are provided only
* In this respect, the user's attention is drawn to the risks associated * with a limited warranty and the software's author, the holder of the
* with loading, using, modifying and/or developing or reproducing the * economic rights, and the successive licensors have only limited
* software by the user in light of its specific status of free software, * liability.
* that may mean that it is complicated to manipulate, and that also *
* therefore means that it is reserved for developers and experienced * In this respect, the user's attention is drawn to the risks associated
* professionals having in-depth computer knowledge. Users are therefore * with loading, using, modifying and/or developing or reproducing the
* encouraged to load and test the software's suitability as regards their * software by the user in light of its specific status of free software,
* requirements in conditions enabling the security of their systems and/or * that may mean that it is complicated to manipulate, and that also
* data to be ensured and, more generally, to use and operate it in the * therefore means that it is reserved for developers and experienced
* same conditions as regards security. * professionals having in-depth computer knowledge. Users are therefore
* * encouraged to load and test the software's suitability as regards their
* The fact that you are presently reading this means that you have had * requirements in conditions enabling the security of their systems and/or
* knowledge of the CeCILL license and that you accept its terms. * data to be ensured and, more generally, to use and operate it in the
*/ * same conditions as regards security.
/** *
* acide:fr.bigeon.acide.Command.java * The fact that you are presently reading this means that you have had
* Created on: Jul 31, 2014 * knowledge of the CeCILL license and that you accept its terms.
*/ * #L%
package fr.bigeon.gclc.command; */
import java.io.IOException;
import java.io.IOException;
import fr.bigeon.gclc.manager.ConsoleOutput;
import fr.bigeon.gclc.manager.ConsoleOutput;
/** A command to execute.
/** A command to execute. * <p>
* <p> * It is mandatory that it has a name and that name cannot start with minus
* It is mandatory that it has a name and that name cannot start with minus * character or contain spaces.
* character or contain spaces. * <p>
* <p> * A command can be executed, with parameters that will be provided as an array
* A command can be executed, with parameters that will be provided as an array * of strings.
* of strings. * <p>
* <p> * The help mechanism is doing the following:
* The help mechanism is doing the following: * <ul>
* <ul> * <li>Print the command name
* <li>Print the command name * <li>Print the {@link #brief()} message
* <li>Print the {@link #brief()} message * <li>Print a blank line
* <li>Print a blank line * <li>Print "Usage:"
* <li>Print "Usage:" * <li>Print the {@link #usagePattern() usage pattern}
* <li>Print the {@link #usagePattern() usage pattern} * <li>Print the {@link #usageDetail() usage details}
* <li>Print the {@link #usageDetail() usage details} * </ul>
* </ul> * <p>
* <p> * The default behavior for the brief message is to print the tip preceeded by a
* The default behavior for the brief message is to print the tip preceeded by a * couple of spaces.
* couple of spaces. *
* * @author Emmanuel BIGEON */
* @author Emmanuel BIGEON */ public abstract class Command implements ICommand {
public abstract class Command implements ICommand {
/** The linux end of line character. */
/** The linux end of line character. */ private static final String EOL_LINUX = "\n"; //$NON-NLS-1$
private static final String EOL_LINUX = "\n"; //$NON-NLS-1$ /** The name of the command. */
/** The name of the command. */ protected final String name;
protected final String name;
/** Create the command.
/** Create the command. *
* * @param name the command name */
* @param name the command name */ public Command(final String name) {
public Command(final String name) { super();
super(); this.name = name;
this.name = name; }
}
/** Get the brief part of the command help.
/** Get the brief part of the command help. * <p>
* <p> * This method may be overriden by implementations to improve the help
* This method may be overriden by implementations to improve the help * content. The default behavior is to print the tip.
* content. The default behavior is to print the tip. *
* * @return a brief description of the command
* @return a brief description of the command * @see Command#help(ConsoleOutput, String...) */
* @see Command#help(ConsoleOutput, String...) */ protected String brief() {
protected String brief() { return " " + tip(); //$NON-NLS-1$
return " " + tip(); //$NON-NLS-1$ }
}
/* (non-Javadoc)
/* (non-Javadoc) * @see fr.bigeon.gclc.command.ICommand#getCommandName() */
* @see fr.bigeon.gclc.command.ICommand#getCommandName() */ @Override
@Override public final String getCommandName() {
public final String getCommandName() { return name;
return name; }
}
/** Prints a help content for this command to the console output.
/** Prints a help content for this command to the console output. * <p>
* <p> * This help is following the given format:
* This help is following the given format: *
* * <pre>
* <pre> * [Command name]
* [Command name] * [brief message]
* [brief message] *
* * Usage:
* Usage: * [Usage pattern]
* [Usage pattern] *
* * [Usage details]
* [Usage details] * </pre>
* </pre> *
* * @see fr.bigeon.gclc.command.ICommand#help(ConsoleOutput, String...) */
* @see fr.bigeon.gclc.command.ICommand#help(ConsoleOutput, String...) */ @Override
@Override public final void help(final ConsoleOutput manager,
public final void help(final ConsoleOutput manager, final String... args) throws IOException {
final String... args) throws IOException { manager.println(getCommandName());
manager.println(getCommandName()); manager.println(brief());
manager.println(brief()); manager.println();
manager.println(); manager.println("Usage:"); //$NON-NLS-1$
manager.println("Usage:"); //$NON-NLS-1$ manager.println(usagePattern());
manager.println(usagePattern()); manager.println();
manager.println(); final String details = usageDetail();
final String details = usageDetail(); if (details != null && !details.isEmpty()) {
if (details != null && !details.isEmpty()) { manager.print(details);
manager.print(details); if (!(details.endsWith(EOL_LINUX) ||
if (!(details.endsWith(EOL_LINUX) || details.endsWith(System.lineSeparator()))) {
details.endsWith(System.lineSeparator()))) { manager.println();
manager.println(); }
} }
} }
}
/** This method return the detail of the help.
/** This method return the detail of the help. * <p>
* <p> * It immediatly follows the {@link #usagePattern() usage pattern}.
* It immediatly follows the {@link #usagePattern() usage pattern}. *
* * @return the detailed help (should end with end of line or be empty) */
* @return the detailed help (should end with end of line or be empty) */ protected abstract String usageDetail();
protected abstract String usageDetail();
/** This prints the usage pattern for the command.
/** This prints the usage pattern for the command. * <p>
* <p> * It follows the brief introduction on the command ({@link #brief()})
* It follows the brief introduction on the command ({@link #brief()}) *
* * @return the usage pattern */
* @return the usage pattern */ protected String usagePattern() {
protected String usagePattern() { return getCommandName();
return getCommandName(); }
} }
}

427
gclc/src/main/java/fr/bigeon/gclc/command/CommandParameters.java
View File

@ -1,214 +1,213 @@
/* /**
* Copyright Bigeon Emmanuel (2014) * gclc:fr.bigeon.gclc.command.CommandParameters.java
* * Created on: Dec 24, 2014
* emmanuel@bigeon.fr */
* package fr.bigeon.gclc.command;
* This software is a computer program whose purpose is to
* provide a generic framework for console applications. /*-
* * #%L
* This software is governed by the CeCILL license under French law and * Generic Command Ligne console
* abiding by the rules of distribution of free software. You can use, * %%
* modify and/or redistribute the software under the terms of the CeCILL * Copyright (C) 2014 - 2018 bigeon.fr
* license as circulated by CEA, CNRS and INRIA at the following URL * %%
* "http://www.cecill.info". * This software is governed by the CeCILL license under French law and
* * abiding by the rules of distribution of free software. You can use,
* As a counterpart to the access to the source code and rights to copy, * modify and/ or redistribute the software under the terms of the CeCILL
* modify and redistribute granted by the license, users are provided only * license as circulated by CEA, CNRS and INRIA at the following URL
* with a limited warranty and the software's author, the holder of the * "http://www.cecill.info".
* economic rights, and the successive licensors have only limited *
* liability. * As a counterpart to the access to the source code and rights to copy,
* * modify and redistribute granted by the license, users are provided only
* In this respect, the user's attention is drawn to the risks associated * with a limited warranty and the software's author, the holder of the
* with loading, using, modifying and/or developing or reproducing the * economic rights, and the successive licensors have only limited
* software by the user in light of its specific status of free software, * liability.
* that may mean that it is complicated to manipulate, and that also *
* therefore means that it is reserved for developers and experienced * In this respect, the user's attention is drawn to the risks associated
* professionals having in-depth computer knowledge. Users are therefore * with loading, using, modifying and/or developing or reproducing the
* encouraged to load and test the software's suitability as regards their * software by the user in light of its specific status of free software,
* requirements in conditions enabling the security of their systems and/or * that may mean that it is complicated to manipulate, and that also
* data to be ensured and, more generally, to use and operate it in the * therefore means that it is reserved for developers and experienced
* same conditions as regards security. * professionals having in-depth computer knowledge. Users are therefore
* * encouraged to load and test the software's suitability as regards their
* The fact that you are presently reading this means that you have had * requirements in conditions enabling the security of their systems and/or
* knowledge of the CeCILL license and that you accept its terms. * data to be ensured and, more generally, to use and operate it in the
*/ * same conditions as regards security.
/** *
* gclc:fr.bigeon.gclc.command.CommandParameters.java * The fact that you are presently reading this means that you have had
* Created on: Dec 24, 2014 * knowledge of the CeCILL license and that you accept its terms.
*/ * #L%
package fr.bigeon.gclc.command; */
import java.util.ArrayList;
import java.util.ArrayList; import java.util.Collections;
import java.util.Collections; import java.util.HashMap;
import java.util.HashMap; import java.util.List;
import java.util.List; import java.util.Map;
import java.util.Map; import java.util.Set;
import java.util.Set;
import fr.bigeon.gclc.exception.CommandParsingException;
import fr.bigeon.gclc.exception.CommandParsingException;
/** An object representing a collection of parameters.
/** An object representing a collection of parameters. * <p>
* <p> * It is used for defaulting values.
* It is used for defaulting values. *
* * @author Emmanuel BIGEON */
* @author Emmanuel BIGEON */ public final class CommandParameters {
public final class CommandParameters { /** Number of element for a string argument. */
/** Number of element for a string argument. */ private static final int STRINGARG_NUMBER_OF_ELEMENTS = 2;
private static final int STRINGARG_NUMBER_OF_ELEMENTS = 2; /** Boolean arguments. */
/** Boolean arguments. */ private final Map<String, Boolean> booleanArguments = new HashMap<>();
private final Map<String, Boolean> booleanArguments = new HashMap<>(); /** String arguments. */
/** String arguments. */ private final Map<String, String> stringArguments = new HashMap<>();
private final Map<String, String> stringArguments = new HashMap<>(); /** Arguments restriction on the named ones. */
/** Arguments restriction on the named ones. */ private final boolean strict;
private final boolean strict; /** additional (unnamed) parameters. */
/** additional (unnamed) parameters. */ private final List<String> additional = new ArrayList<>();
private final List<String> additional = new ArrayList<>();
/** Create a command parameter object.
/** Create a command parameter object. *
* * @param bools the boolean parameters
* @param bools the boolean parameters * @param strings the string parameters
* @param strings the string parameters * @param strict if the argument are restricted to the declared ones */
* @param strict if the argument are restricted to the declared ones */ public CommandParameters(final Set<String> bools, final Set<String> strings,
public CommandParameters(final Set<String> bools, final Set<String> strings, final boolean strict) {
final boolean strict) { for (final String string : bools) {
for (final String string : bools) { booleanArguments.put(string, Boolean.FALSE);
booleanArguments.put(string, Boolean.FALSE); }
} for (final String string : strings) {
for (final String string : strings) { stringArguments.put(string, null);
stringArguments.put(string, null); }
} this.strict = strict;
this.strict = strict; }
}
/** Get the value of a string argument.
/** Get the value of a string argument. *
* * @param key the key
* @param key the key * @return the associated value, null if it was not specified */
* @return the associated value, null if it was not specified */ public String get(final String key) {
public String get(final String key) { return stringArguments.get(key);
return stringArguments.get(key); }
}
/** Get the additional (unrecognized) arguments.
/** Get the additional (unrecognized) arguments. *
* * @return additional non parsed parameters */
* @return additional non parsed parameters */ public List<String> getAdditionals() {
public List<String> getAdditionals() { return Collections.unmodifiableList(additional);
return Collections.unmodifiableList(additional); }
}
/** Get the value of a boolean argument.
/** Get the value of a boolean argument. *
* * @param key the key
* @param key the key * @return if the key was specified */
* @return if the key was specified */ public boolean getBool(final String key) {
public boolean getBool(final String key) { return booleanArguments.containsKey(key) &&
return booleanArguments.containsKey(key) && booleanArguments.get(key).booleanValue();
booleanArguments.get(key).booleanValue(); }
}
/** Get the boolean arguments.
/** Get the boolean arguments. *
* * @return the boolean arguments */
* @return the boolean arguments */ public Set<String> getBooleanArgumentKeys() {
public Set<String> getBooleanArgumentKeys() { return booleanArguments.keySet();
return booleanArguments.keySet(); }
}
/** Get the string arguments.
/** Get the string arguments. *
* * @return the boolean arguments */
* @return the boolean arguments */ public Set<String> getStringArgumentKeys() {
public Set<String> getStringArgumentKeys() { return stringArguments.keySet();
return stringArguments.keySet(); }
}
/** Test if an argument exists in this object.
/** Test if an argument exists in this object. *
* * @param key the key
* @param key the key * @return if the key is present in string arguments or boolean ones. */
* @return if the key is present in string arguments or boolean ones. */ public boolean hasArgument(final String key) {
public boolean hasArgument(final String key) { return stringArguments.containsKey(key) ||
return stringArguments.containsKey(key) || booleanArguments.containsKey(key);
booleanArguments.containsKey(key); }
}
/** Attempt to parse an argument.
/** Attempt to parse an argument. * <p>
* <p> * This method return 0 if the parsing was incorrect, or the number of
* This method return 0 if the parsing was incorrect, or the number of * parsed elements.
* parsed elements. *
* * @param arg the argument
* @param arg the argument * @param next the next element
* @param next the next element * @return the number of element read */
* @return the number of element read */ private int parseArg(final String arg, final String next) {
private int parseArg(final String arg, final String next) { if (!arg.startsWith("-")) { //$NON-NLS-1$
if (!arg.startsWith("-")) { //$NON-NLS-1$ if (strict) {
if (strict) { return 0;
return 0; }
} additional.add(arg);
additional.add(arg); return 1;
return 1; }
} final String name = arg.substring(1);
final String name = arg.substring(1); if (booleanArguments.containsKey(name)) {
if (booleanArguments.containsKey(name)) { booleanArguments.put(name, Boolean.TRUE);
booleanArguments.put(name, Boolean.TRUE); return 1;
return 1; }
} if (stringArguments.containsKey(name)) {
if (stringArguments.containsKey(name)) { return parseStringArg(name, next);
return parseStringArg(name, next); }
} if (strict) {
if (strict) { return 0;
return 0; }
} additional.add(name);
additional.add(name); return 1;
return 1; }
}
/** Parse arguments.
/** Parse arguments. *
* * @param args the arguments to parse
* @param args the arguments to parse * @throws CommandParsingException if the arguments parsing failed */
* @throws CommandParsingException if the arguments parsing failed */ public void parseArgs(final String... args) throws CommandParsingException {
public void parseArgs(final String... args) throws CommandParsingException { int i = 0;
int i = 0; while (i < args.length) {
while (i < args.length) { String next = null;
String next = null; if (i < args.length - 1) {
if (i < args.length - 1) { next = args[i + 1];
next = args[i + 1]; }
} final int p = parseArg(args[i], next);
final int p = parseArg(args[i], next); if (p == 0) {
if (p == 0) { throw new CommandParsingException(
throw new CommandParsingException( "Invalid parameter " + args[i]); //$NON-NLS-1$
"Invalid parameter " + args[i]); //$NON-NLS-1$ }
} i += p;
i += p; }
}
}
}
/** Add a string arg value.
/** Add a string arg value. *
* * @param name the string arg name
* @param name the string arg name * @param next the string arg value
* @param next the string arg value * @return 2 or 0 if next is invalid */
* @return 2 or 0 if next is invalid */ private int parseStringArg(final String name, final String next) {
private int parseStringArg(final String name, final String next) { if (next == null) {
if (next == null) { return 0;
return 0; }
} stringArguments.put(name, next);
stringArguments.put(name, next); return STRINGARG_NUMBER_OF_ELEMENTS;
return STRINGARG_NUMBER_OF_ELEMENTS; }
}
/** Set a boolean parameter value.
/** Set a boolean parameter value. *
* * @param string the key
* @param string the key * @param value the value */
* @param value the value */ public void set(final String string, final boolean value) {
public void set(final String string, final boolean value) { if (booleanArguments.containsKey(string)) {
if (booleanArguments.containsKey(string)) { booleanArguments.put(string, Boolean.valueOf(value));
booleanArguments.put(string, Boolean.valueOf(value)); }
} }
}
/** Set a string parameter value.
/** Set a string parameter value. *
* * @param string the key
* @param string the key * @param value the value */
* @param value the value */ public void set(final String string, final String value) {
public void set(final String string, final String value) { if (stringArguments.containsKey(string)) {
if (stringArguments.containsKey(string)) { stringArguments.put(string, value);
stringArguments.put(string, value); }
} }
} }
}

246
gclc/src/main/java/fr/bigeon/gclc/command/CommandProvider.java
View File

@ -1,125 +1,121 @@
/* /** acide:fr.bigeon.acide.CommandProvider.java
* Copyright Bigeon Emmanuel (2014) * Created on: Aug 6, 2014 */
* package fr.bigeon.gclc.command;
* emmanuel@bigeon.fr
* /*-
* This software is a computer program whose purpose is to * #%L
* provide a generic framework for console applications. * Generic Command Ligne console
* * %%
* This software is governed by the CeCILL license under French law and * Copyright (C) 2014 - 2018 bigeon.fr
* abiding by the rules of distribution of free software. You can use, * %%
* modify and/or redistribute the software under the terms of the CeCILL * This software is governed by the CeCILL license under French law and
* license as circulated by CEA, CNRS and INRIA at the following URL * abiding by the rules of distribution of free software. You can use,
* "http://www.cecill.info". * modify and/ or redistribute the software under the terms of the CeCILL
* * license as circulated by CEA, CNRS and INRIA at the following URL
* As a counterpart to the access to the source code and rights to copy, * "http://www.cecill.info".
* modify and redistribute granted by the license, users are provided only *
* with a limited warranty and the software's author, the holder of the * As a counterpart to the access to the source code and rights to copy,
* economic rights, and the successive licensors have only limited * modify and redistribute granted by the license, users are provided only
* liability. * with a limited warranty and the software's author, the holder of the
* * economic rights, and the successive licensors have only limited
* In this respect, the user's attention is drawn to the risks associated * liability.
* with loading, using, modifying and/or developing or reproducing the *
* software by the user in light of its specific status of free software, * In this respect, the user's attention is drawn to the risks associated
* that may mean that it is complicated to manipulate, and that also * with loading, using, modifying and/or developing or reproducing the
* therefore means that it is reserved for developers and experienced * software by the user in light of its specific status of free software,
* professionals having in-depth computer knowledge. Users are therefore * that may mean that it is complicated to manipulate, and that also
* encouraged to load and test the software's suitability as regards their * therefore means that it is reserved for developers and experienced
* requirements in conditions enabling the security of their systems and/or * professionals having in-depth computer knowledge. Users are therefore
* data to be ensured and, more generally, to use and operate it in the * encouraged to load and test the software's suitability as regards their
* same conditions as regards security. * requirements in conditions enabling the security of their systems and/or
* * data to be ensured and, more generally, to use and operate it in the
* The fact that you are presently reading this means that you have had * same conditions as regards security.
* knowledge of the CeCILL license and that you accept its terms. *
*/ * The fact that you are presently reading this means that you have had
/** acide:fr.bigeon.acide.CommandProvider.java * knowledge of the CeCILL license and that you accept its terms.
* Created on: Aug 6, 2014 */ * #L%
package fr.bigeon.gclc.command; */
import java.util.ArrayList;
import java.util.ArrayList; import java.util.List;
import java.util.List;
import fr.bigeon.gclc.exception.CommandRunException;
import fr.bigeon.gclc.exception.CommandRunException; import fr.bigeon.gclc.exception.InvalidCommandName;
import fr.bigeon.gclc.exception.InvalidCommandName; import fr.bigeon.gclc.i18n.Messages;
import fr.bigeon.gclc.i18n.Messages; import fr.bigeon.gclc.manager.ConsoleInput;
import fr.bigeon.gclc.manager.ConsoleInput; import fr.bigeon.gclc.manager.ConsoleOutput;
import fr.bigeon.gclc.manager.ConsoleOutput;
/** A command provider is a map of key word to command to execute.
/** A command provider is a map of key word to command to execute. *
* * @author Emmanuel BIGEON */
* @author Emmanuel BIGEON */ public class CommandProvider implements ICommandProvider {
public class CommandProvider implements ICommandProvider { /** The minus character. */
/** The minus character. */ private static final String MINUS = "-"; //$NON-NLS-1$
private static final String MINUS = "-"; //$NON-NLS-1$ /** The space character. */
/** The space character. */ private static final String SPACE = " "; //$NON-NLS-1$
private static final String SPACE = " "; //$NON-NLS-1$ /** The commands map. */
/** The commands map. */ protected final List<ICommand> commands;
protected final List<ICommand> commands;
/** Create a command provider. */
/** Create a command provider. */ public CommandProvider() {
public CommandProvider() { super();
super(); commands = new ArrayList<>();
commands = new ArrayList<>(); }
}
/** Test the command name validity.
/** Test the command name validity. *
* * @param name the command name
* @param name the command name * @throws InvalidCommandName if the name is invalid */
* @throws InvalidCommandName if the name is invalid */ private static void testCommandName(final String name) throws InvalidCommandName {
private static void testCommandName(final String name) throws InvalidCommandName { if (name == null || name.isEmpty() || name.startsWith(MINUS)
if (name == null || name.isEmpty() || name.startsWith(MINUS) || || name.contains(SPACE)) {
name.contains(SPACE)) { throw new InvalidCommandName();
throw new InvalidCommandName(); }
} }
}
/* (non-Javadoc)
/* (non-Javadoc) * @see fr.bigeon.gclc.command.ICommandProvider#add(java.lang.String,
* @see fr.bigeon.gclc.command.ICommandProvider#add(java.lang.String, * fr.bigeon.gclc.command.Command) */
* fr.bigeon.gclc.command.Command) */ @Override
@Override public final boolean add(final ICommand value) throws InvalidCommandName {
public final boolean add(final ICommand value) throws InvalidCommandName { final String name = value.getCommandName();
final String name = value.getCommandName(); testCommandName(name);
testCommandName(name); if (commands.contains(value)) {
if (commands.contains(value)) { return true;
return true; }
} for (final ICommand iCommand : commands) {
for (final ICommand iCommand : commands) { if (iCommand.getCommandName().equals(value.getCommandName())) {
if (iCommand.getCommandName().equals(value.getCommandName())) { throw new InvalidCommandName(
throw new InvalidCommandName( "Name already used: " + value.getCommandName()); //$NON-NLS-1$
"Name already used: " + value.getCommandName()); //$NON-NLS-1$ }
} }
} return commands.add(value);
return commands.add(value); }
}
/* (non-Javadoc)
/* (non-Javadoc) * @see
* @see * fr.bigeon.gclc.command.ICommandProvider#executeSub(fr.bigeon.gclc.manager
* fr.bigeon.gclc.command.ICommandProvider#executeSub(fr.bigeon.gclc.manager * .ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, java.lang.String,
* .ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, java.lang.String, * java.lang.String[]) */
* java.lang.String[]) */ @Override
@Override public final void executeSub(final ConsoleOutput out, final ConsoleInput in,
public final void executeSub(final ConsoleOutput out, final ConsoleInput in, final String cmd, final String... args) throws CommandRunException {
final String cmd, final ICommand command = get(cmd);
final String... args) throws CommandRunException { if (command == null) {
for (final ICommand command : commands) { throw new CommandRunException(
if (command.getCommandName().equals(cmd)) { Messages.getString("CommandProvider.unrecognized", cmd), null); //$NON-NLS-1$
command.execute(out, in, args); }
return; command.execute(out, in, args);
} }
}
throw new CommandRunException( /* (non-Javadoc)
Messages.getString("CommandProvider.unrecognized", cmd), null); //$NON-NLS-1$ * @see fr.bigeon.gclc.command.ICommandProvider#get(java.lang.String) */
} @Override
public final ICommand get(final String commandName) {
/* (non-Javadoc) for (final ICommand command : commands) {
* @see fr.bigeon.gclc.command.ICommandProvider#get(java.lang.String) */ if (command.getCommandName().equals(commandName)) {
@Override return command;
public final ICommand get(final String commandName) { }
for (final ICommand command : commands) { }
if (command.getCommandName().equals(commandName)) { return null;
return command; }
} }
}
return null;
}
}

267
gclc/src/main/java/fr/bigeon/gclc/command/HelpExecutor.java
View File

@ -1,117 +1,150 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.HelpExecutor.java * gclc:fr.bigeon.gclc.command.HelpExecutor.java
* Created on: Sep 6, 2014 * Created on: Sep 6, 2014
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
import java.io.IOException; /*-
* #%L
import fr.bigeon.gclc.exception.CommandRunException; * Generic Command Ligne console
import fr.bigeon.gclc.exception.CommandRunExceptionType; * %%
import fr.bigeon.gclc.manager.ConsoleInput; * Copyright (C) 2014 - 2018 bigeon.fr
import fr.bigeon.gclc.manager.ConsoleOutput; * %%
import fr.bigeon.gclc.prompt.CLIPrompterMessages; * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
/** A command to print help of an other command. * modify and/ or redistribute the software under the terms of the CeCILL
* <p> * license as circulated by CEA, CNRS and INRIA at the following URL
* This command will display the help of an other command * "http://www.cecill.info".
* *
* @author Emmanuel BIGEON */ * As a counterpart to the access to the source code and rights to copy,
public final class HelpExecutor extends Command { * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
/** The command to execute the help of. */ * economic rights, and the successive licensors have only limited
private final ICommand cmd; * liability.
*
/** Create the help command. * In this respect, the user's attention is drawn to the risks associated
* * with loading, using, modifying and/or developing or reproducing the
* @param cmdName the command name * software by the user in light of its specific status of free software,
* @param cmd the command to execute the help of */ * that may mean that it is complicated to manipulate, and that also
public HelpExecutor(final String cmdName, * therefore means that it is reserved for developers and experienced
final ICommand cmd) { * professionals having in-depth computer knowledge. Users are therefore
super(cmdName); * encouraged to load and test the software's suitability as regards their
this.cmd = cmd; * requirements in conditions enabling the security of their systems and/or
} * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
/* (non-Javadoc) *
* @see fr.bigeon.gclc.command.Command#brief() */ * The fact that you are presently reading this means that you have had
@Override * knowledge of the CeCILL license and that you accept its terms.
protected String brief() { * #L%
if (cmd instanceof SubedCommand) { */
return " A command to get help for other commands"; //$NON-NLS-1$ import java.io.IOException;
}
return " A command to retrieve help for " + cmd.getCommandName(); //$NON-NLS-1$ import fr.bigeon.gclc.exception.CommandRunException;
} import fr.bigeon.gclc.exception.CommandRunExceptionType;
import fr.bigeon.gclc.manager.ConsoleInput;
/* (non-Javadoc) import fr.bigeon.gclc.manager.ConsoleOutput;
* @see fr.bigeon.gclc.command.ICommand#execute(ConsoleOutput, ConsoleInput, import fr.bigeon.gclc.prompt.CLIPrompterMessages;
* String[]) */
@Override /** A command to print help of an other command.
public void execute(final ConsoleOutput out, final ConsoleInput in, * <p>
final String... args) throws CommandRunException { * This command will display the help of an other command
try { *
cmd.help(out, args); * @author Emmanuel BIGEON */
} catch (final IOException e) { public final class HelpExecutor extends Command {
throw new CommandRunException(CommandRunExceptionType.INTERACTION,
"Console manager closed", e, this); //$NON-NLS-1$ /** The command to execute the help of. */
} private final ICommand cmd;
}
/** Create the help command.
/* (non-Javadoc) *
* @see fr.bigeon.gclc.command.Command#tip() */ * @param cmdName the command name
@Override * @param cmd the command to execute the help of */
public String tip() { public HelpExecutor(final String cmdName,
return CLIPrompterMessages.getString("help.cmd.tip"); //$NON-NLS-1$ final ICommand cmd) {
} super(cmdName);
this.cmd = cmd;
/* (non-Javadoc) }
* @see fr.bigeon.gclc.command.Command#usageDetail()
*/ /* (non-Javadoc)
@Override * @see fr.bigeon.gclc.command.Command#brief() */
protected String usageDetail() { @Override
return null; protected String brief() {
} if (cmd instanceof SubedCommand) {
return " A command to get help for other commands"; //$NON-NLS-1$
/* (non-Javadoc) }
* @see fr.bigeon.gclc.command.Command#usagePattern() */ return " A command to retrieve help for " + cmd.getCommandName(); //$NON-NLS-1$
@Override }
protected String usagePattern() {
if (cmd instanceof SubedCommand) { /* (non-Javadoc)
return getCommandName() + " <otherCommand>"; //$NON-NLS-1$ * @see fr.bigeon.gclc.command.ICommand#execute(ConsoleOutput, ConsoleInput,
} * String[]) */
return getCommandName(); @Override
} public void execute(final ConsoleOutput out, final ConsoleInput in,
} final String... args) throws CommandRunException {
try {
cmd.help(out, args);
} catch (final IOException e) {
throw new CommandRunException(CommandRunExceptionType.INTERACTION,
"Console manager closed", e); //$NON-NLS-1$
}
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.Command#tip() */
@Override
public String tip() {
return CLIPrompterMessages.getString("help.cmd.tip"); //$NON-NLS-1$
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.Command#usageDetail()
*/
@Override
protected String usageDetail() {
return null;
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.Command#usagePattern() */
@Override
protected String usagePattern() {
if (cmd instanceof SubedCommand) {
return getCommandName() + " <otherCommand>"; //$NON-NLS-1$
}
return getCommandName();
}
}

193
gclc/src/main/java/fr/bigeon/gclc/command/ICommand.java
View File

@ -1,80 +1,113 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.ICommand.java * gclc:fr.bigeon.gclc.command.ICommand.java
* Created on: May 31, 2016 * Created on: May 31, 2016
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
import java.io.IOException; /*-
* #%L
import fr.bigeon.gclc.exception.CommandRunException; * Generic Command Ligne console
import fr.bigeon.gclc.manager.ConsoleInput; * %%
import fr.bigeon.gclc.manager.ConsoleOutput; * Copyright (C) 2014 - 2018 bigeon.fr
* %%
/** The contract of commands. * This software is governed by the CeCILL license under French law and
* <p> * abiding by the rules of distribution of free software. You can use,
* This interface describe the contract of commands * modify and/ or redistribute the software under the terms of the CeCILL
* * license as circulated by CEA, CNRS and INRIA at the following URL
* @author Emmanuel Bigeon */ * "http://www.cecill.info".
public interface ICommand { *
* As a counterpart to the access to the source code and rights to copy,
/** Execute the command on the given output and input. * modify and redistribute granted by the license, users are provided only
* * with a limited warranty and the software's author, the holder of the
* @param out the normal output * economic rights, and the successive licensors have only limited
* @param in the input * liability.
* @param args the arguments *
* @throws CommandRunException if the command failed */ * In this respect, the user's attention is drawn to the risks associated
void execute(ConsoleOutput out, ConsoleInput in, * with loading, using, modifying and/or developing or reproducing the
String... args) throws CommandRunException; * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
/** Get teh command name. * therefore means that it is reserved for developers and experienced
* * professionals having in-depth computer knowledge. Users are therefore
* @return the command's name */ * encouraged to load and test the software's suitability as regards their
String getCommandName(); * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
/** This prints the help associated to this command. * same conditions as regards security.
* *
* @param output the output to print the data * The fact that you are presently reading this means that you have had
* @param args the arguments called with the help * knowledge of the CeCILL license and that you accept its terms.
* @throws IOException if the manager was closed */ * #L%
void help(ConsoleOutput output, String... args) throws IOException; */
import java.io.IOException;
/** Get a tip (brief helping message) for the command.
* import fr.bigeon.gclc.exception.CommandRunException;
* @return a tip on the command */ import fr.bigeon.gclc.manager.ConsoleInput;
String tip(); import fr.bigeon.gclc.manager.ConsoleOutput;
} /** The contract of commands.
* <p>
* This interface describe the contract of commands
*
* @author Emmanuel Bigeon */
public interface ICommand {
/** Execute the command on the given output and input.
*
* @param out the normal output
* @param in the input
* @param args the arguments
* @throws CommandRunException if the command failed */
void execute(ConsoleOutput out, ConsoleInput in,
String... args) throws CommandRunException;
/** Get teh command name.
*
* @return the command's name */
String getCommandName();
/** This prints the help associated to this command.
*
* @param output the output to print the data
* @param args the arguments called with the help
* @throws IOException if the manager was closed */
void help(ConsoleOutput output, String... args) throws IOException;
/** Get a tip (brief helping message) for the command.
*
* @return a tip on the command */
String tip();
}

201
gclc/src/main/java/fr/bigeon/gclc/command/ICommandProvider.java
View File

@ -1,84 +1,117 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** gclc:fr.bigeon.gclc.command.ICommandProvider.java /** gclc:fr.bigeon.gclc.command.ICommandProvider.java
* Created on: Sep 6, 2014 */ * Created on: Sep 6, 2014 */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
import fr.bigeon.gclc.exception.CommandRunException; /*-
import fr.bigeon.gclc.exception.InvalidCommandName; * #%L
import fr.bigeon.gclc.manager.ConsoleInput; * Generic Command Ligne console
import fr.bigeon.gclc.manager.ConsoleOutput; * %%
* Copyright (C) 2014 - 2018 bigeon.fr
/** An ICommadProvider is a provider of commands that can register commands * %%
* under some keywords. * This software is governed by the CeCILL license under French law and
* * abiding by the rules of distribution of free software. You can use,
* @author Emmanuel BIGEON */ * modify and/ or redistribute the software under the terms of the CeCILL
public interface ICommandProvider { * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
/** Adds a command to this provider, if no command was associated with the *
* given key. * As a counterpart to the access to the source code and rights to copy,
* * modify and redistribute granted by the license, users are provided only
* @param value the command to execute * with a limited warranty and the software's author, the holder of the
* @return if the command was added * economic rights, and the successive licensors have only limited
* @throws InvalidCommandName if the command name is invalid */ * liability.
boolean add(ICommand value) throws InvalidCommandName; *
* In this respect, the user's attention is drawn to the risks associated
/** Execute the command with the given name. * with loading, using, modifying and/or developing or reproducing the
* <p> * software by the user in light of its specific status of free software,
* If no command with this name is found, an error command is usually * that may mean that it is complicated to manipulate, and that also
* executed. If there are several commands with the same name, the behavior * therefore means that it is reserved for developers and experienced
* is unspecified. Depending on the implementation, it may run an error * professionals having in-depth computer knowledge. Users are therefore
* command or prompt the user for a choice. * encouraged to load and test the software's suitability as regards their
* * requirements in conditions enabling the security of their systems and/or
* @param out the output * data to be ensured and, more generally, to use and operate it in the
* @param in the input * same conditions as regards security.
* @param command the name of the command the user wishes to execute *
* @param args the arguments for the command * The fact that you are presently reading this means that you have had
* @throws CommandRunException if the command failed to run */ * knowledge of the CeCILL license and that you accept its terms.
void executeSub(ConsoleOutput out, ConsoleInput in, String command, * #L%
String... args) throws CommandRunException; */
import fr.bigeon.gclc.exception.CommandRunException;
/** Get the command with the given name. import fr.bigeon.gclc.exception.InvalidCommandName;
* <p> import fr.bigeon.gclc.manager.ConsoleInput;
* If no command with this name is found, an error command is usually import fr.bigeon.gclc.manager.ConsoleOutput;
* returned. If there are several commands with the same name, the behavior
* is unspecified. Depending on the implementation, it may return an error /** An ICommadProvider is a provider of commands that can register commands
* command or the first command with this name found. * under some keywords.
* *
* @param command the name of the command the user wishes to execute * @author Emmanuel BIGEON */
* @return the command to execute */ public interface ICommandProvider {
ICommand get(String command);
/** Adds a command to this provider, if no command was associated with the
} * given key.
*
* @param value the command to execute
* @return if the command was added
* @throws InvalidCommandName if the command name is invalid */
boolean add(ICommand value) throws InvalidCommandName;
/** Execute the command with the given name.
* <p>
* If no command with this name is found, an error command is usually
* executed. If there are several commands with the same name, the behavior
* is unspecified. Depending on the implementation, it may run an error
* command or prompt the user for a choice.
*
* @param out the output
* @param in the input
* @param command the name of the command the user wishes to execute
* @param args the arguments for the command
* @throws CommandRunException if the command failed to run */
void executeSub(ConsoleOutput out, ConsoleInput in, String command,
String... args) throws CommandRunException;
/** Get the command with the given name.
* <p>
* If no command with this name is found, an error command is usually
* returned. If there are several commands with the same name, the behavior
* is unspecified. Depending on the implementation, it may return an error
* command or the first command with this name found.
*
* @param command the name of the command the user wishes to execute
* @return the command to execute */
ICommand get(String command);
}

353
gclc/src/main/java/fr/bigeon/gclc/command/ParametrizedCommand.java
View File

@ -1,160 +1,193 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.ParametrizedCommand.java * gclc:fr.bigeon.gclc.command.ParametrizedCommand.java
* Created on: Dec 24, 2014 * Created on: Dec 24, 2014
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
import java.io.IOException; /*-
import java.util.Set; * #%L
* Generic Command Ligne console
import fr.bigeon.gclc.exception.CommandRunException; * %%
import fr.bigeon.gclc.exception.InvalidParameterException; * Copyright (C) 2014 - 2018 bigeon.fr
import fr.bigeon.gclc.manager.ConsoleInput; * %%
import fr.bigeon.gclc.manager.ConsoleOutput; * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
/** A command relying on the {@link CommandParameters} to store parameters * modify and/ or redistribute the software under the terms of the CeCILL
* values. * license as circulated by CEA, CNRS and INRIA at the following URL
* * "http://www.cecill.info".
* @author Emmanuel BIGEON */ *
public abstract class ParametrizedCommand extends Command { * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
private final ParametrizedCommandData data; * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
/** Create a parametrized command. * liability.
* <p> *
* Implementation are supposed to call the * In this respect, the user's attention is drawn to the risks associated
* {@link #addBooleanParameter(String)} and * with loading, using, modifying and/or developing or reproducing the
* {@link #addStringParameter(String, boolean)} method to set the * software by the user in light of its specific status of free software,
* parameters. * that may mean that it is complicated to manipulate, and that also
* * therefore means that it is reserved for developers and experienced
* @param name the name */ * professionals having in-depth computer knowledge. Users are therefore
public ParametrizedCommand(final String name) { * encouraged to load and test the software's suitability as regards their
this(name, true); * requirements in conditions enabling the security of their systems and/or
} * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
/** Create a parametrized command. *
* <p> * The fact that you are presently reading this means that you have had
* Implementation are supposed to call the * knowledge of the CeCILL license and that you accept its terms.
* {@link #addBooleanParameter(String)} and * #L%
* {@link #addStringParameter(String, boolean)} method to set the */
* parameters. import java.io.IOException;
* import java.util.Set;
* @param name the name
* @param strict if the arguments are restricted to the declared ones */ import fr.bigeon.gclc.exception.CommandRunException;
public ParametrizedCommand(final String name, final boolean strict) { import fr.bigeon.gclc.exception.InvalidParameterException;
super(name); import fr.bigeon.gclc.manager.ConsoleInput;
data = new ParametrizedCommandData(strict); import fr.bigeon.gclc.manager.ConsoleOutput;
}
/** A command relying on the {@link CommandParameters} to store parameters
/** Add a boolean parameter to defined parmaters. * values.
* *
* @param flag the boolean flag * @author Emmanuel BIGEON */
* @throws InvalidParameterException if the parameter is already defined as public abstract class ParametrizedCommand extends Command {
* a string parameter */
protected final void addBooleanParameter(final String flag) throws InvalidParameterException { private final ParametrizedCommandData data;
data.addBooleanParameter(flag);
} /** Create a parametrized command.
* <p>
/** Add a string parameter to defined parmaters. * Implementation are supposed to call the
* * {@link #addBooleanParameter(String)} and
* @param flag the parameter flag * {@link #addStringParameter(String, boolean)} method to set the
* @param needed if the parameter's absence should cause an exception * parameters.
* @throws InvalidParameterException if the parameter is already defined as *
* a boolean parameter */ * @param name the name */
protected final void addStringParameter(final String flag, public ParametrizedCommand(final String name) {
final boolean needed) throws InvalidParameterException { this(name, true);
data.addStringParameter(flag, needed); }
}
/** Create a parametrized command.
/** Actually performs the execution after parsing the parameters. * <p>
* * Implementation are supposed to call the
* @param out the output * {@link #addBooleanParameter(String)} and
* @param in the input * {@link #addStringParameter(String, boolean)} method to set the
* @param parameters the command parameters * parameters.
* @throws CommandRunException if the command failed */ *
protected abstract void doExecute(ConsoleOutput out, ConsoleInput in, * @param name the name
CommandParameters parameters) throws CommandRunException; * @param strict if the arguments are restricted to the declared ones */
public ParametrizedCommand(final String name, final boolean strict) {
/* (non-Javadoc) super(name);
* @see fr.bigeon.gclc.command.Command#execute(java.lang.String[]) */ data = new ParametrizedCommandData(strict);
@Override }
public final void execute(final ConsoleOutput output,
final ConsoleInput input, /** Add a boolean parameter to defined parmaters.
final String... args) throws CommandRunException { *
try { * @param flag the boolean flag
doExecute(output, input, data.getParameters(input, args)); * @throws InvalidParameterException if the parameter is already defined as
} catch (final IOException e) { * a string parameter */
throw new CommandRunException("Unable to get parameters", e, this); protected final void addBooleanParameter(final String flag) throws InvalidParameterException {
} data.addBooleanParameter(flag);
} }
/** Retrieve the boolean parameters (aka flags). /** Add a string parameter to defined parmaters.
* *
* @return the set of boolean parameters */ * @param flag the parameter flag
public final Set<String> getBooleanParameters() { * @param needed if the parameter's absence should cause an exception
return data.getBooleanParameters(); * @throws InvalidParameterException if the parameter is already defined as
} * a boolean parameter */
protected final void addStringParameter(final String flag,
/** Retrieve the parameter names. final boolean needed) throws InvalidParameterException {
* data.addStringParameter(flag, needed);
* @return the stringParams */ }
public final Set<String> getParameters() {
return data.getParameters(); /** Actually performs the execution after parsing the parameters.
} *
* @param out the output
/** Get the string parameters names. * @param in the input
* * @param parameters the command parameters
* @return the stringParams */ * @throws CommandRunException if the command failed */
public final Set<String> getStringParameters() { protected abstract void doExecute(ConsoleOutput out, ConsoleInput in,
return data.getStringParameters(); CommandParameters parameters) throws CommandRunException;
}
/* (non-Javadoc)
/** Test if a parameter is needed. * @see fr.bigeon.gclc.command.Command#execute(java.lang.String[]) */
* @Override
* @param param the parameter name public final void execute(final ConsoleOutput output,
* @return if the parameter is needed */ final ConsoleInput input,
public final boolean isNeeded(final String param) { final String... args) throws CommandRunException {
return data.isNeeded(param); try {
} doExecute(output, input, data.getParameters(input, args));
} catch (final IOException e) {
/** If the command refuse unrecognized parameters. throw new CommandRunException("Unable to get parameters", e);
* }
* @return the strict */ }
public final boolean isStrict() {
return data.isStrict(); /** Retrieve the boolean parameters (aka flags).
} *
} * @return the set of boolean parameters */
public final Set<String> getBooleanParameters() {
return data.getBooleanParameters();
}
/** Retrieve the parameter names.
*
* @return the stringParams */
public final Set<String> getParameters() {
return data.getParameters();
}
/** Get the string parameters names.
*
* @return the stringParams */
public final Set<String> getStringParameters() {
return data.getStringParameters();
}
/** Test if a parameter is needed.
*
* @param param the parameter name
* @return if the parameter is needed */
public final boolean isNeeded(final String param) {
return data.isNeeded(param);
}
/** If the command refuse unrecognized parameters.
*
* @return the strict */
public final boolean isStrict() {
return data.isStrict();
}
}

462
gclc/src/main/java/fr/bigeon/gclc/command/ParametrizedCommandData.java
View File

@ -1,210 +1,252 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.ParametrizedCommand.java * gclc:fr.bigeon.gclc.command.ParametrizedCommand.java
* Created on: Dec 24, 2014 * Created on: Dec 24, 2014
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
import java.io.IOException; /*-
import java.text.MessageFormat; * #%L
import java.util.ArrayList; * Generic Command Ligne console
import java.util.Collections; * %%
import java.util.HashMap; * Copyright (C) 2014 - 2018 bigeon.fr
import java.util.HashSet; * %%
import java.util.List; * This software is governed by the CeCILL license under French law and
import java.util.Map; * abiding by the rules of distribution of free software. You can use,
import java.util.Map.Entry; * modify and/ or redistribute the software under the terms of the CeCILL
import java.util.Set; * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
import fr.bigeon.gclc.exception.CommandParsingException; *
import fr.bigeon.gclc.exception.InvalidParameterException; * As a counterpart to the access to the source code and rights to copy,
import fr.bigeon.gclc.manager.ConsoleInput; * modify and redistribute granted by the license, users are provided only
import fr.bigeon.gclc.manager.EmptyInput; * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
/** An object to handle standardized command parameters. * liability.
* *
* @author Emmanuel BIGEON */ * In this respect, the user's attention is drawn to the risks associated
public final class ParametrizedCommandData { * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
/** The boolean parameters mandatory status. */ * that may mean that it is complicated to manipulate, and that also
private final Set<String> boolParams = new HashSet<>(); * therefore means that it is reserved for developers and experienced
/** The string parameters mandatory status. */ * professionals having in-depth computer knowledge. Users are therefore
private final Map<String, Boolean> stringParams = new HashMap<>(); * encouraged to load and test the software's suitability as regards their
/** The parameters mandatory status. */ * requirements in conditions enabling the security of their systems and/or
private final Map<String, Boolean> params = new HashMap<>(); * data to be ensured and, more generally, to use and operate it in the
/** The restriction of provided parameters on execution to declared paramters in * same conditions as regards security.
* the status maps. */ *
private final boolean strict; * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
public ParametrizedCommandData() { * #L%
this(true); */
} import java.io.IOException;
import java.text.MessageFormat;
public ParametrizedCommandData(final boolean strict) { import java.util.ArrayList;
this.strict = strict; import java.util.Collections;
} import java.util.HashMap;
import java.util.HashSet;
/** Add a boolean parameter to defined parmaters. import java.util.List;
* import java.util.Map;
* @param flag the boolean flag import java.util.Map.Entry;
* @throws InvalidParameterException if the parameter is already defined as a import java.util.Set;
* string parameter */
public final void addBooleanParameter(final String flag) import fr.bigeon.gclc.exception.CommandParsingException;
throws InvalidParameterException { import fr.bigeon.gclc.exception.InvalidParameterException;
if (params.containsKey(flag) && stringParams.containsKey(flag)) { import fr.bigeon.gclc.manager.ConsoleInput;
throw new InvalidParameterException("Parameter is already defined as string"); //$NON-NLS-1$ import fr.bigeon.gclc.manager.EmptyInput;
}
boolParams.add(flag); /** An object to handle standardized command parameters.
params.put(flag, Boolean.FALSE); *
} * @author Emmanuel BIGEON */
public final class ParametrizedCommandData {
/** Add a string parameter to defined parmaters.
* /** The boolean parameters mandatory status. */
* @param flag the parameter flag private final Set<String> boolParams = new HashSet<>();
* @param needed if the parameter's absence should cause an exception /** The string parameters mandatory status. */
* @throws InvalidParameterException if the parameter is already defined as a private final Map<String, Boolean> stringParams = new HashMap<>();
* boolean parameter */ /** The parameters mandatory status. */
public final void addStringParameter(final String flag, final boolean needed) private final Map<String, Boolean> params = new HashMap<>();
throws InvalidParameterException { /** The restriction of provided parameters on execution to declared paramters in
if (params.containsKey(flag)) { * the status maps. */
checkParam(flag, needed); private final boolean strict;
return;
} /** The data for the parametrized command. */
stringParams.put(flag, Boolean.valueOf(needed)); public ParametrizedCommandData() {
params.put(flag, Boolean.valueOf(needed)); this(true);
} }
/** Check a parameter. /** The data for a parametrized command.
* *
* @param param the string parameter * @param strict if the command was refusing unrecognized parameters */
* @param needed if the parameter is needed public ParametrizedCommandData(final boolean strict) {
* @throws InvalidParameterException if the new definition is invalid */ this.strict = strict;
private void checkParam(final String param, final boolean needed) }
throws InvalidParameterException {
if (stringParams.containsKey(param)) { /** Add a boolean parameter to defined parmaters.
final Boolean need = Boolean *
.valueOf(needed || stringParams.get(param).booleanValue()); * @param flag the boolean flag
stringParams.put(param, need); * @throws InvalidParameterException if the parameter is already defined as a
params.put(param, need); * string parameter */
return; public final void addBooleanParameter(final String flag)
} throws InvalidParameterException {
throw new InvalidParameterException("Parameter is already defined as boolean"); //$NON-NLS-1$ if (params.containsKey(flag) && stringParams.containsKey(flag)) {
} throw new InvalidParameterException("Parameter is already defined as string"); //$NON-NLS-1$
}
public final CommandParameters getParameters(final ConsoleInput input, boolParams.add(flag);
final String... args) params.put(flag, Boolean.FALSE);
throws IOException { }
final CommandParameters parameters = new CommandParameters(boolParams,
stringParams.keySet(), strict); /** Add a string parameter to defined parmaters.
try { *
parameters.parseArgs(args); * @param flag the parameter flag
} catch (final CommandParsingException e) { * @param needed if the parameter's absence should cause an exception
throw new IOException(e); * @throws InvalidParameterException if the parameter is already defined as a
} * boolean parameter */
final List<String> toProvide = new ArrayList<>(); public final void addStringParameter(final String flag, final boolean needed)
for (final Entry<String, Boolean> string : params.entrySet()) { throws InvalidParameterException {
if (string.getValue().booleanValue() if (params.containsKey(flag)) {
&& parameters.get(string.getKey()) == null) { checkParam(flag, needed);
if (input == null || input == EmptyInput.INSTANCE) { return;
throw new IOException(); }
} stringParams.put(flag, Boolean.valueOf(needed));
toProvide.add(string.getKey()); params.put(flag, Boolean.valueOf(needed));
} }
}
// for each needed parameters that is missing, prompt the user. /** Check a parameter.
fillParameters(input, toProvide, parameters); *
return parameters; * @param param the string parameter
} * @param needed if the parameter is needed
* @throws InvalidParameterException if the new definition is invalid */
/** Fill the undefined parameters. private void checkParam(final String param, final boolean needed)
* <p> throws InvalidParameterException {
* This method prompts the user to fill the needed parameters. if (stringParams.containsKey(param)) {
* final Boolean need = Boolean
* @param input the input to prompt through .valueOf(needed || stringParams.get(param).booleanValue());
* @param parameters the parameter list to complete stringParams.put(param, need);
* @param toProvide the parameters to ask for params.put(param, need);
* @throws IOException if the manager was closed */ return;
private final static void fillParameters(final ConsoleInput input, }
final List<String> toProvide, final CommandParameters parameters) throw new InvalidParameterException("Parameter is already defined as boolean"); //$NON-NLS-1$
throws IOException { }
for (final String string : toProvide) {
String value; /** Get the parameters from an input.
value = input.prompt(MessageFormat.format("value of {0}? ", string)); //$NON-NLS-1$ *
while (value.isEmpty()) { * @param input the input
value = input * @param args the command arguments
.prompt(MessageFormat.format("value of {0}? (cannot be empty) ", //$NON-NLS-1$ * @return the command object
string)); * @throws IOException if the command could not be filled. */
} public final CommandParameters getParameters(final ConsoleInput input,
parameters.set(string, value); final String... args) throws IOException {
} final CommandParameters parameters = new CommandParameters(boolParams,
} stringParams.keySet(), strict);
try {
/** Retrieve the boolean parameters (aka flags). parameters.parseArgs(args);
* } catch (final CommandParsingException e) {
* @return the set of boolean parameters */ throw new IOException(e);
public final Set<String> getBooleanParameters() { }
return Collections.unmodifiableSet(boolParams); final List<String> toProvide = new ArrayList<>();
} for (final Entry<String, Boolean> string : params.entrySet()) {
if (string.getValue().booleanValue()
/** Retrieve the parameter names. && parameters.get(string.getKey()) == null) {
* if (input == null || input == EmptyInput.INSTANCE) {
* @return the stringParams */ throw new IOException();
public final Set<String> getParameters() { }
return params.keySet(); toProvide.add(string.getKey());
} }
}
/** Get the string parameters names. // for each needed parameters that is missing, prompt the user.
* fillParameters(input, toProvide, parameters);
* @return the stringParams */ return parameters;
public final Set<String> getStringParameters() { }
return stringParams.keySet();
} /** Fill the undefined parameters.
* <p>
/** Test if a parameter is needed. * This method prompts the user to fill the needed parameters.
* *
* @param param the parameter name * @param input the input to prompt through
* @return if the parameter is needed */ * @param parameters the parameter list to complete
public final boolean isNeeded(final String param) { * @param toProvide the parameters to ask for
return params.containsKey(param) && params.get(param).booleanValue(); * @throws IOException if the manager was closed */
} private final static void fillParameters(final ConsoleInput input,
final List<String> toProvide, final CommandParameters parameters)
/** If the command refuse unrecognized parameters. throws IOException {
* for (final String string : toProvide) {
* @return the strict */ String value;
public final boolean isStrict() { value = input.prompt(MessageFormat.format("value of {0}? ", string)); //$NON-NLS-1$
return strict; while (value.isEmpty()) {
} value = input
} .prompt(MessageFormat.format("value of {0}? (cannot be empty) ", //$NON-NLS-1$
string));
}
parameters.set(string, value);
}
}
/** Retrieve the boolean parameters (aka flags).
*
* @return the set of boolean parameters */
public final Set<String> getBooleanParameters() {
return Collections.unmodifiableSet(boolParams);
}
/** Retrieve the parameter names.
*
* @return the stringParams */
public final Set<String> getParameters() {
return params.keySet();
}
/** Get the string parameters names.
*
* @return the stringParams */
public final Set<String> getStringParameters() {
return stringParams.keySet();
}
/** Test if a parameter is needed.
*
* @param param the parameter name
* @return if the parameter is needed */
public final boolean isNeeded(final String param) {
return params.containsKey(param) && params.get(param).booleanValue();
}
/** If the command refuse unrecognized parameters.
*
* @return the strict */
public final boolean isStrict() {
return strict;
}
}

406
gclc/src/main/java/fr/bigeon/gclc/command/SubedCommand.java
View File

@ -1,188 +1,218 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** gclc:fr.bigeon.gclc.command.SubedCommand.java /** gclc:fr.bigeon.gclc.command.SubedCommand.java
* Created on: Sep 6, 2014 */ * Created on: Sep 6, 2014 */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
import java.io.IOException; /*-
import java.util.Arrays; * #%L
* Generic Command Ligne console
import fr.bigeon.gclc.exception.CommandRunException; * %%
import fr.bigeon.gclc.exception.CommandRunExceptionType; * Copyright (C) 2014 - 2018 bigeon.fr
import fr.bigeon.gclc.manager.ConsoleInput; * %%
import fr.bigeon.gclc.manager.ConsoleOutput; * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
/** * modify and/ or redistribute the software under the terms of the CeCILL
* <p> * license as circulated by CEA, CNRS and INRIA at the following URL
* A subed command is a command that can execute sub commands depending on the * "http://www.cecill.info".
* first argument. *
* * As a counterpart to the access to the source code and rights to copy,
* @author Emmanuel BIGEON */ * modify and redistribute granted by the license, users are provided only
public final class SubedCommand extends CommandProvider implements ICommand { * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
/** The tab character. */ * liability.
private static final String TAB = "\t"; //$NON-NLS-1$ *
/** The command to execute when this command is called with no sub * In this respect, the user's attention is drawn to the risks associated
* arguments. * with loading, using, modifying and/or developing or reproducing the
* <p> * software by the user in light of its specific status of free software,
* This may be null, in which case the command should have arguments. */ * that may mean that it is complicated to manipulate, and that also
private final ICommand noArgCommand; * therefore means that it is reserved for developers and experienced
/** A tip on this command. */ * professionals having in-depth computer knowledge. Users are therefore
private final String tip; * encouraged to load and test the software's suitability as regards their
/** The name of the command. */ * requirements in conditions enabling the security of their systems and/or
private final String name; * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
/** Create the command that defines sub commands. *
* * The fact that you are presently reading this means that you have had
* @param name the name of the command */ * knowledge of the CeCILL license and that you accept its terms.
public SubedCommand(final String name) { * #L%
super(); */
this.name = name; import java.io.IOException;
noArgCommand = null; import java.util.Arrays;
tip = null;
} import fr.bigeon.gclc.exception.CommandRunException;
import fr.bigeon.gclc.exception.CommandRunExceptionType;
/** Create the command that defines sub commands. import fr.bigeon.gclc.manager.ConsoleInput;
* import fr.bigeon.gclc.manager.ConsoleOutput;
* @param name the name of the command
* @param noArgCommand the command to execute when no extra parameter are /**
* provided */ * <p>
public SubedCommand(final String name, final ICommand noArgCommand) { * A subed command is a command that can execute sub commands depending on the
super(); * first argument.
this.name = name; *
this.noArgCommand = noArgCommand; * @author Emmanuel BIGEON */
tip = null; public final class SubedCommand extends CommandProvider implements ICommand {
}
/** The tab character. */
/** Create the command that defines sub commands. private static final String TAB = "\t"; //$NON-NLS-1$
* /** The command to execute when this command is called with no sub
* @param name the name of the command * arguments.
* @param noArgCommand the command to execute * <p>
* @param tip the help tip associated */ * This may be null, in which case the command should have arguments. */
public SubedCommand(final String name, final ICommand noArgCommand, private final ICommand noArgCommand;
final String tip) { /** A tip on this command. */
super(); private final String tip;
this.name = name; /** The name of the command. */
this.noArgCommand = noArgCommand; private final String name;
this.tip = tip;
} /** Create the command that defines sub commands.
*
/** Create the command that defines sub commands. * @param name the name of the command */
* public SubedCommand(final String name) {
* @param name the name of the command super();
* @param tip the help tip associated */ this.name = name;
public SubedCommand(final String name, final String tip) { noArgCommand = null;
super(); tip = null;
this.name = name; }
noArgCommand = null;
this.tip = tip; /** Create the command that defines sub commands.
} *
* @param name the name of the command
/* (non-Javadoc) * @param noArgCommand the command to execute when no extra parameter are
* @see fr.bigeon.acide.Command#execute(java.lang.String[]) */ * provided */
@Override public SubedCommand(final String name, final ICommand noArgCommand) {
public void execute(final ConsoleOutput output, final ConsoleInput input, super();
final String... args) throws CommandRunException { this.name = name;
if (args.length == 0 || args[0].startsWith("-")) { //$NON-NLS-1$ this.noArgCommand = noArgCommand;
if (noArgCommand != null) { tip = null;
noArgCommand.execute(output, input, args); }
} else {
throw new CommandRunException("Unrecognized command", this); //$NON-NLS-1$ /** Create the command that defines sub commands.
} *
} else { * @param name the name of the command
* @param noArgCommand the command to execute
try { * @param tip the help tip associated */
executeSub(output, input, args[0], public SubedCommand(final String name, final ICommand noArgCommand,
Arrays.copyOfRange(args, 1, args.length)); final String tip) {
} catch (final CommandRunException e) { super();
if (e.getSource() != null) { this.name = name;
throw e; this.noArgCommand = noArgCommand;
} this.tip = tip;
throw new CommandRunException(CommandRunExceptionType.USAGE, }
e.getLocalizedMessage(), e, this);
} /** Create the command that defines sub commands.
} *
} * @param name the name of the command
* @param tip the help tip associated */
/* (non-Javadoc) public SubedCommand(final String name, final String tip) {
* @see fr.bigeon.gclc.command.ICommand#getCommandName() */ super();
@Override this.name = name;
public String getCommandName() { noArgCommand = null;
return name; this.tip = tip;
} }
/* (non-Javadoc) /* (non-Javadoc)
* @see fr.bigeon.gclc.command.Command#help() */ * @see fr.bigeon.acide.Command#execute(java.lang.String[]) */
@Override @Override
public void help(final ConsoleOutput manager, public void execute(final ConsoleOutput output, final ConsoleInput input,
final String... args) throws IOException { final String... args) throws CommandRunException {
if (args.length != 0 && !args[0].startsWith("-")) { //$NON-NLS-1$ if (args.length == 0 || args[0].startsWith("-")) { //$NON-NLS-1$
// Specific if (noArgCommand != null) {
final ICommand c = get(args[0]); noArgCommand.execute(output, input, args);
if (c != null) { } else {
c.help(manager, Arrays.copyOfRange(args, 1, args.length)); throw new CommandRunException("Unrecognized command"); //$NON-NLS-1$
} else { }
manager.println("No command "+Arrays.toString(args)); } else {
}
} else { try {
// Generic executeSub(output, input, args[0],
if (noArgCommand != null && noArgCommand.tip() != null) { Arrays.copyOfRange(args, 1, args.length));
manager.println(TAB + noArgCommand.tip()); } catch (final CommandRunException e) {
} throw new CommandRunException(CommandRunExceptionType.USAGE,
for (final ICommand cmd : commands) { e.getLocalizedMessage(), e);
if (cmd.tip() == null) { }
manager.println(TAB + cmd.getCommandName()); }
} else { }
manager.println(TAB + cmd.getCommandName() + ": " + //$NON-NLS-1$
cmd.tip()); /* (non-Javadoc)
} * @see fr.bigeon.gclc.command.ICommand#getCommandName() */
} @Override
} public String getCommandName() {
} return name;
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.Command#tip() */ /* (non-Javadoc)
@Override * @see fr.bigeon.gclc.command.Command#help() */
public String tip() { @Override
return tip; public void help(final ConsoleOutput manager,
} final String... args) throws IOException {
if (args.length != 0 && !args[0].startsWith("-")) { //$NON-NLS-1$
/* (non-Javadoc) // Specific
* @see java.lang.Object#toString() */ final ICommand c = get(args[0]);
@Override if (c != null) {
public String toString() { c.help(manager, Arrays.copyOfRange(args, 1, args.length));
return "SubedCommand " + super.toString(); //$NON-NLS-1$ } else {
} manager.println("No command "+Arrays.toString(args));
} }
} else {
// Generic
if (noArgCommand != null && noArgCommand.tip() != null) {
manager.println(TAB + noArgCommand.tip());
}
for (final ICommand cmd : commands) {
if (cmd.tip() == null) {
manager.println(TAB + cmd.getCommandName());
} else {
manager.println(TAB + cmd.getCommandName() + ": " + //$NON-NLS-1$
cmd.tip());
}
}
}
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.Command#tip() */
@Override
public String tip() {
return tip;
}
/* (non-Javadoc)
* @see java.lang.Object#toString() */
@Override
public String toString() {
return "SubedCommand " + super.toString(); //$NON-NLS-1$
}
}

236
gclc/src/main/java/fr/bigeon/gclc/command/ExitCommand.java → gclc/src/main/java/fr/bigeon/gclc/command/base/ExitCommand.java
View File

@ -1,101 +1,135 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.ExitCommand.java * gclc:fr.bigeon.gclc.ExitCommand.java
* Created on: Jun 8, 2016 * Created on: Jun 8, 2016
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command.base;
import java.io.IOException; /*-
* #%L
import fr.bigeon.gclc.ConsoleApplication; * Generic Command Ligne console
import fr.bigeon.gclc.manager.ConsoleInput; * %%
import fr.bigeon.gclc.manager.ConsoleOutput; * Copyright (C) 2014 - 2018 bigeon.fr
import fr.bigeon.gclc.prompt.CLIPrompterMessages; * %%
* This software is governed by the CeCILL license under French law and
/** A command to exit a {@link ConsoleApplication}. * abiding by the rules of distribution of free software. You can use,
* * modify and/ or redistribute the software under the terms of the CeCILL
* @author Emmanuel BIGEON */ * license as circulated by CEA, CNRS and INRIA at the following URL
public class ExitCommand implements ICommand { * "http://www.cecill.info".
/** The exit command manual message key. */ *
private static final String EXIT_MAN = "exit.man"; //$NON-NLS-1$ * As a counterpart to the access to the source code and rights to copy,
/** The tip of the exit command. */ * modify and redistribute granted by the license, users are provided only
private static final String EXIT = "exit.tip"; //$NON-NLS-1$ * with a limited warranty and the software's author, the holder of the
/** The application that will be exited when this command runs. */ * economic rights, and the successive licensors have only limited
private final ConsoleApplication app; * liability.
/** The exit command name. */ *
private final String name; * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
/** Create the exiting command. * software by the user in light of its specific status of free software,
* * that may mean that it is complicated to manipulate, and that also
* @param name the name of the command * therefore means that it is reserved for developers and experienced
* @param app the application to exit */ * professionals having in-depth computer knowledge. Users are therefore
public ExitCommand(final String name, final ConsoleApplication app) { * encouraged to load and test the software's suitability as regards their
this.name = name; * requirements in conditions enabling the security of their systems and/or
this.app = app; * data to be ensured and, more generally, to use and operate it in the
} * same conditions as regards security.
*
/** The actions to take before exiting. * The fact that you are presently reading this means that you have had
* <p> * knowledge of the CeCILL license and that you accept its terms.
* This method is intended to be overriden by sub classes. */ * #L%
protected void beforeExit() { */
// Do nothing by default import java.io.IOException;
}
import fr.bigeon.gclc.ConsoleApplication;
@Override import fr.bigeon.gclc.command.ICommand;
public final void execute(final ConsoleOutput output, import fr.bigeon.gclc.manager.ConsoleInput;
final ConsoleInput input, final String... args) { import fr.bigeon.gclc.manager.ConsoleOutput;
beforeExit(); import fr.bigeon.gclc.prompt.CLIPrompterMessages;
app.exit();
} /** A command to exit a {@link ConsoleApplication}.
*
/* (non-Javadoc) * @author Emmanuel BIGEON */
* @see fr.bigeon.gclc.command.ICommand#getCommandName() */ public final class ExitCommand implements ICommand {
@Override /** The exit command manual message key. */
public final String getCommandName() { private static final String EXIT_MAN = "exit.man"; //$NON-NLS-1$
return name; /** The tip of the exit command. */
} private static final String EXIT = "exit.tip"; //$NON-NLS-1$
/** The application that will be exited when this command runs. */
@Override private final ConsoleApplication app;
public final void help(final ConsoleOutput manager, /** The exit command name. */
final String... args) throws IOException { private final String name;
manager.println(
CLIPrompterMessages.getString(EXIT_MAN, (Object[]) args)); /** Create the exiting command.
} *
@Override * @param name the name of the command
public final String tip() { * @param app the application to exit */
return CLIPrompterMessages.getString(EXIT); public ExitCommand(final String name, final ConsoleApplication app) {
} this.name = name;
} this.app = app;
}
/** The actions to take before exiting.
* <p>
* This method is intended to be overriden by sub classes. */
protected void beforeExit() {
// Do nothing by default
}
@Override
public final void execute(final ConsoleOutput output,
final ConsoleInput input, final String... args) {
beforeExit();
app.exit();
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.ICommand#getCommandName() */
@Override
public final String getCommandName() {
return name;
}
@Override
public final void help(final ConsoleOutput manager,
final String... args) throws IOException {
manager.println(
CLIPrompterMessages.getString(EXIT_MAN, (Object[]) args));
}
@Override
public final String tip() {
return CLIPrompterMessages.getString(EXIT);
}
}

220
gclc/src/main/java/fr/bigeon/gclc/command/MockCommand.java → gclc/src/main/java/fr/bigeon/gclc/command/base/MockCommand.java
View File

@ -1,93 +1,127 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.MockCommand.java * gclc:fr.bigeon.gclc.command.MockCommand.java
* Created on: Nov 18, 2016 * Created on: Nov 18, 2016
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command.base;
import fr.bigeon.gclc.manager.ConsoleInput; import fr.bigeon.gclc.command.ICommand;
import fr.bigeon.gclc.manager.ConsoleOutput; /*-
* #%L
/** This implement a command that does nothing. * Generic Command Ligne console
* <p> * %%
* This class is intended for testing purpose only. * Copyright (C) 2014 - 2018 bigeon.fr
* * %%
* @author Emmanuel Bigeon */ * This software is governed by the CeCILL license under French law and
public final class MockCommand implements ICommand { * abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
/** The command name. */ * license as circulated by CEA, CNRS and INRIA at the following URL
private final String name; * "http://www.cecill.info".
*
/** Create the command. * As a counterpart to the access to the source code and rights to copy,
* * modify and redistribute granted by the license, users are provided only
* @param name the command name */ * with a limited warranty and the software's author, the holder of the
public MockCommand(final String name) { * economic rights, and the successive licensors have only limited
this.name = name; * liability.
} *
* In this respect, the user's attention is drawn to the risks associated
/* (non-Javadoc) * with loading, using, modifying and/or developing or reproducing the
* @see fr.bigeon.gclc.command.ICommand#execute(ConsoleOutput, ConsoleInput, * software by the user in light of its specific status of free software,
* String[]) */ * that may mean that it is complicated to manipulate, and that also
@Override * therefore means that it is reserved for developers and experienced
public void execute(final ConsoleOutput out, final ConsoleInput in, * professionals having in-depth computer knowledge. Users are therefore
final String... args) { * encouraged to load and test the software's suitability as regards their
// * requirements in conditions enabling the security of their systems and/or
} * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
/* (non-Javadoc) *
* @see fr.bigeon.gclc.command.ICommand#getCommandName() */ * The fact that you are presently reading this means that you have had
@Override * knowledge of the CeCILL license and that you accept its terms.
public String getCommandName() { * #L%
return name; */
} import fr.bigeon.gclc.manager.ConsoleInput;
import fr.bigeon.gclc.manager.ConsoleOutput;
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.ICommand#help(fr.bigeon.gclc.manager. /** This implement a command that does nothing.
* ConsoleManager, java.lang.String[]) */ * <p>
@Override * This class is intended for testing purpose only.
public void help(final ConsoleOutput manager, *
final String... args) { * @author Emmanuel Bigeon */
// public final class MockCommand implements ICommand {
}
/** The command name. */
/* (non-Javadoc) private final String name;
* @see fr.bigeon.gclc.command.ICommand#tip() */
@Override /** Create the command.
public String tip() { *
return null; * @param name the command name */
} public MockCommand(final String name) {
this.name = name;
} }
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.ICommand#execute(ConsoleOutput, ConsoleInput,
* String[]) */
@Override
public void execute(final ConsoleOutput out, final ConsoleInput in,
final String... args) {
//
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.ICommand#getCommandName() */
@Override
public String getCommandName() {
return name;
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.ICommand#help(fr.bigeon.gclc.manager.
* ConsoleManager, java.lang.String[]) */
@Override
public void help(final ConsoleOutput manager,
final String... args) {
//
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.ICommand#tip() */
@Override
public String tip() {
return null;
}
}

463
gclc/src/main/java/fr/bigeon/gclc/command/ScriptExecution.java → gclc/src/main/java/fr/bigeon/gclc/command/base/ScriptExecution.java
View File

@ -1,217 +1,246 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.ScriptExecution.java * gclc:fr.bigeon.gclc.command.ScriptExecution.java
* Created on: Jun 12, 2016 * Created on: Jun 12, 2016
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command.base;
import java.io.BufferedReader; /*-
import java.io.FileInputStream; * #%L
import java.io.IOException; * Generic Command Ligne console
import java.io.InputStreamReader; * %%
import java.nio.charset.Charset; * Copyright (C) 2014 - 2018 bigeon.fr
import java.text.MessageFormat; * %%
import java.util.Arrays; * This software is governed by the CeCILL license under French law and
import java.util.List; * abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
import fr.bigeon.gclc.ConsoleApplication; * license as circulated by CEA, CNRS and INRIA at the following URL
import fr.bigeon.gclc.GCLCConstants; * "http://www.cecill.info".
import fr.bigeon.gclc.exception.CommandParsingException; *
import fr.bigeon.gclc.exception.CommandRunException; * As a counterpart to the access to the source code and rights to copy,
import fr.bigeon.gclc.exception.CommandRunExceptionType; * modify and redistribute granted by the license, users are provided only
import fr.bigeon.gclc.manager.ConsoleInput; * with a limited warranty and the software's author, the holder of the
import fr.bigeon.gclc.manager.ConsoleOutput; * economic rights, and the successive licensors have only limited
* liability.
/** A command that will launch a series of command from a file. *
* <p> * In this respect, the user's attention is drawn to the risks associated
* This command will read a file and execute each non empty non commented line * with loading, using, modifying and/or developing or reproducing the
* as a command of the application. * software by the user in light of its specific status of free software,
* * that may mean that it is complicated to manipulate, and that also
* @author Emmanuel Bigeon */ * therefore means that it is reserved for developers and experienced
public final class ScriptExecution extends Command { * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
/** The tab character. */ * requirements in conditions enabling the security of their systems and/or
private static final String TAB = "\t"; //$NON-NLS-1$ * data to be ensured and, more generally, to use and operate it in the
/** the space character. */ * same conditions as regards security.
private static final String SPACE = " "; //$NON-NLS-1$ *
/** The application. */ * The fact that you are presently reading this means that you have had
private final ConsoleApplication application; * knowledge of the CeCILL license and that you accept its terms.
/** The commenting prefix. */ * #L%
private final String commentPrefix; */
/** The charset for files. */ import java.io.BufferedReader;
private final Charset charset; import java.io.FileInputStream;
import java.io.IOException;
/** Create the script command. import java.io.InputStreamReader;
* import java.nio.charset.Charset;
* @param name the name of the command import java.text.MessageFormat;
* @param application the application import java.util.Arrays;
* @param commentPrefix the comment prefix in the script files import java.util.List;
* @param charset the charset to use for files */
public ScriptExecution(final String name, final ConsoleApplication application, import fr.bigeon.gclc.ConsoleApplication;
final String commentPrefix, final Charset charset) { import fr.bigeon.gclc.GCLCConstants;
super(name); import fr.bigeon.gclc.command.Command;
this.application = application; import fr.bigeon.gclc.exception.CommandParsingException;
this.commentPrefix = commentPrefix; import fr.bigeon.gclc.exception.CommandRunException;
this.charset = charset; import fr.bigeon.gclc.exception.CommandRunExceptionType;
} import fr.bigeon.gclc.manager.ConsoleInput;
import fr.bigeon.gclc.manager.ConsoleOutput;
/** Check the arguments.
* /** A command that will launch a series of command from a file.
* @param args the arguments * <p>
* @throws CommandRunException if the arguments were not the ones * This command will read a file and execute each non empty non commented line
* expected */ * as a command of the application.
private void checkArgs(final String[] args) throws CommandRunException { *
if (args.length == 0) { * @author Emmanuel Bigeon */
throw new CommandRunException(CommandRunExceptionType.USAGE, public final class ScriptExecution extends Command {
"Expecting a file", this); //$NON-NLS-1$
} /** The tab character. */
} private static final String TAB = "\t"; //$NON-NLS-1$
/** the space character. */
private static final String SPACE = " "; //$NON-NLS-1$
/** The application. */
/* (non-Javadoc) private final ConsoleApplication application;
* @see fr.bigeon.gclc.command.ICommand#execute(java.lang.String[]) */ /** The commenting prefix. */
@Override private final String commentPrefix;
public void execute(final ConsoleOutput out, final ConsoleInput in, /** The charset for files. */
final String... args) throws CommandRunException { private final Charset charset;
checkArgs(args);
final String scriptFile = args[0]; /** Create the script command.
final String[] params = Arrays.copyOfRange(args, 1, args.length); *
String cmd; * @param name the name of the command
int lineNo = -1; * @param application the application
try (InputStreamReader fReader = new InputStreamReader( * @param commentPrefix the comment prefix in the script files
new FileInputStream(scriptFile), charset); * @param charset the charset to use for files */
BufferedReader reader = new BufferedReader(fReader)) { public ScriptExecution(final String name, final ConsoleApplication application,
while ((cmd = reader.readLine()) != null) { final String commentPrefix, final Charset charset) {
lineNo++; super(name);
final String cmdLine = readCommandLine(cmd, params); this.application = application;
if (cmdLine == null) { this.commentPrefix = commentPrefix;
continue; this.charset = charset;
} }
final List<String> ps = GCLCConstants.splitCommand(cmdLine);
final String command = ps.remove(0); /** Check the arguments.
application.executeSub(out, in, command, *
ps.toArray(new String[0])); * @param args the arguments
} * @throws CommandRunException if the arguments were not the ones
} catch (final CommandParsingException e) { * expected */
throw new CommandRunException(MessageFormat.format( private static void checkArgs(final String[] args) throws CommandRunException {
"Invalid command in script ({0})", e.getLocalizedMessage()), //$NON-NLS-1$ if (args.length == 0) {
e, this); throw new CommandRunException(CommandRunExceptionType.USAGE,
} catch (final IOException e) { "Expecting a file"); //$NON-NLS-1$
throw new CommandRunException("Unable to read script", //$NON-NLS-1$ }
e, this); }
} catch (final CommandRunException e) {
throw manageRunException(e, lineNo);
}
} /* (non-Javadoc)
* @see fr.bigeon.gclc.command.ICommand#execute(java.lang.String[]) */
/** This method will create the correct exception. The exception source must @Override
* be this command. public void execute(final ConsoleOutput out, final ConsoleInput in,
* final String... args) throws CommandRunException {
* @param e the exception checkArgs(args);
* @param lineNo the line nu;ber final String scriptFile = args[0];
* @return the exception to actually throw */ final String[] params = Arrays.copyOfRange(args, 1, args.length);
private CommandRunException manageRunException(final CommandRunException e, String cmd;
final int lineNo) { int lineNo = -1;
if (e.getSource() == this) { try (InputStreamReader fReader = new InputStreamReader(
// ensure closing? new FileInputStream(scriptFile), charset);
return e; BufferedReader reader = new BufferedReader(fReader)) {
} while ((cmd = reader.readLine()) != null) {
return new CommandRunException(CommandRunExceptionType.EXECUTION, lineNo++;
MessageFormat.format( final String cmdLine = readCommandLine(cmd, params);
"The script could not complete due to command failure at line {0} ({1})", //$NON-NLS-1$ if (cmdLine == null) {
Integer.valueOf(lineNo), e.getLocalizedMessage()), continue;
e, this); }
} final List<String> ps = GCLCConstants.splitCommand(cmdLine);
final String command = ps.remove(0);
/** Read a line of the script. application.executeSub(out, in, command,
* ps.toArray(new String[0]));
* @param cmd the line }
* @param params the formatting parameters } catch (final CommandParsingException e) {
* @return the command if it is indeed one, null otherwise throw new CommandRunException(MessageFormat.format(
* @throws CommandRunException if the line stqrted with a space character */ "Invalid command in script ({0})", e.getLocalizedMessage()), //$NON-NLS-1$
private String readCommandLine(final String cmd, e);
final Object[] params) throws CommandRunException { } catch (final IOException e) {
if (cmd.startsWith(SPACE) || cmd.startsWith(TAB)) { throw new CommandRunException("Unable to read script", //$NON-NLS-1$
throw new CommandRunException( e);
"Invalid line in script (line starts with space character)", //$NON-NLS-1$ } catch (final CommandRunException e) {
this); throw manageRunException(e, lineNo);
} }
if (cmd.isEmpty() || cmd.startsWith(commentPrefix)) { }
// Comment line
return null; /** This method will create the correct exception. The exception source must
} * be this command.
return MessageFormat.format(cmd, params); *
} * @param e the exception
* @param lineNo the line nu;ber
/* (non-Javadoc) * @return the exception to actually throw */
* @see fr.bigeon.gclc.command.ICommand#tip() */ private static CommandRunException manageRunException(final CommandRunException e,
@Override final int lineNo) {
public String tip() { return new CommandRunException(CommandRunExceptionType.EXECUTION,
return "Execute a script"; //$NON-NLS-1$ MessageFormat.format(
} "The script could not complete due to command failure at line {0} ({1})", //$NON-NLS-1$
Integer.valueOf(lineNo), e.getLocalizedMessage()),
/* (non-Javadoc) e);
* @see fr.bigeon.gclc.command.Command#usageDetail() */ }
@Override
protected String usageDetail() { /** Read a line of the script.
final StringBuilder builder = new StringBuilder(); *
builder.append( * @param cmd the line
" scriptfile: path to the file containing the script to execute."); //$NON-NLS-1$ * @param params the formatting parameters
builder.append(System.lineSeparator()); * @return the command if it is indeed one, null otherwise
builder.append(System.lineSeparator()); * @throws CommandRunException if the line stqrted with a space character */
builder.append( private String readCommandLine(final String cmd,
" The script file must contain one line commands. The lines must never"); //$NON-NLS-1$ final Object[] params) throws CommandRunException {
builder.append(System.lineSeparator()); if (cmd.startsWith(SPACE) || cmd.startsWith(TAB)) {
builder.append( throw new CommandRunException(
"start with whitespace characters. The lines starting with"); //$NON-NLS-1$ "Invalid line in script (line starts with space character)");
builder.append(System.lineSeparator()); }
builder.append('"'); if (cmd.isEmpty() || cmd.startsWith(commentPrefix)) {
builder.append(commentPrefix); // Comment line
builder.append("\" will be ignored as well as empty lines."); //$NON-NLS-1$ return null;
builder.append(System.lineSeparator()); }
return MessageFormat.format(cmd, params);
return builder.toString(); }
}
/* (non-Javadoc)
/* (non-Javadoc) * @see fr.bigeon.gclc.command.ICommand#tip() */
* @see fr.bigeon.gclc.command.Command#usagePattern() */ @Override
@Override public String tip() {
protected String usagePattern() { return "Execute a script"; //$NON-NLS-1$
return super.usagePattern() + " <scriptfile>"; //$NON-NLS-1$ }
}
/* (non-Javadoc)
} * @see fr.bigeon.gclc.command.Command#usageDetail() */
@Override
protected String usageDetail() {
final StringBuilder builder = new StringBuilder();
builder.append(
" scriptfile: path to the file containing the script to execute."); //$NON-NLS-1$
builder.append(System.lineSeparator());
builder.append(System.lineSeparator());
builder.append(
" The script file must contain one line commands. The lines must never"); //$NON-NLS-1$
builder.append(System.lineSeparator());
builder.append(
"start with whitespace characters. The lines starting with"); //$NON-NLS-1$
builder.append(System.lineSeparator());
builder.append('"');
builder.append(commentPrefix);
builder.append("\" will be ignored as well as empty lines."); //$NON-NLS-1$
builder.append(System.lineSeparator());
return builder.toString();
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.Command#usagePattern() */
@Override
protected String usagePattern() {
return super.usagePattern() + " <scriptfile>"; //$NON-NLS-1$
}
}

8
gclc/src/main/java/fr/bigeon/gclc/command/base/package-info.java Normal file
View File

@ -0,0 +1,8 @@
/**
*
*/
/**
* @author Emmanuel Bigeon
*
*/
package fr.bigeon.gclc.command.base;

132
gclc/src/main/java/fr/bigeon/gclc/command/package-info.java
View File

@ -1,49 +1,83 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** gclc:fr.bigeon.gclc.command.package-info.java /** gclc:fr.bigeon.gclc.command.package-info.java
* Created on: Sep 6, 2014 */ * Created on: Sep 6, 2014 */
/** This package groups elements related to /** This package groups elements related to
* {@link fr.bigeon.gclc.command.ICommand} * {@link fr.bigeon.gclc.command.ICommand}
* <p> * <p>
* There are some implementations, such as the * There are some implementations, such as the
* {@link fr.bigeon.gclc.command.ParametrizedCommand} for commands with a * {@link fr.bigeon.gclc.command.ParametrizedCommand} for commands with a
* predefined set of flags and option taking a string as value, the * predefined set of flags and option taking a string as value, the
* {@link fr.bigeon.gclc.command.SubedCommand} for a command that is declined in * {@link fr.bigeon.gclc.command.SubedCommand} for a command that is declined in
* a set of sub commands, the {@link fr.bigeon.gclc.command.HelpExecutor} for * a set of sub commands, the {@link fr.bigeon.gclc.command.HelpExecutor} for
* help display of other commands and the * help display of other commands and the
* *
* @author Emmanuel BIGEON */ * @author Emmanuel BIGEON */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
/*-
* #%L
* Generic Command Ligne console
* %%
* Copyright (C) 2014 - 2018 bigeon.fr
* %%
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
* liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
* #L%
*/

175
gclc/src/main/java/fr/bigeon/gclc/exception/CommandParsingException.java
View File

@ -1,71 +1,104 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.exception.CommandParsingException.java * gclc:fr.bigeon.gclc.exception.CommandParsingException.java
* Created on: Jun 1, 2016 * Created on: Jun 1, 2016
*/ */
package fr.bigeon.gclc.exception; package fr.bigeon.gclc.exception;
/** An exception raised during command parsing. /*-
* * #%L
* @author Emmanuel Bigeon */ * Generic Command Ligne console
public class CommandParsingException extends Exception { * %%
* Copyright (C) 2014 - 2018 bigeon.fr
/** svuid. */ * %%
private static final long serialVersionUID = 1L; * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
/** Create the exception with a message. * modify and/ or redistribute the software under the terms of the CeCILL
* * license as circulated by CEA, CNRS and INRIA at the following URL
* @param message the message */ * "http://www.cecill.info".
public CommandParsingException(final String message) { *
super(message); * As a counterpart to the access to the source code and rights to copy,
} * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
/** Create the exception with a message and a cause. * economic rights, and the successive licensors have only limited
* * liability.
* @param message the message *
* @param cause the cause */ * In this respect, the user's attention is drawn to the risks associated
public CommandParsingException(final String message, final Throwable cause) { * with loading, using, modifying and/or developing or reproducing the
super(message, cause); * software by the user in light of its specific status of free software,
} * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
/** Create the exception with a message. * professionals having in-depth computer knowledge. Users are therefore
* * encouraged to load and test the software's suitability as regards their
* @param cause the cause */ * requirements in conditions enabling the security of their systems and/or
public CommandParsingException(final Throwable cause) { * data to be ensured and, more generally, to use and operate it in the
super(cause); * same conditions as regards security.
} *
* The fact that you are presently reading this means that you have had
} * knowledge of the CeCILL license and that you accept its terms.
* #L%
*/
/** An exception raised during command parsing.
*
* @author Emmanuel Bigeon */
public class CommandParsingException extends Exception {
/** svuid. */
private static final long serialVersionUID = 1L;
/** Create the exception with a message.
*
* @param message the message */
public CommandParsingException(final String message) {
super(message);
}
/** Create the exception with a message and a cause.
*
* @param message the message
* @param cause the cause */
public CommandParsingException(final String message, final Throwable cause) {
super(message, cause);
}
/** Create the exception with a message.
*
* @param cause the cause */
public CommandParsingException(final Throwable cause) {
super(cause);
}
}

272
gclc/src/main/java/fr/bigeon/gclc/exception/CommandRunException.java
View File

@ -1,130 +1,142 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.exception.CommandRunException.java * gclc:fr.bigeon.gclc.exception.CommandRunException.java
* Created on: Feb 10, 2015 * Created on: Feb 10, 2015
*/ */
package fr.bigeon.gclc.exception; package fr.bigeon.gclc.exception;
import fr.bigeon.gclc.command.ICommand; /*-
* #%L
/** An exception thrown when a command failed to run correctly. * Generic Command Ligne console
* * %%
* @author Emmanuel BIGEON */ * Copyright (C) 2014 - 2018 Bigeon
public final class CommandRunException extends Exception { * %%
* This software is governed by the CeCILL license under French law and
/** the SVUID. */ * abiding by the rules of distribution of free software. You can use,
private static final long serialVersionUID = 1L; * modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
/** The type of run exception. */ * "http://www.cecill.info".
private final CommandRunExceptionType type; *
/** The command that caused the error. */ * As a counterpart to the access to the source code and rights to copy,
private transient ICommand source; * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
/** Create the exception. * economic rights, and the successive licensors have only limited
* * liability.
* @param type the type of exception *
* @param message the message * In this respect, the user's attention is drawn to the risks associated
* @param source the source */ * with loading, using, modifying and/or developing or reproducing the
public CommandRunException(final CommandRunExceptionType type, * software by the user in light of its specific status of free software,
final String message, final ICommand source) { * that may mean that it is complicated to manipulate, and that also
super(message); * therefore means that it is reserved for developers and experienced
this.type = type; * professionals having in-depth computer knowledge. Users are therefore
this.source = source; * encouraged to load and test the software's suitability as regards their
} * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
/** Create the exception with a cause. * same conditions as regards security.
* *
* @param type the type of exception * The fact that you are presently reading this means that you have had
* @param message a message * knowledge of the CeCILL license and that you accept its terms.
* @param cause the cause * #L%
* @param source the source */ */
public CommandRunException(final CommandRunExceptionType type,
final String message, final Throwable cause, /** An exception thrown when a command failed to run correctly.
final ICommand source) { *
super(message, cause); * @author Emmanuel BIGEON */
this.type = type; public final class CommandRunException extends Exception {
this.source = source;
} /** the SVUID. */
private static final long serialVersionUID = 1L;
/** Create the exception with type
* {@link CommandRunExceptionType#EXECUTION}. /** The type of run exception. */
* private final CommandRunExceptionType type;
* @param message a message
* @param source the source */ /** Create the exception.
public CommandRunException(final String message, final ICommand source) { *
super(message); * @param type the type of exception
type = CommandRunExceptionType.EXECUTION; * @param message the message */
this.source = source; public CommandRunException(final CommandRunExceptionType type,
} final String message) {
super(message);
/** Create the exception with type {@link CommandRunExceptionType#EXECUTION} this.type = type;
* and a cause. }
*
* @param message a message /** Create the exception with a cause.
* @param cause the cause *
* @param source the source */ * @param type the type of exception
public CommandRunException(final String message, final Throwable cause, * @param message a message
final ICommand source) { * @param cause the cause */
super(message, cause); public CommandRunException(final CommandRunExceptionType type,
type = CommandRunExceptionType.EXECUTION; final String message, final Throwable cause) {
this.source = source; super(message, cause);
} this.type = type;
}
/* (non-Javadoc)
* @see java.lang.Throwable#getLocalizedMessage() */ /** Create the exception with type {@link CommandRunExceptionType#EXECUTION}.
@Override *
public String getLocalizedMessage() { * @param message a message */
if (getCause() != null) { public CommandRunException(final String message) {
return super.getLocalizedMessage() + ": " + //$NON-NLS-1$ super(message);
getCause().getLocalizedMessage(); type = CommandRunExceptionType.EXECUTION;
} }
return super.getLocalizedMessage();
} /** Create the exception with type {@link CommandRunExceptionType#EXECUTION} and
* a cause.
/** Get the exception raising command. *
* * @param message a message
* @return the source */ * @param cause the cause */
public ICommand getSource() { public CommandRunException(final String message, final Throwable cause) {
return source; super(message, cause);
} type = CommandRunExceptionType.EXECUTION;
}
/** Get the exception type.
* /* (non-Javadoc)
* @return the type */ * @see java.lang.Throwable#getLocalizedMessage() */
public CommandRunExceptionType getType() { @Override
return type; public String getLocalizedMessage() {
} if (getCause() != null) {
} return super.getLocalizedMessage() + ": " + //$NON-NLS-1$
getCause().getLocalizedMessage();
}
return super.getLocalizedMessage();
}
/** Get the exception type.
*
* @return the type */
public CommandRunExceptionType getType() {
return type;
}
}

135
gclc/src/main/java/fr/bigeon/gclc/exception/CommandRunExceptionType.java
View File

@ -1,51 +1,84 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.exception.CommandRunExceptionType.java * gclc:fr.bigeon.gclc.exception.CommandRunExceptionType.java
* Created on: Jun 12, 2016 * Created on: Jun 12, 2016
*/ */
package fr.bigeon.gclc.exception; package fr.bigeon.gclc.exception;
/** The command run exception possible types. /*-
* * #%L
* @author Emmanuel Bigeon */ * Generic Command Ligne console
public enum CommandRunExceptionType { * %%
/** Type of exception due to a wrong usage. */ * Copyright (C) 2014 - 2018 bigeon.fr
USAGE, * %%
/** Type of exception due to a problem in execution. */ * This software is governed by the CeCILL license under French law and
EXECUTION, * abiding by the rules of distribution of free software. You can use,
/** Type of exception due to the impossibility to interact with user. */ * modify and/ or redistribute the software under the terms of the CeCILL
INTERACTION; * license as circulated by CEA, CNRS and INRIA at the following URL
} * "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
* liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
* #L%
*/
/** The command run exception possible types.
*
* @author Emmanuel Bigeon */
public enum CommandRunExceptionType {
/** Type of exception due to a wrong usage. */
USAGE,
/** Type of exception due to a problem in execution. */
EXECUTION,
/** Type of exception due to the impossibility to interact with user. */
INTERACTION;
}

187
gclc/src/main/java/fr/bigeon/gclc/exception/InvalidCommandName.java
View File

@ -1,77 +1,110 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.exception.InvalidCommandName.java * gclc:fr.bigeon.gclc.exception.InvalidCommandName.java
* Created on: Dec 23, 2014 * Created on: Dec 23, 2014
*/ */
package fr.bigeon.gclc.exception; package fr.bigeon.gclc.exception;
/** Exception sent from the application when a command is added but the name of /*-
* the command is already used. * #%L
* * Generic Command Ligne console
* @author Emmanuel BIGEON */ * %%
public class InvalidCommandName extends Exception { * Copyright (C) 2014 - 2018 bigeon.fr
* %%
/** the SVUID. */ * This software is governed by the CeCILL license under French law and
private static final long serialVersionUID = 1L; * abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
/** Default constructor. */ * license as circulated by CEA, CNRS and INRIA at the following URL
public InvalidCommandName() { * "http://www.cecill.info".
super(); *
} * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
/** Create the exception with a message. * with a limited warranty and the software's author, the holder of the
* * economic rights, and the successive licensors have only limited
* @param message the message */ * liability.
public InvalidCommandName(final String message) { *
super(message); * In this respect, the user's attention is drawn to the risks associated
} * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
/** Create the exception with a message and a cause. * that may mean that it is complicated to manipulate, and that also
* * therefore means that it is reserved for developers and experienced
* @param message the message * professionals having in-depth computer knowledge. Users are therefore
* @param cause the cause */ * encouraged to load and test the software's suitability as regards their
public InvalidCommandName(final String message, final Throwable cause) { * requirements in conditions enabling the security of their systems and/or
super(message, cause); * data to be ensured and, more generally, to use and operate it in the
} * same conditions as regards security.
*
/** Create the exception with a cause. * The fact that you are presently reading this means that you have had
* * knowledge of the CeCILL license and that you accept its terms.
* @param cause the cause */ * #L%
public InvalidCommandName(final Throwable cause) { */
super(cause); /** Exception sent from the application when a command is added but the name of
} * the command is already used.
*
} * @author Emmanuel BIGEON */
public class InvalidCommandName extends Exception {
/** the SVUID. */
private static final long serialVersionUID = 1L;
/** Default constructor. */
public InvalidCommandName() {
super();
}
/** Create the exception with a message.
*
* @param message the message */
public InvalidCommandName(final String message) {
super(message);
}
/** Create the exception with a message and a cause.
*
* @param message the message
* @param cause the cause */
public InvalidCommandName(final String message, final Throwable cause) {
super(message, cause);
}
/** Create the exception with a cause.
*
* @param cause the cause */
public InvalidCommandName(final Throwable cause) {
super(cause);
}
}

180
gclc/src/main/java/fr/bigeon/gclc/exception/InvalidParameterException.java
View File

@ -1,75 +1,105 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.exception.InvalidParameterException.java * gclc:fr.bigeon.gclc.exception.InvalidParameterException.java
* Created on: Nov 19, 2016 * Created on: Nov 19, 2016
*/ */
package fr.bigeon.gclc.exception; package fr.bigeon.gclc.exception;
/** This exception is thrown during command definitions to indicate a wrong /*-
* parameter definition. * #%L
* <p> * Generic Command Ligne console
* This class is particularly used by * %%
* {@link fr.bigeon.gclc.command.ParametrizedCommand parameterized commands}. * Copyright (C) 2014 - 2018 bigeon.fr
* * %%
* @author Emmanuel Bigeon */ * This software is governed by the CeCILL license under French law and
public class InvalidParameterException extends Exception { * abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
/** the SVUID. */ * license as circulated by CEA, CNRS and INRIA at the following URL
private static final long serialVersionUID = 1L; * "http://www.cecill.info".
*
/** Create the exception with a message. * As a counterpart to the access to the source code and rights to copy,
* * modify and redistribute granted by the license, users are provided only
* @param message the message */ * with a limited warranty and the software's author, the holder of the
public InvalidParameterException(final String message) { * economic rights, and the successive licensors have only limited
super(message); * liability.
} *
* In this respect, the user's attention is drawn to the risks associated
/** Create the exception with a message and a cause. * with loading, using, modifying and/or developing or reproducing the
* * software by the user in light of its specific status of free software,
* @param message the message * that may mean that it is complicated to manipulate, and that also
* @param cause the cause */ * therefore means that it is reserved for developers and experienced
public InvalidParameterException(final String message, final Throwable cause) { * professionals having in-depth computer knowledge. Users are therefore
super(message, cause); * encouraged to load and test the software's suitability as regards their
} * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
/** Create the exception with a cause. * same conditions as regards security.
* *
* @param cause the cause */ * The fact that you are presently reading this means that you have had
public InvalidParameterException(final Throwable cause) { * knowledge of the CeCILL license and that you accept its terms.
super(cause); * #L%
} */
/** This exception is thrown during command definitions to indicate a wrong
} * parameter definition.
*
* @author Emmanuel Bigeon */
public class InvalidParameterException extends Exception {
/** the SVUID. */
private static final long serialVersionUID = 1L;
/** Create the exception with a message.
*
* @param message the message */
public InvalidParameterException(final String message) {
super(message);
}
/** Create the exception with a message and a cause.
*
* @param message the message
* @param cause the cause */
public InvalidParameterException(final String message, final Throwable cause) {
super(message, cause);
}
/** Create the exception with a cause.
*
* @param cause the cause */
public InvalidParameterException(final Throwable cause) {
super(cause);
}
}

195
gclc/src/main/java/fr/bigeon/gclc/i18n/Messages.java
View File

@ -1,81 +1,114 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.i18n.Messages.java * gclc:fr.bigeon.gclc.i18n.Messages.java
* Created on: Jun 1, 2016 * Created on: Jun 1, 2016
*/ */
package fr.bigeon.gclc.i18n; package fr.bigeon.gclc.i18n;
import java.text.MessageFormat; /*-
import java.util.MissingResourceException; * #%L
import java.util.ResourceBundle; * Generic Command Ligne console
import java.util.logging.Level; * %%
import java.util.logging.Logger; * Copyright (C) 2014 - 2018 bigeon.fr
* %%
/** Internationalization class. * This software is governed by the CeCILL license under French law and
* * abiding by the rules of distribution of free software. You can use,
* @author Emmanuel Bigeon */ * modify and/ or redistribute the software under the terms of the CeCILL
public final class Messages { * license as circulated by CEA, CNRS and INRIA at the following URL
/** The resource bundle name. */ * "http://www.cecill.info".
private static final String BUNDLE_NAME = "fr.bigeon.gclc.l10n.messages"; //$NON-NLS-1$ *
* As a counterpart to the access to the source code and rights to copy,
/** The resource bundle. */ * modify and redistribute granted by the license, users are provided only
private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle * with a limited warranty and the software's author, the holder of the
.getBundle(BUNDLE_NAME); * economic rights, and the successive licensors have only limited
* liability.
/** The class logger. */ *
private static final Logger LOGGER = Logger * In this respect, the user's attention is drawn to the risks associated
.getLogger(Messages.class.getName()); * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
/** Utility class. */ * that may mean that it is complicated to manipulate, and that also
private Messages() { * therefore means that it is reserved for developers and experienced
// Utility class * professionals having in-depth computer knowledge. Users are therefore
} * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
/** Get formatted internationalized messages. * data to be ensured and, more generally, to use and operate it in the
* * same conditions as regards security.
* @param key the message key *
* @param args the formatting arguments * The fact that you are presently reading this means that you have had
* @return the formatted internationalized message */ * knowledge of the CeCILL license and that you accept its terms.
public static String getString(final String key, final Object... args) { * #L%
try { */
return MessageFormat.format(RESOURCE_BUNDLE.getString(key), args); import java.text.MessageFormat;
} catch (final MissingResourceException e) { import java.util.MissingResourceException;
LOGGER.log(Level.WARNING, import java.util.ResourceBundle;
"Unrecognized internationalization message key: " + key, e); //$NON-NLS-1$ import java.util.logging.Level;
return '!' + key + '!'; import java.util.logging.Logger;
}
} /** Internationalization class.
} *
* @author Emmanuel Bigeon */
public final class Messages {
/** The resource bundle name. */
private static final String BUNDLE_NAME = "fr.bigeon.gclc.l10n.messages"; //$NON-NLS-1$
/** The resource bundle. */
private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle
.getBundle(BUNDLE_NAME);
/** The class logger. */
private static final Logger LOGGER = Logger
.getLogger(Messages.class.getName());
/** Utility class. */
private Messages() {
// Utility class
}
/** Get formatted internationalized messages.
*
* @param key the message key
* @param args the formatting arguments
* @return the formatted internationalized message */
public static String getString(final String key, final Object... args) {
try {
return MessageFormat.format(RESOURCE_BUNDLE.getString(key), args);
} catch (final MissingResourceException e) {
LOGGER.log(Level.WARNING,
"Unrecognized internationalization message key: " + key, e); //$NON-NLS-1$
return '!' + key + '!';
}
}
}

270
gclc/src/main/java/fr/bigeon/gclc/manager/ConsoleInput.java
View File

@ -1,118 +1,152 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.manager.ConsoleInput.java * gclc:fr.bigeon.gclc.manager.ConsoleInput.java
* Created on: Nov 13, 2017 * Created on: Nov 13, 2017
*/ */
package fr.bigeon.gclc.manager; package fr.bigeon.gclc.manager;
import java.io.IOException; /*-
import java.io.InterruptedIOException; * #%L
* Generic Command Ligne console
import fr.bigeon.gclc.tools.StringProvider; * %%
* Copyright (C) 2014 - 2018 bigeon.fr
/** A console application input. * %%
* * This software is governed by the CeCILL license under French law and
* @author Emmanuel Bigeon */ * abiding by the rules of distribution of free software. You can use,
public interface ConsoleInput extends AutoCloseable { * modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
/** Closes the input. * "http://www.cecill.info".
* *
* @throws IOException if the close raised an exception */ * As a counterpart to the access to the source code and rights to copy,
@Override * modify and redistribute granted by the license, users are provided only
void close() throws IOException; * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
/** Get the prompt string. * liability.
* *
* @return the prompt prefix */ * In this respect, the user's attention is drawn to the risks associated
StringProvider getPrompt(); * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
/** Indicate to the input that is should interrompt the prompting, if * that may mean that it is complicated to manipulate, and that also
* possible. * therefore means that it is reserved for developers and experienced
* <p> * professionals having in-depth computer knowledge. Users are therefore
* The pending {@link #prompt()} or {@link #prompt(String)} operations * encouraged to load and test the software's suitability as regards their
* should return immediatly. However the returned value can be anything * requirements in conditions enabling the security of their systems and/or
* (from the partial prompt content to an empty string or even a null * data to be ensured and, more generally, to use and operate it in the
* pointer). */ * same conditions as regards security.
void interruptPrompt(); *
* The fact that you are presently reading this means that you have had
/** Test if the input is closed. * knowledge of the CeCILL license and that you accept its terms.
* <p> * #L%
* If this is true, {@link #prompt()} methods will return immediatly and a */
* null chain. import java.io.IOException;
* import java.io.InterruptedIOException;
* @return if the manager is closed. */
boolean isClosed(); import fr.bigeon.gclc.tools.StringProvider;
/** Prompt the user. /** A console application input.
* *
* @return the user inputed string * @author Emmanuel Bigeon */
* @throws IOException if the manager is closed or could not read the prompt public interface ConsoleInput extends AutoCloseable {
* @throws InterruptedIOException if the prompt was interrupted */
String prompt() throws IOException; /** Closes the input.
*
/** Prompt the user, with an allotated time to answer. * @throws IOException if the close raised an exception */
* @Override
* @param timeout the time to wait in milliseconds void close() throws IOException;
* @return the user inputed string, null if the timeout was reached
* @throws IOException if the manager is closed or could not read the prompt /** Get the prompt string.
* @throws InterruptedIOException if the prompt was interrupted */ *
String prompt(long timeout) throws IOException; * @return the prompt prefix */
StringProvider getPrompt();
/** Prompt the user, with a hint on what is prompted.
* /** Indicate to the input that is should interrompt the prompting, if possible.
* @param message the message to prompt the user * <p>
* @return the user inputed string * The pending {@link #prompt()} or {@link #prompt(String)} operations should
* @throws IOException if the manager is closed or could not read the prompt * return immediatly. However the returned value can be anything (from the
* @throws InterruptedIOException if the prompt was interrupted */ * partial prompt content to an empty string or even a null pointer). */
String prompt(String message) throws IOException; void interruptPrompt();
/** Prompt the user, with a hint on what is prompted and an allotated time /** Test if the input is closed.
* to answer. * <p>
* * If this is true, {@link #prompt()} methods will return immediatly and a null
* @param timeout the time to wait in milliseconds * chain.
* @param message the message to prompt the user *
* @return the user inputed string, null if the timeout was reached * @return if the manager is closed. */
* @throws IOException if the manager is closed or could not read the prompt boolean isClosed();
* @throws InterruptedIOException if the prompt was interrupted */
String prompt(String message, long timeout) throws IOException; /** Prompt the user.
*
/** Set a prompting prefix. * @return the user inputed string
* * @throws IOException if the manager is closed or could not read the prompt
* @param prompt the prompt */ * @throws InterruptedIOException if the prompt was interrupted */
void setPrompt(String prompt); String prompt() throws IOException;
void setPrompt(StringProvider string); /** Prompt the user, with an allotated time to answer.
} *
* @param timeout the time to wait in milliseconds
* @return the user inputed string, null if the timeout was reached
* @throws IOException if the manager is closed or could not read the prompt
* @throws InterruptedIOException if the prompt was interrupted */
String prompt(long timeout) throws IOException;
/** Prompt the user, with a hint on what is prompted.
*
* @param message the message to prompt the user
* @return the user inputed string
* @throws IOException if the manager is closed or could not read the prompt
* @throws InterruptedIOException if the prompt was interrupted */
String prompt(String message) throws IOException;
/** Prompt the user, with a hint on what is prompted and an allotated time to
* answer.
*
* @param timeout the time to wait in milliseconds
* @param message the message to prompt the user
* @return the user inputed string, null if the timeout was reached
* @throws IOException if the manager is closed or could not read the prompt
* @throws InterruptedIOException if the prompt was interrupted */
String prompt(String message, long timeout) throws IOException;
/** Set a prompting prefix.
*
* @param prompt the prompt */
void setPrompt(String prompt);
/** Set the prompting string.
*
* @param string the prompt string */
void setPrompt(StringProvider string);
}

185
gclc/src/main/java/fr/bigeon/gclc/manager/ConsoleOutput.java
View File

@ -1,76 +1,109 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.manager.ConsoleOutput.java * gclc:fr.bigeon.gclc.manager.ConsoleOutput.java
* Created on: Nov 13, 2017 * Created on: Nov 13, 2017
*/ */
package fr.bigeon.gclc.manager; package fr.bigeon.gclc.manager;
import java.io.IOException; /*-
* #%L
/** A console output definition. * Generic Command Ligne console
* * %%
* @author Emmanuel Bigeon */ * Copyright (C) 2014 - 2018 bigeon.fr
public interface ConsoleOutput extends AutoCloseable { * %%
* This software is governed by the CeCILL license under French law and
/** Test if the output is closed. * abiding by the rules of distribution of free software. You can use,
* * modify and/ or redistribute the software under the terms of the CeCILL
* @return if the manager is closed. */ * license as circulated by CEA, CNRS and INRIA at the following URL
boolean isClosed(); * "http://www.cecill.info".
*
/** Print a string. * As a counterpart to the access to the source code and rights to copy,
* * modify and redistribute granted by the license, users are provided only
* @param text the message to print (without line break at the end). * with a limited warranty and the software's author, the holder of the
* @throws IOException if the manager is closed or could not read the * economic rights, and the successive licensors have only limited
* prompt */ * liability.
void print(String text) throws IOException; *
* In this respect, the user's attention is drawn to the risks associated
/** Prints an end of line. * with loading, using, modifying and/or developing or reproducing the
* * software by the user in light of its specific status of free software,
* @throws IOException if the manager is closed or could not read the * that may mean that it is complicated to manipulate, and that also
* prompt */ * therefore means that it is reserved for developers and experienced
void println() throws IOException; * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
/** Print a string followed by an end of line. * requirements in conditions enabling the security of their systems and/or
* <p> * data to be ensured and, more generally, to use and operate it in the
* This is the same as calling successively {@link #print(String)} and * same conditions as regards security.
* {@link #println()}. *
* * The fact that you are presently reading this means that you have had
* @param message the message to print * knowledge of the CeCILL license and that you accept its terms.
* @throws IOException if the manager is closed or could not read the * #L%
* prompt */ */
void println(String message) throws IOException; import java.io.IOException;
} /** A console output definition.
*
* @author Emmanuel Bigeon */
public interface ConsoleOutput extends AutoCloseable {
/** Test if the output is closed.
*
* @return if the manager is closed. */
boolean isClosed();
/** Print a string.
*
* @param text the message to print (without line break at the end).
* @throws IOException if the manager is closed or could not read the
* prompt */
void print(String text) throws IOException;
/** Prints an end of line.
*
* @throws IOException if the manager is closed or could not read the
* prompt */
void println() throws IOException;
/** Print a string followed by an end of line.
* <p>
* This is the same as calling successively {@link #print(String)} and
* {@link #println()}.
*
* @param message the message to print
* @throws IOException if the manager is closed or could not read the
* prompt */
void println(String message) throws IOException;
}

281
gclc/src/main/java/fr/bigeon/gclc/manager/EmptyInput.java
View File

@ -1,124 +1,157 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.manager.EmptyInput.java * gclc:fr.bigeon.gclc.manager.EmptyInput.java
* Created on: Nov 13, 2017 * Created on: Nov 13, 2017
*/ */
package fr.bigeon.gclc.manager; package fr.bigeon.gclc.manager;
import fr.bigeon.gclc.tools.ConstantString; /*-
import fr.bigeon.gclc.tools.StringProvider; * #%L
* Generic Command Ligne console
/** A console input that return empty to all prompting. * %%
* * Copyright (C) 2014 - 2018 bigeon.fr
* @author Emmanuel Bigeon */ * %%
public final class EmptyInput implements ConsoleInput { * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
/** The empty prompter. */ * modify and/ or redistribute the software under the terms of the CeCILL
public static final ConsoleInput INSTANCE = new EmptyInput(); * license as circulated by CEA, CNRS and INRIA at the following URL
/** The empty input. */ * "http://www.cecill.info".
private EmptyInput() { *
// * As a counterpart to the access to the source code and rights to copy,
} * modify and redistribute granted by the license, users are provided only
/* (non-Javadoc) * with a limited warranty and the software's author, the holder of the
* @see fr.bigeon.gclc.manager.ConsoleInput#close() */ * economic rights, and the successive licensors have only limited
@Override * liability.
public void close() { *
// * In this respect, the user's attention is drawn to the risks associated
} * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
/* (non-Javadoc) * that may mean that it is complicated to manipulate, and that also
* @see fr.bigeon.gclc.manager.ConsoleInput#getPrompt() */ * therefore means that it is reserved for developers and experienced
@Override * professionals having in-depth computer knowledge. Users are therefore
public StringProvider getPrompt() { * encouraged to load and test the software's suitability as regards their
return new ConstantString(""); //$NON-NLS-1$ * requirements in conditions enabling the security of their systems and/or
} * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
/* (non-Javadoc) *
* @see fr.bigeon.gclc.manager.ConsoleInput#interruptPrompt() */ * The fact that you are presently reading this means that you have had
@Override * knowledge of the CeCILL license and that you accept its terms.
public void interruptPrompt() { * #L%
// */
} import fr.bigeon.gclc.tools.ConstantString;
import fr.bigeon.gclc.tools.StringProvider;
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleInput#isClosed() */ /** A console input that return empty to all prompting.
@Override *
public boolean isClosed() { * @author Emmanuel Bigeon */
return false; public final class EmptyInput implements ConsoleInput {
}
/** The empty prompter. */
/* (non-Javadoc) public static final ConsoleInput INSTANCE = new EmptyInput();
* @see fr.bigeon.gclc.manager.ConsoleInput#prompt() */ /** The empty input. */
@Override private EmptyInput() {
public String prompt() { //
return ""; //$NON-NLS-1$ }
} /* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleInput#close() */
/* (non-Javadoc) @Override
* @see fr.bigeon.gclc.manager.ConsoleInput#prompt(long) */ public void close() {
@Override //
public String prompt(final long timeout) { }
return ""; //$NON-NLS-1$
} /* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleInput#getPrompt() */
/* (non-Javadoc) @Override
* @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String) */ public StringProvider getPrompt() {
@Override return new ConstantString(""); //$NON-NLS-1$
public String prompt(final String message) { }
return ""; //$NON-NLS-1$
} /* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleInput#interruptPrompt() */
/* (non-Javadoc) @Override
* @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String, public void interruptPrompt() {
* long) */ //
@Override }
public String prompt(final String message,
final long timeout) { /* (non-Javadoc)
return ""; //$NON-NLS-1$ * @see fr.bigeon.gclc.manager.ConsoleInput#isClosed() */
} @Override
public boolean isClosed() {
/* (non-Javadoc) return false;
* @see fr.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String) */ }
@Override
public void setPrompt(final String prompt) { /* (non-Javadoc)
// * @see fr.bigeon.gclc.manager.ConsoleInput#prompt() */
} @Override
public String prompt() {
@Override return ""; //$NON-NLS-1$
public void setPrompt(StringProvider string) { }
//
} /* (non-Javadoc)
} * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(long) */
@Override
public String prompt(final long timeout) {
return ""; //$NON-NLS-1$
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String) */
@Override
public String prompt(final String message) {
return ""; //$NON-NLS-1$
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String,
* long) */
@Override
public String prompt(final String message,
final long timeout) {
return ""; //$NON-NLS-1$
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String) */
@Override
public void setPrompt(final String prompt) {
//
}
@Override
public void setPrompt(StringProvider string) {
//
}
}

1065
gclc/src/main/java/fr/bigeon/gclc/prompt/CLIPrompter.java
View File

File diff suppressed because it is too large Load Diff

191
gclc/src/main/java/fr/bigeon/gclc/prompt/CLIPrompterMessages.java
View File

@ -1,79 +1,112 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* acide:fr.bigeon.acide.tool.CLIPrompterMessages.java * acide:fr.bigeon.acide.tool.CLIPrompterMessages.java
* Created on: Aug 6, 2014 * Created on: Aug 6, 2014
*/ */
package fr.bigeon.gclc.prompt; package fr.bigeon.gclc.prompt;
import java.text.MessageFormat; /*-
import java.util.MissingResourceException; * #%L
import java.util.ResourceBundle; * Generic Command Ligne console
import java.util.logging.Level; * %%
import java.util.logging.Logger; * Copyright (C) 2014 - 2018 bigeon.fr
* %%
/** Utility class for the messages of the CLIPrompter. * This software is governed by the CeCILL license under French law and
* * abiding by the rules of distribution of free software. You can use,
* @author Emmanuel BIGEON */ * modify and/ or redistribute the software under the terms of the CeCILL
public final class CLIPrompterMessages { * license as circulated by CEA, CNRS and INRIA at the following URL
/** The resource name. */ * "http://www.cecill.info".
private static final String BUNDLE_NAME = "fr.bigeon.gclc.messages"; //$NON-NLS-1$ *
/** The resource. */ * As a counterpart to the access to the source code and rights to copy,
private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle * modify and redistribute granted by the license, users are provided only
.getBundle(BUNDLE_NAME); * with a limited warranty and the software's author, the holder of the
/** The logger. */ * economic rights, and the successive licensors have only limited
private static final Logger LOGGER = Logger * liability.
.getLogger(CLIPrompterMessages.class.getName()); *
* In this respect, the user's attention is drawn to the risks associated
/** Utility class. */ * with loading, using, modifying and/or developing or reproducing the
private CLIPrompterMessages() { * software by the user in light of its specific status of free software,
// Utility constructor * that may mean that it is complicated to manipulate, and that also
} * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
/** Return the formatted message corresponding to the given key. * encouraged to load and test the software's suitability as regards their
* * requirements in conditions enabling the security of their systems and/or
* @param key the message's key * data to be ensured and, more generally, to use and operate it in the
* @param args the arguments * same conditions as regards security.
* @return the formatted message */ *
public static String getString(final String key, final Object... args) { * The fact that you are presently reading this means that you have had
try { * knowledge of the CeCILL license and that you accept its terms.
return MessageFormat.format(RESOURCE_BUNDLE.getString(key), args); * #L%
} catch (final MissingResourceException e) { */
LOGGER.warning("Unrecognized key: " + key); //$NON-NLS-1$ import java.text.MessageFormat;
LOGGER.log(Level.FINE, "Missing key in " + BUNDLE_NAME, e); //$NON-NLS-1$ import java.util.MissingResourceException;
return '!' + key + '!'; import java.util.ResourceBundle;
} import java.util.logging.Level;
} import java.util.logging.Logger;
}
/** Utility class for the messages of the CLIPrompter.
*
* @author Emmanuel BIGEON */
public final class CLIPrompterMessages {
/** The resource name. */
private static final String BUNDLE_NAME = "fr.bigeon.gclc.messages"; //$NON-NLS-1$
/** The resource. */
private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle
.getBundle(BUNDLE_NAME);
/** The logger. */
private static final Logger LOGGER = Logger
.getLogger(CLIPrompterMessages.class.getName());
/** Utility class. */
private CLIPrompterMessages() {
// Utility constructor
}
/** Return the formatted message corresponding to the given key.
*
* @param key the message's key
* @param args the arguments
* @return the formatted message */
public static String getString(final String key, final Object... args) {
try {
return MessageFormat.format(RESOURCE_BUNDLE.getString(key), args);
} catch (final MissingResourceException e) {
LOGGER.warning("Unrecognized key: " + key); //$NON-NLS-1$
LOGGER.log(Level.FINE, "Missing key in " + BUNDLE_NAME, e); //$NON-NLS-1$
return '!' + key + '!';
}
}
}

128
gclc/src/main/java/fr/bigeon/gclc/prompt/package-info.java
View File

@ -1,47 +1,81 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** gclc:fr.bigeon.gclc.prompt.package-info.java /** gclc:fr.bigeon.gclc.prompt.package-info.java
* Created on: Sep 6, 2014 */ * Created on: Sep 6, 2014 */
/** Client prompting related objects. /** Client prompting related objects.
* <p> * <p>
* This package is used for the formatting of prompts for the user. The * This package is used for the formatting of prompts for the user. The
* {@link fr.bigeon.gclc.prompt.CLIPrompter} class provides utility methods to * {@link fr.bigeon.gclc.prompt.CLIPrompter} class provides utility methods to
* retrieve certain basic type of data from the user or to give list choices. * retrieve certain basic type of data from the user or to give list choices.
* <p> * <p>
* The {@link fr.bigeon.gclc.prompt.CLIPrompterMessages} class is used for * The {@link fr.bigeon.gclc.prompt.CLIPrompterMessages} class is used for
* internationalization of the prompting methods. * internationalization of the prompting methods.
* *
* @author Emmanuel BIGEON */ * @author Emmanuel BIGEON */
package fr.bigeon.gclc.prompt; package fr.bigeon.gclc.prompt;
/*-
* #%L
* Generic Command Ligne console
* %%
* Copyright (C) 2014 - 2018 bigeon.fr
* %%
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
* liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
* #L%
*/

60
gclc/src/main/java/fr/bigeon/gclc/tools/ConstantString.java
View File

@ -34,17 +34,57 @@
*/ */
package fr.bigeon.gclc.tools; package fr.bigeon.gclc.tools;
/*-
* #%L
* Generic Command Ligne console
* %%
* Copyright (C) 2014 - 2018 bigeon.fr
* %%
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
* liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
* #L%
*/
/** A {@link StringProvider} that hold a constant string.
*
* @author Emmanuel Bigeon */
public class ConstantString implements StringProvider { public class ConstantString implements StringProvider {
private String string; private final String string;
@Override
public String apply() {
return string; }
/* (non-Javadoc)
* @see fr.bigeon.gclc.tools.StringProvider#apply() */
@Override
public String apply() {
return string;
}
public ConstantString(String string) { /** Create a provider for a string.
this.string = string; *
} * @param string the string */
public ConstantString(String string) {
this.string = string;
}
} }

265
gclc/src/main/java/fr/bigeon/gclc/tools/PrintUtils.java
View File

@ -1,116 +1,149 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* acide:fr.bigeon.acide.tools.PrintUtils.java * acide:fr.bigeon.acide.tools.PrintUtils.java
* Created on: Jan 20, 2015 * Created on: Jan 20, 2015
*/ */
package fr.bigeon.gclc.tools; package fr.bigeon.gclc.tools;
import java.util.ArrayList; /*-
import java.util.List; * #%L
* Generic Command Ligne console
/** A tool class for printing text in a console. * %%
* * Copyright (C) 2014 - 2018 bigeon.fr
* @author Emmanuel BIGEON */ * %%
public final class PrintUtils { * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
/** The continuation dot string. */ * modify and/ or redistribute the software under the terms of the CeCILL
private static final String CONT_DOT = "..."; //$NON-NLS-1$ * license as circulated by CEA, CNRS and INRIA at the following URL
/** The continuation dot string length. */ * "http://www.cecill.info".
private static final int CONT_DOT_LENGTH = CONT_DOT.length(); *
/** The empty string constant. */ * As a counterpart to the access to the source code and rights to copy,
private static final String EMPTY = ""; //$NON-NLS-1$ * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
/** Utility class. */ * economic rights, and the successive licensors have only limited
private PrintUtils() { * liability.
// Utility class *
} * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
/** Print the text possibly cutting it if it goes over the authorized length * software by the user in light of its specific status of free software,
* and adding a mark of continuation. * that may mean that it is complicated to manipulate, and that also
* * therefore means that it is reserved for developers and experienced
* @param text the text to print * professionals having in-depth computer knowledge. Users are therefore
* @param nbCharacters the number of characters of the resulting text * encouraged to load and test the software's suitability as regards their
* @param indicateTooLong if an indication shell be given that the text * requirements in conditions enabling the security of their systems and/or
* didn't fit * data to be ensured and, more generally, to use and operate it in the
* @return the text to print (will be of exactly nbCharacters). */ * same conditions as regards security.
public static String print(final String text, final int nbCharacters, *
final boolean indicateTooLong) { * The fact that you are presently reading this means that you have had
StringBuilder res = new StringBuilder(text); * knowledge of the CeCILL license and that you accept its terms.
if (res.length() > nbCharacters) { * #L%
// Cut */
if (indicateTooLong) { import java.util.ArrayList;
// With suspension dots import java.util.List;
res = res.replace(nbCharacters - CONT_DOT_LENGTH, text.length(),
CONT_DOT); /** A tool class for printing text in a console.
} else { *
res = res.replace(nbCharacters, text.length(), ""); //$NON-NLS-1$ * @author Emmanuel BIGEON */
} public final class PrintUtils {
}
while (res.length() < nbCharacters) { /** The continuation dot string. */
// Add trailing space private static final String CONT_DOT = "..."; //$NON-NLS-1$
res.append(' '); /** The continuation dot string length. */
} private static final int CONT_DOT_LENGTH = CONT_DOT.length();
return res.toString(); /** The empty string constant. */
} private static final String EMPTY = ""; //$NON-NLS-1$
/** Wrap the text, cutting at spaces. /** Utility class. */
* private PrintUtils() {
* @param description the element to wrap in lines // Utility class
* @param i the length of the wrap }
* @return the list of resulting strings */
public static List<String> wrap(final String description, final int i) { /** Print the text possibly cutting it if it goes over the authorized length
final String[] originalLines = description * and adding a mark of continuation.
.split(System.lineSeparator()); *
final List<String> result = new ArrayList<>(); * @param text the text to print
for (final String string : originalLines) { * @param nbCharacters the number of characters of the resulting text
String toCut = string; * @param indicateTooLong if an indication shell be given that the text
while (toCut.length() > i) { * didn't fit
int index = toCut.lastIndexOf(' ', i); * @return the text to print (will be of exactly nbCharacters). */
if (index == -1) { public static String print(final String text, final int nbCharacters,
result.add(toCut.substring(0, i)); final boolean indicateTooLong) {
index = i - 1; StringBuilder res = new StringBuilder(text);
} else { if (res.length() > nbCharacters) {
result.add(toCut.substring(0, index)); // Cut
} if (indicateTooLong) {
toCut = toCut.substring(index + 1); // With suspension dots
} res = res.replace(nbCharacters - CONT_DOT_LENGTH, text.length(),
result.add(toCut); CONT_DOT);
result.add(EMPTY); } else {
} res = res.replace(nbCharacters, text.length(), ""); //$NON-NLS-1$
result.remove(result.size() - 1); }
return result; }
} while (res.length() < nbCharacters) {
} // Add trailing space
res.append(' ');
}
return res.toString();
}
/** Wrap the text, cutting at spaces.
*
* @param description the element to wrap in lines
* @param i the length of the wrap
* @return the list of resulting strings */
public static List<String> wrap(final String description, final int i) {
final String[] originalLines = description
.split(System.lineSeparator());
final List<String> result = new ArrayList<>();
for (final String string : originalLines) {
String toCut = string;
while (toCut.length() > i) {
int index = toCut.lastIndexOf(' ', i);
if (index == -1) {
result.add(toCut.substring(0, i));
index = i - 1;
} else {
result.add(toCut.substring(0, index));
}
toCut = toCut.substring(index + 1);
}
result.add(toCut);
result.add(EMPTY);
}
result.remove(result.size() - 1);
return result;
}
}

46
gclc/src/main/java/fr/bigeon/gclc/tools/StringProvider.java
View File

@ -34,16 +34,50 @@
*/ */
package fr.bigeon.gclc.tools; package fr.bigeon.gclc.tools;
/** /*-
* A string providing object. * #%L
* Generic Command Ligne console
* %%
* Copyright (C) 2014 - 2018 bigeon.fr
* %%
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
* liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
* #L%
*/
/** A string providing object.
* <p> * <p>
* Implementations of this interface will provide a string, this internal state * Implementations of this interface will provide a string, this internal state
* of the object may be so that successive calls to the apply method return * of the object may be so that successive calls to the apply method return
* different results. * different results.
* *
* @author Emmanuel * @author Emmanuel */
*
*/
public interface StringProvider { public interface StringProvider {
String apply(); /** Provide a string.
*
* @return the string */
String apply();
} }

305
gclc/src/main/java/fr/bigeon/gclc/tools/AOutputForwardRunnable.java → gclc/src/main/java/fr/bigeon/gclc/utils/AOutputForwardRunnable.java
View File

@ -1,137 +1,168 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.tools.AOutputForwardRunnable.java * gclc:fr.bigeon.gclc.tools.AOutputForwardRunnable.java
* Created on: Dec 1, 2016 * Created on: Dec 1, 2016
*/ */
package fr.bigeon.gclc.tools; package fr.bigeon.gclc.utils;
import java.io.IOException; /*-
import java.util.logging.Level; * #%L
import java.util.logging.Logger; * Generic Command Ligne console
* %%
import fr.bigeon.gclc.manager.PipedConsoleOutput; * Copyright (C) 2014 - 2018 bigeon.fr
* %%
/** An incomplete implematation used to forward messages from a piped console. * This software is governed by the CeCILL license under French law and
* <p> * abiding by the rules of distribution of free software. You can use,
* This forwarding can be interrupted without closing the piped manager. * modify and/ or redistribute the software under the terms of the CeCILL
* * license as circulated by CEA, CNRS and INRIA at the following URL
* @author Emmanuel Bigeon */ * "http://www.cecill.info".
public abstract class AOutputForwardRunnable implements Runnable { *
* As a counterpart to the access to the source code and rights to copy,
/** The class logger. */ * modify and redistribute granted by the license, users are provided only
private static final Logger LOGGER = Logger * with a limited warranty and the software's author, the holder of the
.getLogger(AOutputForwardRunnable.class.getName()); * economic rights, and the successive licensors have only limited
/** The default timeout (one tenth of second). */ * liability.
private static final long DEFAULT_TIMEOUT = 100; *
/** The manager. */ * In this respect, the user's attention is drawn to the risks associated
private final PipedConsoleOutput manager; * with loading, using, modifying and/or developing or reproducing the
/** The timeout. */ * software by the user in light of its specific status of free software,
private final long timeout; * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
/** Create a forwarding runnable. * professionals having in-depth computer knowledge. Users are therefore
* * encouraged to load and test the software's suitability as regards their
* @param manager the manager */ * requirements in conditions enabling the security of their systems and/or
public AOutputForwardRunnable(final PipedConsoleOutput manager) { * data to be ensured and, more generally, to use and operate it in the
super(); * same conditions as regards security.
this.manager = manager; *
timeout = DEFAULT_TIMEOUT; * The fact that you are presently reading this means that you have had
} * knowledge of the CeCILL license and that you accept its terms.
* #L%
/** Create a forward runnable with the given timeout. */
* <p> import java.io.IOException;
* Short timeout will be very responsive to the application actual messages, import java.util.logging.Level;
* but may use computation time if the application is not verbose. Long import java.util.logging.Logger;
* timeout will save computation time, but will read batches of messages at
* once if the application is verbose. The right length for the timeout is /** An incomplete implematation used to forward messages from a piped console.
* likely to depend on the application and the use of it. * <p>
* <p> * This forwarding can be interrupted without closing the piped manager.
* If you do not know what timeout length to use, please use the *
* {@link #AOutputForwardRunnable(PipedConsoleOutput)} constructor. * @author Emmanuel Bigeon */
* public abstract class AOutputForwardRunnable implements Runnable {
* @param manager the manager
* @param timeout the timeout between message requests. */ /** The class logger. */
public AOutputForwardRunnable(final PipedConsoleOutput manager, private static final Logger LOGGER = Logger
final long timeout) { .getLogger(AOutputForwardRunnable.class.getName());
super(); /** The default timeout (one tenth of second). */
this.manager = manager; private static final long DEFAULT_TIMEOUT = 100;
this.timeout = timeout; /** The manager. */
} private final PipedConsoleOutput manager;
/** The timeout. */
/** Do forward the line. private final long timeout;
*
* @param m the line to forward */ /** Create a forwarding runnable.
protected abstract void forwardLine(String m); *
* @param manager the manager */
/** Test if the runable is still running. public AOutputForwardRunnable(final PipedConsoleOutput manager) {
* super();
* @return if the thread should keep running */ this.manager = manager;
protected abstract boolean isRunning(); timeout = DEFAULT_TIMEOUT;
}
/* (non-Javadoc)
* @see java.lang.Runnable#run() */ /** Create a forward runnable with the given timeout.
@Override * <p>
public final void run() { * Short timeout will be very responsive to the application actual messages,
try { * but may use computation time if the application is not verbose. Long
while (isRunning()) { * timeout will save computation time, but will read batches of messages at
while (isRunning() && !manager.available()) { * once if the application is verbose. The right length for the timeout is
waitASec(); * likely to depend on the application and the use of it.
} * <p>
if (!isRunning()) { * If you do not know what timeout length to use, please use the
return; * {@link #AOutputForwardRunnable(PipedConsoleOutput)} constructor.
} *
final String m = manager.readNextLine(); * @param manager the manager
forwardLine(m); * @param timeout the timeout between message requests. */
} public AOutputForwardRunnable(final PipedConsoleOutput manager,
} catch (final IOException e) { final long timeout) {
LOGGER.log(Level.SEVERE, "Unexpected problem in manager", //$NON-NLS-1$ super();
e); this.manager = manager;
} this.timeout = timeout;
} }
/** a method to wait some time. */ /** Do forward the line.
protected final void waitASec() { *
try { * @param m the line to forward */
synchronized (this) { protected abstract void forwardLine(String m);
wait(timeout);
} /** Test if the runable is still running.
} catch (final InterruptedException e) { *
LOGGER.log(Level.SEVERE, "Interrupted wait", //$NON-NLS-1$ * @return if the thread should keep running */
e); protected abstract boolean isRunning();
Thread.currentThread().interrupt();
} /* (non-Javadoc)
} * @see java.lang.Runnable#run() */
@Override
} public final void run() {
try {
while (isRunning()) {
while (isRunning() && !manager.available()) {
waitASec();
}
if (!isRunning()) {
return;
}
final String m = manager.readNextLine();
forwardLine(m);
}
} catch (final IOException e) {
LOGGER.log(Level.SEVERE, "Unexpected problem in manager", //$NON-NLS-1$
e);
}
}
/** a method to wait some time. */
protected final void waitASec() {
try {
synchronized (this) {
wait(timeout);
}
} catch (final InterruptedException e) {
LOGGER.log(Level.SEVERE, "Interrupted wait", //$NON-NLS-1$
e);
Thread.currentThread().interrupt();
}
}
}

354
gclc/src/main/java/fr/bigeon/gclc/manager/PipedConsoleInput.java → gclc/src/main/java/fr/bigeon/gclc/utils/PipedConsoleInput.java
View File

@ -1,160 +1,194 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc-test:fr.bigeon.gclc.test.TestConsoleManager.java * gclc-test:fr.bigeon.gclc.test.TestConsoleManager.java
* Created on: Nov 18, 2016 * Created on: Nov 18, 2016
*/ */
package fr.bigeon.gclc.manager; package fr.bigeon.gclc.utils;
import java.io.IOException; /*-
import java.io.PipedInputStream; * #%L
import java.io.PipedOutputStream; * Generic Command Ligne console
import java.io.PrintStream; * %%
import java.nio.charset.StandardCharsets; * Copyright (C) 2014 - 2018 bigeon.fr
* %%
import fr.bigeon.gclc.tools.StringProvider; * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
/** This console input allows to enter commands and retrieve the output as an * modify and/ or redistribute the software under the terms of the CeCILL
* input. * license as circulated by CEA, CNRS and INRIA at the following URL
* <p> * "http://www.cecill.info".
* This console input is used to internally pilot an application. This can be *
* used to test application behavior. * As a counterpart to the access to the source code and rights to copy,
* * modify and redistribute granted by the license, users are provided only
* @author Emmanuel Bigeon */ * with a limited warranty and the software's author, the holder of the
public final class PipedConsoleInput * economic rights, and the successive licensors have only limited
implements ConsoleInput { * liability.
*
/** THe inner manager. */ * In this respect, the user's attention is drawn to the risks associated
private final StreamConsoleInput innerManager; * with loading, using, modifying and/or developing or reproducing the
/** The stream to pipe commands into. */ * software by the user in light of its specific status of free software,
private final PipedOutputStream commandInput; * that may mean that it is complicated to manipulate, and that also
/** The stream for the application to read commands from. */ * therefore means that it is reserved for developers and experienced
private final PipedInputStream in; * professionals having in-depth computer knowledge. Users are therefore
/** The writing thread. */ * encouraged to load and test the software's suitability as regards their
private final WritingRunnable writing; * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
/** Create a manager that will write and read through piped stream. * same conditions as regards security.
* *
* @param outPrint the stream to write the prompting messages to * The fact that you are presently reading this means that you have had
* @throws IOException if the piping failed for streams */ * knowledge of the CeCILL license and that you accept its terms.
public PipedConsoleInput(final PrintStream outPrint) throws IOException { * #L%
commandInput = new PipedOutputStream(); */
in = new PipedInputStream(commandInput); import java.io.IOException;
innerManager = new StreamConsoleInput(outPrint, in, import java.io.PipedInputStream;
StandardCharsets.UTF_8); import java.io.PipedOutputStream;
writing = new WritingRunnable(commandInput, StandardCharsets.UTF_8); import java.io.PrintStream;
final Thread th = new Thread(writing, import java.nio.charset.StandardCharsets;
"GCLC console piped input stream"); //$NON-NLS-1$
th.start(); import fr.bigeon.gclc.manager.ConsoleInput;
} import fr.bigeon.gclc.tools.StringProvider;
@Override /** This console input allows to enter commands and retrieve the output as an
public void close() throws IOException { * input.
writing.setRunning(false); * <p>
in.close(); * This console input is used to internally pilot an application. This can be
innerManager.close(); * used to test application behavior.
commandInput.close(); *
} * @author Emmanuel Bigeon */
public final class PipedConsoleInput
@Override implements ConsoleInput {
public StringProvider getPrompt() {
return innerManager.getPrompt(); /** THe inner manager. */
} private final StreamConsoleInput innerManager;
/** The stream to pipe commands into. */
/* (non-Javadoc) private final PipedOutputStream commandInput;
* @see fr.bigeon.gclc.manager.ConsoleManager#interruptPrompt() */ /** The stream for the application to read commands from. */
@Override private final PipedInputStream in;
public void interruptPrompt() { /** The writing thread. */
innerManager.interruptPrompt(); private final WritingRunnable writing;
}
/** Create a manager that will write and read through piped stream.
/* (non-Javadoc) *
* @see fr.bigeon.gclc.manager.ConsoleInput#isClosed() */ * @param outPrint the stream to write the prompting messages to
@Override * @throws IOException if the piping failed for streams */
public boolean isClosed() { public PipedConsoleInput(final PrintStream outPrint) throws IOException {
return innerManager.isClosed(); commandInput = new PipedOutputStream();
} in = new PipedInputStream(commandInput);
innerManager = new StreamConsoleInput(outPrint, in,
/* (non-Javadoc) StandardCharsets.UTF_8);
* @see fr.bigeon.gclc.manager.ConsoleInput#prompt() */ writing = new WritingRunnable(commandInput, StandardCharsets.UTF_8);
@Override final Thread th = new Thread(writing,
public String prompt() throws IOException { "GCLC console piped input stream"); //$NON-NLS-1$
return innerManager th.start();
.prompt(innerManager.getPrompt() + System.lineSeparator()); }
}
@Override
/* (non-Javadoc) public void close() throws IOException {
* @see fr.bigeon.gclc.manager.ConsoleManager#prompt(long) */ writing.setRunning(false);
@Override in.close();
public String prompt(final long timeout) throws IOException { innerManager.close();
return innerManager.prompt(timeout); commandInput.close();
} }
/* (non-Javadoc) @Override
* @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String) */ public StringProvider getPrompt() {
@Override return innerManager.getPrompt();
public String prompt(final String message) throws IOException { }
return innerManager.prompt(message + System.lineSeparator());
} /* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleManager#interruptPrompt() */
/* (non-Javadoc) @Override
* @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String, public void interruptPrompt() {
* long) */ innerManager.interruptPrompt();
@Override }
public String prompt(final String message, final long timeout) throws IOException {
return innerManager.prompt(message + System.lineSeparator(), timeout); /* (non-Javadoc)
} * @see fr.bigeon.gclc.manager.ConsoleInput#isClosed() */
@Override
/* (non-Javadoc) public boolean isClosed() {
* @see fr.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String) */ return innerManager.isClosed();
@Override }
public void setPrompt(final String prompt) {
innerManager.setPrompt(prompt); /* (non-Javadoc)
} * @see fr.bigeon.gclc.manager.ConsoleInput#prompt() */
@Override
@Override public String prompt() throws IOException {
public void setPrompt(StringProvider string) { return innerManager
innerManager.setPrompt(string); .prompt(innerManager.getPrompt() + System.lineSeparator());
} }
/** Type a message in the input. /* (non-Javadoc)
* * @see fr.bigeon.gclc.manager.ConsoleManager#prompt(long) */
* @param content the content to type to the application @Override
* @throws IOException if the typing failed */ public String prompt(final long timeout) throws IOException {
public void type(final String content) throws IOException { return innerManager.prompt(timeout);
writing.addMessage(content); }
}
/* (non-Javadoc)
} * @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String) */
@Override
public String prompt(final String message) throws IOException {
return innerManager.prompt(message + System.lineSeparator());
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleInput#prompt(java.lang.String,
* long) */
@Override
public String prompt(final String message, final long timeout) throws IOException {
return innerManager.prompt(message + System.lineSeparator(), timeout);
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String) */
@Override
public void setPrompt(final String prompt) {
innerManager.setPrompt(prompt);
}
@Override
public void setPrompt(StringProvider string) {
innerManager.setPrompt(string);
}
/** Type a message in the input.
*
* @param content the content to type to the application
* @throws IOException if the typing failed */
public void type(final String content) throws IOException {
writing.addMessage(content);
}
}

341
gclc/src/main/java/fr/bigeon/gclc/manager/PipedConsoleOutput.java → gclc/src/main/java/fr/bigeon/gclc/utils/PipedConsoleOutput.java
View File

@ -1,153 +1,188 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc-test:fr.bigeon.gclc.test.TestConsoleManager.java * gclc-test:fr.bigeon.gclc.test.TestConsoleManager.java
* Created on: Nov 18, 2016 * Created on: Nov 18, 2016
*/ */
package fr.bigeon.gclc.manager; package fr.bigeon.gclc.utils;
import java.io.BufferedReader; /*-
import java.io.IOException; * #%L
import java.io.InputStreamReader; * Generic Command Ligne console
import java.io.PipedInputStream; * %%
import java.io.PipedOutputStream; * Copyright (C) 2014 - 2018 bigeon.fr
import java.io.PrintStream; * %%
import java.nio.charset.StandardCharsets; * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
/** This console output allows to retrieve the output as an input. * modify and/ or redistribute the software under the terms of the CeCILL
* <p> * license as circulated by CEA, CNRS and INRIA at the following URL
* This console output is used to internally pilot an application. This can be * "http://www.cecill.info".
* used to test application behavior. *
* * As a counterpart to the access to the source code and rights to copy,
* @author Emmanuel Bigeon */ * modify and redistribute granted by the license, users are provided only
public final class PipedConsoleOutput * with a limited warranty and the software's author, the holder of the
implements ConsoleOutput { * economic rights, and the successive licensors have only limited
* liability.
/** The encoding between streams. */ *
private static final String UTF_8 = "UTF-8"; //$NON-NLS-1$ * In this respect, the user's attention is drawn to the risks associated
/** THe inner manager. */ * with loading, using, modifying and/or developing or reproducing the
private final StreamConsoleOutput innerManager; * software by the user in light of its specific status of free software,
/** The reader to get application return from. */ * that may mean that it is complicated to manipulate, and that also
private final BufferedReader commandBuffOutput; * therefore means that it is reserved for developers and experienced
/** The stream to get application return from. */ * professionals having in-depth computer knowledge. Users are therefore
private final PipedInputStream commandOutput; * encouraged to load and test the software's suitability as regards their
/** The print writer for application to write return to. */ * requirements in conditions enabling the security of their systems and/or
private final PrintStream outPrint; * data to be ensured and, more generally, to use and operate it in the
/** The reading thread. */ * same conditions as regards security.
private final ReadingRunnable reading; *
* The fact that you are presently reading this means that you have had
/** Create a manager that will write and read through piped stream. * knowledge of the CeCILL license and that you accept its terms.
* * #L%
* @throws IOException if the piping failed for streams */ */
public PipedConsoleOutput() throws IOException { import java.io.BufferedReader;
commandOutput = new PipedInputStream(); import java.io.IOException;
final PipedOutputStream out = new PipedOutputStream(commandOutput); import java.io.InputStreamReader;
commandBuffOutput = new BufferedReader( import java.io.PipedInputStream;
new InputStreamReader(commandOutput, StandardCharsets.UTF_8)); import java.io.PipedOutputStream;
outPrint = new PrintStream(out, true, UTF_8); import java.io.PrintStream;
innerManager = new StreamConsoleOutput(outPrint); import java.nio.charset.StandardCharsets;
reading = new ReadingRunnable(commandBuffOutput);
final Thread th = new Thread(reading, "GCLC console output forward"); //$NON-NLS-1$ import fr.bigeon.gclc.manager.ConsoleOutput;
th.setDaemon(true);
th.start(); /** This console output allows to retrieve the output as an input.
} * <p>
* This console output is used to internally pilot an application. This can be
/** Test if there is available data. * used to test application behavior.
* *
* @return the content of the next line written by the application * @author Emmanuel Bigeon */
* @throws IOException if the reading failed */ public final class PipedConsoleOutput
public boolean available() throws IOException { implements ConsoleOutput {
return reading.hasMessage();
} /** The encoding between streams. */
private static final String UTF_8 = "UTF-8"; //$NON-NLS-1$
/* (non-Javadoc) /** THe inner manager. */
* @see java.lang.AutoCloseable#close() */ private final StreamConsoleOutput innerManager;
@Override /** The reader to get application return from. */
public void close() throws IOException { private final BufferedReader commandBuffOutput;
reading.setRunning(false); /** The stream to get application return from. */
innerManager.close(); private final PipedInputStream commandOutput;
outPrint.close(); /** The print writer for application to write return to. */
commandBuffOutput.close(); private final PrintStream outPrint;
commandOutput.close(); /** The reading thread. */
} private final ReadingRunnable reading;
/** Wait for a specific message to arrive. /** Create a manager that will write and read through piped stream.
* <p> *
* When this method returns, the message was appended to the data, it * @throws IOException if the piping failed for streams */
* <em>may or may not</em> be the next line of data. public PipedConsoleOutput() throws IOException {
* commandOutput = new PipedInputStream();
* @param message the message final PipedOutputStream out = new PipedOutputStream(commandOutput);
* @return the thread to join to wait for message delivery commandBuffOutput = new BufferedReader(
* @see fr.bigeon.gclc.manager.ReadingRunnable#getWaitForDelivery(java.lang.String) */ new InputStreamReader(commandOutput, StandardCharsets.UTF_8));
public Thread getWaitForDelivery(final String message) { outPrint = new PrintStream(out, true, UTF_8);
return reading.getWaitForDelivery(message); innerManager = new StreamConsoleOutput(outPrint);
} reading = new ReadingRunnable(commandBuffOutput);
final Thread th = new Thread(reading, "GCLC console output forward"); //$NON-NLS-1$
/* (non-Javadoc) th.setDaemon(true);
* @see fr.bigeon.gclc.manager.ConsoleOutput#isClosed() */ th.start();
@Override }
public boolean isClosed() {
return innerManager.isClosed(); /** Test if there is available data.
} *
* @return the content of the next line written by the application
/* (non-Javadoc) * @throws IOException if the reading failed */
* @see fr.bigeon.gclc.manager.ConsoleOutput#print(java.lang.String) */ public boolean available() throws IOException {
@Override return reading.hasMessage();
public void print(final String object) throws IOException { }
innerManager.print(object);
} /* (non-Javadoc)
* @see java.lang.AutoCloseable#close() */
/* (non-Javadoc) @Override
* @see fr.bigeon.gclc.manager.ConsoleOutput#println() */ public void close() throws IOException {
@Override reading.setRunning(false);
public void println() throws IOException { innerManager.close();
innerManager.println(); outPrint.close();
} commandBuffOutput.close();
commandOutput.close();
/* (non-Javadoc) }
* @see fr.bigeon.gclc.manager.ConsoleOutput#println(java.lang.String) */
@Override /** Wait for a specific message to arrive.
public void println(final String object) throws IOException { * <p>
innerManager.println(object); * When this method returns, the message was appended to the data, it
} * <em>may or may not</em> be the next line of data.
*
/** Read the next line of data. * @param message the message
* * @return the thread to join to wait for message delivery
* @return the content of the next line written by the application * @see fr.bigeon.gclc.utils.ReadingRunnable#getWaitForDelivery(java.lang.String) */
* @throws IOException if the reading failed */ public Thread getWaitForDelivery(final String message) {
public String readNextLine() throws IOException { return reading.getWaitForDelivery(message);
return reading.getMessage(); }
}
} /* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleOutput#isClosed() */
@Override
public boolean isClosed() {
return innerManager.isClosed();
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleOutput#print(java.lang.String) */
@Override
public void print(final String object) throws IOException {
innerManager.print(object);
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleOutput#println() */
@Override
public void println() throws IOException {
innerManager.println();
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleOutput#println(java.lang.String) */
@Override
public void println(final String object) throws IOException {
innerManager.println(object);
}
/** Read the next line of data.
*
* @return the content of the next line written by the application
* @throws IOException if the reading failed */
public String readNextLine() throws IOException {
return reading.getMessage();
}
}

740
gclc/src/main/java/fr/bigeon/gclc/manager/ReadingRunnable.java → gclc/src/main/java/fr/bigeon/gclc/utils/ReadingRunnable.java
View File

@ -1,354 +1,386 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.test.utils.WritingRunnable.java * gclc:fr.bigeon.gclc.test.utils.WritingRunnable.java
* Created on: Nov 29, 2016 * Created on: Nov 29, 2016
*/ */
package fr.bigeon.gclc.manager; package fr.bigeon.gclc.utils;
import java.io.BufferedReader; /*-
import java.io.IOException; * #%L
import java.io.InterruptedIOException; * Generic Command Ligne console
import java.util.ArrayDeque; * %%
import java.util.Deque; * Copyright (C) 2014 - 2018 bigeon.fr
import java.util.HashMap; * %%
import java.util.Map; * This software is governed by the CeCILL license under French law and
import java.util.logging.Level; * abiding by the rules of distribution of free software. You can use,
import java.util.logging.Logger; * modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
/** A runnable to read the piped output. * "http://www.cecill.info".
* *
* @author Emmanuel Bigeon */ * As a counterpart to the access to the source code and rights to copy,
public final class ReadingRunnable implements Runnable { * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
/** The runnable to wait for arrival of a message in the queue. * economic rights, and the successive licensors have only limited
* * liability.
* @author Emmanuel Bigeon */ *
private final class ToWaitRunnable implements Runnable { * In this respect, the user's attention is drawn to the risks associated
/** The Object. */ * with loading, using, modifying and/or developing or reproducing the
private final Object obj; * software by the user in light of its specific status of free software,
/** The locking object. */ * that may mean that it is complicated to manipulate, and that also
private final Object start; * therefore means that it is reserved for developers and experienced
/** The message. */ * professionals having in-depth computer knowledge. Users are therefore
private final String message; * encouraged to load and test the software's suitability as regards their
/** The started status. */ * requirements in conditions enabling the security of their systems and/or
private boolean started = false; * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
/** Create the waiting runnable. *
* * The fact that you are presently reading this means that you have had
* @param obj the object to lock on * knowledge of the CeCILL license and that you accept its terms.
* @param start the object to notify when ready to wait * #L%
* @param message the message to wait for */ */
public ToWaitRunnable(final Object obj, final Object start, import java.io.BufferedReader;
final String message) { import java.io.IOException;
this.obj = obj; import java.io.InterruptedIOException;
this.start = start; import java.util.ArrayDeque;
this.message = message; import java.util.Deque;
} import java.util.HashMap;
import java.util.Map;
/** Test if the waiting runnable is started. import java.util.logging.Level;
* import java.util.logging.Logger;
* @return the started */
public boolean isStarted() { /** A runnable to read the piped output.
synchronized (start) { *
return started; * @author Emmanuel Bigeon */
} public final class ReadingRunnable implements Runnable {
}
/** The runnable to wait for arrival of a message in the queue.
/* (non-Javadoc) *
* @see java.lang.Runnable#run() */ * @author Emmanuel Bigeon */
@SuppressWarnings("synthetic-access") private final class ToWaitRunnable implements Runnable {
@Override /** The Object. */
public void run() { private final Object obj;
synchronized (obj) { /** The locking object. */
synchronized (start) { private final Object start;
started = true; /** The message. */
start.notifyAll(); private final String message;
} /** The started status. */
while (isRunning()) { private boolean started = false;
try {
obj.wait(); /** Create the waiting runnable.
if (delivering.equals(message)) { *
return; * @param obj the object to lock on
} * @param start the object to notify when ready to wait
} catch (final InterruptedException e) { * @param message the message to wait for */
LOGGER.log(Level.SEVERE, THREAD_INTERRUPTION_EXCEPTION, public ToWaitRunnable(final Object obj, final Object start,
e); final String message) {
Thread.currentThread().interrupt(); this.obj = obj;
} this.start = start;
} this.message = message;
} }
}
} /** Test if the waiting runnable is started.
*
/** The thread intteruption logging message. */ * @return the started */
private static final String THREAD_INTERRUPTION_EXCEPTION = "Thread interruption exception."; //$NON-NLS-1$ public boolean isStarted() {
/** The closed pipe message. */ synchronized (start) {
private static final String CLOSED_PIPE = "Closed pipe"; //$NON-NLS-1$ return started;
/** Wait timeout. */ }
private static final long TIMEOUT = 1000; }
/** Class logger. */
private static final Logger LOGGER = Logger /* (non-Javadoc)
.getLogger(ReadingRunnable.class.getName()); * @see java.lang.Runnable#run() */
/** Read messages. */ @Override
private final Deque<String> messages = new ArrayDeque<>(); public void run() {
/** the reader. */ synchronized (obj) {
private final BufferedReader reader; synchronized (start) {
/** the state of this runnable. */ started = true;
private boolean running = true; start.notifyAll();
/** Synchro object. */ }
private final Object lock = new Object(); while (isRunning()) {
/** The waiting status for a message. */ try {
private boolean waiting; obj.wait();
/** The blocker for a given message. */ if (delivering.equals(message)) {
private final Map<String, Object> messageBlocker = new HashMap<>(); return;
/** The lock. */ }
private final Object messageBlockerLock = new Object(); } catch (final InterruptedException e) {
/** The message being delivered. */ LOGGER.log(Level.SEVERE, THREAD_INTERRUPTION_EXCEPTION,
private String delivering; e);
Thread.currentThread().interrupt();
/** Create a reading runnable. }
* }
* @param reader the input to read from */ }
public ReadingRunnable(final BufferedReader reader) { }
super(); }
this.reader = reader;
} /** The thread intteruption logging message. */
private static final String THREAD_INTERRUPTION_EXCEPTION = "Thread interruption exception."; //$NON-NLS-1$
/** Strip the string from head NULL characters. /** The closed pipe message. */
* private static final String CLOSED_PIPE = "Closed pipe"; //$NON-NLS-1$
* @param line the line to strip the null character from /** Wait timeout. */
* @return the resulting string */ private static final long TIMEOUT = 1000;
private static String stripNull(final String line) { /** Class logger. */
String res = line; private static final Logger LOGGER = Logger
while (res.length() > 0 && res.charAt(0) == 0) { .getLogger(ReadingRunnable.class.getName());
LOGGER.severe( /** Read messages. */
"NULL character heading the result of the read. This is a stream problem..."); //$NON-NLS-1$ private final Deque<String> messages = new ArrayDeque<>();
res = res.substring(1); /** the reader. */
} private final BufferedReader reader;
return res; /** the state of this runnable. */
} private boolean running = true;
/** Synchro object. */
/** do wait for a message. private final Object lock = new Object();
* <p>This method should only be called inside a loop. /** The waiting status for a message. */
* @param timeout the timeout of the wait. private boolean waiting;
* @throws IOException if the runnable was stopped and no essage was found. /** The blocker for a given message. */
*/ private final Map<String, Object> messageBlocker = new HashMap<>();
private void doWaitMessage(final long timeout) throws IOException { /** The lock. */
try { private final Object messageBlockerLock = new Object();
lock.wait(timeout); /** The message being delivered. */
} catch (final InterruptedException e) { private String delivering;
LOGGER.log(Level.SEVERE, THREAD_INTERRUPTION_EXCEPTION, e);
Thread.currentThread().interrupt(); /** Create a reading runnable.
} *
if (messages.isEmpty() && !running) { * @param reader the input to read from */
throw new IOException(CLOSED_PIPE); public ReadingRunnable(final BufferedReader reader) {
} super();
} this.reader = reader;
}
/** Get the next message.
* /** Strip the string from head NULL characters.
* @return the next read message *
* @throws IOException if the pipe is closed */ * @param line the line to strip the null character from
public String getMessage() throws IOException { * @return the resulting string */
synchronized (lock) { private static String stripNull(final String line) {
if (!running) { String res = line;
throw new IOException(CLOSED_PIPE); while (res.length() > 0 && res.charAt(0) == 0) {
} LOGGER.severe(
waiting = true; "NULL character heading the result of the read. This is a stream problem..."); //$NON-NLS-1$
waitMessage(TIMEOUT); res = res.substring(1);
LOGGER.finest("Polled: " + messages.peek()); //$NON-NLS-1$ }
waiting = false; return res;
notifyMessage(messages.peek()); }
return messages.poll();
} /** do wait for a message.
} * <p>This method should only be called inside a loop.
* @param timeout the timeout of the wait.
/** Get the next message, but wait only a given time for it. * @throws IOException if the runnable was stopped and no essage was found.
* */
* @param timeout the read time out private void doWaitMessage(final long timeout) throws IOException {
* @return The next message that was in the input try {
* @throws IOException if the input was closed */ lock.wait(timeout);
public String getNextMessage(final long timeout) throws IOException { } catch (final InterruptedException e) {
synchronized (lock) { LOGGER.log(Level.SEVERE, THREAD_INTERRUPTION_EXCEPTION, e);
if (!running) { Thread.currentThread().interrupt();
throw new IOException(CLOSED_PIPE); }
} if (messages.isEmpty() && !running) {
waiting = true; throw new IOException(CLOSED_PIPE);
doWaitMessage(timeout); }
waiting = false; }
if (messages.isEmpty()) {
return null; /** Get the next message.
} *
return messages.poll(); * @return the next read message
} * @throws IOException if the pipe is closed */
} public String getMessage() throws IOException {
synchronized (lock) {
/** Get a waiting thread for a specific message delivery. if (!running) {
* throw new IOException(CLOSED_PIPE);
* @param message the message }
* @return the thread to join to wait for message delivery */ waiting = true;
public Thread getWaitForDelivery(final String message) { waitMessage(TIMEOUT);
synchronized (messageBlockerLock) { LOGGER.finest("Polled: " + messages.peek()); //$NON-NLS-1$
if (!messageBlocker.containsKey(message)) { waiting = false;
messageBlocker.put(message, new Object()); notifyMessage(messages.peek());
} return messages.poll();
final Object obj = messageBlocker.get(message); }
final Object start = new Object(); }
final ToWaitRunnable waitRunn = new ToWaitRunnable(obj, start,
message); /** Get the next message, but wait only a given time for it.
final Thread th = new Thread(waitRunn); *
* @param timeout the read time out
synchronized (start) { * @return The next message that was in the input
th.start(); * @throws IOException if the input was closed */
while (!waitRunn.isStarted()) { public String getNextMessage(final long timeout) throws IOException {
try { synchronized (lock) {
start.wait(TIMEOUT); if (!running) {
} catch (final InterruptedException e) { throw new IOException(CLOSED_PIPE);
LOGGER.log(Level.SEVERE, THREAD_INTERRUPTION_EXCEPTION, }
e); waiting = true;
Thread.currentThread().interrupt(); doWaitMessage(timeout);
} waiting = false;
} if (messages.isEmpty()) {
} return null;
return th; }
} return messages.poll();
} }
}
/** Test if some data is available.
* /** Get a waiting thread for a specific message delivery.
* @return if a message is waiting *
* @throws IOException if the pipe is closed */ * @param message the message
public boolean hasMessage() throws IOException { * @return the thread to join to wait for message delivery */
synchronized (lock) { public Thread getWaitForDelivery(final String message) {
if (!running) { synchronized (messageBlockerLock) {
throw new IOException(CLOSED_PIPE); if (!messageBlocker.containsKey(message)) {
} messageBlocker.put(message, new Object());
return !messages.isEmpty(); }
} final Object obj = messageBlocker.get(message);
} final Object start = new Object();
final ToWaitRunnable waitRunn = new ToWaitRunnable(obj, start,
/** Interrupts the wait on the next message by providing an empty message);
* message. */ final Thread th = new Thread(waitRunn);
public void interrupt() {
synchronized (lock) { synchronized (start) {
if (waiting) { th.start();
messages.offer(""); //$NON-NLS-1$ while (!waitRunn.isStarted()) {
lock.notifyAll(); try {
} start.wait(TIMEOUT);
} } catch (final InterruptedException e) {
} LOGGER.log(Level.SEVERE, THREAD_INTERRUPTION_EXCEPTION,
e);
/** Test if this element is still running. Thread.currentThread().interrupt();
* }
* @return the running */ }
public boolean isRunning() { }
synchronized (lock) { return th;
return running; }
} }
}
/** Test if some data is available.
/** Notify the arrival of a given message. *
* * @return if a message is waiting
* @param message the message */ * @throws IOException if the pipe is closed */
private void notifyMessage(final String message) { public boolean hasMessage() throws IOException {
synchronized (messageBlockerLock) { synchronized (lock) {
delivering = message; if (!running) {
if (messageBlocker.containsKey(message)) { throw new IOException(CLOSED_PIPE);
final Object mLock = messageBlocker.get(message); }
synchronized (mLock) { return !messages.isEmpty();
mLock.notifyAll(); }
} }
messageBlocker.remove(message);
} /** Interrupts the wait on the next message by providing an empty
} * message. */
} public void interrupt() {
synchronized (lock) {
/* (non-Javadoc) if (waiting) {
* @see java.lang.Runnable#run() */ messages.offer(""); //$NON-NLS-1$
@Override lock.notifyAll();
public void run() { }
while (running) { }
try { }
String line = reader.readLine();
if (line == null) { /** Test if this element is still running.
// Buffer end *
running = false; * @return the running */
return; public boolean isRunning() {
} synchronized (lock) {
LOGGER.finer("Read: " + line); //$NON-NLS-1$ return running;
line = stripNull(line); }
synchronized (lock) { }
messages.add(line);
lock.notifyAll(); /** Notify the arrival of a given message.
} *
} catch (final InterruptedIOException e) { * @param message the message */
if (running) { private void notifyMessage(final String message) {
LOGGER.info("Reading interrupted"); //$NON-NLS-1$ synchronized (messageBlockerLock) {
} delivering = message;
LOGGER.log(Level.FINER, if (messageBlocker.containsKey(message)) {
"Read interruption was caused by an exception", e); //$NON-NLS-1$ final Object mLock = messageBlocker.get(message);
} catch (final IOException e) { synchronized (mLock) {
LOGGER.log(Level.FINE, "The stream reading threw an exception", //$NON-NLS-1$ mLock.notifyAll();
e); }
if (running) { messageBlocker.remove(message);
LOGGER.severe("Unable to read from stream"); //$NON-NLS-1$ }
running = false; }
} }
return;
} /* (non-Javadoc)
} * @see java.lang.Runnable#run() */
} @Override
public void run() {
/** Set the running status for this reading runnable. while (running) {
* try {
* @param running the running to set */ String line = reader.readLine();
public void setRunning(final boolean running) { if (line == null) {
synchronized (lock) { // Buffer end
this.running = running; running = false;
} return;
} }
LOGGER.finer("Read: " + line); //$NON-NLS-1$
/** Wait for the next message to be integratted. line = stripNull(line);
* synchronized (lock) {
* @param timeout the timeout to wait messages.add(line);
* @throws IOException if the next message was not delivered and the lock.notifyAll();
* runnable stopped. */ }
private void waitMessage(final long timeout) throws IOException { } catch (final InterruptedIOException e) {
while (messages.isEmpty()) { if (running) {
doWaitMessage(timeout); LOGGER.info("Reading interrupted"); //$NON-NLS-1$
} }
} LOGGER.log(Level.FINER,
} "Read interruption was caused by an exception", e); //$NON-NLS-1$
} catch (final IOException e) {
LOGGER.log(Level.FINE, "The stream reading threw an exception", //$NON-NLS-1$
e);
if (running) {
LOGGER.severe("Unable to read from stream"); //$NON-NLS-1$
running = false;
}
return;
}
}
}
/** Set the running status for this reading runnable.
*
* @param running the running to set */
public void setRunning(final boolean running) {
synchronized (lock) {
this.running = running;
}
}
/** Wait for the next message to be integratted.
*
* @param timeout the timeout to wait
* @throws IOException if the next message was not delivered and the
* runnable stopped. */
private void waitMessage(final long timeout) throws IOException {
while (messages.isEmpty()) {
doWaitMessage(timeout);
}
}
}

213
gclc/src/main/java/fr/bigeon/gclc/manager/SinkOutput.java → gclc/src/main/java/fr/bigeon/gclc/utils/SinkOutput.java
View File

@ -1,89 +1,124 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.manager.SinkOutput.java * gclc:fr.bigeon.gclc.manager.SinkOutput.java
* Created on: Nov 13, 2017 * Created on: Nov 13, 2017
*/ */
package fr.bigeon.gclc.manager; package fr.bigeon.gclc.utils;
/** A console output that absorbs every message. import fr.bigeon.gclc.manager.ConsoleOutput;
*
* @author Emmanuel Bigeon */ /*-
public final class SinkOutput implements ConsoleOutput { * #%L
* Generic Command Ligne console
/** The sink output. */ * %%
public static final ConsoleOutput INSTANCE = new SinkOutput(); * Copyright (C) 2014 - 2018 bigeon.fr
* %%
/** Singleton constructor. */ * This software is governed by the CeCILL license under French law and
private SinkOutput() { * abiding by the rules of distribution of free software. You can use,
// * modify and/ or redistribute the software under the terms of the CeCILL
} * license as circulated by CEA, CNRS and INRIA at the following URL
/* (non-Javadoc) * "http://www.cecill.info".
* @see fr.bigeon.gclc.manager.ConsoleOutput#close() */ *
@Override * As a counterpart to the access to the source code and rights to copy,
public void close() { * modify and redistribute granted by the license, users are provided only
// * with a limited warranty and the software's author, the holder of the
} * economic rights, and the successive licensors have only limited
* liability.
/* (non-Javadoc) *
* @see fr.bigeon.gclc.manager.ConsoleOutput#isClosed() */ * In this respect, the user's attention is drawn to the risks associated
@Override * with loading, using, modifying and/or developing or reproducing the
public boolean isClosed() { * software by the user in light of its specific status of free software,
return false; * that may mean that it is complicated to manipulate, and that also
} * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
/* (non-Javadoc) * encouraged to load and test the software's suitability as regards their
* @see fr.bigeon.gclc.manager.ConsoleOutput#print(java.lang.String) */ * requirements in conditions enabling the security of their systems and/or
@Override * data to be ensured and, more generally, to use and operate it in the
public void print(final String text) { * same conditions as regards security.
// *
} * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
/* (non-Javadoc) * #L%
* @see fr.bigeon.gclc.manager.ConsoleOutput#println() */ */
@Override /** A console output that absorbs every message.
public void println() { *
// * @author Emmanuel Bigeon */
} public final class SinkOutput implements ConsoleOutput {
/* (non-Javadoc) /** The sink output. */
* @see fr.bigeon.gclc.manager.ConsoleOutput#println(java.lang.String) public static final ConsoleOutput INSTANCE = new SinkOutput();
*/
@Override /** Singleton constructor. */
public void println(final String message) { private SinkOutput() {
// //
} }
/* (non-Javadoc)
} * @see fr.bigeon.gclc.manager.ConsoleOutput#close() */
@Override
public void close() {
//
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleOutput#isClosed() */
@Override
public boolean isClosed() {
return false;
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleOutput#print(java.lang.String) */
@Override
public void print(final String text) {
//
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleOutput#println() */
@Override
public void println() {
//
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleOutput#println(java.lang.String)
*/
@Override
public void println(final String message) {
//
}
}

414
gclc/src/main/java/fr/bigeon/gclc/manager/StreamConsoleInput.java → gclc/src/main/java/fr/bigeon/gclc/utils/StreamConsoleInput.java
View File

@ -1,190 +1,224 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.system.SystemConsoleManager.java * gclc:fr.bigeon.gclc.system.SystemConsoleManager.java
* Created on: Dec 19, 2014 * Created on: Dec 19, 2014
*/ */
package fr.bigeon.gclc.manager; package fr.bigeon.gclc.utils;
import java.io.BufferedReader; /*-
import java.io.IOException; * #%L
import java.io.InputStream; * Generic Command Ligne console
import java.io.InputStreamReader; * %%
import java.io.PrintStream; * Copyright (C) 2014 - 2018 bigeon.fr
import java.nio.charset.Charset; * %%
* This software is governed by the CeCILL license under French law and
import fr.bigeon.gclc.tools.ConstantString; * abiding by the rules of distribution of free software. You can use,
import fr.bigeon.gclc.tools.StringProvider; * modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
/** A console using the input stream and print stream. * "http://www.cecill.info".
* <p> *
* The default constructor will use the system standart input and output. * As a counterpart to the access to the source code and rights to copy,
* * modify and redistribute granted by the license, users are provided only
* @author Emmanuel BIGEON */ * with a limited warranty and the software's author, the holder of the
public final class StreamConsoleInput implements ConsoleInput { * economic rights, and the successive licensors have only limited
* liability.
/** The default prompt. */ *
public static final StringProvider DEFAULT_PROMPT = new ConstantString("> "); //$NON-NLS-1$ * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
/** The command prompt. It can be changed. */ * software by the user in light of its specific status of free software,
private StringProvider prompt = DEFAULT_PROMPT; * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
/** The print stream. */ * professionals having in-depth computer knowledge. Users are therefore
private final PrintStream out; * encouraged to load and test the software's suitability as regards their
/** The input stream. */ * requirements in conditions enabling the security of their systems and/or
private final BufferedReader in; * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
/** If the manager is closed. */ *
private boolean closed = false; * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
/** The prompting thread. */ * #L%
private final Thread promptThread; */
import java.io.BufferedReader;
/** The reading runnable. */ import java.io.IOException;
private final ReadingRunnable reading; import java.io.InputStream;
import java.io.InputStreamReader;
/** This default constructor relies on the system defined standart output import java.io.PrintStream;
* and input stream. */ import java.nio.charset.Charset;
public StreamConsoleInput() {
this(System.out, System.in, Charset.defaultCharset()); import fr.bigeon.gclc.manager.ConsoleInput;
} import fr.bigeon.gclc.tools.ConstantString;
import fr.bigeon.gclc.tools.StringProvider;
/** Create the stream base console input.
* /** A console using the input stream and print stream.
* @param out the output stream * <p>
* @param in the input stream * The default constructor will use the system standart input and output.
* @param charset the charset for the input */ *
public StreamConsoleInput(final PrintStream out, final InputStream in, * @author Emmanuel BIGEON */
final Charset charset) { public final class StreamConsoleInput implements ConsoleInput {
super();
this.out = out; /** The default prompt. */
this.in = new BufferedReader(new InputStreamReader(in, charset)); public static final StringProvider DEFAULT_PROMPT = new ConstantString("> "); //$NON-NLS-1$
reading = new ReadingRunnable(this.in);
promptThread = new Thread(reading, "prompt"); //$NON-NLS-1$ /** The command prompt. It can be changed. */
promptThread.setDaemon(true); private StringProvider prompt = DEFAULT_PROMPT;
promptThread.start();
} /** The print stream. */
private final PrintStream out;
/** Check that the console input is not closed. /** The input stream. */
* private final BufferedReader in;
* @throws IOException if the stream was closed */
private void checkOpen() throws IOException { /** If the manager is closed. */
if (closed) { private boolean closed = false;
throw new IOException();
} /** The prompting thread. */
} private final Thread promptThread;
/* (non-Javadoc) /** The reading runnable. */
* @see fr.bigeon.gclc.manager.ConsoleManager#close() */ private final ReadingRunnable reading;
@Override
public void close() throws IOException { /** This default constructor relies on the system defined standart output
closed = true; * and input stream. */
reading.setRunning(false); public StreamConsoleInput() {
promptThread.interrupt(); this(System.out, System.in, Charset.defaultCharset());
} }
/* (non-Javadoc) /** Create the stream base console input.
* @see fr.bigeon.gclc.manager.ConsoleInput#getPrompt() */ *
@Override * @param out the output stream
public StringProvider getPrompt() { * @param in the input stream
return prompt; * @param charset the charset for the input */
} public StreamConsoleInput(final PrintStream out, final InputStream in,
final Charset charset) {
/** Beware, in this implementation this is the same as closing the manager. super();
* this.out = out;
* @see fr.bigeon.gclc.manager.ConsoleInput#interruptPrompt() */ this.in = new BufferedReader(new InputStreamReader(in, charset));
@Override reading = new ReadingRunnable(this.in);
public void interruptPrompt() { promptThread = new Thread(reading, "prompt"); //$NON-NLS-1$
reading.interrupt(); promptThread.setDaemon(true);
} promptThread.start();
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleManager#isClosed() */ /** Check that the console input is not closed.
@Override *
public boolean isClosed() { * @throws IOException if the stream was closed */
return closed; private void checkOpen() throws IOException {
} if (closed) {
throw new IOException();
/* (non-Javadoc) }
* @see fr.bigeon.gclc.ConsoleManager#prompt() */ }
@Override
public String prompt() throws IOException { /* (non-Javadoc)
return prompt(prompt.apply()); * @see fr.bigeon.gclc.manager.ConsoleManager#close() */
} @Override
public void close() throws IOException {
/* (non-Javadoc) closed = true;
* @see fr.bigeon.gclc.manager.ConsoleManager#prompt(long) */ reading.setRunning(false);
@Override promptThread.interrupt();
public String prompt(final long timeout) throws IOException { }
return prompt(prompt.apply(), timeout);
} /* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleInput#getPrompt() */
/* (non-Javadoc) @Override
* @see fr.bigeon.gclc.ConsoleManager#prompt(java.lang.String) */ public StringProvider getPrompt() {
@Override return prompt;
public String prompt(final String message) throws IOException { }
checkOpen();
if (out != null) { /** Beware, in this implementation this is the same as closing the manager.
out.print(message); *
out.flush(); * @see fr.bigeon.gclc.manager.ConsoleInput#interruptPrompt() */
} @Override
return reading.getMessage(); public void interruptPrompt() {
} reading.interrupt();
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.ConsoleManager#prompt(java.lang.String) */ /* (non-Javadoc)
@Override * @see fr.bigeon.gclc.manager.ConsoleManager#isClosed() */
public String prompt(final String message, @Override
final long timeout) throws IOException { public boolean isClosed() {
checkOpen(); return closed;
if (out != null) { }
out.print(message);
out.flush(); /* (non-Javadoc)
} * @see fr.bigeon.gclc.ConsoleManager#prompt() */
return reading.getNextMessage(timeout); @Override
} public String prompt() throws IOException {
return prompt(prompt.apply());
/* (non-Javadoc) }
* @see fr.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String) */
@Override /* (non-Javadoc)
public void setPrompt(final String prompt) { * @see fr.bigeon.gclc.manager.ConsoleManager#prompt(long) */
this.prompt = new ConstantString(prompt); @Override
} public String prompt(final long timeout) throws IOException {
return prompt(prompt.apply(), timeout);
@Override }
public void setPrompt(StringProvider string) {
this.prompt = string; /* (non-Javadoc)
} * @see fr.bigeon.gclc.ConsoleManager#prompt(java.lang.String) */
} @Override
public String prompt(final String message) throws IOException {
checkOpen();
if (out != null) {
out.print(message);
out.flush();
}
return reading.getMessage();
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.ConsoleManager#prompt(java.lang.String) */
@Override
public String prompt(final String message,
final long timeout) throws IOException {
checkOpen();
if (out != null) {
out.print(message);
out.flush();
}
return reading.getNextMessage(timeout);
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String) */
@Override
public void setPrompt(final String prompt) {
this.prompt = new ConstantString(prompt);
}
@Override
public void setPrompt(StringProvider string) {
this.prompt = string;
}
}

265
gclc/src/main/java/fr/bigeon/gclc/manager/StreamConsoleOutput.java → gclc/src/main/java/fr/bigeon/gclc/utils/StreamConsoleOutput.java
View File

@ -1,115 +1,150 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.system.SystemConsoleManager.java * gclc:fr.bigeon.gclc.system.SystemConsoleManager.java
* Created on: Dec 19, 2014 * Created on: Dec 19, 2014
*/ */
package fr.bigeon.gclc.manager; package fr.bigeon.gclc.utils;
import java.io.IOException; /*-
import java.io.PrintStream; * #%L
* Generic Command Ligne console
/** A console using the input stream and print stream. * %%
* <p> * Copyright (C) 2014 - 2018 bigeon.fr
* The default constructor will use the system standart input and output. * %%
* * This software is governed by the CeCILL license under French law and
* @author Emmanuel BIGEON */ * abiding by the rules of distribution of free software. You can use,
public final class StreamConsoleOutput implements ConsoleOutput { * modify and/ or redistribute the software under the terms of the CeCILL
/** The print stream. */ * license as circulated by CEA, CNRS and INRIA at the following URL
private final PrintStream out; * "http://www.cecill.info".
/** If the manager is closed. */ *
private boolean closed = false; * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
/** This default constructor relies on the system defined standart output * with a limited warranty and the software's author, the holder of the
* and input stream. */ * economic rights, and the successive licensors have only limited
public StreamConsoleOutput() { * liability.
this(System.out); *
} * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
/** Create a print stream based console output. * software by the user in light of its specific status of free software,
* * that may mean that it is complicated to manipulate, and that also
* @param out the output stream */ * therefore means that it is reserved for developers and experienced
public StreamConsoleOutput(final PrintStream out) { * professionals having in-depth computer knowledge. Users are therefore
super(); * encouraged to load and test the software's suitability as regards their
this.out = out; * requirements in conditions enabling the security of their systems and/or
} * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
/** Check the open status. *
* * The fact that you are presently reading this means that you have had
* @throws IOException if the stream was closed */ * knowledge of the CeCILL license and that you accept its terms.
private void checkOpen() throws IOException { * #L%
if (closed) { */
throw new IOException(); import java.io.IOException;
} import java.io.PrintStream;
}
import fr.bigeon.gclc.manager.ConsoleOutput;
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleManager#close() */ /** A console using the input stream and print stream.
@Override * <p>
public void close() { * The default constructor will use the system standart input and output.
closed = true; *
} * @author Emmanuel BIGEON */
public final class StreamConsoleOutput implements ConsoleOutput {
/* (non-Javadoc) /** The print stream. */
* @see fr.bigeon.gclc.manager.ConsoleManager#isClosed() */ private final PrintStream out;
@Override /** If the manager is closed. */
public boolean isClosed() { private boolean closed = false;
return closed;
} /** This default constructor relies on the system defined standart output
* and input stream. */
/* (non-Javadoc) public StreamConsoleOutput() {
* @see fr.bigeon.gclc.ConsoleManager#print(java.lang.Object) */ this(System.out);
@Override }
public void print(final String object) throws IOException {
checkOpen(); /** Create a print stream based console output.
out.print(object); *
} * @param out the output stream */
public StreamConsoleOutput(final PrintStream out) {
/* (non-Javadoc) super();
* @see fr.bigeon.gclc.ConsoleManager#println() */ this.out = out;
@Override }
public void println() throws IOException {
checkOpen(); /** Check the open status.
out.println(); *
} * @throws IOException if the stream was closed */
private void checkOpen() throws IOException {
/* (non-Javadoc) if (closed) {
* @see fr.bigeon.gclc.ConsoleManager#println(java.lang.Object) */ throw new IOException();
@Override }
public void println(final String object) throws IOException { }
checkOpen();
out.println(object); /* (non-Javadoc)
} * @see fr.bigeon.gclc.manager.ConsoleManager#close() */
} @Override
public void close() {
closed = true;
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.manager.ConsoleManager#isClosed() */
@Override
public boolean isClosed() {
return closed;
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.ConsoleManager#print(java.lang.Object) */
@Override
public void print(final String object) throws IOException {
checkOpen();
out.print(object);
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.ConsoleManager#println() */
@Override
public void println() throws IOException {
checkOpen();
out.println();
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.ConsoleManager#println(java.lang.Object) */
@Override
public void println(final String object) throws IOException {
checkOpen();
out.println(object);
}
}

353
gclc/src/main/java/fr/bigeon/gclc/manager/WritingRunnable.java → gclc/src/main/java/fr/bigeon/gclc/utils/WritingRunnable.java
View File

@ -1,160 +1,193 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.test.utils.WritingRunnable.java * gclc:fr.bigeon.gclc.test.utils.WritingRunnable.java
* Created on: Nov 29, 2016 * Created on: Nov 29, 2016
*/ */
package fr.bigeon.gclc.manager; package fr.bigeon.gclc.utils;
import java.io.IOException; /*-
import java.io.OutputStream; * #%L
import java.nio.ByteBuffer; * Generic Command Ligne console
import java.nio.charset.Charset; * %%
import java.util.ArrayDeque; * Copyright (C) 2014 - 2018 bigeon.fr
import java.util.Deque; * %%
import java.util.logging.Level; * This software is governed by the CeCILL license under French law and
import java.util.logging.Logger; * abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
/** The runnable in charge of writing messages as they are read. * license as circulated by CEA, CNRS and INRIA at the following URL
* <p> * "http://www.cecill.info".
* Messages are queued to be retrieved latter on. *
* * As a counterpart to the access to the source code and rights to copy,
* @author Emmanuel Bigeon */ * modify and redistribute granted by the license, users are provided only
public final class WritingRunnable implements Runnable { * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
/** Wait timeout. */ * liability.
private static final long TIMEOUT = 1000; *
/** Class logger. */ * In this respect, the user's attention is drawn to the risks associated
private static final Logger LOGGER = Logger * with loading, using, modifying and/or developing or reproducing the
.getLogger(WritingRunnable.class.getName()); * software by the user in light of its specific status of free software,
/** Messages to write. */ * that may mean that it is complicated to manipulate, and that also
private final Deque<String> messages = new ArrayDeque<>(); * therefore means that it is reserved for developers and experienced
/** Stream to write to. */ * professionals having in-depth computer knowledge. Users are therefore
private final OutputStream outPrint; * encouraged to load and test the software's suitability as regards their
/** The charset. */ * requirements in conditions enabling the security of their systems and/or
private final Charset charset; * data to be ensured and, more generally, to use and operate it in the
/** Runnable state. */ * same conditions as regards security.
private boolean running = true; *
* The fact that you are presently reading this means that you have had
/** Synchro object. */ * knowledge of the CeCILL license and that you accept its terms.
private final Object lock = new Object(); * #L%
*/
/** Create the writing runnable. import java.io.IOException;
* import java.io.OutputStream;
* @param outPrint the output to print to import java.nio.ByteBuffer;
* @param charset the charset of the stream */ import java.nio.charset.Charset;
public WritingRunnable(final OutputStream outPrint, final Charset charset) { import java.util.ArrayDeque;
super(); import java.util.Deque;
this.outPrint = outPrint; import java.util.logging.Level;
this.charset = charset; import java.util.logging.Logger;
}
/** The runnable in charge of writing messages as they are read.
/** Add a message in the queue. * <p>
* * Messages are queued to be retrieved latter on.
* @param message the message *
* @throws IOException if the pipe is closed */ * @author Emmanuel Bigeon */
public void addMessage(final String message) throws IOException { public final class WritingRunnable implements Runnable {
synchronized (lock) {
if (!running) { /** Wait timeout. */
throw new IOException("Closed pipe"); //$NON-NLS-1$ private static final long TIMEOUT = 1000;
} /** Class logger. */
messages.offer(message); private static final Logger LOGGER = Logger
lock.notifyAll(); .getLogger(WritingRunnable.class.getName());
} /** Messages to write. */
} private final Deque<String> messages = new ArrayDeque<>();
/** Stream to write to. */
/** Test if the message is running. private final OutputStream outPrint;
* /** The charset. */
* @return the running */ private final Charset charset;
public boolean isRunning() { /** Runnable state. */
synchronized (lock) { private boolean running = true;
return running;
} /** Synchro object. */
} private final Object lock = new Object();
/* (non-Javadoc) /** Create the writing runnable.
* @see java.lang.Runnable#run() */ *
@Override * @param outPrint the output to print to
public void run() { * @param charset the charset of the stream */
while (running) { public WritingRunnable(final OutputStream outPrint, final Charset charset) {
synchronized (lock) { super();
while (messages.isEmpty()) { this.outPrint = outPrint;
waitNextMessage(); this.charset = charset;
if (!running) { }
return;
} /** Add a message in the queue.
} *
writeMessage(); * @param message the message
} * @throws IOException if the pipe is closed */
} public void addMessage(final String message) throws IOException {
} synchronized (lock) {
if (!running) {
/** Set the running status. throw new IOException("Closed pipe"); //$NON-NLS-1$
* }
* @param running the running to set */ messages.offer(message);
public void setRunning(final boolean running) { lock.notifyAll();
synchronized (lock) { }
this.running = running; }
}
} /** Test if the message is running.
*
/** Wait for next message. */ * @return the running */
private void waitNextMessage() { public boolean isRunning() {
try { synchronized (lock) {
lock.wait(TIMEOUT); return running;
} catch (final InterruptedException e) { }
if (running) { }
LOGGER.log(Level.SEVERE,
"Thread interruption exception.", e); //$NON-NLS-1$ /* (non-Javadoc)
} * @see java.lang.Runnable#run() */
Thread.currentThread().interrupt(); @Override
} public void run() {
} while (running) {
synchronized (lock) {
/** Write next message to output. */ while (messages.isEmpty()) {
private void writeMessage() { waitNextMessage();
final String message = messages.poll(); if (!running) {
final ByteBuffer buff = charset return;
.encode(message + System.lineSeparator()); }
if (buff.hasArray()) { }
try { writeMessage();
outPrint.write(buff.array()); }
} catch (final IOException e) { }
LOGGER.log(Level.SEVERE, "Unable to write to stream", //$NON-NLS-1$ }
e);
} /** Set the running status.
} *
} * @param running the running to set */
} public void setRunning(final boolean running) {
synchronized (lock) {
this.running = running;
}
}
/** Wait for next message. */
private void waitNextMessage() {
try {
lock.wait(TIMEOUT);
} catch (final InterruptedException e) {
if (running) {
LOGGER.log(Level.SEVERE,
"Thread interruption exception.", e); //$NON-NLS-1$
}
Thread.currentThread().interrupt();
}
}
/** Write next message to output. */
private void writeMessage() {
final String message = messages.poll();
final ByteBuffer buff = charset
.encode(message + System.lineSeparator());
if (buff.hasArray()) {
try {
outPrint.write(buff.array());
} catch (final IOException e) {
LOGGER.log(Level.SEVERE, "Unable to write to stream", //$NON-NLS-1$
e);
}
}
}
}

8
gclc/src/main/java/fr/bigeon/gclc/utils/package-info.java Normal file
View File

@ -0,0 +1,8 @@
/**
*
*/
/**
* @author Emmanuel Bigeon
*
*/
package fr.bigeon.gclc.utils;

37
gclc/src/main/resources/fr/bigeon/gclc/l10n/messages.properties
View File

@ -1,2 +1,35 @@
CommandProvider.unrecognized=Unrecognized command "{0}" ###
ConsoleApplication.cmd.failed=The command "{0}" failed due to : # #%L
# Generic Command Ligne console
# %%
# Copyright (C) 2014 - 2018 bigeon.fr
# %%
# This software is governed by the CeCILL license under French law and
# abiding by the rules of distribution of free software. You can use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty and the software's author, the holder of the
# economic rights, and the successive licensors have only limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading, using, modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean that it is complicated to manipulate, and that also
# therefore means that it is reserved for developers and experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and, more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.
# #L%
###
CommandProvider.unrecognized=Unrecognized command "{0}"
ConsoleApplication.cmd.failed=The command "{0}" failed due to :

32
gclc/src/main/resources/fr/bigeon/gclc/licensing/cecill/CeCILL-header.txt
View File

@ -1,32 +0,0 @@
Copyright ${owner} (${project.inceptionYear})
${email}
This software is a computer program whose purpose is to
${project.description}.
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.

85
gclc/src/main/resources/fr/bigeon/gclc/messages.properties
View File

@ -1,26 +1,59 @@
exit.tip=Exit the application ###
help.cmd.tip=Display an help tip # #%L
# Generic Command Ligne console
prompt.lineprompt=>\ # %%
# Copyright (C) 2014 - 2018 bigeon.fr
promptlist.exit.defaultkey=\\q # %%
promptlist.exit.dispkey=\ (exit with a new line made of "{0}") # This software is governed by the CeCILL license under French law and
promptlist.prompt=>\ # abiding by the rules of distribution of free software. You can use,
promptlist.multi.sepkey=\ # modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
promptbool.choices=\ (Y/N) # "http://www.cecill.info".
promptbool.choices.invalid=Invalid input. Please input one of {0}. #
promptbool.choices.yes1=Y # As a counterpart to the access to the source code and rights to copy,
promptbool.choices.yes2=yes # modify and redistribute granted by the license, users are provided only
promptbool.choices.no1=N # with a limited warranty and the software's author, the holder of the
promptbool.choices.no2=no # economic rights, and the successive licensors have only limited
# liability.
promptchoice.outofbounds=Please choose something between {0} and {1}. The choices were: #
promptchoice.formaterr=The input seems to be something that is not an integer.\ # In this respect, the user's attention is drawn to the risks associated
Please choose something between {0} and {1}. The choices were: # with loading, using, modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
promptlongtext.exit.defaultkey=\\q # that may mean that it is complicated to manipulate, and that also
promptlongtext.exit.dispkey=\ (exit with a new line made of "{0}") # therefore means that it is reserved for developers and experienced
# professionals having in-depth computer knowledge. Users are therefore
unrecognized.cmd=Unrecognized command "{0}" # encouraged to load and test the software's suitability as regards their
expected.cmd=A Command was expected but nothing was provided... # requirements in conditions enabling the security of their systems and/or
# data to be ensured and, more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.
# #L%
###
exit.tip=Exit the application
help.cmd.tip=Display an help tip
prompt.lineprompt=>\
promptlist.exit.defaultkey=\\q
promptlist.exit.dispkey=\ (exit with a new line made of "{0}")
promptlist.prompt=>\
promptlist.multi.sepkey=\
promptbool.choices=\ (Y/N)
promptbool.choices.invalid=Invalid input. Please input one of {0}.
promptbool.choices.yes1=Y
promptbool.choices.yes2=yes
promptbool.choices.no1=N
promptbool.choices.no2=no
promptchoice.outofbounds=Please choose something between {0} and {1}. The choices were:
promptchoice.formaterr=The input seems to be something that is not an integer.\
Please choose something between {0} and {1}. The choices were:
promptlongtext.exit.defaultkey=\\q
promptlongtext.exit.dispkey=\ (exit with a new line made of "{0}")
unrecognized.cmd=Unrecognized command "{0}"
expected.cmd=A Command was expected but nothing was provided...

279
gclc/src/test/java/fr/bigeon/gclc/CommandTestingApplication.java
View File

@ -1,123 +1,156 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.CommandTestingApplication.java * gclc:fr.bigeon.gclc.command.CommandTestingApplication.java
* Created on: Jun 12, 2016 * Created on: Jun 12, 2016
*/ */
package fr.bigeon.gclc; package fr.bigeon.gclc;
import java.io.IOException; /*-
* #%L
import fr.bigeon.gclc.command.ICommand; * Generic Command Ligne console
import fr.bigeon.gclc.exception.InvalidCommandName; * %%
import fr.bigeon.gclc.manager.PipedConsoleInput; * Copyright (C) 2014 - 2018 bigeon.fr
import fr.bigeon.gclc.manager.PipedConsoleOutput; * %%
* This software is governed by the CeCILL license under French law and
/** * abiding by the rules of distribution of free software. You can use,
* <p> * modify and/ or redistribute the software under the terms of the CeCILL
* TODO * license as circulated by CEA, CNRS and INRIA at the following URL
* * "http://www.cecill.info".
* @author Emmanuel Bigeon *
* * As a counterpart to the access to the source code and rights to copy,
*/ * modify and redistribute granted by the license, users are provided only
@SuppressWarnings("javadoc") * with a limited warranty and the software's author, the holder of the
public class CommandTestingApplication implements AutoCloseable { * economic rights, and the successive licensors have only limited
* liability.
private final ConsoleApplication application; *
private final Thread th; * In this respect, the user's attention is drawn to the risks associated
private final PipedConsoleOutput out; * with loading, using, modifying and/or developing or reproducing the
private final PipedConsoleInput in; * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
/** @throws IOException if the streams cannot be build */ * therefore means that it is reserved for developers and experienced
public CommandTestingApplication() throws IOException { * professionals having in-depth computer knowledge. Users are therefore
out = new PipedConsoleOutput(); * encouraged to load and test the software's suitability as regards their
in = new PipedConsoleInput(null); * requirements in conditions enabling the security of their systems and/or
application = new ConsoleApplication(out, in, "", ""); * data to be ensured and, more generally, to use and operate it in the
new ConsoleTestApplication().attach(application); * same conditions as regards security.
th = new Thread(new Runnable() { *
* The fact that you are presently reading this means that you have had
@SuppressWarnings("synthetic-access") * knowledge of the CeCILL license and that you accept its terms.
@Override * #L%
public void run() { */
application.start(); import java.io.IOException;
}
}); import fr.bigeon.gclc.command.ICommand;
import fr.bigeon.gclc.exception.InvalidCommandName;
th.start(); import fr.bigeon.gclc.utils.PipedConsoleInput;
} import fr.bigeon.gclc.utils.PipedConsoleOutput;
/** @param cmd the command /**
* @return if the command was added * <p>
* @throws InvalidCommandName if the command name is invalid * TODO
* @see fr.bigeon.gclc.ConsoleApplication#add(fr.bigeon.gclc.command.ICommand) */ *
public final boolean add(final ICommand cmd) throws InvalidCommandName { * @author Emmanuel Bigeon
return application.add(cmd); *
} */
@SuppressWarnings("javadoc")
@Override public class CommandTestingApplication implements AutoCloseable {
public void close() throws IOException {
application.exit(); private final ConsoleApplication application;
out.close(); private final Thread th;
in.close(); private final PipedConsoleOutput out;
} private final PipedConsoleInput in;
/** @return the application */ /** @throws IOException if the streams cannot be build */
public ConsoleApplication getApplication() { public CommandTestingApplication() throws IOException {
return application; out = new PipedConsoleOutput();
} in = new PipedConsoleInput(null);
application = new ConsoleApplication(out, in, "", "");
/** @return the next written line, null if it is the prompt new ConsoleTestApplication().attach(application);
* @throws IOException if the reading failed */ th = new Thread(new Runnable() {
public String readNextLine() throws IOException {
final String ret = out.readNextLine(); @SuppressWarnings("synthetic-access")
return ret; @Override
} public void run() {
application.start();
public void sendCommand(final String cmd) throws IOException { }
in.type(cmd); });
}
th.start();
/** @throws IOException if the writing failed */ }
public void waitAndStop() throws IOException {
in.type(ConsoleTestApplication.EXIT); /** @param cmd the command
try { * @return if the command was added
th.join(); * @throws InvalidCommandName if the command name is invalid
} catch (final InterruptedException e) { * @see fr.bigeon.gclc.ConsoleApplication#add(fr.bigeon.gclc.command.ICommand) */
// TODO Auto-generated catch block public final boolean add(final ICommand cmd) throws InvalidCommandName {
e.printStackTrace(); return application.add(cmd);
} }
}
@Override
} public void close() throws IOException {
application.exit();
out.close();
in.close();
}
/** @return the application */
public ConsoleApplication getApplication() {
return application;
}
/** @return the next written line, null if it is the prompt
* @throws IOException if the reading failed */
public String readNextLine() throws IOException {
final String ret = out.readNextLine();
return ret;
}
public void sendCommand(final String cmd) throws IOException {
in.type(cmd);
}
/** @throws IOException if the writing failed */
public void waitAndStop() throws IOException {
in.type(ConsoleTestApplication.EXIT);
try {
th.join();
} catch (final InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

526
gclc/src/test/java/fr/bigeon/gclc/ConsoleApplicationTest.java
View File

@ -1,247 +1,279 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.ConsoleApplicationTest.java * gclc:fr.bigeon.gclc.ConsoleApplicationTest.java
* Created on: Jun 9, 2016 * Created on: Jun 9, 2016
*/ */
package fr.bigeon.gclc; package fr.bigeon.gclc;
import static org.junit.Assert.assertEquals; /*-
import static org.junit.Assert.assertFalse; * #%L
import static org.junit.Assert.assertNotNull; * Generic Command Ligne console
import static org.junit.Assert.assertTrue; * %%
import static org.junit.Assert.fail; * Copyright (C) 2014 - 2018 bigeon.fr
* %%
import java.io.BufferedReader; * This software is governed by the CeCILL license under French law and
import java.io.IOException; * abiding by the rules of distribution of free software. You can use,
import java.io.InputStreamReader; * modify and/ or redistribute the software under the terms of the CeCILL
import java.io.PipedInputStream; * license as circulated by CEA, CNRS and INRIA at the following URL
import java.io.PipedOutputStream; * "http://www.cecill.info".
import java.io.PrintStream; *
import java.nio.charset.StandardCharsets; * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
import org.junit.Test; * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
import fr.bigeon.gclc.command.ExitCommand; * liability.
import fr.bigeon.gclc.command.ICommand; *
import fr.bigeon.gclc.exception.CommandRunException; * In this respect, the user's attention is drawn to the risks associated
import fr.bigeon.gclc.exception.CommandRunExceptionType; * with loading, using, modifying and/or developing or reproducing the
import fr.bigeon.gclc.exception.InvalidCommandName; * software by the user in light of its specific status of free software,
import fr.bigeon.gclc.i18n.Messages; * that may mean that it is complicated to manipulate, and that also
import fr.bigeon.gclc.manager.ConsoleInput; * therefore means that it is reserved for developers and experienced
import fr.bigeon.gclc.manager.ConsoleOutput; * professionals having in-depth computer knowledge. Users are therefore
import fr.bigeon.gclc.manager.PipedConsoleInput; * encouraged to load and test the software's suitability as regards their
import fr.bigeon.gclc.manager.PipedConsoleOutput; * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
/** Test class for ConsoleApplication * same conditions as regards security.
* *
* @author Emmanuel Bigeon */ * The fact that you are presently reading this means that you have had
@SuppressWarnings({"javadoc", "nls", "static-method"}) * knowledge of the CeCILL license and that you accept its terms.
public class ConsoleApplicationTest { * #L%
*/
/** 3 seconds in milliseconds */ import static org.junit.Assert.assertEquals;
protected static final long THREE_SECONDS = 3000; import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
/** Test the base of a console application */ import static org.junit.Assert.assertTrue;
@Test import static org.junit.Assert.fail;
public void testConsoleApplication() {
import java.io.BufferedReader;
try (PipedOutputStream pout = new PipedOutputStream(); import java.io.IOException;
PipedInputStream pis = new PipedInputStream(pout); import java.io.InputStreamReader;
BufferedReader buf = new BufferedReader( import java.io.PipedInputStream;
new InputStreamReader(pis, StandardCharsets.UTF_8)); import java.io.PipedOutputStream;
PipedConsoleInput in = new PipedConsoleInput( import java.io.PrintStream;
new PrintStream(pout))) { import java.nio.charset.StandardCharsets;
final ConsoleApplication app = new ConsoleApplication(null, in,
"", ""); import org.junit.Test;
app.exit();
} catch (final IOException e) { import fr.bigeon.gclc.command.ICommand;
fail("System Console Manager failed"); import fr.bigeon.gclc.command.base.ExitCommand;
} import fr.bigeon.gclc.exception.CommandRunException;
import fr.bigeon.gclc.exception.CommandRunExceptionType;
} import fr.bigeon.gclc.exception.InvalidCommandName;
import fr.bigeon.gclc.i18n.Messages;
@Test import fr.bigeon.gclc.manager.ConsoleInput;
public void testExecution() throws IOException, InterruptedException, import fr.bigeon.gclc.manager.ConsoleOutput;
InvalidCommandName { import fr.bigeon.gclc.utils.PipedConsoleInput;
try (CommandTestingApplication application = new CommandTestingApplication()) { import fr.bigeon.gclc.utils.PipedConsoleOutput;
// remove welcome /** Test class for ConsoleApplication
assertEquals("Header should be preserved", *
application.getApplication().header, * @author Emmanuel Bigeon */
application.readNextLine()); @SuppressWarnings({"javadoc", "nls", "static-method"})
// Remove first prompt public class ConsoleApplicationTest {
application.sendCommand("");
application.sendCommand("test"); /** 3 seconds in milliseconds */
assertEquals("Test should run", "Test command ran fine", protected static final long THREE_SECONDS = 3000;
application.readNextLine());
application.sendCommand("toto"); /** Test the base of a console application */
assertEquals("Command fail should dispaly appropriate message", @Test
Messages.getString("ConsoleApplication.cmd.failed", "toto"), public void testConsoleApplication() {
application.readNextLine());
assertEquals( try (PipedOutputStream pout = new PipedOutputStream();
"Unrecognized comment should result in a specific message.", PipedInputStream pis = new PipedInputStream(pout);
Messages.getString("CommandProvider.unrecognized", "toto"), BufferedReader buf = new BufferedReader(
application.readNextLine()); new InputStreamReader(pis, StandardCharsets.UTF_8));
application.sendCommand("long"); PipedConsoleInput in = new PipedConsoleInput(
assertEquals("Before wait should receive message", "Waita minute", new PrintStream(pout))) {
application.readNextLine()); final ConsoleApplication app = new ConsoleApplication(null, in,
assertEquals("Unexpected message", "done!", "", "");
application.readNextLine()); app.exit();
} catch (final IOException e) {
final CommandRequestListener crl = new CommandRequestListener() { fail("System Console Manager failed");
}
@Override
public void commandRequest(final String command) { }
//
} @Test
}; public void testExecution() throws IOException, InterruptedException,
final CommandRequestListener crl2 = new CommandRequestListener() { InvalidCommandName {
try (CommandTestingApplication application = new CommandTestingApplication()) {
@Override
public void commandRequest(final String command) { // remove welcome
// assertEquals("Header should be preserved",
} application.getApplication().header,
}; application.readNextLine());
application.getApplication().addListener(crl); // Remove first prompt
application.getApplication().addListener(crl2); application.sendCommand("");
application.sendCommand("test"); application.sendCommand("test");
assertEquals("Unexpected message", "Test command ran fine", assertEquals("Test should run", "Test command ran fine",
application.readNextLine()); application.readNextLine());
application.getApplication().removeListener(crl2); application.sendCommand("toto");
application.getApplication().removeListener(crl); assertEquals("Command fail should dispaly appropriate message",
application.getApplication().removeListener(crl); Messages.getString("ConsoleApplication.cmd.failed", "toto"),
application.readNextLine());
assertTrue("Unclosed application should be running", assertEquals(
application.getApplication().isRunning()); "Unrecognized comment should result in a specific message.",
Messages.getString("CommandProvider.unrecognized", "toto"),
application.sendCommand("exit"); application.readNextLine());
assertEquals("Footer should be preserved", application.sendCommand("long");
application.getApplication().footer, assertEquals("Before wait should receive message", "Waita minute",
application.readNextLine()); application.readNextLine());
assertFalse("Stopped application should not be running", assertEquals("Unexpected message", "done!",
application.getApplication().isRunning()); application.readNextLine());
}
final CommandRequestListener crl = new CommandRequestListener() {
ConsoleApplication appli = null;
try (PipedConsoleOutput manager = new PipedConsoleOutput(); @Override
PipedOutputStream pout = new PipedOutputStream(); public void commandRequest(final String command) {
PipedInputStream pis = new PipedInputStream(pout); //
BufferedReader buf = new BufferedReader( }
new InputStreamReader(pis, StandardCharsets.UTF_8)); };
PipedConsoleInput in = new PipedConsoleInput( final CommandRequestListener crl2 = new CommandRequestListener() {
new PrintStream(pout))) {
final ConsoleApplication app = new ConsoleApplication(manager, in, @Override
null, null); public void commandRequest(final String command) {
appli = app; //
app.add(new ExitCommand("exit", app)); }
};
final Thread th = new Thread(new Runnable() { application.getApplication().addListener(crl);
application.getApplication().addListener(crl2);
@SuppressWarnings("synthetic-access") application.sendCommand("test");
@Override assertEquals("Unexpected message", "Test command ran fine",
public void run() { application.readNextLine());
app.start(); application.getApplication().removeListener(crl2);
} application.getApplication().removeListener(crl);
}); application.getApplication().removeListener(crl);
th.start();
in.type("exit"); assertTrue("Unclosed application should be running",
th.join(); application.getApplication().isRunning());
}
application.sendCommand("exit");
assertNotNull( assertEquals("Footer should be preserved",
"Application should still exist even if the console input and output are closed.", application.getApplication().footer,
appli); application.readNextLine());
appli.start(); assertFalse("Stopped application should not be running",
assertFalse( application.getApplication().isRunning());
"Application should not start on closed console input and output", }
appli.isRunning());
} ConsoleApplication appli = null;
try (PipedConsoleOutput manager = new PipedConsoleOutput();
@Test PipedOutputStream pout = new PipedOutputStream();
public void testInterpretCommand() throws InvalidCommandName, IOException { PipedInputStream pis = new PipedInputStream(pout);
try (PipedConsoleInput test = new PipedConsoleInput(null); BufferedReader buf = new BufferedReader(
PipedConsoleOutput out = new PipedConsoleOutput()) { new InputStreamReader(pis, StandardCharsets.UTF_8));
final ConsoleApplication appl = new ConsoleApplication(out, test, PipedConsoleInput in = new PipedConsoleInput(
"", ""); new PrintStream(pout))) {
final ConsoleApplication app = new ConsoleApplication(manager, in,
appl.interpretCommand("invalid cmd \"due to misplaced\"quote"); null, null);
assertEquals("Specific error message expected", appli = app;
"Command line cannot be parsed", out.readNextLine()); app.add(new ExitCommand("exit", app));
appl.interpretCommand(""); final Thread th = new Thread(new Runnable() {
final String message = "message"; @Override
appl.add(new ICommand() { public void run() {
app.start();
/* (non-Javadoc) }
* @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc. });
* manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, th.start();
* java.lang.String[]) */ in.type("exit");
@Override th.join();
public void execute(final ConsoleOutput out, }
final ConsoleInput in,
final String... args) throws CommandRunException { assertNotNull(
throw new CommandRunException(CommandRunExceptionType.USAGE, "Application should still exist even if the console input and output are closed.",
message, this); appli);
} appli.start();
assertFalse(
@Override "Application should not start on closed console input and output",
public String getCommandName() { appli.isRunning());
return "fail"; }
}
@Test
@Override public void testInterpretCommand() throws InvalidCommandName, IOException {
public void help(final ConsoleOutput manager, try (PipedConsoleInput test = new PipedConsoleInput(null);
final String... args) throws IOException { PipedConsoleOutput out = new PipedConsoleOutput()) {
manager.println(message); final ConsoleApplication appl = new ConsoleApplication(out, test,
} "", "");
@Override appl.interpretCommand("invalid cmd \"due to misplaced\"quote");
public String tip() { assertEquals("Specific error message expected",
return ""; "Command line cannot be parsed", out.readNextLine());
}
appl.interpretCommand("");
});
appl.interpretCommand("fail"); final String message = "message";
assertEquals("Unexpected message", appl.add(new ICommand() {
Messages.getString("ConsoleApplication.cmd.failed", "fail"),
out.readNextLine()); /* (non-Javadoc)
assertEquals("Unexpected message", message, out.readNextLine()); * @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc.
assertEquals("Unexpected message", message, out.readNextLine()); * manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput,
* java.lang.String[]) */
} @Override
} public void execute(final ConsoleOutput out,
} final ConsoleInput in,
final String... args) throws CommandRunException {
throw new CommandRunException(CommandRunExceptionType.USAGE,
message);
}
@Override
public String getCommandName() {
return "fail";
}
@Override
public void help(final ConsoleOutput manager,
final String... args) throws IOException {
manager.println(message);
}
@Override
public String tip() {
return "";
}
});
appl.interpretCommand("fail");
assertEquals("Unexpected message",
Messages.getString("ConsoleApplication.cmd.failed", "fail"),
out.readNextLine());
assertEquals("Unexpected message", message, out.readNextLine());
assertEquals("Unexpected message", message, out.readNextLine());
}
}
}

331
gclc/src/test/java/fr/bigeon/gclc/ConsoleTestApplication.java
View File

@ -1,152 +1,179 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
package fr.bigeon.gclc; package fr.bigeon.gclc;
import java.io.IOException; /*-
* #%L
import fr.bigeon.gclc.command.Command; * Generic Command Ligne console
import fr.bigeon.gclc.command.ExitCommand; * %%
import fr.bigeon.gclc.command.HelpExecutor; * Copyright (C) 2014 - 2018 bigeon.fr
import fr.bigeon.gclc.command.ICommandProvider; * %%
import fr.bigeon.gclc.exception.CommandRunException; * This software is governed by the CeCILL license under French law and
import fr.bigeon.gclc.exception.InvalidCommandName; * abiding by the rules of distribution of free software. You can use,
import fr.bigeon.gclc.manager.ConsoleInput; * modify and/ or redistribute the software under the terms of the CeCILL
import fr.bigeon.gclc.manager.ConsoleOutput; * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
/** A test-purpose application *
* * As a counterpart to the access to the source code and rights to copy,
* @author Emmanuel Bigeon */ * modify and redistribute granted by the license, users are provided only
public class ConsoleTestApplication implements ApplicationAttachement { * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
/** Exit command */ * liability.
public static final String EXIT = "exit"; //$NON-NLS-1$ *
/** Two seconds in milliseconds */ * In this respect, the user's attention is drawn to the risks associated
protected static final long TWO_SECONDS = 2000; * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
/***/ * that may mean that it is complicated to manipulate, and that also
@Override * therefore means that it is reserved for developers and experienced
@SuppressWarnings("nls") * professionals having in-depth computer knowledge. Users are therefore
public void attach(final ICommandProvider application) { * encouraged to load and test the software's suitability as regards their
try { * requirements in conditions enabling the security of their systems and/or
application.add(new ExitCommand(EXIT, (ConsoleApplication) application)); * data to be ensured and, more generally, to use and operate it in the
application.add(new HelpExecutor("help", * same conditions as regards security.
((ConsoleApplication) application).root)); *
application.add(new Command("test") { * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
/* (non-Javadoc) * #L%
* @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc. */
* manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, import java.io.IOException;
* java.lang.String[]) */
@Override import fr.bigeon.gclc.command.Command;
public void execute(final ConsoleOutput out, import fr.bigeon.gclc.command.HelpExecutor;
final ConsoleInput in, import fr.bigeon.gclc.command.ICommandProvider;
final String... args) throws CommandRunException { import fr.bigeon.gclc.command.base.ExitCommand;
try { import fr.bigeon.gclc.exception.CommandRunException;
out.println("Test command ran fine"); import fr.bigeon.gclc.exception.InvalidCommandName;
} catch (final IOException e) { import fr.bigeon.gclc.manager.ConsoleInput;
throw new CommandRunException("manager closed", e, import fr.bigeon.gclc.manager.ConsoleOutput;
this);
} /** A test-purpose application
} *
* @author Emmanuel Bigeon */
@Override public class ConsoleTestApplication implements ApplicationAttachement {
public String tip() {
return "A test command"; /** Exit command */
} public static final String EXIT = "exit"; //$NON-NLS-1$
/** Two seconds in milliseconds */
@Override protected static final long TWO_SECONDS = 2000;
protected String usageDetail() {
return null; /***/
} @Override
}); @SuppressWarnings("nls")
application.add(new Command("long") { public void attach(final ICommandProvider application) {
/* (non-Javadoc) try {
* @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc. application.add(new ExitCommand(EXIT, (ConsoleApplication) application));
* manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, application.add(
* java.lang.String[]) */ new HelpExecutor("help", ((ConsoleApplication) application).root));
@Override application.add(new Command("test") {
public void execute(final ConsoleOutput out,
final ConsoleInput in, /* (non-Javadoc)
final String... args) throws CommandRunException { * @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc.
try { * manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput,
out.println("Waita minute"); * java.lang.String[]) */
Thread.sleep(TWO_SECONDS); @Override
out.println("done!"); public void execute(final ConsoleOutput out, final ConsoleInput in,
} catch (final IOException e) { final String... args) throws CommandRunException {
throw new CommandRunException("manager closed", e, try {
this); out.println("Test command ran fine");
} catch (final InterruptedException e) { } catch (final IOException e) {
throw new CommandRunException("wait interrupted", e, throw new CommandRunException("manager closed", e);
this); }
} }
}
@Override
@Override public String tip() {
public String tip() { return "A test command";
return "A long execution command"; }
}
@Override
@Override protected String usageDetail() {
protected String usageDetail() { return null;
return null; }
} });
}); application.add(new Command("long") {
application.add(new Command("failingCmd") { /* (non-Javadoc)
/* (non-Javadoc) * @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc.
* @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc. * manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput,
* manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, * java.lang.String[]) */
* java.lang.String[]) */ @Override
@Override public void execute(final ConsoleOutput out, final ConsoleInput in,
public void execute(final ConsoleOutput out, final String... args) throws CommandRunException {
final ConsoleInput in, try {
final String... args) throws CommandRunException { out.println("Waita minute");
throw new CommandRunException("Failing command", this); Thread.sleep(TWO_SECONDS);
} out.println("done!");
} catch (final IOException e) {
@Override throw new CommandRunException("manager closed", e);
public String tip() { } catch (final InterruptedException e) {
return "A long execution command"; throw new CommandRunException("wait interrupted", e);
} }
}
@Override
protected String usageDetail() { @Override
return null; public String tip() {
} return "A long execution command";
}); }
} catch (final InvalidCommandName e) {
e.printStackTrace(); @Override
} protected String usageDetail() {
} return null;
} }
});
application.add(new Command("failingCmd") {
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.ICommand#execute(fr.bigeon.gclc.
* manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput,
* java.lang.String[]) */
@Override
public void execute(final ConsoleOutput out, final ConsoleInput in,
final String... args) throws CommandRunException {
throw new CommandRunException("Failing command");
}
@Override
public String tip() {
return "A long execution command";
}
@Override
protected String usageDetail() {
return null;
}
});
} catch (final InvalidCommandName e) {
e.printStackTrace();
}
}
}

289
gclc/src/test/java/fr/bigeon/gclc/GCLCConstantsTest.java
View File

@ -1,128 +1,161 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.GCLCConstantsTest.java * gclc:fr.bigeon.gclc.GCLCConstantsTest.java
* Created on: Jun 8, 2016 * Created on: Jun 8, 2016
*/ */
package fr.bigeon.gclc; package fr.bigeon.gclc;
import static org.junit.Assert.assertEquals; /*-
import static org.junit.Assert.assertTrue; * #%L
import static org.junit.Assert.fail; * Generic Command Ligne console
* %%
import java.util.List; * Copyright (C) 2014 - 2018 bigeon.fr
* %%
import org.junit.Test; * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
import fr.bigeon.gclc.exception.CommandParsingException; * modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
/** Test class for {@link GCLCConstants} * "http://www.cecill.info".
* *
* @author Emmanuel Bigeon */ * As a counterpart to the access to the source code and rights to copy,
@SuppressWarnings({"nls", "static-method"}) * modify and redistribute granted by the license, users are provided only
public class GCLCConstantsTest { * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
/** Test method for * liability.
* {@link fr.bigeon.gclc.GCLCConstants#splitCommand(java.lang.String)}. *
* * In this respect, the user's attention is drawn to the risks associated
* @throws CommandParsingException if an error occured */ * with loading, using, modifying and/or developing or reproducing the
@Test * software by the user in light of its specific status of free software,
public void testSplitCommand() throws CommandParsingException { * that may mean that it is complicated to manipulate, and that also
List<String> res; * therefore means that it is reserved for developers and experienced
res = GCLCConstants.splitCommand("aCommand"); * professionals having in-depth computer knowledge. Users are therefore
assertTrue("single word command should have one element", * encouraged to load and test the software's suitability as regards their
res.size() == 1); * requirements in conditions enabling the security of their systems and/or
assertTrue("Command should be preserved", * data to be ensured and, more generally, to use and operate it in the
res.get(0).equals("aCommand")); * same conditions as regards security.
*
res = GCLCConstants.splitCommand("aCommand with some arguments"); * The fact that you are presently reading this means that you have had
assertEquals("Command size", 4, res.size()); * knowledge of the CeCILL license and that you accept its terms.
assertEquals("Elements should be preserved", "aCommand", res.get(0)); * #L%
assertTrue("Elements should be preserved", res.get(1).equals("with")); */
assertTrue("Elements should be preserved", res.get(2).equals("some")); import static org.junit.Assert.assertEquals;
assertTrue("Elements should be preserved", import static org.junit.Assert.assertTrue;
res.get(3).equals("arguments")); import static org.junit.Assert.fail;
res = GCLCConstants.splitCommand("aCommand with some arguments");
assertEquals("Command size", 4, res.size()); import java.util.List;
assertTrue("Elements should be preserved",
res.get(0).equals("aCommand")); import org.junit.Test;
assertTrue("Elements should be preserved", res.get(1).equals("with"));
assertTrue("Elements should be preserved", res.get(2).equals("some")); import fr.bigeon.gclc.exception.CommandParsingException;
assertTrue("Elements should be preserved",
res.get(3).equals("arguments")); /** Test class for {@link GCLCConstants}
res = GCLCConstants.splitCommand("aCommand \"with some\" arguments"); *
assertEquals("Command size", 3, res.size()); * @author Emmanuel Bigeon */
assertTrue("Elements should be preserved", @SuppressWarnings({"nls", "static-method"})
res.get(0).equals("aCommand")); public class GCLCConstantsTest {
assertTrue("Elements should be preserved",
res.get(1).equals("with some")); /** Test method for
assertTrue("Elements should be preserved", * {@link fr.bigeon.gclc.GCLCConstants#splitCommand(java.lang.String)}.
res.get(2).equals("arguments")); *
res = GCLCConstants.splitCommand("aCommand with\\ some arguments"); * @throws CommandParsingException if an error occured */
assertEquals("Command size", 3, res.size()); @Test
assertTrue("Elements should be preserved", public void testSplitCommand() throws CommandParsingException {
res.get(0).equals("aCommand")); List<String> res;
assertTrue("Elements should be preserved", res = GCLCConstants.splitCommand("aCommand");
res.get(1).equals("with some")); assertTrue("single word command should have one element",
assertTrue("Elements should be preserved", res.size() == 1);
res.get(2).equals("arguments")); assertTrue("Command should be preserved",
res = GCLCConstants.splitCommand("aCommand wi\\\"th some arguments"); res.get(0).equals("aCommand"));
assertEquals("Command size", 4, res.size());
assertTrue("Elements should be preserved", res = GCLCConstants.splitCommand("aCommand with some arguments");
res.get(0).equals("aCommand")); assertEquals("Command size", 4, res.size());
assertTrue("Elements should be preserved", res.get(1).equals("wi\"th")); assertEquals("Elements should be preserved", "aCommand", res.get(0));
assertTrue("Elements should be preserved", res.get(2).equals("some")); assertTrue("Elements should be preserved", res.get(1).equals("with"));
assertTrue("Elements should be preserved", assertTrue("Elements should be preserved", res.get(2).equals("some"));
res.get(3).equals("arguments")); assertTrue("Elements should be preserved",
res.get(3).equals("arguments"));
res = GCLCConstants.splitCommand("aCommand with \"some arguments\""); res = GCLCConstants.splitCommand("aCommand with some arguments");
assertEquals("Command size", 3, res.size()); assertEquals("Command size", 4, res.size());
assertTrue("Elements should be preserved", assertTrue("Elements should be preserved",
res.get(0).equals("aCommand")); res.get(0).equals("aCommand"));
assertTrue("Elements should be preserved", res.get(1).equals("with")); assertTrue("Elements should be preserved", res.get(1).equals("with"));
assertTrue("Elements should be preserved", assertTrue("Elements should be preserved", res.get(2).equals("some"));
res.get(2).equals("some arguments")); assertTrue("Elements should be preserved",
res.get(3).equals("arguments"));
try { res = GCLCConstants.splitCommand("aCommand \"with some\" arguments");
// Wrong lines? assertEquals("Command size", 3, res.size());
res = GCLCConstants assertTrue("Elements should be preserved",
.splitCommand("aCommand with \"some ar\"guments"); res.get(0).equals("aCommand"));
fail("Misplaced quotes should fail"); assertTrue("Elements should be preserved",
} catch (final CommandParsingException e) { res.get(1).equals("with some"));
// ok assertTrue("Elements should be preserved",
} res.get(2).equals("arguments"));
} res = GCLCConstants.splitCommand("aCommand with\\ some arguments");
assertEquals("Command size", 3, res.size());
} assertTrue("Elements should be preserved",
res.get(0).equals("aCommand"));
assertTrue("Elements should be preserved",
res.get(1).equals("with some"));
assertTrue("Elements should be preserved",
res.get(2).equals("arguments"));
res = GCLCConstants.splitCommand("aCommand wi\\\"th some arguments");
assertEquals("Command size", 4, res.size());
assertTrue("Elements should be preserved",
res.get(0).equals("aCommand"));
assertTrue("Elements should be preserved", res.get(1).equals("wi\"th"));
assertTrue("Elements should be preserved", res.get(2).equals("some"));
assertTrue("Elements should be preserved",
res.get(3).equals("arguments"));
res = GCLCConstants.splitCommand("aCommand with \"some arguments\"");
assertEquals("Command size", 3, res.size());
assertTrue("Elements should be preserved",
res.get(0).equals("aCommand"));
assertTrue("Elements should be preserved", res.get(1).equals("with"));
assertTrue("Elements should be preserved",
res.get(2).equals("some arguments"));
try {
// Wrong lines?
res = GCLCConstants
.splitCommand("aCommand with \"some ar\"guments");
fail("Misplaced quotes should fail");
} catch (final CommandParsingException e) {
// ok
}
}
}

689
gclc/src/test/java/fr/bigeon/gclc/command/CommandParametersTest.java
View File

@ -1,328 +1,361 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.CommandParametersTest.java * gclc:fr.bigeon.gclc.command.CommandParametersTest.java
* Created on: Nov 18, 2016 * Created on: Nov 18, 2016
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
import static org.junit.Assert.assertEquals; /*-
import static org.junit.Assert.assertFalse; * #%L
import static org.junit.Assert.assertNull; * Generic Command Ligne console
import static org.junit.Assert.assertTrue; * %%
import static org.junit.Assert.fail; * Copyright (C) 2014 - 2018 bigeon.fr
* %%
import java.util.HashSet; * This software is governed by the CeCILL license under French law and
import java.util.Set; * abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
import org.junit.Test; * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
import fr.bigeon.gclc.exception.CommandParsingException; *
* As a counterpart to the access to the source code and rights to copy,
/** * modify and redistribute granted by the license, users are provided only
* <p> * with a limited warranty and the software's author, the holder of the
* TODO * economic rights, and the successive licensors have only limited
* * liability.
* @author Emmanuel Bigeon */ *
@SuppressWarnings({"static-method", "nls"}) * In this respect, the user's attention is drawn to the risks associated
public class CommandParametersTest { * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
/** Test method for * that may mean that it is complicated to manipulate, and that also
* {@link fr.bigeon.gclc.command.CommandParameters#CommandParameters(java.util.Set, java.util.Set, boolean)}. * therefore means that it is reserved for developers and experienced
* * professionals having in-depth computer knowledge. Users are therefore
* @throws CommandParsingException if an unexpected exception is thrown */ * encouraged to load and test the software's suitability as regards their
@Test * requirements in conditions enabling the security of their systems and/or
public final void testCommandParameters() throws CommandParsingException { * data to be ensured and, more generally, to use and operate it in the
final Set<String> strings = new HashSet<>(); * same conditions as regards security.
final Set<String> bools = new HashSet<>(); *
CommandParameters parameters = new CommandParameters(bools, strings, * The fact that you are presently reading this means that you have had
true); * knowledge of the CeCILL license and that you accept its terms.
* #L%
try { */
parameters.parseArgs("-ungivenFlag"); import static org.junit.Assert.assertEquals;
fail("parse of unknown in strict should fail"); import static org.junit.Assert.assertFalse;
} catch (final CommandParsingException e) { import static org.junit.Assert.assertNull;
// ok import static org.junit.Assert.assertTrue;
} import static org.junit.Assert.fail;
parameters = new CommandParameters(bools, strings, false);
import java.util.HashSet;
parameters.parseArgs("-ungivenFlag"); import java.util.Set;
}
import org.junit.Test;
/** Test method for
* {@link fr.bigeon.gclc.command.CommandParameters#get(java.lang.String)}. import fr.bigeon.gclc.exception.CommandParsingException;
*
* @throws CommandParsingException if an exception occired */ /**
@Test * <p>
public final void testGet() throws CommandParsingException { * TODO
final Set<String> strings = new HashSet<>(); *
final Set<String> bools = new HashSet<>(); * @author Emmanuel Bigeon */
@SuppressWarnings({"static-method", "nls"})
bools.add("boolFlag"); public class CommandParametersTest {
strings.add("str");
/** Test method for
final CommandParameters parameters = new CommandParameters(bools, * {@link fr.bigeon.gclc.command.CommandParameters#CommandParameters(java.util.Set, java.util.Set, boolean)}.
strings, true); *
* @throws CommandParsingException if an unexpected exception is thrown */
assertNull(parameters.get("ungiven")); @Test
assertNull(parameters.get("str")); public final void testCommandParameters() throws CommandParsingException {
final Set<String> strings = new HashSet<>();
try { final Set<String> bools = new HashSet<>();
parameters.parseArgs("-ungiven", "val"); CommandParameters parameters = new CommandParameters(bools, strings,
fail("Missing parameter should fail for strict element"); true);
} catch (final CommandParsingException e) {
// ok try {
} parameters.parseArgs("-ungivenFlag");
assertNull(parameters.get("ungiven")); fail("parse of unknown in strict should fail");
assertNull(parameters.get("str")); } catch (final CommandParsingException e) {
// ok
parameters.parseArgs("-str", "val"); }
assertNull(parameters.get("ungiven")); parameters = new CommandParameters(bools, strings, false);
assertEquals("val", parameters.get("str"));
parameters.parseArgs("-ungivenFlag");
try { }
parameters.parseArgs("-ungiven");
fail("Invalid argument type parsing should fail"); /** Test method for
} catch (final CommandParsingException e) { * {@link fr.bigeon.gclc.command.CommandParameters#get(java.lang.String)}.
// ok *
} * @throws CommandParsingException if an exception occired */
assertNull(parameters.get("ungiven")); @Test
assertEquals("val", parameters.get("str")); public final void testGet() throws CommandParsingException {
} final Set<String> strings = new HashSet<>();
final Set<String> bools = new HashSet<>();
/** Test method for
* {@link fr.bigeon.gclc.command.CommandParameters#getAdditionals()}. */ bools.add("boolFlag");
@Test strings.add("str");
public final void testGetAdditionals() throws CommandParsingException {
final Set<String> strings = new HashSet<>(); final CommandParameters parameters = new CommandParameters(bools,
final Set<String> bools = new HashSet<>(); strings, true);
bools.add("boolFlag"); assertNull(parameters.get("ungiven"));
strings.add("str"); assertNull(parameters.get("str"));
CommandParameters parameters = new CommandParameters(bools, strings, try {
true); parameters.parseArgs("-ungiven", "val");
fail("Missing parameter should fail for strict element");
parameters.parseArgs("-boolFlag"); } catch (final CommandParsingException e) {
assertTrue(parameters.getAdditionals().isEmpty()); // ok
}
try { assertNull(parameters.get("ungiven"));
parameters.parseArgs("-ungiven"); assertNull(parameters.get("str"));
fail("Should fail");
} catch (final CommandParsingException e) { parameters.parseArgs("-str", "val");
// ok assertNull(parameters.get("ungiven"));
} assertEquals("val", parameters.get("str"));
assertTrue(parameters.getAdditionals().isEmpty());
try {
parameters = new CommandParameters(bools, strings, false); parameters.parseArgs("-ungiven");
fail("Invalid argument type parsing should fail");
parameters.parseArgs("-boolFlag"); } catch (final CommandParsingException e) {
assertTrue(parameters.getAdditionals().isEmpty()); // ok
}
parameters.parseArgs("ungiven"); assertNull(parameters.get("ungiven"));
assertTrue(parameters.getAdditionals().contains("ungiven")); assertEquals("val", parameters.get("str"));
assertEquals(1, parameters.getAdditionals().size()); }
}
/** Test method for
/** Test method for * {@link fr.bigeon.gclc.command.CommandParameters#getAdditionals()}. */
* {@link fr.bigeon.gclc.command.CommandParameters#getBool(java.lang.String)}. @Test
* public final void testGetAdditionals() throws CommandParsingException {
* @throws CommandParsingException if a command parsing failed */ final Set<String> strings = new HashSet<>();
@Test final Set<String> bools = new HashSet<>();
public final void testGetBool() throws CommandParsingException {
final Set<String> strings = new HashSet<>(); bools.add("boolFlag");
final Set<String> bools = new HashSet<>(); strings.add("str");
bools.add("boolFlag"); CommandParameters parameters = new CommandParameters(bools, strings,
strings.add("str"); true);
CommandParameters parameters = new CommandParameters(bools, strings, parameters.parseArgs("-boolFlag");
true); assertTrue(parameters.getAdditionals().isEmpty());
assertFalse(parameters.getBool("ungiven")); try {
assertFalse(parameters.getBool("boolFlag")); parameters.parseArgs("-ungiven");
fail("Should fail");
parameters.parseArgs("-boolFlag"); } catch (final CommandParsingException e) {
assertTrue(parameters.getBool("boolFlag")); // ok
assertFalse(parameters.getBool("ungiven")); }
assertTrue(parameters.getAdditionals().isEmpty());
try {
parameters.parseArgs("-ungiven"); parameters = new CommandParameters(bools, strings, false);
fail("unknown parameter should fail");
} catch (final CommandParsingException e) { parameters.parseArgs("-boolFlag");
// ok assertTrue(parameters.getAdditionals().isEmpty());
}
assertFalse(parameters.getBool("ungiven")); parameters.parseArgs("ungiven");
assertTrue(parameters.getBool("boolFlag")); assertTrue(parameters.getAdditionals().contains("ungiven"));
assertEquals(1, parameters.getAdditionals().size());
parameters = new CommandParameters(bools, strings, false); }
assertFalse(parameters.getBool("ungiven")); /** Test method for
assertFalse(parameters.getBool("boolFlag")); * {@link fr.bigeon.gclc.command.CommandParameters#getBool(java.lang.String)}.
*
try { * @throws CommandParsingException if a command parsing failed */
parameters.parseArgs("-boolFlag"); @Test
} catch (final CommandParsingException e) { public final void testGetBool() throws CommandParsingException {
// ok final Set<String> strings = new HashSet<>();
} final Set<String> bools = new HashSet<>();
assertTrue(parameters.getBool("boolFlag"));
assertFalse(parameters.getBool("ungiven")); bools.add("boolFlag");
strings.add("str");
try {
parameters.parseArgs("-ungiven"); CommandParameters parameters = new CommandParameters(bools, strings,
} catch (final CommandParsingException e) { true);
// ok
} assertFalse(parameters.getBool("ungiven"));
assertFalse(parameters.getBool("ungiven")); assertFalse(parameters.getBool("boolFlag"));
assertTrue(parameters.getBool("boolFlag"));
} parameters.parseArgs("-boolFlag");
assertTrue(parameters.getBool("boolFlag"));
/** Test method for assertFalse(parameters.getBool("ungiven"));
* {@link fr.bigeon.gclc.command.CommandParameters#parseArgs(java.lang.String[])}.
* try {
* @throws CommandParsingException if a command parsing failed */ parameters.parseArgs("-ungiven");
@Test fail("unknown parameter should fail");
public final void testParseArgs() throws CommandParsingException { } catch (final CommandParsingException e) {
final Set<String> strings = new HashSet<>(); // ok
final Set<String> bools = new HashSet<>(); }
assertFalse(parameters.getBool("ungiven"));
bools.add("boolFlag"); assertTrue(parameters.getBool("boolFlag"));
strings.add("str");
parameters = new CommandParameters(bools, strings, false);
final CommandParameters parameters = new CommandParameters(bools,
strings, true); assertFalse(parameters.getBool("ungiven"));
assertFalse(parameters.getBool("boolFlag"));
try {
parameters.parseArgs("-ungivenFlag"); try {
fail("Strict should fail with flag"); parameters.parseArgs("-boolFlag");
} catch (final CommandParsingException e) { } catch (final CommandParsingException e) {
// ok // ok
} }
try { assertTrue(parameters.getBool("boolFlag"));
parameters.parseArgs("-str"); assertFalse(parameters.getBool("ungiven"));
fail("String argument without second element should fail");
} catch (final CommandParsingException e) { try {
// ok parameters.parseArgs("-ungiven");
} } catch (final CommandParsingException e) {
parameters.parseArgs("-boolFlag"); // ok
parameters.parseArgs("-str", "-boolFlag"); }
parameters.parseArgs("-boolFlag", "-str", "val"); assertFalse(parameters.getBool("ungiven"));
} assertTrue(parameters.getBool("boolFlag"));
}
/** Test method for
* {@link fr.bigeon.gclc.command.CommandParameters#set(java.lang.String, boolean)}. */ /** Test method for
@Test * {@link fr.bigeon.gclc.command.CommandParameters#parseArgs(java.lang.String[])}.
public final void testSetStringBoolean() { *
final Set<String> strings = new HashSet<>(); * @throws CommandParsingException if a command parsing failed */
final Set<String> bools = new HashSet<>(); @Test
public final void testParseArgs() throws CommandParsingException {
bools.add("boolFlag"); final Set<String> strings = new HashSet<>();
strings.add("str"); final Set<String> bools = new HashSet<>();
CommandParameters parameters = new CommandParameters(bools, strings, bools.add("boolFlag");
true); strings.add("str");
assertFalse(parameters.getBool("ungiven")); final CommandParameters parameters = new CommandParameters(bools,
assertFalse(parameters.getBool("boolFlag")); strings, true);
parameters.set("boolFlag", true); try {
assertTrue(parameters.getBool("boolFlag")); parameters.parseArgs("-ungivenFlag");
assertFalse(parameters.getBool("ungiven")); fail("Strict should fail with flag");
} catch (final CommandParsingException e) {
parameters.set("ungiven", true); // ok
assertFalse(parameters.getBool("ungiven")); }
assertTrue(parameters.getBool("boolFlag")); try {
parameters.parseArgs("-str");
parameters = new CommandParameters(bools, strings, false); fail("String argument without second element should fail");
} catch (final CommandParsingException e) {
assertFalse(parameters.getBool("ungiven")); // ok
assertFalse(parameters.getBool("boolFlag")); }
parameters.parseArgs("-boolFlag");
parameters.set("boolFlag", true); parameters.parseArgs("-str", "-boolFlag");
assertTrue(parameters.getBool("boolFlag")); parameters.parseArgs("-boolFlag", "-str", "val");
assertFalse(parameters.getBool("ungiven")); }
parameters.set("ungiven", true); /** Test method for
assertFalse(parameters.getBool("ungiven")); * {@link fr.bigeon.gclc.command.CommandParameters#set(java.lang.String, boolean)}. */
assertTrue(parameters.getBool("boolFlag")); @Test
} public final void testSetStringBoolean() {
final Set<String> strings = new HashSet<>();
/** Test method for final Set<String> bools = new HashSet<>();
* {@link fr.bigeon.gclc.command.CommandParameters#set(java.lang.String, java.lang.String)}. */
@Test bools.add("boolFlag");
public final void testSetStringString() { strings.add("str");
final Set<String> strings = new HashSet<>();
final Set<String> bools = new HashSet<>(); CommandParameters parameters = new CommandParameters(bools, strings,
true);
bools.add("boolFlag");
strings.add("str"); assertFalse(parameters.getBool("ungiven"));
assertFalse(parameters.getBool("boolFlag"));
CommandParameters parameters = new CommandParameters(bools, strings,
true); parameters.set("boolFlag", true);
assertTrue(parameters.getBool("boolFlag"));
assertNull(parameters.get("ungiven")); assertFalse(parameters.getBool("ungiven"));
assertNull(parameters.get("str"));
parameters.set("ungiven", true);
parameters.set("ungiven", "val"); assertFalse(parameters.getBool("ungiven"));
assertNull(parameters.get("ungiven")); assertTrue(parameters.getBool("boolFlag"));
assertNull(parameters.get("str"));
parameters = new CommandParameters(bools, strings, false);
parameters.set("str", "val");
assertNull(parameters.get("ungiven")); assertFalse(parameters.getBool("ungiven"));
assertEquals("val", parameters.get("str")); assertFalse(parameters.getBool("boolFlag"));
parameters.set("ungiven", "val"); parameters.set("boolFlag", true);
assertNull(parameters.get("ungiven")); assertTrue(parameters.getBool("boolFlag"));
assertEquals("val", parameters.get("str")); assertFalse(parameters.getBool("ungiven"));
parameters = new CommandParameters(bools, strings, false); parameters.set("ungiven", true);
assertFalse(parameters.getBool("ungiven"));
assertNull(parameters.get("ungiven")); assertTrue(parameters.getBool("boolFlag"));
assertNull(parameters.get("str")); }
parameters.set("ungiven", "val"); /** Test method for
assertNull(parameters.get("ungiven")); * {@link fr.bigeon.gclc.command.CommandParameters#set(java.lang.String, java.lang.String)}. */
assertNull(parameters.get("str")); @Test
public final void testSetStringString() {
parameters.set("str", "val"); final Set<String> strings = new HashSet<>();
assertNull(parameters.get("ungiven")); final Set<String> bools = new HashSet<>();
assertEquals("val", parameters.get("str"));
bools.add("boolFlag");
parameters.set("ungiven", "val"); strings.add("str");
assertNull(parameters.get("ungiven"));
assertEquals("val", parameters.get("str")); CommandParameters parameters = new CommandParameters(bools, strings,
} true);
} assertNull(parameters.get("ungiven"));
assertNull(parameters.get("str"));
parameters.set("ungiven", "val");
assertNull(parameters.get("ungiven"));
assertNull(parameters.get("str"));
parameters.set("str", "val");
assertNull(parameters.get("ungiven"));
assertEquals("val", parameters.get("str"));
parameters.set("ungiven", "val");
assertNull(parameters.get("ungiven"));
assertEquals("val", parameters.get("str"));
parameters = new CommandParameters(bools, strings, false);
assertNull(parameters.get("ungiven"));
assertNull(parameters.get("str"));
parameters.set("ungiven", "val");
assertNull(parameters.get("ungiven"));
assertNull(parameters.get("str"));
parameters.set("str", "val");
assertNull(parameters.get("ungiven"));
assertEquals("val", parameters.get("str"));
parameters.set("ungiven", "val");
assertNull(parameters.get("ungiven"));
assertEquals("val", parameters.get("str"));
}
}

230
gclc/src/test/java/fr/bigeon/gclc/command/CommandProviderTest.java
View File

@ -1,98 +1,132 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.CommandProviderTest.java * gclc:fr.bigeon.gclc.command.CommandProviderTest.java
* Created on: Nov 19, 2016 * Created on: Nov 19, 2016
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
import static org.junit.Assert.fail; /*-
* #%L
import org.junit.Test; * Generic Command Ligne console
* %%
import fr.bigeon.gclc.exception.InvalidCommandName; * Copyright (C) 2014 - 2018 bigeon.fr
* %%
/** * This software is governed by the CeCILL license under French law and
* <p> * abiding by the rules of distribution of free software. You can use,
* TODO * modify and/ or redistribute the software under the terms of the CeCILL
* * license as circulated by CEA, CNRS and INRIA at the following URL
* @author Emmanuel Bigeon */ * "http://www.cecill.info".
public class CommandProviderTest { *
* As a counterpart to the access to the source code and rights to copy,
/** Test method for * modify and redistribute granted by the license, users are provided only
* {@link fr.bigeon.gclc.command.CommandProvider#add(fr.bigeon.gclc.command.ICommand)}. * with a limited warranty and the software's author, the holder of the
* * economic rights, and the successive licensors have only limited
* @throws InvalidCommandName if the test failed */ * liability.
@Test *
public final void testAdd() throws InvalidCommandName { * In this respect, the user's attention is drawn to the risks associated
final CommandProvider provider = new CommandProvider(); * with loading, using, modifying and/or developing or reproducing the
try { * software by the user in light of its specific status of free software,
provider.add(new MockCommand(null)); * that may mean that it is complicated to manipulate, and that also
fail("null name for command should be rejected"); * therefore means that it is reserved for developers and experienced
} catch (final InvalidCommandName e) { * professionals having in-depth computer knowledge. Users are therefore
// ok * encouraged to load and test the software's suitability as regards their
} * requirements in conditions enabling the security of their systems and/or
try { * data to be ensured and, more generally, to use and operate it in the
provider.add(new MockCommand("")); * same conditions as regards security.
fail("null name for command should be rejected"); *
} catch (final InvalidCommandName e) { * The fact that you are presently reading this means that you have had
// ok * knowledge of the CeCILL license and that you accept its terms.
} * #L%
try { */
provider.add(new MockCommand("-name")); import static org.junit.Assert.fail;
fail("name with minus as starting character for command should be rejected");
} catch (final InvalidCommandName e) { import org.junit.Test;
// ok
} import fr.bigeon.gclc.command.base.MockCommand;
try { import fr.bigeon.gclc.exception.InvalidCommandName;
provider.add(new MockCommand("name command"));
fail("name with space for command should be rejected"); /**
} catch (final InvalidCommandName e) { * <p>
// ok * TODO
} *
final ICommand mock = new MockCommand("name"); * @author Emmanuel Bigeon */
provider.add(mock); public class CommandProviderTest {
try { /** Test method for
provider.add(new MockCommand(mock.getCommandName())); * {@link fr.bigeon.gclc.command.CommandProvider#add(fr.bigeon.gclc.command.ICommand)}.
fail("already existing command name should be rejected"); *
} catch (final InvalidCommandName e) { * @throws InvalidCommandName if the test failed */
// ok @Test
} public final void testAdd() throws InvalidCommandName {
final CommandProvider provider = new CommandProvider();
provider.add(mock); try {
} provider.add(new MockCommand(null));
fail("null name for command should be rejected");
} } catch (final InvalidCommandName e) {
// ok
}
try {
provider.add(new MockCommand(""));
fail("null name for command should be rejected");
} catch (final InvalidCommandName e) {
// ok
}
try {
provider.add(new MockCommand("-name"));
fail("name with minus as starting character for command should be rejected");
} catch (final InvalidCommandName e) {
// ok
}
try {
provider.add(new MockCommand("name command"));
fail("name with space for command should be rejected");
} catch (final InvalidCommandName e) {
// ok
}
final ICommand mock = new MockCommand("name");
provider.add(mock);
try {
provider.add(new MockCommand(mock.getCommandName()));
fail("already existing command name should be rejected");
} catch (final InvalidCommandName e) {
// ok
}
provider.add(mock);
}
}

785
gclc/src/test/java/fr/bigeon/gclc/command/CommandTest.java
View File

@ -1,376 +1,409 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.CommandTest.java * gclc:fr.bigeon.gclc.command.CommandTest.java
* Created on: Nov 19, 2016 * Created on: Nov 19, 2016
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
import static org.junit.Assert.assertEquals; /*-
import static org.junit.Assert.assertFalse; * #%L
import static org.junit.Assert.assertTrue; * Generic Command Ligne console
* %%
import java.io.IOException; * Copyright (C) 2014 - 2018 bigeon.fr
* %%
import org.junit.Test; * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
import fr.bigeon.gclc.exception.CommandRunException; * modify and/ or redistribute the software under the terms of the CeCILL
import fr.bigeon.gclc.manager.ConsoleInput; * license as circulated by CEA, CNRS and INRIA at the following URL
import fr.bigeon.gclc.manager.ConsoleOutput; * "http://www.cecill.info".
import fr.bigeon.gclc.manager.PipedConsoleOutput; *
* As a counterpart to the access to the source code and rights to copy,
/** <p> * modify and redistribute granted by the license, users are provided only
* TODO * with a limited warranty and the software's author, the holder of the
* * economic rights, and the successive licensors have only limited
* @author Emmanuel Bigeon */ * liability.
public class CommandTest { *
* In this respect, the user's attention is drawn to the risks associated
@Test * with loading, using, modifying and/or developing or reproducing the
public final void testCommand() throws IOException { * software by the user in light of its specific status of free software,
try (PipedConsoleOutput test = new PipedConsoleOutput()) { * that may mean that it is complicated to manipulate, and that also
Command cmd; * therefore means that it is reserved for developers and experienced
cmd = new Command("name") { * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
@Override * requirements in conditions enabling the security of their systems and/or
public void execute(final ConsoleOutput out, * data to be ensured and, more generally, to use and operate it in the
final ConsoleInput in, * same conditions as regards security.
final String... args) throws CommandRunException { *
// * The fact that you are presently reading this means that you have had
} * knowledge of the CeCILL license and that you accept its terms.
* #L%
@Override */
public String tip() { import static org.junit.Assert.assertEquals;
return null; import static org.junit.Assert.assertFalse;
} import static org.junit.Assert.assertTrue;
@Override import java.io.IOException;
protected String usageDetail() {
return null; import org.junit.Test;
}
}; import fr.bigeon.gclc.exception.CommandRunException;
cmd.help(test); import fr.bigeon.gclc.manager.ConsoleInput;
import fr.bigeon.gclc.manager.ConsoleOutput;
// name import fr.bigeon.gclc.utils.PipedConsoleOutput;
assertEquals("First line should be command name", "name",
test.readNextLine()); /** <p>
// tip * TODO
test.readNextLine(); *
// * @author Emmanuel Bigeon */
assertTrue("Section line is empty", test.readNextLine().isEmpty()); public class CommandTest {
// Usage
test.readNextLine(); @Test
// details public final void testCommand() throws IOException {
test.readNextLine(); try (PipedConsoleOutput test = new PipedConsoleOutput()) {
// Command cmd;
assertTrue("Section line is empty", test.readNextLine().isEmpty()); cmd = new Command("name") {
assertFalse("Only 6 line should be printed", test.available());
@Override
cmd = new Command("name") { public void execute(final ConsoleOutput out,
final ConsoleInput in,
@Override final String... args) throws CommandRunException {
public void execute(final ConsoleOutput out, //
final ConsoleInput in, }
final String... args) throws CommandRunException {
// @Override
} public String tip() {
return null;
@Override }
public String tip() {
return ""; @Override
} protected String usageDetail() {
return null;
@Override }
protected String usageDetail() { };
return null; cmd.help(test);
}
}; // name
cmd.help(test); assertEquals("First line should be command name", "name",
// name test.readNextLine());
assertEquals("First line should be command name", "name", // tip
test.readNextLine()); test.readNextLine();
// tip //
test.readNextLine(); assertTrue("Section line is empty", test.readNextLine().isEmpty());
// // Usage
assertTrue("Section line is empty", test.readNextLine().isEmpty()); test.readNextLine();
// Usage // details
test.readNextLine(); test.readNextLine();
// details //
test.readNextLine(); assertTrue("Section line is empty", test.readNextLine().isEmpty());
// assertFalse("Only 6 line should be printed", test.available());
assertTrue("Section line is empty", test.readNextLine().isEmpty());
assertFalse("Only 6 line should be printed", test.available()); cmd = new Command("name") {
cmd = new Command("name") { @Override
public void execute(final ConsoleOutput out,
/* (non-Javadoc) final ConsoleInput in,
* @see fr.bigeon.gclc.command.Command#brief() */ final String... args) throws CommandRunException {
@Override //
protected String brief() { }
return null;
} @Override
public String tip() {
@Override return "";
public void execute(final ConsoleOutput out, }
final ConsoleInput in,
final String... args) throws CommandRunException { @Override
// protected String usageDetail() {
} return null;
}
@Override };
public String tip() { cmd.help(test);
return "tip"; // name
} assertEquals("First line should be command name", "name",
test.readNextLine());
@Override // tip
protected String usageDetail() { test.readNextLine();
return null; //
} assertTrue("Section line is empty", test.readNextLine().isEmpty());
}; // Usage
cmd.help(test); test.readNextLine();
// name // details
assertEquals("First line should be command name", "name", test.readNextLine();
test.readNextLine()); //
// tip assertTrue("Section line is empty", test.readNextLine().isEmpty());
test.readNextLine(); assertFalse("Only 6 line should be printed", test.available());
//
assertTrue("Section line is empty", test.readNextLine().isEmpty()); cmd = new Command("name") {
// Usage
test.readNextLine(); /* (non-Javadoc)
// details * @see fr.bigeon.gclc.command.Command#brief() */
test.readNextLine(); @Override
// protected String brief() {
assertTrue("Section line is empty", test.readNextLine().isEmpty()); return null;
assertFalse("Only 6 line should be printed", test.available()); }
cmd = new Command("name") { @Override
public void execute(final ConsoleOutput out,
/* (non-Javadoc) final ConsoleInput in,
* @see fr.bigeon.gclc.command.Command#brief() */ final String... args) throws CommandRunException {
@Override //
protected String brief() { }
return "brief";
} @Override
public String tip() {
@Override return "tip";
public void execute(final ConsoleOutput out, }
final ConsoleInput in,
final String... args) throws CommandRunException { @Override
// protected String usageDetail() {
} return null;
}
@Override };
public String tip() { cmd.help(test);
return "tip"; // name
} assertEquals("First line should be command name", "name",
test.readNextLine());
@Override // tip
protected String usageDetail() { test.readNextLine();
return null; //
} assertTrue("Section line is empty", test.readNextLine().isEmpty());
}; // Usage
cmd.help(test); test.readNextLine();
// name // details
assertEquals("First line should be command name", "name", test.readNextLine();
test.readNextLine()); //
// tip assertTrue("Section line is empty", test.readNextLine().isEmpty());
test.readNextLine(); assertFalse("Only 6 line should be printed", test.available());
//
assertTrue("Section line is empty", test.readNextLine().isEmpty()); cmd = new Command("name") {
// Usage
test.readNextLine(); /* (non-Javadoc)
// details * @see fr.bigeon.gclc.command.Command#brief() */
test.readNextLine(); @Override
// protected String brief() {
assertTrue("Section line is empty", test.readNextLine().isEmpty()); return "brief";
assertFalse("Only 6 line should be printed", test.available()); }
cmd = new Command("name") { @Override
public void execute(final ConsoleOutput out,
@Override final ConsoleInput in,
public void execute(final ConsoleOutput out, final String... args) throws CommandRunException {
final ConsoleInput in, //
final String... args) throws CommandRunException { }
//
} @Override
public String tip() {
@Override return "tip";
public String tip() { }
return "tip";
} @Override
protected String usageDetail() {
/* (non-Javadoc) return null;
* @see fr.bigeon.gclc.command.Command#usageDetail() */ }
@Override };
protected String usageDetail() { cmd.help(test);
return null; // name
} assertEquals("First line should be command name", "name",
}; test.readNextLine());
cmd.help(test); // tip
// name test.readNextLine();
assertEquals("First line should be command name", "name", //
test.readNextLine()); assertTrue("Section line is empty", test.readNextLine().isEmpty());
// tip // Usage
test.readNextLine(); test.readNextLine();
// // details
assertTrue("Section line is empty", test.readNextLine().isEmpty()); test.readNextLine();
// Usage //
test.readNextLine(); assertTrue("Section line is empty", test.readNextLine().isEmpty());
// details assertFalse("Only 6 line should be printed", test.available());
test.readNextLine();
// cmd = new Command("name") {
assertTrue("Section line is empty", test.readNextLine().isEmpty());
assertFalse("Only 6 line should be printed", test.available()); @Override
public void execute(final ConsoleOutput out,
cmd = new Command("name") { final ConsoleInput in,
final String... args) throws CommandRunException {
@Override //
public void execute(final ConsoleOutput out, }
final ConsoleInput in,
final String... args) throws CommandRunException { @Override
// public String tip() {
} return "tip";
}
@Override
public String tip() { /* (non-Javadoc)
return "tip"; * @see fr.bigeon.gclc.command.Command#usageDetail() */
} @Override
protected String usageDetail() {
/* (non-Javadoc) return null;
* @see fr.bigeon.gclc.command.Command#usageDetail() */ }
@Override };
protected String usageDetail() { cmd.help(test);
return "details"; // name
} assertEquals("First line should be command name", "name",
}; test.readNextLine());
cmd.help(test); // tip
test.readNextLine();
// name //
assertEquals("First line should be command name", "name", assertTrue("Section line is empty", test.readNextLine().isEmpty());
test.readNextLine()); // Usage
// tip test.readNextLine();
test.readNextLine(); // details
// test.readNextLine();
assertTrue("Section line is empty", test.readNextLine().isEmpty()); //
// Usage assertTrue("Section line is empty", test.readNextLine().isEmpty());
test.readNextLine(); assertFalse("Only 6 line should be printed", test.available());
// pattern
test.readNextLine(); cmd = new Command("name") {
//
assertTrue("Section line is empty", test.readNextLine().isEmpty()); @Override
// details public void execute(final ConsoleOutput out,
assertEquals("Unexpected detail", "details", test.readNextLine()); final ConsoleInput in,
assertFalse("Only 6 line should be printed", test.available()); final String... args) throws CommandRunException {
//
cmd = new Command("name") { }
@Override @Override
public void execute(final ConsoleOutput out, public String tip() {
final ConsoleInput in, return "tip";
final String... args) throws CommandRunException { }
//
} /* (non-Javadoc)
* @see fr.bigeon.gclc.command.Command#usageDetail() */
@Override @Override
public String tip() { protected String usageDetail() {
return "tip"; return "details";
} }
};
/* (non-Javadoc) cmd.help(test);
* @see fr.bigeon.gclc.command.Command#usageDetail() */
@Override // name
protected String usageDetail() { assertEquals("First line should be command name", "name",
return "details" + System.lineSeparator(); test.readNextLine());
} // tip
}; test.readNextLine();
cmd.help(test); //
// name assertTrue("Section line is empty", test.readNextLine().isEmpty());
assertEquals("First line should be command name", "name", // Usage
test.readNextLine()); test.readNextLine();
// tip // pattern
test.readNextLine(); test.readNextLine();
// //
assertTrue("Section line is empty", test.readNextLine().isEmpty()); assertTrue("Section line is empty", test.readNextLine().isEmpty());
// Usage // details
test.readNextLine(); assertEquals("Unexpected detail", "details", test.readNextLine());
// pattern assertFalse("Only 6 line should be printed", test.available());
test.readNextLine();
// cmd = new Command("name") {
assertTrue("Section line is empty", test.readNextLine().isEmpty());
// details @Override
assertEquals("Unexpected detail", "details", test.readNextLine()); public void execute(final ConsoleOutput out,
assertFalse("Only 6 line should be printed", test.available()); final ConsoleInput in,
final String... args) throws CommandRunException {
cmd = new Command("name") { //
}
@Override
public void execute(final ConsoleOutput out, @Override
final ConsoleInput in, public String tip() {
final String... args) throws CommandRunException { return "tip";
// }
}
/* (non-Javadoc)
@Override * @see fr.bigeon.gclc.command.Command#usageDetail() */
public String tip() { @Override
return "tip"; protected String usageDetail() {
} return "details" + System.lineSeparator();
}
/* (non-Javadoc) };
* @see fr.bigeon.gclc.command.Command#usageDetail() */ cmd.help(test);
@Override // name
protected String usageDetail() { assertEquals("First line should be command name", "name",
return "\n"; test.readNextLine());
} // tip
}; test.readNextLine();
cmd.help(test); //
// name assertTrue("Section line is empty", test.readNextLine().isEmpty());
assertEquals("First line should be command name", "name", // Usage
test.readNextLine()); test.readNextLine();
// tip // pattern
test.readNextLine(); test.readNextLine();
// //
assertTrue("Section line is empty", test.readNextLine().isEmpty()); assertTrue("Section line is empty", test.readNextLine().isEmpty());
// Usage // details
test.readNextLine(); assertEquals("Unexpected detail", "details", test.readNextLine());
// pattern assertFalse("Only 6 line should be printed", test.available());
test.readNextLine();
// cmd = new Command("name") {
assertTrue("Section line is empty", test.readNextLine().isEmpty());
// @Override
assertTrue("Section line is empty", test.readNextLine().isEmpty()); public void execute(final ConsoleOutput out,
assertFalse("Only 6 line should be printed", test.available()); final ConsoleInput in,
final String... args) throws CommandRunException {
} //
} }
}
@Override
public String tip() {
return "tip";
}
/* (non-Javadoc)
* @see fr.bigeon.gclc.command.Command#usageDetail() */
@Override
protected String usageDetail() {
return "\n";
}
};
cmd.help(test);
// name
assertEquals("First line should be command name", "name",
test.readNextLine());
// tip
test.readNextLine();
//
assertTrue("Section line is empty", test.readNextLine().isEmpty());
// Usage
test.readNextLine();
// pattern
test.readNextLine();
//
assertTrue("Section line is empty", test.readNextLine().isEmpty());
//
assertTrue("Section line is empty", test.readNextLine().isEmpty());
assertFalse("Only 6 line should be printed", test.available());
}
}
}

270
gclc/src/test/java/fr/bigeon/gclc/command/HelpExecutorTest.java
View File

@ -1,118 +1,152 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.HelpExecutorTest.java * gclc:fr.bigeon.gclc.command.HelpExecutorTest.java
* Created on: Nov 19, 2016 * Created on: Nov 19, 2016
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
import static org.junit.Assert.assertNotNull; /*-
import static org.junit.Assert.fail; * #%L
* Generic Command Ligne console
import java.io.IOException; * %%
* Copyright (C) 2014 - 2018 bigeon.fr
import org.junit.Test; * %%
* This software is governed by the CeCILL license under French law and
import fr.bigeon.gclc.exception.CommandRunException; * abiding by the rules of distribution of free software. You can use,
import fr.bigeon.gclc.manager.ConsoleInput; * modify and/ or redistribute the software under the terms of the CeCILL
import fr.bigeon.gclc.manager.ConsoleOutput; * license as circulated by CEA, CNRS and INRIA at the following URL
import fr.bigeon.gclc.manager.PipedConsoleOutput; * "http://www.cecill.info".
*
/** * As a counterpart to the access to the source code and rights to copy,
* <p> * modify and redistribute granted by the license, users are provided only
* TODO * with a limited warranty and the software's author, the holder of the
* * economic rights, and the successive licensors have only limited
* @author Emmanuel Bigeon */ * liability.
public class HelpExecutorTest { *
* In this respect, the user's attention is drawn to the risks associated
/** Test method for * with loading, using, modifying and/or developing or reproducing the
* {@link fr.bigeon.gclc.command.HelpExecutor#execute(ConsoleOutput, ConsoleInput, String...)}. * software by the user in light of its specific status of free software,
* * that may mean that it is complicated to manipulate, and that also
* @throws CommandRunException if the test failed * therefore means that it is reserved for developers and experienced
* @throws IOException if the test failed */ * professionals having in-depth computer knowledge. Users are therefore
@Test * encouraged to load and test the software's suitability as regards their
public final void testExecute() throws CommandRunException, IOException { * requirements in conditions enabling the security of their systems and/or
final PipedConsoleOutput test = new PipedConsoleOutput(); * data to be ensured and, more generally, to use and operate it in the
final HelpExecutor help = new HelpExecutor("?", new Command("mock") { * same conditions as regards security.
*
@Override * The fact that you are presently reading this means that you have had
public void execute(final ConsoleOutput out, final ConsoleInput in, * knowledge of the CeCILL license and that you accept its terms.
final String... args) throws CommandRunException { * #L%
// */
} import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.fail;
@Override
public String tip() { import java.io.IOException;
return "";
} import org.junit.Test;
@Override import fr.bigeon.gclc.command.base.MockCommand;
protected String usageDetail() { import fr.bigeon.gclc.exception.CommandRunException;
return null; import fr.bigeon.gclc.manager.ConsoleInput;
} import fr.bigeon.gclc.manager.ConsoleOutput;
import fr.bigeon.gclc.utils.PipedConsoleOutput;
});
/**
help.execute(test, null); * <p>
test.close(); * TODO
*
try { * @author Emmanuel Bigeon */
help.execute(test, null); public class HelpExecutorTest {
fail("manager closed shall provoke failure of help command execution");
} catch (final Exception e) { /** Test method for
// ok * {@link fr.bigeon.gclc.command.HelpExecutor#execute(ConsoleOutput, ConsoleInput, String...)}.
} *
} * @throws CommandRunException if the test failed
* @throws IOException if the test failed */
/** Test method for {@link fr.bigeon.gclc.command.HelpExecutor#tip()}. @Test
* public final void testExecute() throws CommandRunException, IOException {
* @throws IOException if the test failed */ final PipedConsoleOutput test = new PipedConsoleOutput();
@Test final HelpExecutor help = new HelpExecutor("?", new Command("mock") {
public final void testTip() throws IOException {
try (PipedConsoleOutput test = new PipedConsoleOutput()) { @Override
final HelpExecutor help = new HelpExecutor("?", public void execute(final ConsoleOutput out, final ConsoleInput in,
new MockCommand("mock")); final String... args) throws CommandRunException {
assertNotNull("Tip should be provided", help.tip()); //
help.help(test); }
}
try (PipedConsoleOutput test = new PipedConsoleOutput()) { @Override
final HelpExecutor help = new HelpExecutor("?", public String tip() {
new SubedCommand("sub", new MockCommand("mock"))); return "";
help.tip(); }
help.help(test);
} @Override
} protected String usageDetail() {
return null;
} }
});
help.execute(test, null);
test.close();
try {
help.execute(test, null);
fail("manager closed shall provoke failure of help command execution");
} catch (final Exception e) {
// ok
}
}
/** Test method for {@link fr.bigeon.gclc.command.HelpExecutor#tip()}.
*
* @throws IOException if the test failed */
@Test
public final void testTip() throws IOException {
try (PipedConsoleOutput test = new PipedConsoleOutput()) {
final HelpExecutor help = new HelpExecutor("?",
new MockCommand("mock"));
assertNotNull("Tip should be provided", help.tip());
help.help(test);
}
try (PipedConsoleOutput test = new PipedConsoleOutput()) {
final HelpExecutor help = new HelpExecutor("?",
new SubedCommand("sub", new MockCommand("mock")));
help.tip();
help.help(test);
}
}
}

1396
gclc/src/test/java/fr/bigeon/gclc/command/ParametrizedCommandTest.java
View File

File diff suppressed because it is too large Load Diff

390
gclc/src/test/java/fr/bigeon/gclc/command/ScriptExecutionTest.java
View File

@ -1,181 +1,209 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.ScriptExecutionTest.java * gclc:fr.bigeon.gclc.command.ScriptExecutionTest.java
* Created on: Jun 12, 2016 * Created on: Jun 12, 2016
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
import static org.junit.Assert.assertEquals; /*-
import static org.junit.Assert.assertNotNull; * #%L
import static org.junit.Assert.fail; * Generic Command Ligne console
* %%
import java.io.IOException; * Copyright (C) 2014 - 2018 bigeon.fr
import java.nio.charset.Charset; * %%
* This software is governed by the CeCILL license under French law and
import org.junit.Test; * abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
import fr.bigeon.gclc.ConsoleApplication; * license as circulated by CEA, CNRS and INRIA at the following URL
import fr.bigeon.gclc.ConsoleTestApplication; * "http://www.cecill.info".
import fr.bigeon.gclc.exception.CommandRunException; *
import fr.bigeon.gclc.exception.CommandRunExceptionType; * As a counterpart to the access to the source code and rights to copy,
import fr.bigeon.gclc.manager.PipedConsoleInput; * modify and redistribute granted by the license, users are provided only
import fr.bigeon.gclc.manager.PipedConsoleOutput; * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
/** <p> * liability.
* Test class for {@link ScriptExecution} *
* * In this respect, the user's attention is drawn to the risks associated
* @author Emmanuel Bigeon */ * with loading, using, modifying and/or developing or reproducing the
@SuppressWarnings("static-method") * software by the user in light of its specific status of free software,
public class ScriptExecutionTest { * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
/** Test method for * professionals having in-depth computer knowledge. Users are therefore
* {@link fr.bigeon.gclc.command.ScriptExecution#execute(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, String...)}. */ * encouraged to load and test the software's suitability as regards their
@Test * requirements in conditions enabling the security of their systems and/or
public void testExecute() { * data to be ensured and, more generally, to use and operate it in the
PipedConsoleOutput test; * same conditions as regards security.
PipedConsoleInput in; *
try { * The fact that you are presently reading this means that you have had
in = new PipedConsoleInput(null); * knowledge of the CeCILL license and that you accept its terms.
test = new PipedConsoleOutput(); * #L%
} catch (final IOException e2) { */
fail("creation of console manager failed"); //$NON-NLS-1$ import static org.junit.Assert.assertEquals;
return; import static org.junit.Assert.assertNotNull;
} import static org.junit.Assert.fail;
final ConsoleApplication app = new ConsoleApplication(
test, in, "", ""); import java.io.IOException;
new ConsoleTestApplication().attach(app); import java.nio.charset.Charset;
final ScriptExecution exec = new ScriptExecution("script", app, "#", //$NON-NLS-1$ //$NON-NLS-2$
Charset.forName("UTF-8")); import org.junit.Test;
try {
exec.execute(test, in); import fr.bigeon.gclc.ConsoleApplication;
fail("execution of script command with no file should fail"); //$NON-NLS-1$ import fr.bigeon.gclc.ConsoleTestApplication;
} catch (final CommandRunException e1) { import fr.bigeon.gclc.command.base.ScriptExecution;
// ok import fr.bigeon.gclc.exception.CommandRunException;
assertEquals(exec, e1.getSource()); import fr.bigeon.gclc.exception.CommandRunExceptionType;
assertEquals(CommandRunExceptionType.USAGE, e1.getType()); import fr.bigeon.gclc.utils.PipedConsoleInput;
} import fr.bigeon.gclc.utils.PipedConsoleOutput;
try { /** <p>
exec.execute(test, in, * Test class for {@link ScriptExecution}
"src/test/resources/scripts/withprependSpace.txt"); //$NON-NLS-1$ *
fail("execution of script with lines begining with space should fail"); //$NON-NLS-1$ * @author Emmanuel Bigeon */
} catch (final CommandRunException e1) { @SuppressWarnings("static-method")
// ok public class ScriptExecutionTest {
assertEquals(exec, e1.getSource());
assertEquals(CommandRunExceptionType.EXECUTION, e1.getType()); /** Test method for
} * {@link fr.bigeon.gclc.command.base.ScriptExecution#execute(fr.bigeon.gclc.manager.ConsoleOutput, fr.bigeon.gclc.manager.ConsoleInput, String...)}. */
@Test
try { public void testExecute() {
exec.execute(test, in, PipedConsoleOutput test;
"src/test/resources/scripts/invalidCmdParse.txt"); //$NON-NLS-1$ PipedConsoleInput in;
fail("execution of script with invalid command line should fail"); //$NON-NLS-1$ try {
} catch (final CommandRunException e1) { in = new PipedConsoleInput(null);
// ok test = new PipedConsoleOutput();
assertEquals(exec, e1.getSource()); } catch (final IOException e2) {
assertEquals(CommandRunExceptionType.EXECUTION, e1.getType()); fail("creation of console manager failed"); //$NON-NLS-1$
} return;
}
try { final ConsoleApplication app = new ConsoleApplication(
exec.execute(test, in, test, in, "", "");
"src/test/resources/scripts/invalidCmd.txt"); //$NON-NLS-1$ new ConsoleTestApplication().attach(app);
fail("execution of script with invalid command should fail"); //$NON-NLS-1$ final ScriptExecution exec = new ScriptExecution("script", app, "#", //$NON-NLS-1$ //$NON-NLS-2$
} catch (final CommandRunException e1) { Charset.forName("UTF-8"));
// ok try {
assertEquals(exec, e1.getSource()); exec.execute(test, in);
assertEquals(CommandRunExceptionType.EXECUTION, e1.getType()); fail("execution of script command with no file should fail"); //$NON-NLS-1$
} } catch (final CommandRunException e1) {
// ok
try { assertEquals(CommandRunExceptionType.USAGE, e1.getType());
exec.execute(test, in, }
"src/test/resources/scripts/failingCmdInvoc.txt"); //$NON-NLS-1$
fail("execution of script with failing command should fail"); //$NON-NLS-1$ try {
} catch (final CommandRunException e1) { exec.execute(test, in,
// ok "src/test/resources/scripts/withprependSpace.txt"); //$NON-NLS-1$
assertEquals(exec, e1.getSource()); fail("execution of script with lines begining with space should fail"); //$NON-NLS-1$
assertEquals(CommandRunExceptionType.EXECUTION, e1.getType()); } catch (final CommandRunException e1) {
} // ok
assertEquals(CommandRunExceptionType.EXECUTION, e1.getType());
try { }
exec.execute(test, in,
"src/test/resources/scripts/someNonExisting.file"); //$NON-NLS-1$ try {
fail("execution of script with unexisting file should fail"); //$NON-NLS-1$ exec.execute(test, in,
} catch (final CommandRunException e1) { "src/test/resources/scripts/invalidCmdParse.txt"); //$NON-NLS-1$
// ok fail("execution of script with invalid command line should fail"); //$NON-NLS-1$
assertEquals(exec, e1.getSource()); } catch (final CommandRunException e1) {
assertEquals(CommandRunExceptionType.EXECUTION, e1.getType()); // ok
} assertEquals(CommandRunExceptionType.EXECUTION, e1.getType());
}
try {
exec.execute(test, in, "src/test/resources/script1.txt"); //$NON-NLS-1$ try {
exec.execute(test, in, "src/test/resources/script2.txt"); //$NON-NLS-1$ exec.execute(test, in,
exec.execute(test, in, "src/test/resources/script3.txt"); //$NON-NLS-1$ "src/test/resources/scripts/invalidCmd.txt"); //$NON-NLS-1$
exec.execute(test, in, "src/test/resources/script4.txt"); //$NON-NLS-1$ fail("execution of script with invalid command should fail"); //$NON-NLS-1$
exec.execute(test, in, "src/test/resources/script5.txt", "test"); //$NON-NLS-1$ //$NON-NLS-2$ } catch (final CommandRunException e1) {
} catch (final CommandRunException e) { // ok
e.printStackTrace(); assertEquals(CommandRunExceptionType.EXECUTION, e1.getType());
fail("execution of wellformed script should not fail"); //$NON-NLS-1$ }
}
try { try {
test.close(); exec.execute(test, in,
} catch (final IOException e) { "src/test/resources/scripts/failingCmdInvoc.txt"); //$NON-NLS-1$
// TODO Auto-generated catch block fail("execution of script with failing command should fail"); //$NON-NLS-1$
e.printStackTrace(); } catch (final CommandRunException e1) {
} // ok
} assertEquals(CommandRunExceptionType.EXECUTION, e1.getType());
}
/** Test method for
* {@link fr.bigeon.gclc.command.ScriptExecution#help(fr.bigeon.gclc.manager.ConsoleOutput, String...)}. */ try {
@Test exec.execute(test, in,
public void testHelp() { "src/test/resources/scripts/someNonExisting.file"); //$NON-NLS-1$
final ScriptExecution exec = new ScriptExecution("script", null, "#", //$NON-NLS-1$ //$NON-NLS-2$ fail("execution of script with unexisting file should fail"); //$NON-NLS-1$
Charset.forName("UTF-8")); } catch (final CommandRunException e1) {
try (PipedConsoleOutput test = new PipedConsoleOutput()) { // ok
exec.help(test); assertEquals(CommandRunExceptionType.EXECUTION, e1.getType());
exec.help(test, "ignored element"); }
} catch (final IOException e) {
e.printStackTrace(); try {
fail("unexpected error in help invocation"); //$NON-NLS-1$ exec.execute(test, in, "src/test/resources/script1.gclc"); //$NON-NLS-1$
} exec.execute(test, in, "src/test/resources/script2.txt"); //$NON-NLS-1$
} exec.execute(test, in, "src/test/resources/script3.txt"); //$NON-NLS-1$
exec.execute(test, in, "src/test/resources/script4.txt"); //$NON-NLS-1$
/** Test method for {@link fr.bigeon.gclc.command.ScriptExecution#tip()}. */ exec.execute(test, in, "src/test/resources/script5.txt", "test"); //$NON-NLS-1$ //$NON-NLS-2$
@Test } catch (final CommandRunException e) {
public void testTip() { e.printStackTrace();
final ScriptExecution exec = new ScriptExecution("script", null, "#", //$NON-NLS-1$ //$NON-NLS-2$ fail("execution of wellformed script should not fail"); //$NON-NLS-1$
Charset.forName("UTF-8")); }
assertNotNull("Tip should not be null", exec.tip()); try {
} test.close();
} } catch (final IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/** Test method for
* {@link fr.bigeon.gclc.command.base.ScriptExecution#help(fr.bigeon.gclc.manager.ConsoleOutput, String...)}. */
@Test
public void testHelp() {
final ScriptExecution exec = new ScriptExecution("script", null, "#", //$NON-NLS-1$ //$NON-NLS-2$
Charset.forName("UTF-8"));
try (PipedConsoleOutput test = new PipedConsoleOutput()) {
exec.help(test);
exec.help(test, "ignored element");
} catch (final IOException e) {
e.printStackTrace();
fail("unexpected error in help invocation"); //$NON-NLS-1$
}
}
/** Test method for {@link fr.bigeon.gclc.command.base.ScriptExecution#tip()}. */
@Test
public void testTip() {
final ScriptExecution exec = new ScriptExecution("script", null, "#", //$NON-NLS-1$ //$NON-NLS-2$
Charset.forName("UTF-8"));
assertNotNull("Tip should not be null", exec.tip());
}
}

846
gclc/src/test/java/fr/bigeon/gclc/command/SubedCommandTest.java
View File

@ -1,408 +1,438 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.command.SubedCommandTest.java * gclc:fr.bigeon.gclc.command.SubedCommandTest.java
* Created on: Nov 18, 2016 * Created on: Nov 18, 2016
*/ */
package fr.bigeon.gclc.command; package fr.bigeon.gclc.command;
import static org.junit.Assert.assertEquals; /*-
import static org.junit.Assert.assertNotNull; * #%L
import static org.junit.Assert.assertNull; * Generic Command Ligne console
import static org.junit.Assert.fail; * %%
* Copyright (C) 2014 - 2018 bigeon.fr
import java.io.IOException; * %%
* This software is governed by the CeCILL license under French law and
import org.junit.Test; * abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
import fr.bigeon.gclc.exception.CommandRunException; * license as circulated by CEA, CNRS and INRIA at the following URL
import fr.bigeon.gclc.exception.InvalidCommandName; * "http://www.cecill.info".
import fr.bigeon.gclc.manager.ConsoleInput; *
import fr.bigeon.gclc.manager.ConsoleOutput; * As a counterpart to the access to the source code and rights to copy,
import fr.bigeon.gclc.manager.PipedConsoleOutput; * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
/** * economic rights, and the successive licensors have only limited
* <p> * liability.
* TODO *
* * In this respect, the user's attention is drawn to the risks associated
* @author Emmanuel Bigeon */ * with loading, using, modifying and/or developing or reproducing the
@SuppressWarnings("all") * software by the user in light of its specific status of free software,
public class SubedCommandTest { * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
/** Test method for * professionals having in-depth computer knowledge. Users are therefore
* {@link fr.bigeon.gclc.command.SubedCommand#add(fr.bigeon.gclc.command.ICommand)}. */ * encouraged to load and test the software's suitability as regards their
@Test * requirements in conditions enabling the security of their systems and/or
public final void testAdd() { * data to be ensured and, more generally, to use and operate it in the
final SubedCommand cmd = new SubedCommand("name"); * same conditions as regards security.
*
try { * The fact that you are presently reading this means that you have had
cmd.add(new MockCommand("id")); * knowledge of the CeCILL license and that you accept its terms.
} catch (final InvalidCommandName e) { * #L%
fail("addition of command with valid id failed"); */
} import static org.junit.Assert.assertEquals;
try { import static org.junit.Assert.assertNotNull;
cmd.add(new MockCommand("id")); import static org.junit.Assert.assertNull;
fail("addition of command with already used id succeeded"); import static org.junit.Assert.fail;
} catch (final InvalidCommandName e) {
// import java.io.IOException;
}
try { import org.junit.Test;
cmd.add(new MockCommand(""));
fail("addition of command with invalid id succeeded"); import fr.bigeon.gclc.command.base.MockCommand;
} catch (final InvalidCommandName e) { import fr.bigeon.gclc.exception.CommandRunException;
// import fr.bigeon.gclc.exception.InvalidCommandName;
} import fr.bigeon.gclc.manager.ConsoleInput;
import fr.bigeon.gclc.manager.ConsoleOutput;
} import fr.bigeon.gclc.utils.PipedConsoleOutput;
/** Test method for /**
* {@link fr.bigeon.gclc.command.SubedCommand#execute(ConsoleOutput, ConsoleInput, String...)}. */ * <p>
@Test * TODO
public final void testExecute() { *
SubedCommand cmd = new SubedCommand("name"); * @author Emmanuel Bigeon */
@SuppressWarnings("all")
final MockCommand mock = new MockCommand("id"); public class SubedCommandTest {
try {
cmd.add(mock); /** Test method for
cmd.add(new Command("fail") { * {@link fr.bigeon.gclc.command.SubedCommand#add(fr.bigeon.gclc.command.ICommand)}. */
@Test
@Override public final void testAdd() {
public void execute(final ConsoleOutput out, final SubedCommand cmd = new SubedCommand("name");
final ConsoleInput in,
final String... args) throws CommandRunException { try {
throw new CommandRunException("Failing command", null); cmd.add(new MockCommand("id"));
} } catch (final InvalidCommandName e) {
fail("addition of command with valid id failed");
@Override }
public String tip() { try {
return null; cmd.add(new MockCommand("id"));
} fail("addition of command with already used id succeeded");
} catch (final InvalidCommandName e) {
@Override //
protected String usageDetail() { }
return null; try {
} cmd.add(new MockCommand(""));
}); fail("addition of command with invalid id succeeded");
} catch (final InvalidCommandName e) { } catch (final InvalidCommandName e) {
fail("addition of command with valid id failed"); //
assertNotNull(e); }
}
}
try {
cmd.execute(null, null, "id"); /** Test method for
} catch (final CommandRunException e) { * {@link fr.bigeon.gclc.command.SubedCommand#execute(ConsoleOutput, ConsoleInput, String...)}. */
fail("Unexpected exception when running mock command"); @Test
assertNotNull(e); public final void testExecute() {
} SubedCommand cmd = new SubedCommand("name");
try {
cmd.execute(null, null, "fail"); final MockCommand mock = new MockCommand("id");
fail("Fail command error should be re thrown"); try {
} catch (final CommandRunException e) { cmd.add(mock);
assertNotNull(e); cmd.add(new Command("fail") {
assertEquals(cmd, e.getSource());
} @Override
try { public void execute(final ConsoleOutput out,
cmd.execute(null, null); final ConsoleInput in,
fail("Request for inexistent default command should fail"); final String... args) throws CommandRunException {
} catch (final CommandRunException e) { throw new CommandRunException("Failing command", null);
assertNotNull(e); }
assertEquals(cmd, e.getSource());
} @Override
cmd = new SubedCommand("name", mock); public String tip() {
return null;
try { }
cmd.add(mock);
cmd.add(new Command("fail") { @Override
protected String usageDetail() {
@Override return null;
public void execute(final ConsoleOutput out, }
final ConsoleInput in, });
final String... args) throws CommandRunException { } catch (final InvalidCommandName e) {
throw new CommandRunException("Failing command", this); fail("addition of command with valid id failed");
} assertNotNull(e);
}
@Override
public String tip() { try {
return null; cmd.execute(null, null, "id");
} } catch (final CommandRunException e) {
fail("Unexpected exception when running mock command");
@Override assertNotNull(e);
protected String usageDetail() { }
return null; try {
} cmd.execute(null, null, "fail");
}); fail("Fail command error should be re thrown");
} catch (final InvalidCommandName e) { } catch (final CommandRunException e) {
fail("addition of command with valid id failed"); assertNotNull(e);
assertNotNull(e); }
} try {
cmd.execute(null, null);
try { fail("Request for inexistent default command should fail");
cmd.execute(null, null, "id"); } catch (final CommandRunException e) {
} catch (final CommandRunException e) { assertNotNull(e);
fail("Unexpected exception when running mock command"); }
assertNotNull(e); cmd = new SubedCommand("name", mock);
}
try { try {
cmd.execute(null, null, "fail"); cmd.add(mock);
fail("Fail command error should be re thrown"); cmd.add(new Command("fail") {
} catch (final CommandRunException e) {
assertNotNull(e); @Override
assertEquals(cmd.get("fail"), e.getSource()); public void execute(final ConsoleOutput out,
} final ConsoleInput in,
try { final String... args) throws CommandRunException {
cmd.execute(null, null); throw new CommandRunException("Failing command");
} catch (final CommandRunException e) { }
fail("Request for default command should execute default command");
assertNotNull(e); @Override
} public String tip() {
} return null;
}
/** Test method for
* {@link fr.bigeon.gclc.command.SubedCommand#executeSub(ConsoleOutput, ConsoleInput, String, String...)}. */ @Override
@Test protected String usageDetail() {
public final void testExecuteSub() { return null;
final SubedCommand cmd = new SubedCommand("name"); }
});
final MockCommand mock = new MockCommand("id"); } catch (final InvalidCommandName e) {
try { fail("addition of command with valid id failed");
cmd.add(mock); assertNotNull(e);
cmd.add(new Command("fail") { }
@Override try {
public void execute(final ConsoleOutput out, cmd.execute(null, null, "id");
final ConsoleInput in, } catch (final CommandRunException e) {
final String... args) throws CommandRunException { fail("Unexpected exception when running mock command");
throw new CommandRunException("Failing command", this); assertNotNull(e);
} }
try {
@Override cmd.execute(null, null, "fail");
public String tip() { fail("Fail command error should be re thrown");
return null; } catch (final CommandRunException e) {
} assertNotNull(e);
}
@Override try {
protected String usageDetail() { cmd.execute(null, null);
return null; } catch (final CommandRunException e) {
} fail("Request for default command should execute default command");
}); assertNotNull(e);
} catch (final InvalidCommandName e) { }
fail("addition of command with valid id failed"); }
assertNotNull(e);
} /** Test method for
* {@link fr.bigeon.gclc.command.SubedCommand#executeSub(ConsoleOutput, ConsoleInput, String, String...)}. */
try { @Test
cmd.executeSub(null, null,"id"); public final void testExecuteSub() {
} catch (final CommandRunException e) { final SubedCommand cmd = new SubedCommand("name");
fail("Unexpected exception when running mock command");
assertNotNull(e); final MockCommand mock = new MockCommand("id");
} try {
try { cmd.add(mock);
cmd.executeSub(null, null, "fail"); cmd.add(new Command("fail") {
fail("Fail command error should be re thrown");
} catch (final CommandRunException e) { @Override
assertNotNull(e); public void execute(final ConsoleOutput out,
assertEquals(cmd.get("fail"), e.getSource()); final ConsoleInput in,
} final String... args) throws CommandRunException {
} throw new CommandRunException("Failing command");
}
/** Test method for
* {@link fr.bigeon.gclc.command.SubedCommand#get(java.lang.String)}. */ @Override
@Test public String tip() {
public final void testGet() { return null;
final SubedCommand cmd = new SubedCommand("name"); }
assertNull(cmd.get("id")); @Override
protected String usageDetail() {
final MockCommand mock = new MockCommand("id"); return null;
try { }
cmd.add(mock); });
} catch (final InvalidCommandName e) { } catch (final InvalidCommandName e) {
fail("addition of command with valid id failed"); fail("addition of command with valid id failed");
assertNotNull(e); assertNotNull(e);
} }
assertEquals(mock, cmd.get("id"));
} try {
cmd.executeSub(null, null,"id");
/** Test method for } catch (final CommandRunException e) {
* {@link fr.bigeon.gclc.command.SubedCommand#getCommandName()}. */ fail("Unexpected exception when running mock command");
@Test assertNotNull(e);
public final void testGetCommandName() { }
SubedCommand cmd = new SubedCommand("name"); try {
assertEquals("name", cmd.getCommandName()); cmd.executeSub(null, null, "fail");
cmd = new SubedCommand("name with spaces"); fail("Fail command error should be re thrown");
assertEquals("name with spaces", cmd.getCommandName()); } catch (final CommandRunException e) {
cmd = new SubedCommand("name", "some tip"); assertNotNull(e);
assertEquals("name", cmd.getCommandName()); }
cmd = new SubedCommand("name", new MockCommand("")); }
assertEquals("name", cmd.getCommandName());
cmd = new SubedCommand("name", new MockCommand(""), "some tip"); /** Test method for
assertEquals("name", cmd.getCommandName()); * {@link fr.bigeon.gclc.command.SubedCommand#get(java.lang.String)}. */
} @Test
public final void testGet() {
/** Test method for final SubedCommand cmd = new SubedCommand("name");
* {@link fr.bigeon.gclc.command.SubedCommand#help(ConsoleOutput, String...)}. */
@Test assertNull(cmd.get("id"));
public final void testHelp() {
SubedCommand cmd = new SubedCommand("name"); final MockCommand mock = new MockCommand("id");
try {
ICommand mock = new MockCommand("id"); cmd.add(mock);
try { } catch (final InvalidCommandName e) {
cmd.add(mock); fail("addition of command with valid id failed");
} catch (final InvalidCommandName e) { assertNotNull(e);
fail("addition of command with valid id failed"); }
assertNotNull(e); assertEquals(mock, cmd.get("id"));
} }
try (PipedConsoleOutput manager = new PipedConsoleOutput()) { /** Test method for
cmd.help(manager); * {@link fr.bigeon.gclc.command.SubedCommand#getCommandName()}. */
assertEquals("\tid", manager.readNextLine()); @Test
cmd.help(manager, "id"); public final void testGetCommandName() {
cmd.help(manager, "inexistent"); SubedCommand cmd = new SubedCommand("name");
} catch (final IOException e) { assertEquals("name", cmd.getCommandName());
fail("Unexpected exception when running help"); cmd = new SubedCommand("name with spaces");
assertNotNull(e); assertEquals("name with spaces", cmd.getCommandName());
} cmd = new SubedCommand("name", "some tip");
assertEquals("name", cmd.getCommandName());
cmd = new SubedCommand("name", mock); cmd = new SubedCommand("name", new MockCommand(""));
assertEquals("name", cmd.getCommandName());
try { cmd = new SubedCommand("name", new MockCommand(""), "some tip");
cmd.add(mock); assertEquals("name", cmd.getCommandName());
} catch (final InvalidCommandName e) { }
fail("addition of command with valid id failed");
assertNotNull(e); /** Test method for
} * {@link fr.bigeon.gclc.command.SubedCommand#help(ConsoleOutput, String...)}. */
@Test
try (PipedConsoleOutput manager = new PipedConsoleOutput()) { public final void testHelp() {
cmd.help(manager); SubedCommand cmd = new SubedCommand("name");
assertEquals("\tid", manager.readNextLine());
} catch (final IOException e) { ICommand mock = new MockCommand("id");
fail("Unexpected exception when running help"); try {
assertNotNull(e); cmd.add(mock);
} } catch (final InvalidCommandName e) {
fail("addition of command with valid id failed");
mock = new ICommand() { assertNotNull(e);
}
@Override
public void execute(final ConsoleOutput out, final ConsoleInput in, try (PipedConsoleOutput manager = new PipedConsoleOutput()) {
final String... args) throws CommandRunException { cmd.help(manager);
// assertEquals("\tid", manager.readNextLine());
} cmd.help(manager, "id");
cmd.help(manager, "inexistent");
@Override } catch (final IOException e) {
public String getCommandName() { fail("Unexpected exception when running help");
return "id"; assertNotNull(e);
} }
@Override cmd = new SubedCommand("name", mock);
public void help(final ConsoleOutput manager,
final String... args) throws IOException { try {
// cmd.add(mock);
} } catch (final InvalidCommandName e) {
fail("addition of command with valid id failed");
@Override assertNotNull(e);
public String tip() { }
return "tip";
} try (PipedConsoleOutput manager = new PipedConsoleOutput()) {
}; cmd.help(manager);
cmd = new SubedCommand("name", mock); assertEquals("\tid", manager.readNextLine());
} catch (final IOException e) {
try { fail("Unexpected exception when running help");
cmd.add(mock); assertNotNull(e);
} catch (final InvalidCommandName e) { }
fail("addition of command with valid id failed");
assertNotNull(e); mock = new ICommand() {
}
@Override
try (PipedConsoleOutput manager = new PipedConsoleOutput()) { public void execute(final ConsoleOutput out, final ConsoleInput in,
cmd.help(manager); final String... args) throws CommandRunException {
assertEquals("\ttip", manager.readNextLine()); //
assertEquals("\tid: tip", manager.readNextLine()); }
} catch (final IOException e) {
fail("Unexpected exception when running help"); @Override
assertNotNull(e); public String getCommandName() {
} return "id";
} }
/** Test method for @Override
* {@link fr.bigeon.gclc.command.SubedCommand#SubedCommand(java.lang.String)}. */ public void help(final ConsoleOutput manager,
@Test final String... args) throws IOException {
public final void testSubedCommandString() { //
SubedCommand cmd = new SubedCommand("name"); }
assertEquals("name", cmd.getCommandName());
cmd = new SubedCommand("name with spaces"); @Override
assertNull(cmd.tip()); public String tip() {
assertEquals("name with spaces", cmd.getCommandName()); return "tip";
} }
};
/** Test method for cmd = new SubedCommand("name", mock);
* {@link fr.bigeon.gclc.command.SubedCommand#SubedCommand(java.lang.String, fr.bigeon.gclc.command.ICommand)}. */
@Test try {
public final void testSubedCommandStringICommand() { cmd.add(mock);
SubedCommand cmd = new SubedCommand("name", new MockCommand("")); } catch (final InvalidCommandName e) {
assertEquals("name", cmd.getCommandName()); fail("addition of command with valid id failed");
cmd = new SubedCommand("name with spaces", new MockCommand("")); assertNotNull(e);
assertNull(cmd.tip()); }
assertEquals("name with spaces", cmd.getCommandName());
} try (PipedConsoleOutput manager = new PipedConsoleOutput()) {
cmd.help(manager);
/** Test method for assertEquals("\ttip", manager.readNextLine());
* {@link fr.bigeon.gclc.command.SubedCommand#SubedCommand(java.lang.String, fr.bigeon.gclc.command.ICommand, java.lang.String)}. */ assertEquals("\tid: tip", manager.readNextLine());
@Test } catch (final IOException e) {
public final void testSubedCommandStringICommandString() { fail("Unexpected exception when running help");
SubedCommand cmd = new SubedCommand("name", new MockCommand(""), "tip"); assertNotNull(e);
assertEquals("name", cmd.getCommandName()); }
cmd = new SubedCommand("name with spaces", new MockCommand(""), "tip"); }
assertEquals("name with spaces", cmd.getCommandName());
} /** Test method for
* {@link fr.bigeon.gclc.command.SubedCommand#SubedCommand(java.lang.String)}. */
/** Test method for @Test
* {@link fr.bigeon.gclc.command.SubedCommand#SubedCommand(java.lang.String, java.lang.String)}. */ public final void testSubedCommandString() {
@Test SubedCommand cmd = new SubedCommand("name");
public final void testSubedCommandStringString() { assertEquals("name", cmd.getCommandName());
SubedCommand cmd = new SubedCommand("name", "tip"); cmd = new SubedCommand("name with spaces");
assertEquals("name", cmd.getCommandName()); assertNull(cmd.tip());
cmd = new SubedCommand("name with spaces", "tip"); assertEquals("name with spaces", cmd.getCommandName());
assertEquals("name with spaces", cmd.getCommandName()); }
}
/** Test method for
/** Test method for {@link fr.bigeon.gclc.command.SubedCommand#tip()}. */ * {@link fr.bigeon.gclc.command.SubedCommand#SubedCommand(java.lang.String, fr.bigeon.gclc.command.ICommand)}. */
@Test @Test
public final void testTip() { public final void testSubedCommandStringICommand() {
SubedCommand cmd = new SubedCommand("name"); SubedCommand cmd = new SubedCommand("name", new MockCommand(""));
assertNull(cmd.tip()); assertEquals("name", cmd.getCommandName());
cmd = new SubedCommand("name with spaces", new MockCommand(""), "tip"); cmd = new SubedCommand("name with spaces", new MockCommand(""));
assertEquals("tip", cmd.tip()); assertNull(cmd.tip());
} assertEquals("name with spaces", cmd.getCommandName());
} }
/** Test method for
* {@link fr.bigeon.gclc.command.SubedCommand#SubedCommand(java.lang.String, fr.bigeon.gclc.command.ICommand, java.lang.String)}. */
@Test
public final void testSubedCommandStringICommandString() {
SubedCommand cmd = new SubedCommand("name", new MockCommand(""), "tip");
assertEquals("name", cmd.getCommandName());
cmd = new SubedCommand("name with spaces", new MockCommand(""), "tip");
assertEquals("name with spaces", cmd.getCommandName());
}
/** Test method for
* {@link fr.bigeon.gclc.command.SubedCommand#SubedCommand(java.lang.String, java.lang.String)}. */
@Test
public final void testSubedCommandStringString() {
SubedCommand cmd = new SubedCommand("name", "tip");
assertEquals("name", cmd.getCommandName());
cmd = new SubedCommand("name with spaces", "tip");
assertEquals("name with spaces", cmd.getCommandName());
}
/** Test method for {@link fr.bigeon.gclc.command.SubedCommand#tip()}. */
@Test
public final void testTip() {
SubedCommand cmd = new SubedCommand("name");
assertNull(cmd.tip());
cmd = new SubedCommand("name with spaces", new MockCommand(""), "tip");
assertEquals("tip", cmd.tip());
}
}

182
gclc/src/test/java/fr/bigeon/gclc/exception/CommandRunExceptionTest.java
View File

@ -1,75 +1,107 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.exception.CommandRunExceptionTest.java * gclc:fr.bigeon.gclc.exception.CommandRunExceptionTest.java
* Created on: Nov 19, 2016 * Created on: Nov 19, 2016
*/ */
package fr.bigeon.gclc.exception; package fr.bigeon.gclc.exception;
import static org.junit.Assert.assertEquals; /*-
* #%L
import org.junit.Test; * Generic Command Ligne console
* %%
import fr.bigeon.gclc.command.ICommand; * Copyright (C) 2014 - 2018 bigeon.fr
import fr.bigeon.gclc.command.MockCommand; * %%
* This software is governed by the CeCILL license under French law and
/** * abiding by the rules of distribution of free software. You can use,
* <p> * modify and/ or redistribute the software under the terms of the CeCILL
* TODO * license as circulated by CEA, CNRS and INRIA at the following URL
* * "http://www.cecill.info".
* @author Emmanuel Bigeon *
* * As a counterpart to the access to the source code and rights to copy,
*/ * modify and redistribute granted by the license, users are provided only
public class CommandRunExceptionTest { * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited
/** * liability.
* Test method for {@link fr.bigeon.gclc.exception.CommandRunException#getLocalizedMessage()}. *
*/ * In this respect, the user's attention is drawn to the risks associated
@Test * with loading, using, modifying and/or developing or reproducing the
public final void testGetLocalizedMessage() { * software by the user in light of its specific status of free software,
CommandRunException e; * that may mean that it is complicated to manipulate, and that also
ICommand cmd = new MockCommand("name"); * therefore means that it is reserved for developers and experienced
String messageInner = "inner"; * professionals having in-depth computer knowledge. Users are therefore
String message = "message"; * encouraged to load and test the software's suitability as regards their
e = new CommandRunException(message, * requirements in conditions enabling the security of their systems and/or
new CommandRunException(messageInner, new MockCommand("name")), //$NON-NLS-1$ * data to be ensured and, more generally, to use and operate it in the
cmd); * same conditions as regards security.
*
assertEquals(message + ": " + messageInner, e.getLocalizedMessage()); * The fact that you are presently reading this means that you have had
e = new CommandRunException(message, cmd); * knowledge of the CeCILL license and that you accept its terms.
assertEquals(message, e.getLocalizedMessage()); * #L%
} */
import static org.junit.Assert.assertEquals;
}
import org.junit.Test;
import fr.bigeon.gclc.command.ICommand;
import fr.bigeon.gclc.command.base.MockCommand;
/**
* <p>
* TODO
*
* @author Emmanuel Bigeon
*
*/
public class CommandRunExceptionTest {
/**
* Test method for {@link fr.bigeon.gclc.exception.CommandRunException#getLocalizedMessage()}.
*/
@Test
public final void testGetLocalizedMessage() {
CommandRunException e;
final ICommand cmd = new MockCommand("name");
final String messageInner = "inner";
final String message = "message";
e = new CommandRunException(message,
new CommandRunException(messageInner));
assertEquals(message + ": " + messageInner, e.getLocalizedMessage());
e = new CommandRunException(message);
assertEquals(message, e.getLocalizedMessage());
}
}

319
gclc/src/test/java/fr/bigeon/gclc/manager/ReadingRunnableTest.java
View File

@ -1,142 +1,177 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.manager.ReadingRunnableTest.java * gclc:fr.bigeon.gclc.manager.ReadingRunnableTest.java
* Created on: Dec 6, 2016 * Created on: Dec 6, 2016
*/ */
package fr.bigeon.gclc.manager; package fr.bigeon.gclc.manager;
import static org.junit.Assert.assertFalse; /*-
import static org.junit.Assert.fail; * #%L
* Generic Command Ligne console
import java.io.BufferedReader; * %%
import java.io.IOException; * Copyright (C) 2014 - 2018 bigeon.fr
import java.io.InputStream; * %%
import java.io.InputStreamReader; * This software is governed by the CeCILL license under French law and
import java.io.PipedInputStream; * abiding by the rules of distribution of free software. You can use,
import java.io.PipedOutputStream; * modify and/ or redistribute the software under the terms of the CeCILL
import java.nio.charset.Charset; * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
import org.junit.Before; *
import org.junit.Test; * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
/** * with a limited warranty and the software's author, the holder of the
* <p> * economic rights, and the successive licensors have only limited
* TODO * liability.
* *
* @author Emmanuel Bigeon */ * In this respect, the user's attention is drawn to the risks associated
public class ReadingRunnableTest { * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
/** * that may mean that it is complicated to manipulate, and that also
*/ * therefore means that it is reserved for developers and experienced
@Before * professionals having in-depth computer knowledge. Users are therefore
public void setUp() {} * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
/** Test method for * data to be ensured and, more generally, to use and operate it in the
* {@link fr.bigeon.gclc.manager.ReadingRunnable#getMessage()}. */ * same conditions as regards security.
@Test *
public final void testGetMessage() { * The fact that you are presently reading this means that you have had
final BufferedReader reader = null; * knowledge of the CeCILL license and that you accept its terms.
final ReadingRunnable runnable = new ReadingRunnable(reader); * #L%
runnable.setRunning(false); */
import static org.junit.Assert.assertFalse;
try { import static org.junit.Assert.fail;
runnable.getMessage();
fail("reading from closed runnable"); import java.io.BufferedReader;
} catch (final IOException e) { import java.io.IOException;
// ok import java.io.InputStream;
} import java.io.InputStreamReader;
import java.io.PipedInputStream;
} import java.io.PipedOutputStream;
import java.nio.charset.Charset;
/** Test method for
* {@link fr.bigeon.gclc.manager.ReadingRunnable#getWaitForDelivery(java.lang.String)}. import org.junit.Before;
* import org.junit.Test;
* @throws InterruptedException if the test failed
* @throws IOException if the test failed */ import fr.bigeon.gclc.utils.ReadingRunnable;
@Test
public final void testGetWaitForDelivery() throws InterruptedException, /**
IOException { * <p>
try (PipedOutputStream out = new PipedOutputStream(); * TODO
InputStream piped = new PipedInputStream(out); *
BufferedReader reader = new BufferedReader( * @author Emmanuel Bigeon */
new InputStreamReader(piped, "UTF-8"))) { public class ReadingRunnableTest {
final ReadingRunnable runnable = new ReadingRunnable(reader);
final Thread th0 = new Thread(runnable, "read"); /**
th0.start(); */
final Thread th = runnable.getWaitForDelivery("msg"); @Before
public void setUp() {}
out.write(Charset.forName("UTF-8")
.encode("msg" + System.lineSeparator()).array()); /** Test method for
* {@link fr.bigeon.gclc.utils.ReadingRunnable#getMessage()}. */
final Thread th2 = new Thread(new Runnable() { @Test
public final void testGetMessage() {
@Override final BufferedReader reader = null;
public void run() { final ReadingRunnable runnable = new ReadingRunnable(reader);
try { runnable.setRunning(false);
runnable.getMessage();
} catch (final IOException e) { try {
// TODO Auto-generated catch block runnable.getMessage();
e.printStackTrace(); fail("reading from closed runnable");
} } catch (final IOException e) {
} // ok
}, "get"); }
th2.start();
th.join(); }
assertFalse("Runnable should have consumed every message",
runnable.hasMessage()); /** Test method for
runnable.setRunning(false); * {@link fr.bigeon.gclc.utils.ReadingRunnable#getWaitForDelivery(java.lang.String)}.
out.close(); *
} * @throws InterruptedException if the test failed
} * @throws IOException if the test failed */
@Test
/** Test method for public final void testGetWaitForDelivery() throws InterruptedException,
* {@link fr.bigeon.gclc.manager.ReadingRunnable#hasMessage()}. */ IOException {
@Test try (PipedOutputStream out = new PipedOutputStream();
public final void testHasMessage() { InputStream piped = new PipedInputStream(out);
BufferedReader reader = new BufferedReader(
final BufferedReader reader = null; new InputStreamReader(piped, "UTF-8"))) {
final ReadingRunnable runnable = new ReadingRunnable(reader); final ReadingRunnable runnable = new ReadingRunnable(reader);
runnable.setRunning(false); final Thread th0 = new Thread(runnable, "read");
th0.start();
try { final Thread th = runnable.getWaitForDelivery("msg");
runnable.getMessage();
fail("reading from closed runnable"); out.write(Charset.forName("UTF-8")
} catch (final IOException e) { .encode("msg" + System.lineSeparator()).array());
// ok
} final Thread th2 = new Thread(new Runnable() {
}
@Override
} public void run() {
try {
runnable.getMessage();
} catch (final IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}, "get");
th2.start();
th.join();
assertFalse("Runnable should have consumed every message",
runnable.hasMessage());
runnable.setRunning(false);
out.close();
}
}
/** Test method for
* {@link fr.bigeon.gclc.utils.ReadingRunnable#hasMessage()}. */
@Test
public final void testHasMessage() {
final BufferedReader reader = null;
final ReadingRunnable runnable = new ReadingRunnable(reader);
runnable.setRunning(false);
try {
runnable.getMessage();
fail("reading from closed runnable");
} catch (final IOException e) {
// ok
}
}
}

327
gclc/src/test/java/fr/bigeon/gclc/manager/SystemConsoleManagerTest.java
View File

@ -1,146 +1,181 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.manager.SystemConsoleManagerTest.java * gclc:fr.bigeon.gclc.manager.SystemConsoleManagerTest.java
* Created on: Nov 19, 2016 * Created on: Nov 19, 2016
*/ */
package fr.bigeon.gclc.manager; package fr.bigeon.gclc.manager;
import static org.junit.Assert.assertEquals; /*-
import static org.junit.Assert.assertFalse; * #%L
import static org.junit.Assert.assertTrue; * Generic Command Ligne console
import static org.junit.Assert.fail; * %%
* Copyright (C) 2014 - 2018 bigeon.fr
import java.io.IOException; * %%
import java.io.InputStream; * This software is governed by the CeCILL license under French law and
import java.io.PipedInputStream; * abiding by the rules of distribution of free software. You can use,
import java.io.PipedOutputStream; * modify and/ or redistribute the software under the terms of the CeCILL
import java.io.PrintStream; * license as circulated by CEA, CNRS and INRIA at the following URL
import java.nio.charset.Charset; * "http://www.cecill.info".
*
import org.junit.Test; * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
/** * with a limited warranty and the software's author, the holder of the
* <p> * economic rights, and the successive licensors have only limited
* TODO * liability.
* *
* @author Emmanuel Bigeon */ * In this respect, the user's attention is drawn to the risks associated
public class SystemConsoleManagerTest { * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
/** Test method for {@link fr.bigeon.gclc.manager.ConsoleInput#isClosed()}. * that may mean that it is complicated to manipulate, and that also
* * therefore means that it is reserved for developers and experienced
* @throws IOException if the test failed * professionals having in-depth computer knowledge. Users are therefore
* @throws InterruptedException if the test failed */ * encouraged to load and test the software's suitability as regards their
@Test * requirements in conditions enabling the security of their systems and/or
public final void testIsClosed() throws IOException, InterruptedException { * data to be ensured and, more generally, to use and operate it in the
final PipedOutputStream outStream = new PipedOutputStream(); * same conditions as regards security.
final InputStream in = new PipedInputStream(outStream); *
final PrintStream out = new PrintStream(outStream); * The fact that you are presently reading this means that you have had
final String test = "test"; * knowledge of the CeCILL license and that you accept its terms.
final StreamConsoleInput manager = new StreamConsoleInput(System.out, * #L%
in, Charset.forName("UTF-8")); */
import static org.junit.Assert.assertEquals;
final Thread th = new Thread(new Runnable() { import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
@SuppressWarnings("synthetic-access") import static org.junit.Assert.fail;
@Override
public void run() { import java.io.IOException;
out.println(test); import java.io.InputStream;
} import java.io.PipedInputStream;
}); import java.io.PipedOutputStream;
import java.io.PrintStream;
th.start(); import java.nio.charset.Charset;
assertEquals(test, manager.prompt());
assertFalse(manager.isClosed()); import org.junit.Test;
manager.close();
assertTrue(manager.isClosed()); import fr.bigeon.gclc.utils.StreamConsoleInput;
try {
manager.prompt(); /**
fail("prompt on closed manager"); * <p>
} catch (final IOException e) { * TODO
// ok *
} * @author Emmanuel Bigeon */
th.join(); public class SystemConsoleManagerTest {
}
/** Test method for {@link fr.bigeon.gclc.manager.ConsoleInput#isClosed()}.
/** Test method for {@link fr.bigeon.gclc.manager.ConsoleInput#prompt()}. *
* * @throws IOException if the test failed
* @throws IOException if the test failed * @throws InterruptedException if the test failed */
* @throws InterruptedException if the test failed */ @Test
@Test public final void testIsClosed() throws IOException, InterruptedException {
public final void testPrompt() throws IOException, InterruptedException { final PipedOutputStream outStream = new PipedOutputStream();
final InputStream in = new PipedInputStream(outStream);
final String test = "test"; final PrintStream out = new PrintStream(outStream);
try (PipedOutputStream outStream = new PipedOutputStream(); final String test = "test";
InputStream in = new PipedInputStream(outStream); final StreamConsoleInput manager = new StreamConsoleInput(System.out,
final PrintStream out = new PrintStream(outStream); in, Charset.forName("UTF-8"));
StreamConsoleInput manager = new StreamConsoleInput(System.out, in,
Charset.forName("UTF-8"))) { final Thread th = new Thread(new Runnable() {
final Thread th = new Thread(new Runnable() { @SuppressWarnings("synthetic-access")
@Override
@SuppressWarnings("synthetic-access") public void run() {
@Override out.println(test);
public void run() { }
out.println(test); });
}
}); th.start();
assertEquals(test, manager.prompt());
th.start(); assertFalse(manager.isClosed());
assertEquals(test, manager.prompt()); manager.close();
assertTrue(manager.isClosed());
th.join(); try {
} manager.prompt();
} fail("prompt on closed manager");
} catch (final IOException e) {
/** Test method for // ok
* {@link fr.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String)}. }
* th.join();
* @throws IOException if the test failed */ }
@Test
public final void testSetPrompt() throws IOException { /** Test method for {@link fr.bigeon.gclc.manager.ConsoleInput#prompt()}.
try (PipedOutputStream outStream = new PipedOutputStream(); *
InputStream in = new PipedInputStream(outStream); * @throws IOException if the test failed
final PrintStream out = new PrintStream(outStream); * @throws InterruptedException if the test failed */
StreamConsoleInput manager = new StreamConsoleInput(System.out, in, @Test
Charset.forName("UTF-8"))) { public final void testPrompt() throws IOException, InterruptedException {
final String prt = "++"; final String test = "test";
manager.setPrompt(prt); try (PipedOutputStream outStream = new PipedOutputStream();
assertEquals(prt, manager.getPrompt().apply()); InputStream in = new PipedInputStream(outStream);
} final PrintStream out = new PrintStream(outStream);
} StreamConsoleInput manager = new StreamConsoleInput(System.out, in,
Charset.forName("UTF-8"))) {
}
final Thread th = new Thread(new Runnable() {
@SuppressWarnings("synthetic-access")
@Override
public void run() {
out.println(test);
}
});
th.start();
assertEquals(test, manager.prompt());
th.join();
}
}
/** Test method for
* {@link fr.bigeon.gclc.manager.ConsoleInput#setPrompt(java.lang.String)}.
*
* @throws IOException if the test failed */
@Test
public final void testSetPrompt() throws IOException {
try (PipedOutputStream outStream = new PipedOutputStream();
InputStream in = new PipedInputStream(outStream);
final PrintStream out = new PrintStream(outStream);
StreamConsoleInput manager = new StreamConsoleInput(System.out, in,
Charset.forName("UTF-8"))) {
final String prt = "++";
manager.setPrompt(prt);
assertEquals(prt, manager.getPrompt().apply());
}
}
}

167
gclc/src/test/java/fr/bigeon/gclc/prompt/CLIPrompterMessagesTest.java
View File

@ -1,67 +1,100 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.prompt.CLIPrompterMessagesTest.java * gclc:fr.bigeon.gclc.prompt.CLIPrompterMessagesTest.java
* Created on: Nov 19, 2016 * Created on: Nov 19, 2016
*/ */
package fr.bigeon.gclc.prompt; package fr.bigeon.gclc.prompt;
import static org.junit.Assert.assertEquals; /*-
* #%L
import org.junit.Test; * Generic Command Ligne console
* %%
/** * Copyright (C) 2014 - 2018 bigeon.fr
* <p> * %%
* TODO * This software is governed by the CeCILL license under French law and
* * abiding by the rules of distribution of free software. You can use,
* @author Emmanuel Bigeon * modify and/ or redistribute the software under the terms of the CeCILL
* * license as circulated by CEA, CNRS and INRIA at the following URL
*/ * "http://www.cecill.info".
public class CLIPrompterMessagesTest { *
* As a counterpart to the access to the source code and rights to copy,
/** * modify and redistribute granted by the license, users are provided only
* Test method for {@link fr.bigeon.gclc.prompt.CLIPrompterMessages#getString(java.lang.String, java.lang.Object[])}. * with a limited warranty and the software's author, the holder of the
*/ * economic rights, and the successive licensors have only limited
@Test * liability.
public final void testGetString() { *
String key = "bad.key"; * In this respect, the user's attention is drawn to the risks associated
assertEquals('!' + key + '!', CLIPrompterMessages.getString(key)); * with loading, using, modifying and/or developing or reproducing the
assertEquals('!' + key + '!', * software by the user in light of its specific status of free software,
CLIPrompterMessages.getString(key, "some arg")); * that may mean that it is complicated to manipulate, and that also
assertEquals('!' + key + '!', * therefore means that it is reserved for developers and experienced
CLIPrompterMessages.getString(key, new Object[] {})); * professionals having in-depth computer knowledge. Users are therefore
} * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
} * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
*
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
* #L%
*/
import static org.junit.Assert.assertEquals;
import org.junit.Test;
/**
* <p>
* TODO
*
* @author Emmanuel Bigeon
*
*/
public class CLIPrompterMessagesTest {
/**
* Test method for {@link fr.bigeon.gclc.prompt.CLIPrompterMessages#getString(java.lang.String, java.lang.Object[])}.
*/
@Test
public final void testGetString() {
String key = "bad.key";
assertEquals('!' + key + '!', CLIPrompterMessages.getString(key));
assertEquals('!' + key + '!',
CLIPrompterMessages.getString(key, "some arg"));
assertEquals('!' + key + '!',
CLIPrompterMessages.getString(key, new Object[] {}));
}
}

2457
gclc/src/test/java/fr/bigeon/gclc/prompt/CLIPrompterTest.java
View File

File diff suppressed because it is too large Load Diff

314
gclc/src/test/java/fr/bigeon/gclc/tools/AOutputForwardRunnableTest.java
View File

@ -1,140 +1,174 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.tools.AOutputForwardRunnableTest.java * gclc:fr.bigeon.gclc.tools.AOutputForwardRunnableTest.java
* Created on: Dec 3, 2016 * Created on: Dec 3, 2016
*/ */
package fr.bigeon.gclc.tools; package fr.bigeon.gclc.tools;
import static org.junit.Assert.assertEquals; /*-
* #%L
import java.io.IOException; * Generic Command Ligne console
* %%
import org.junit.Test; * Copyright (C) 2014 - 2018 bigeon.fr
* %%
import fr.bigeon.gclc.manager.PipedConsoleOutput; * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
/** <p> * modify and/ or redistribute the software under the terms of the CeCILL
* TODO * license as circulated by CEA, CNRS and INRIA at the following URL
* * "http://www.cecill.info".
* @author Emmanuel Bigeon */ *
public class AOutputForwardRunnableTest { * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
/** <p> * with a limited warranty and the software's author, the holder of the
* TODO * economic rights, and the successive licensors have only limited
* * liability.
* @author Emmanuel Bigeon */ *
private final class AOutputForwardTestRunnable * In this respect, the user's attention is drawn to the risks associated
extends AOutputForwardRunnable { * with loading, using, modifying and/or developing or reproducing the
private int count = 2; * software by the user in light of its specific status of free software,
private String message; * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
private AOutputForwardTestRunnable(final PipedConsoleOutput manager) { * professionals having in-depth computer knowledge. Users are therefore
super(manager); * encouraged to load and test the software's suitability as regards their
} * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
@Override * same conditions as regards security.
protected void forwardLine(final String m) { *
// Do nothing * The fact that you are presently reading this means that you have had
message = m; * knowledge of the CeCILL license and that you accept its terms.
synchronized (this) { * #L%
notify(); */
try { import static org.junit.Assert.assertEquals;
wait();
} catch (final InterruptedException e) { import java.io.IOException;
// TODO Auto-generated catch block
e.printStackTrace(); import org.junit.Test;
}
} import fr.bigeon.gclc.utils.AOutputForwardRunnable;
} import fr.bigeon.gclc.utils.PipedConsoleOutput;
/** @return the message */ /** <p>
public String getMessage() { * TODO
if (message == null) { *
synchronized (this) { * @author Emmanuel Bigeon */
try { public class AOutputForwardRunnableTest {
wait();
} catch (final InterruptedException e) { /** <p>
// TODO Auto-generated catch block * TODO
e.printStackTrace(); *
} * @author Emmanuel Bigeon */
} private final class AOutputForwardTestRunnable
} extends AOutputForwardRunnable {
final String m = message; private int count = 2;
count--; private String message;
message = null;
synchronized (this) { private AOutputForwardTestRunnable(final PipedConsoleOutput manager) {
notify(); super(manager);
} }
return m;
} @Override
protected void forwardLine(final String m) {
@Override // Do nothing
protected boolean isRunning() { message = m;
return count != 0; synchronized (this) {
} notify();
} try {
wait();
/** Test method for } catch (final InterruptedException e) {
* {@link fr.bigeon.gclc.tools.AOutputForwardRunnable#run()}. */ // TODO Auto-generated catch block
@Test e.printStackTrace();
public final void testRun() { }
try (PipedConsoleOutput manager = new PipedConsoleOutput()) { }
final AOutputForwardTestRunnable runnable = new AOutputForwardTestRunnable( }
manager);
/** @return the message */
final Thread th = new Thread(runnable, "forward"); public String getMessage() {
manager.println("before"); if (message == null) {
th.start(); synchronized (this) {
try {
assertEquals("before", runnable.getMessage()); wait();
} catch (final InterruptedException e) {
synchronized (this) { // TODO Auto-generated catch block
wait(3000); e.printStackTrace();
} }
manager.println("after"); }
assertEquals("after", runnable.getMessage()); }
synchronized (this) { final String m = message;
wait(3000); count--;
} message = null;
synchronized (this) {
th.join(); notify();
}
} catch (IOException | InterruptedException e) { return m;
// TODO Auto-generated catch block }
e.printStackTrace();
} @Override
} protected boolean isRunning() {
} return count != 0;
}
}
/** Test method for
* {@link fr.bigeon.gclc.utils.AOutputForwardRunnable#run()}. */
@Test
public final void testRun() {
try (PipedConsoleOutput manager = new PipedConsoleOutput()) {
final AOutputForwardTestRunnable runnable = new AOutputForwardTestRunnable(
manager);
final Thread th = new Thread(runnable, "forward");
manager.println("before");
th.start();
assertEquals("before", runnable.getMessage());
synchronized (this) {
wait(3000);
}
manager.println("after");
assertEquals("after", runnable.getMessage());
synchronized (this) {
wait(3000);
}
th.join();
} catch (IOException | InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

221
gclc/src/test/java/fr/bigeon/gclc/tools/PrintUtilsTest.java
View File

@ -1,94 +1,127 @@
/* /*
* Copyright Bigeon Emmanuel (2014) * Copyright Bigeon Emmanuel (2014)
* *
* emmanuel@bigeon.fr * emmanuel@bigeon.fr
* *
* This software is a computer program whose purpose is to * This software is a computer program whose purpose is to
* provide a generic framework for console applications. * provide a generic framework for console applications.
* *
* This software is governed by the CeCILL license under French law and * This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use, * abiding by the rules of distribution of free software. You can use,
* modify and/or redistribute the software under the terms of the CeCILL * modify and/or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL * license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info". * "http://www.cecill.info".
* *
* As a counterpart to the access to the source code and rights to copy, * As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only * modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the * with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited * economic rights, and the successive licensors have only limited
* liability. * liability.
* *
* In this respect, the user's attention is drawn to the risks associated * In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the * with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software, * software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also * that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced * therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore * professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their * encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or * requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the * data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security. * same conditions as regards security.
* *
* The fact that you are presently reading this means that you have had * The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms. * knowledge of the CeCILL license and that you accept its terms.
*/ */
/** /**
* gclc:fr.bigeon.gclc.tools.PrintUtilsTest.java * gclc:fr.bigeon.gclc.tools.PrintUtilsTest.java
* Created on: Nov 19, 2016 * Created on: Nov 19, 2016
*/ */
package fr.bigeon.gclc.tools; package fr.bigeon.gclc.tools;
import static org.junit.Assert.assertEquals; /*-
* #%L
import java.util.Arrays; * Generic Command Ligne console
* %%
import org.junit.Test; * Copyright (C) 2014 - 2018 bigeon.fr
* %%
/** <p> * This software is governed by the CeCILL license under French law and
* TODO * abiding by the rules of distribution of free software. You can use,
* * modify and/ or redistribute the software under the terms of the CeCILL
* @author Emmanuel Bigeon */ * license as circulated by CEA, CNRS and INRIA at the following URL
public class PrintUtilsTest { * "http://www.cecill.info".
*
/** Test method for * As a counterpart to the access to the source code and rights to copy,
* {@link fr.bigeon.gclc.tools.PrintUtils#print(java.lang.String, int, boolean)}. */ * modify and redistribute granted by the license, users are provided only
@Test * with a limited warranty and the software's author, the holder of the
public final void testPrint() { * economic rights, and the successive licensors have only limited
String text = "Some text"; * liability.
String longText = text + " that may be abbreviated"; *
assertEquals(text, PrintUtils.print(text, text.length(), true)); * In this respect, the user's attention is drawn to the risks associated
assertEquals(text, PrintUtils.print(text, text.length(), false)); * with loading, using, modifying and/or developing or reproducing the
assertEquals(text + " ", * software by the user in light of its specific status of free software,
PrintUtils.print(text, text.length() + 3, false)); * that may mean that it is complicated to manipulate, and that also
assertEquals(text + " ", * therefore means that it is reserved for developers and experienced
PrintUtils.print(text, text.length() + 3, true)); * professionals having in-depth computer knowledge. Users are therefore
assertEquals(text, PrintUtils.print(longText, text.length(), false)); * encouraged to load and test the software's suitability as regards their
assertEquals(text + "...", * requirements in conditions enabling the security of their systems and/or
PrintUtils.print(longText, text.length() + 3, true)); * data to be ensured and, more generally, to use and operate it in the
} * same conditions as regards security.
*
/** Test method for * The fact that you are presently reading this means that you have had
* {@link fr.bigeon.gclc.tools.PrintUtils#wrap(java.lang.String, int)}. */ * knowledge of the CeCILL license and that you accept its terms.
@Test * #L%
public final void testWrap() { */
String[] line = {"A text separated", "on several lines", "with cuts at", import static org.junit.Assert.assertEquals;
"whitespace", "characters"};
String text = line[0] + " " + line[1] + " " + line[2] + " " + line[3] + import java.util.Arrays;
" " + line[4];
assertEquals(Arrays.asList(line), import org.junit.Test;
PrintUtils.wrap(text, line[0].length() + 1));
assertEquals(Arrays.asList(line), /** <p>
PrintUtils.wrap(text, line[0].length())); * TODO
*
// test with split word * @author Emmanuel Bigeon */
line = new String[] {"A text separated", "on several lines", "", public class PrintUtilsTest {
"with cuts at", "whitespacecharac", "ters"};
text = line[0] + " " + line[1] + System.lineSeparator() + line[3] + /** Test method for
" " + line[4] + line[5]; * {@link fr.bigeon.gclc.tools.PrintUtils#print(java.lang.String, int, boolean)}. */
assertEquals(Arrays.asList(line), @Test
PrintUtils.wrap(text, line[0].length())); public final void testPrint() {
assertEquals(Arrays.asList(""), String text = "Some text";
PrintUtils.wrap("", line[0].length())); String longText = text + " that may be abbreviated";
} assertEquals(text, PrintUtils.print(text, text.length(), true));
assertEquals(text, PrintUtils.print(text, text.length(), false));
} assertEquals(text + " ",
PrintUtils.print(text, text.length() + 3, false));
assertEquals(text + " ",
PrintUtils.print(text, text.length() + 3, true));
assertEquals(text, PrintUtils.print(longText, text.length(), false));
assertEquals(text + "...",
PrintUtils.print(longText, text.length() + 3, true));
}
/** Test method for
* {@link fr.bigeon.gclc.tools.PrintUtils#wrap(java.lang.String, int)}. */
@Test
public final void testWrap() {
String[] line = {"A text separated", "on several lines", "with cuts at",
"whitespace", "characters"};
String text = line[0] + " " + line[1] + " " + line[2] + " " + line[3] +
" " + line[4];
assertEquals(Arrays.asList(line),
PrintUtils.wrap(text, line[0].length() + 1));
assertEquals(Arrays.asList(line),
PrintUtils.wrap(text, line[0].length()));
// test with split word
line = new String[] {"A text separated", "on several lines", "",
"with cuts at", "whitespacecharac", "ters"};
text = line[0] + " " + line[1] + System.lineSeparator() + line[3] +
" " + line[4] + line[5];
assertEquals(Arrays.asList(line),
PrintUtils.wrap(text, line[0].length()));
assertEquals(Arrays.asList(""),
PrintUtils.wrap("", line[0].length()));
}
}

33
gclc/src/test/resources/script1.gclc Normal file
View File

@ -0,0 +1,33 @@
###
# #%L
# Generic Command Ligne console
# %%
# Copyright (C) 2014 - 2018 bigeon.fr
# %%
# This software is governed by the CeCILL license under French law and
# abiding by the rules of distribution of free software. You can use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty and the software's author, the holder of the
# economic rights, and the successive licensors have only limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading, using, modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean that it is complicated to manipulate, and that also
# therefore means that it is reserved for developers and experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and, more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.
# #L%
###

0
gclc/src/test/resources/script1.txt
View File

35
gclc/src/test/resources/script2.txt
View File

@ -1 +1,34 @@
# test only comment ###
# #%L
# Generic Command Ligne console
# %%
# Copyright (C) 2014 - 2018 Bigeon
# %%
# This software is governed by the CeCILL license under French law and
# abiding by the rules of distribution of free software. You can use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty and the software's author, the holder of the
# economic rights, and the successive licensors have only limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading, using, modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean that it is complicated to manipulate, and that also
# therefore means that it is reserved for developers and experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and, more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.
# #L%
###
# test only comment

35
gclc/src/test/resources/script3.txt
View File

@ -1 +1,34 @@
test ###
# #%L
# Generic Command Ligne console
# %%
# Copyright (C) 2014 - 2018 Bigeon
# %%
# This software is governed by the CeCILL license under French law and
# abiding by the rules of distribution of free software. You can use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty and the software's author, the holder of the
# economic rights, and the successive licensors have only limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading, using, modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean that it is complicated to manipulate, and that also
# therefore means that it is reserved for developers and experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and, more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.
# #L%
###
test

47
gclc/src/test/resources/script4.txt
View File

@ -1,7 +1,40 @@
# Test file with commands ###
test # #%L
# and comments # Generic Command Ligne console
long # %%
# interwined # Copyright (C) 2014 - 2018 Bigeon
# %%
# with empty line too # This software is governed by the CeCILL license under French law and
# abiding by the rules of distribution of free software. You can use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty and the software's author, the holder of the
# economic rights, and the successive licensors have only limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading, using, modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean that it is complicated to manipulate, and that also
# therefore means that it is reserved for developers and experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and, more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.
# #L%
###
# Test file with commands
test
# and comments
long
# interwined
# with empty line too

37
gclc/src/test/resources/script5.txt
View File

@ -1,2 +1,35 @@
# A script with arguments ###
{0} # #%L
# Generic Command Ligne console
# %%
# Copyright (C) 2014 - 2018 Bigeon
# %%
# This software is governed by the CeCILL license under French law and
# abiding by the rules of distribution of free software. You can use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty and the software's author, the holder of the
# economic rights, and the successive licensors have only limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading, using, modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean that it is complicated to manipulate, and that also
# therefore means that it is reserved for developers and experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and, more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.
# #L%
###
# A script with arguments
{0}

37
gclc/src/test/resources/scripts/failingCmdInvoc.txt
View File

@ -1,2 +1,35 @@
# a script invoking a failing command ###
failingCmd # #%L
# Generic Command Ligne console
# %%
# Copyright (C) 2014 - 2018 Bigeon
# %%
# This software is governed by the CeCILL license under French law and
# abiding by the rules of distribution of free software. You can use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty and the software's author, the holder of the
# economic rights, and the successive licensors have only limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading, using, modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean that it is complicated to manipulate, and that also
# therefore means that it is reserved for developers and experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and, more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.
# #L%
###
# a script invoking a failing command
failingCmd

37
gclc/src/test/resources/scripts/invalidCmd.txt
View File

@ -1,2 +1,35 @@
# a script with invalid commands ###
invalid # #%L
# Generic Command Ligne console
# %%
# Copyright (C) 2014 - 2018 Bigeon
# %%
# This software is governed by the CeCILL license under French law and
# abiding by the rules of distribution of free software. You can use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty and the software's author, the holder of the
# economic rights, and the successive licensors have only limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading, using, modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean that it is complicated to manipulate, and that also
# therefore means that it is reserved for developers and experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and, more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.
# #L%
###
# a script with invalid commands
invalid

37
gclc/src/test/resources/scripts/invalidCmdParse.txt
View File

@ -1,2 +1,35 @@
# a script with invalid commands ###
test "po"m # #%L
# Generic Command Ligne console
# %%
# Copyright (C) 2014 - 2018 Bigeon
# %%
# This software is governed by the CeCILL license under French law and
# abiding by the rules of distribution of free software. You can use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty and the software's author, the holder of the
# economic rights, and the successive licensors have only limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading, using, modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean that it is complicated to manipulate, and that also
# therefore means that it is reserved for developers and experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and, more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.
# #L%
###
# a script with invalid commands
test "po"m

39
gclc/src/test/resources/scripts/withprependSpace.txt
View File

@ -1,3 +1,36 @@
# a script with space in begining ###
test # #%L
should never be reached # Generic Command Ligne console
# %%
# Copyright (C) 2014 - 2018 Bigeon
# %%
# This software is governed by the CeCILL license under French law and
# abiding by the rules of distribution of free software. You can use,
# modify and/ or redistribute the software under the terms of the CeCILL
# license as circulated by CEA, CNRS and INRIA at the following URL
# "http://www.cecill.info".
#
# As a counterpart to the access to the source code and rights to copy,
# modify and redistribute granted by the license, users are provided only
# with a limited warranty and the software's author, the holder of the
# economic rights, and the successive licensors have only limited
# liability.
#
# In this respect, the user's attention is drawn to the risks associated
# with loading, using, modifying and/or developing or reproducing the
# software by the user in light of its specific status of free software,
# that may mean that it is complicated to manipulate, and that also
# therefore means that it is reserved for developers and experienced
# professionals having in-depth computer knowledge. Users are therefore
# encouraged to load and test the software's suitability as regards their
# requirements in conditions enabling the security of their systems and/or
# data to be ensured and, more generally, to use and operate it in the
# same conditions as regards security.
#
# The fact that you are presently reading this means that you have had
# knowledge of the CeCILL license and that you accept its terms.
# #L%
###
# a script with space in begining
test
should never be reached