Create command-line interface

Author: Maarten

README.md

@@ -46,21 +46,59 @@ Furthermore, I needed a efficient parser that does not limit token types
 to strings.
 
 ## Usage
-Download [the latest JAR](https://github.com/digitalheir/java-probabilistic-earley-parser/releases/latest) or grab from Maven:
+You can use this project as a library in your Java application or as a standalone command-line app.
+ 
+### Command line
+
+Download [the latest JAR](https://github.com/digitalheir/java-probabilistic-earley-parser/releases/latest)
+
+Create a UTF8-encoded `.cfg` file that contains your grammar, such as the following: 
+ 
+
+```
+# grammar.cfg
+
+S -> NP VP (1.0)  # Use '->'  
+NP → i   (0.5)    # or '→'
+VP → eat          # probability defaults to 1.0
+```
+
+By default, the parser will assume that you distinguish non-terminals from terminals by capitalizing them. You can also add a custom category handler if you call the API from Java code. 
+ 
+Execute runnable jar on the terminal:
+```
+probabilistic-earley-parser-jar-with-dependencies.jar -i grammar.cfg -goal S I EAT
+```
+
+This will give the Viterbi parse to the **S**entence "I EAT":
+
+```
+0.5
+└── <start>
+    └── S
+        ├── NP
+        │   └── i (I)
+        └── VP
+            └── eat (EAT)
+```
+
+### Java library
+
+Grab from Maven:
 
 ```xml
 <dependencies>
         <dependency>
             <groupId>org.leibnizcenter</groupId>
             <artifactId>probabilistic-earley-parser</artifactId>
-            <version>0.9.10</version>
+            <version>0.9.11</version>
         </dependency>
 </dependencies>
 ```
 
 or Gradle:
 ```groovy
-compile 'org.leibnizcenter:probabilistic-earley-parser:0.9.10'
+compile 'org.leibnizcenter:probabilistic-earley-parser:0.9.11'
 ```
 
 Most applications will want to interface with the static functions in `Parser`:
@@ -129,17 +167,8 @@ public class Example {
     }
 }
 ```
-
-You can parse a text file describing your CFG. 
-By default, the parser will assume that you distinguish non-terminals from terminals by capitalizing them. You can also add a custom category handler.
-
-```
-# grammar.cfg
-
-S -> NP VP (1.0)  # Use '->'  
-NP → i   (0.5)    # or '→'
-VP → eat          # probability defaults to 1.0
-```
+ 
+You can parse `.cfg` files as follows:
 
 ```java
 Grammar<String> g = Grammar.parse(Paths.get("path", "to", "grammar.cfg"), Charset.forName("UTF-8"));

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>org.leibnizcenter</groupId>
     <artifactId>probabilistic-earley-parser</artifactId>
-    <version>0.9.10</version>
+    <version>0.9.11</version>
     <packaging>jar</packaging>
 
     <licenses>

src/main/java/org/leibnizcenter/cfg/category/terminal/stringterminal/CaseInsenstiveStringTerminal.java

@@ -41,6 +41,11 @@ public boolean equals(Object o) {
         return true;
     }
 
+    @Override
+    public String toString() {
+        return string;
+    }
+
     @Override
     public int hashCode() {
         int result = string.hashCode();

src/main/java/org/leibnizcenter/cfg/earleyparser/CommandLine.java

@@ -34,11 +34,10 @@ public class CommandLine {
      */
     public static void main(String[] args) {
         HandleArguments handleArguments = new HandleArguments(args).invoke();
-        //todo Token.of
         ParseTreeWithScore parse = Parser.getViterbiParseWithScore(
                 handleArguments.getGoal(),
                 handleArguments.getGrammar(),
-                Stream.of(handleArguments.getTokens()).map(Token::new).collect(Collectors.toList())
+                Stream.of(handleArguments.getTokens()).map(Token::of).collect(Collectors.toList())
         );
 
         System.out.println(parse.score.semiring.toProbability(parse.score.getScore()));
@@ -69,6 +68,9 @@ NonTerminal getGoal() {
         }
 
         HandleArguments invoke() {
+            if (args.length < 2) {
+                throw new IllegalArgumentException("No arguments specified.\n\n" + USAGE);
+            }
             int lastOption = 0;
             final Map<String, String> options = new HashMap<>();
             for (int i = 0; i < args.length; i++) {
@@ -104,7 +106,6 @@ HandleArguments invoke() {
                 throw new IllegalArgumentException("No goal category specified. \n" + USAGE);
             }
 
-            //NonTerminal.of//TODO
             goal = Category.nonTerminal(options.get(OPTION_GOAL));
             if (!grammar.getNonTerminals().contains(goal)) {
                 throw new IllegalArgumentException("Grammar does not contains non-terminal \"" + goal + "\". \n" + USAGE);

src/main/java/org/leibnizcenter/cfg/earleyparser/ParseTree.java

@@ -96,7 +96,9 @@ public String toString() {
     }
 
     private void toString(StringBuilder sb, String prefix, boolean isTail) {
-        sb.append(prefix + (isTail ? "└── " : "├── ") + category.toString() + "\n");
+        sb.append(prefix + (isTail ? "└── " : "├── ") + (
+                category.toString() + ((this instanceof Token) ? (" (" + ((Token) this).token + ")") : "")
+        ) + "\n");
         if (children != null) {
             for (int i = 0; i < children.size() - 1; i++) {
                 children.get(i).toString(sb, prefix + (isTail ? "    " : "│   "), false);

src/main/java/org/leibnizcenter/cfg/grammar/Grammar.java

@@ -152,7 +152,7 @@ public static Grammar<String> parse(String s, Function<String, Category> parseCa
         b.addRules(Arrays.stream(NEWLINE.split(s.trim()))
                 .map(line -> TRAILING_COMMENT.matcher(line).replaceAll("").trim())
                 .filter(line -> !line.isEmpty())
-                .map(line -> Rule.parse(line, parseCategory, semiring)).collect(Collectors.toSet())
+                .map(line -> Rule.fromString(line, parseCategory, semiring)).collect(Collectors.toSet())
         );
         return b.build();
     }
@@ -171,7 +171,7 @@ public static Grammar<String> parse(Path path, Charset charset, Function<String,
         final Collection<Rule> rules = Files.lines(path, charset)
                 .map(line -> TRAILING_COMMENT.matcher(line).replaceAll("").trim())
                 .filter(line -> !line.isEmpty())
-                .map(line -> Rule.parse(line, parseCategory, semiring)).collect(Collectors.toSet());
+                .map(line -> Rule.fromString(line, parseCategory, semiring)).collect(Collectors.toSet());
         b.addRules(rules);
         return b.build();
     }
@@ -195,7 +195,7 @@ public static Grammar<String> parse(InputStream inputStream, Charset charset, Fu
         while (line != null) {
             line = TRAILING_COMMENT.matcher(line).replaceAll("").trim();
             if (!line.isEmpty())
-                rules.add(Rule.parse(line, parseCategory, semiring));
+                rules.add(Rule.fromString(line, parseCategory, semiring));
             line = reader.readLine();
         }
         b.addRules(rules);

src/main/java/org/leibnizcenter/cfg/rule/Rule.java

@@ -30,7 +30,7 @@
  * @see Grammar
  */
 public class Rule {
-    private static Pattern RULE = Pattern.compile("\\s*([^\\s]+)\\s*(?:->|→)((?:\\s*[^\\s]+\\s*)+)\\s*(\\([0-9](?:[0-9]+)?\\))?\\s*");
+    private static Pattern RULE = Pattern.compile("\\s*([^\\s]+)\\s*(?:->|→)((?:\\s*[^\\s(]+\\s*)+)\\s*(?:\\(([0-9](?:[.,][0-9]+)?)\\))?\\s*");
     private static Pattern WHITESPACE = Pattern.compile("\\s+");
     public final NonTerminal left;
     public final Category[] right;
@@ -149,9 +149,16 @@ public static Rule create(DblSemiring semiring, double probability, NonTerminal
 //        return (isPreterminal() && right.length == 1);
 //    }
 
-    public static Rule parse(String line, Function<String, Category> parseCategory, DblSemiring semiring) {
+    /**
+     * @param line          Of the form "S -> NP VP"
+     * @param parseCategory how to parse category string into category
+     * @param semiring
+     * @return Parsed rule
+     */
+    public static Rule fromString(String line, Function<String, Category> parseCategory, DblSemiring semiring) {
         Matcher m = RULE.matcher(line);
-        if(!m.matches()) throw new IllegalArgumentException("String was not a valid rule: "+line);
+        if (!m.matches())
+            throw new IllegalArgumentException("String was not a valid rule: " + line);
         else{
             final NonTerminal LHS = new NonTerminal(m.group(1));
 

src/test/java/org/leibnizcenter/cfg/rule/RuleTest.java

@@ -82,14 +82,22 @@ public void isUnitProduction() throws Exception {
     public void parse() throws Exception {
         assertEquals(
                 Rule.create(LogSemiring.get(), new NonTerminal("S"), new NonTerminal("NP"), new NonTerminal("VP")),
-                Rule.parse("S -> NP VP",
+                Rule.fromString("S -> NP VP",
                         s -> Character.isUpperCase(s.charAt(0)) ? new NonTerminal(s) : new CaseInsenstiveStringTerminal(s),
                         LogSemiring.get()
                 )
         );
         assertEquals(
                 Rule.create(LogSemiring.get(), new NonTerminal("S"), new CaseInsenstiveStringTerminal("Np"), new CaseInsenstiveStringTerminal("Vp")),
-                Rule.parse("S -> nP vP",
+                Rule.fromString("S -> nP vP",
+                        s -> Character.isUpperCase(s.charAt(0)) ? new NonTerminal(s) : new CaseInsenstiveStringTerminal(s),
+                        LogSemiring.get()
+                )
+        );
+
+        assertEquals(
+                Rule.create(LogSemiring.get(), 0.5, new NonTerminal("S"), new CaseInsenstiveStringTerminal("Np"), new CaseInsenstiveStringTerminal("Vp")),
+                Rule.fromString("S -> nP vP(0.5)",
                         s -> Character.isUpperCase(s.charAt(0)) ? new NonTerminal(s) : new CaseInsenstiveStringTerminal(s),
                         LogSemiring.get()
                 )