Merge tag '0.5.0'

* tag '0.5.0':

  * prepare on releases/0.5.0
    push possible print API change to 1.0.0
    version shown in README is 0.5.0
    travis icon in README references master branch
    build as 0.5.0

  * issue 51 (travis should also build against jdk8)
    show travis build status of develop branch
    51: add oraclejdk8 to travis configuration

  * issue 49, 50 (dupicate keys in maps)
    check for duplicates in SimpleParserConfigTest
    Note that CollectionBuilder.add() should check for duplicates
    throw EdnSyntaxException upon duplicate set element
    throw EdnSyntaxException upon duplicate map key
    DefaultMapFactory should throw EdnSyntaxException

  * issue 47 (read namespaced maps)
    47 Test that supporting namespaced maps doens't mess up normal maps
    47 refactor
    47 First pass at implementing namespaced maps per CLJ-1910

Author: bpsm

.travis.yml

@@ -1,5 +1,6 @@
 language: java
 jdk:
+  - oraclejdk8
   - oraclejdk7
   - openjdk7
   - openjdk6

README.md

@@ -2,7 +2,7 @@
 
 *edn-java* is a library to parse (read) and print (write) [edn](https://github.com/edn-format/edn).
 
-This is very early days. There are still rough edges in the design which may see me moving things around some before I'm happy with the result.
+[![Build Status](https://travis-ci.org/bpsm/edn-java.svg?branch=master)](https://travis-ci.org/bpsm/edn-java)
 
 ## Installation
 
@@ -12,7 +12,7 @@ This is a Maven project with the following coordinates:
 <dependency>
     <groupId>us.bpsm</groupId>
     <artifactId>edn-java</artifactId>
-    <version>0.4.7</version>
+    <version>0.5.0</version>
 </dependency>
 ```
 
@@ -98,7 +98,13 @@ public class SimpleParserConfigTest {
                 public CollectionBuilder builder() {
                     return new CollectionBuilder() {
                         SortedSet<Object> s = new TreeSet<Object>();
-                        public void add(Object o) { s.add(o); }
+                        public void add(Object o) {
+                            if (!s.add(o)) {
+                                throw new EdnSyntaxException(
+                                  "Set contains duplicate element '" + o + "'."
+                                );
+                            }
+                        }
                         public Object build() { return s; }
                     };
                 }
@@ -350,5 +356,5 @@ public class CustomTagPrinter {
 ### Limitations
 
  - Edn values must be *acyclic*. Any attempt to print a data structure containing cycles will surely end in a stack overflow.
- - The current Printing support stikes me a as a bit of a hack. The API may change with 0.5.0.
+ - The current Printing support stikes me a as a bit of a hack. The API may change with 1.0.0.
  - Edn-Java does not provide much by way of "convenience" methods. As a library it's still to young to really know what would be convenient, though I'm open to suggestions.

pom.xml

@@ -8,7 +8,7 @@
   </parent>
   <groupId>us.bpsm</groupId>
   <artifactId>edn-java</artifactId>
-  <version>0.4.7</version>
+  <version>0.5.0</version>
   <packaging>jar</packaging>
   <name>EDN Java</name>
   <description>

src/main/java/us/bpsm/edn/parser/CollectionBuilder.java

@@ -14,6 +14,11 @@ public interface CollectionBuilder {
      * pairs of the map have been added.
      * <p>
      * For other collections is can be called any number of times.
+     * <p>
+     * Implementations which construct Maps or Sets an should throw an
+     * EdnSyntaxException if they detect a duplicate key (in the case of
+     * a map) or a duplicate element (in the case of a set).
+     * </p>
      *
      * <p>{@code add()} may not be called after {@code build()}.
      * @param o an object to add to the collection under construction. o may

src/main/java/us/bpsm/edn/parser/DefaultMapFactory.java

@@ -1,6 +1,8 @@
 // (c) 2012 B Smith-Mannschott -- Distributed under the Eclipse Public License
 package us.bpsm.edn.parser;
 
+import us.bpsm.edn.EdnSyntaxException;
+
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
@@ -14,14 +16,18 @@ public CollectionBuilder builder() {
             public void add(Object o) {
                 if (key == none) {
                     key = o;
+                    if (map.containsKey(key)) {
+                        throw new EdnSyntaxException(
+                          "Map contains duplicate key '" + key + "'.");
+                    }
                 } else {
                     map.put(key, o);
                     key = none;
                 }
             }
             public Object build() {
                 if (key != none) {
-                    throw new IllegalStateException(
+                    throw new EdnSyntaxException(
                             "Every map must have an equal number of keys and values.");
                 }
                 return Collections.unmodifiableMap(map);

src/main/java/us/bpsm/edn/parser/DefaultSetFactory.java

@@ -1,6 +1,8 @@
 // (c) 2012 B Smith-Mannschott -- Distributed under the Eclipse Public License
 package us.bpsm.edn.parser;
 
+import us.bpsm.edn.EdnSyntaxException;
+
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
@@ -10,7 +12,10 @@ public CollectionBuilder builder() {
         return new CollectionBuilder() {
             Set<Object> set = new HashSet<Object>();
             public void add(Object o) {
-                set.add(o);
+                if (!set.add(o)) {
+                    throw new EdnSyntaxException(
+                      "Set contains duplicate element '" + o + "'.");
+                }
             }
             public Object build() {
                 return Collections.unmodifiableSet(set);

src/main/java/us/bpsm/edn/parser/ParserImpl.java

@@ -5,8 +5,8 @@
 import static us.bpsm.edn.parser.Token.END_LIST;
 import static us.bpsm.edn.parser.Token.END_MAP_OR_SET;
 import static us.bpsm.edn.parser.Token.END_VECTOR;
-import us.bpsm.edn.EdnSyntaxException;
-import us.bpsm.edn.Tag;
+
+import us.bpsm.edn.*;
 
 
 class ParserImpl implements Parser {
@@ -48,6 +48,16 @@ private Object nextValue(Parseable pbr, boolean discard) {
             case BEGIN_MAP:
                 return parseIntoCollection(cfg.getMapFactory(),
                                            END_MAP_OR_SET, pbr, discard);
+            case DEFAULT_NAMESPACE_FOLLOWS: {
+                final String ns = parseNamespaceName(pbr, discard);
+                Object t = scanner.nextToken(pbr);
+                if (t != Token.BEGIN_MAP) {
+                    throw new EdnSyntaxException(
+                      "Expected #:" + ns + " to be followed by a map.");
+                }
+                return parseIntoCollection(new NamespacedMapFactory(ns),
+                  END_MAP_OR_SET, pbr, discard);
+            }
             case DISCARD:
                 nextValue(pbr, true);
                 return nextValue(pbr, discard);
@@ -68,6 +78,21 @@ private Object nextValue(Parseable pbr, boolean discard) {
         }
     }
 
+    private String parseNamespaceName(Parseable pbr, boolean discard) {
+        final Object nsObj = nextValue(pbr, discard);
+        if (!(nsObj instanceof Symbol)) {
+            throw new EdnSyntaxException(
+              "Expected symbol following #:, but found: " + nsObj);
+        }
+        final Symbol nsSym = (Symbol) nsObj;
+        if (nsSym.getPrefix().length() > 0) {
+            throw new EdnSyntaxException(
+              "Expected symbol following #: to be namespaceless, " +
+                "but found: " + nsSym);
+        }
+        return nsSym.getName();
+    }
+
     private Object nextValue(Tag t, Parseable pbr, boolean discard) {
         Object v = nextValue(pbr, discard);
         if (discard) {
@@ -95,4 +120,62 @@ private Object parseIntoCollection(CollectionBuilder.Factory f, Token end,
         return !discard ? b.build() : null;
     }
 
+    private class NamespacedMapFactory implements CollectionBuilder.Factory {
+        private final String defaultNs;
+
+        public NamespacedMapFactory(String defaultNs) {
+            this.defaultNs = defaultNs;
+        }
+
+        @Override
+        public CollectionBuilder builder() {
+            return new NamespacedMapBuilder();
+        }
+
+        private class NamespacedMapBuilder implements CollectionBuilder {
+            private final CollectionBuilder cfgBuilder =
+              cfg.getMapFactory().builder();
+            boolean key = true;
+
+            @Override
+            public void add(Object o) {
+                if (key) {
+                    o = maybeApplyDefaultNamespace(o);
+                }
+                key = !key;
+                cfgBuilder.add(o);
+            }
+
+            @Override
+            public Object build() {
+                return cfgBuilder.build();
+            }
+
+            private Object maybeApplyDefaultNamespace(final Object o) {
+                if (!(o instanceof Symbol || o instanceof Keyword)) {
+                    return o;
+                }
+
+                final Named named = (Named) o;
+
+                final String prefix = named.getPrefix();
+                final String ns;
+                if ("".equals(prefix)) {
+                    ns = defaultNs;
+                } else if ("_".equals(prefix)) {
+                    ns = "";
+                } else {
+                    return o;
+                }
+
+                final String name = named.getName();
+                if (o instanceof Symbol) {
+                    return Symbol.newSymbol(ns, name);
+                } else {
+                    assert o instanceof Keyword;
+                    return Keyword.newKeyword(ns, name);
+                }
+            }
+        }
+    }
 }

src/main/java/us/bpsm/edn/parser/ScannerImpl.java

@@ -191,6 +191,8 @@ private Object readHashDispatched(Parseable pbr) throws IOException {
             return Token.BEGIN_SET;
         case '_':
             return Token.DISCARD;
+        case ':':
+            return Token.DEFAULT_NAMESPACE_FOLLOWS;
         default:
             return newTag(readSymbol(peek, pbr));
         }

src/main/java/us/bpsm/edn/parser/Token.java

@@ -38,5 +38,10 @@ public enum Token {
      * A '#_', which instructs the parser to ignore the next value
      * parsed from the input.
      */
-    DISCARD;
+    DISCARD,
+
+    /**
+     * A '#:', which introduces a namespaced map as per CLJ-1910.
+     */
+    DEFAULT_NAMESPACE_FOLLOWS;
 }

src/test/java/us/bpsm/edn/examples/SimpleParserConfigTest.java

@@ -12,6 +12,7 @@
 
 import org.junit.Test;
 
+import us.bpsm.edn.EdnSyntaxException;
 import us.bpsm.edn.parser.CollectionBuilder;
 import us.bpsm.edn.parser.Parseable;
 import us.bpsm.edn.parser.Parser;
@@ -27,7 +28,13 @@ public void test() throws IOException {
                 public CollectionBuilder builder() {
                     return new CollectionBuilder() {
                         SortedSet<Object> s = new TreeSet<Object>();
-                        public void add(Object o) { s.add(o); }
+                        public void add(Object o) {
+                            if (!s.add(o)) {
+                                throw new EdnSyntaxException(
+                                  "Set contains duplicate element '" + o + "'."
+                                );
+                            }
+                        }
                         public Object build() { return s; }
                     };
                 }

src/test/java/us/bpsm/edn/parser/ParserTest.java

@@ -30,6 +30,9 @@
 
 import org.junit.Test;
 
+import us.bpsm.edn.EdnSyntaxException;
+import us.bpsm.edn.Keyword;
+import us.bpsm.edn.Symbol;
 import us.bpsm.edn.Tag;
 
 
@@ -88,6 +91,54 @@ public void discardedTaggedValuesDoNotCallTransformer() {
         assertEquals(123L, parse("#_ " + INVALID_UUID + " 123"));
     }
 
+    /**
+     * <p>
+     * This tests parsing of Namespaced maps as per
+     * <a href="http://dev.clojure.org/jira/browse/CLJ-1910">CLJ-1910</a>.
+     * </p>
+     * <p>
+     * A map may be optionally preceded by #:SYM, where SYM will be taken to be the
+     * namespace off all unnamespaced symbol or keyword keys in the map so introduced.
+     * Furthermore, symbol and keyword keys in the map with the namespace "_" will
+     * emerge unnamespaced from the parsing.
+     * </p>
+     */
+    @Test
+    public void parserUnderstandsNamespacedMaps() {
+        assertEquals(
+          parse("#:foo{ :a 1, b 2, _/c 3, :_/d 4, bar/e 5, :bar/f 6}"),
+          parse("{:foo/a 1, foo/b 2, c 3, :d 4, bar/e 5, :bar/f 6}")
+        );
+    }
+
+    /**
+     * This is just a sanity check to make sure that the fact that we add
+     * support of namespaced maps (which assign "_" a special meaning as a
+     * namespace prefix on keys) does not interfere with the use of "_" as
+     * a namespace on keys in non-namespaced maps.
+     */
+    @Test
+    public void parserShouldNotBeConfusedByUnderscoreInNonNamespacedMaps() {
+        Map<?,?> m = (Map<?, ?>) parse("{:_/foo 1, _/bar 2}");
+        assertEquals(1L, m.get(Keyword.newKeyword("_", "foo")));
+        assertEquals(2L, m.get(Symbol.newSymbol("_", "bar")));
+    }
+
+    @Test(expected=EdnSyntaxException.class)
+    public void parserShouldDetectDuplicateMapKeys() {
+        parse("{:a 1, :a 2}");
+    }
+
+    @Test(expected=EdnSyntaxException.class)
+    public void parserShouldDetectDuplicateMapKeysInNamespacedMaps() {
+        parse("#:foo{:foo/a 1, :a 2}");
+    }
+
+    @Test(expected=EdnSyntaxException.class)
+    public void parserShouldDetectDuplicateSetElements() {
+        parse("#{1 1}");
+    }
+
     @Test(expected=UnsupportedOperationException.class)
     public void parserShouldReturnUnmodifiableListByDefault() {
         ((List<?>)parse("(1)")).remove(0);