fixed bug and adding more readme

Vasyl Khrystiuk · Vasyl Khrystiuk · commit 3f88468bb361 · 2019-05-15T19:57:35.000+03:00
diff --git a/README.md b/README.md
@@ -8,7 +8,98 @@ Draft for creating classical property file: https://gist.github.com/msangel/1167
 Follow instructions here: https://jitpack.io/#msangel/Yaml2DotNotation
 
 ## Usage
-TBD
+The library can work with both POJOs and primitives. 
+This is sample usages from tests:
+```java
+public class DottedPropertiesInjectorTest {
+    public static class InnerObject {
+        @JsonProperty("innerField")
+        public String a;
+    }
+
+    public static class TestObjectFine {
+        @Value("a")
+        public String as;
+
+        @Value("b")
+        private Integer bas;
+
+        @Value("c")
+        private Boolean das;
+
+        @Value("d")
+        private InnerObject inner;
+
+        public void setBas(Integer bas) {
+            this.bas = bas;
+        }
+
+        public Integer getBas() {
+            return bas;
+        }
+
+        public Boolean isDas() {
+            return das;
+        }
+
+        public void setDas(Boolean das) {
+            this.das = das;
+        }
+
+        public InnerObject getInner() {
+            return inner;
+        }
+
+        public void setInner(InnerObject inner) {
+            this.inner = inner;
+        }
+    }
+
+    @Test
+    public void testInjectFine() {
+        // yaml is superset of json, so we can use either of them
+        DottedProperties properties = Yaml2Props.create("{ a: 1, b: 3, c: true, d: { innerField : 'inner object'}}");
+        TestObjectFine to = new TestObjectFine();
+        
+        // this method expect existed object, the marked for setting fields must be accessible for that(not final and public/have setter )  
+        DottedPropertiesInjector.injectAnnotatedFields(to, properties);
+        assertEquals("1", to.as);
+        assertEquals(3, (int)to.bas);
+        assertTrue(to.isDas());
+        
+        // none that top-level properties use @Value annotation as this object is utilazed by our library
+        // but for nested we have to use JsonProperty as problems of writing proper type for value is Jackson responsibility
+        assertEquals("inner object", to.inner.a);
+    }
+    
+    @Test
+        public void testGettingFine() {
+        
+            // yaml is superset of json, so we can use either of them
+            DottedProperties properties = Yaml2Props.create("{ a: 1, b: 3, c: true, d: { innerField : 'inner object'}}");
+            String a = properties.getProperty("a").asString();
+            assertEquals("1", a);
+    
+            Integer b = properties.getProperty("b").asInteger();
+            assertEquals(3L, b.longValue());
+    
+            InnerObject inner = properties.getProperty("d", new TypeReference<InnerObject>() {}); // can be generics
+            InnerObject expectd = new InnerObject();
+            expectd.a = "inner object";
+            assertEquals(expectd, inner);
+    
+            // all of them are valid and equal selectors:
+            // d.innerField
+            // d['innerField']
+            // ['d'].innerField
+            // ['d']['innerField']
+            String nestedValue = properties.getProperty("d['innerField']", String.class); // value will be converted to needed type, if conversion is possible
+    
+            assertEquals("inner object", nestedValue);
+    
+        }
+}
+```
 
 ## Alternatives
 Here are two similar projects with answers about why they did not fit my needs:
diff --git a/build.gradle b/build.gradle
@@ -8,7 +8,7 @@ apply plugin: "maven-publish"
 apply plugin: "jacoco"
 
 group 'io.github.msangel'
-version '1.0.0-SNAPSHOT'
+version '1.0.3-SNAPSHOT'
 
 sourceCompatibility = 1.8
 targetCompatibility = 1.8
diff --git a/src/main/java/ua/co/k/yaml2dotnotation/Base.java b/src/main/java/ua/co/k/yaml2dotnotation/Base.java
@@ -1,6 +1,7 @@
 package ua.co.k.yaml2dotnotation;
 
 import com.fasterxml.jackson.core.JsonParser;
+import com.fasterxml.jackson.core.JsonPointer;
 import com.fasterxml.jackson.core.TreeNode;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -25,8 +26,8 @@ public boolean hasProperty(String path) {
 
     @Override
     public <T> T getProperty(String path, TypeReference<T> ref) {
-        path = dotted2pointer(path);
-        TreeNode node = this.treeNode.at(path);
+        JsonPointer jsonPointer = new DottedPathLexer(path).convert();
+        TreeNode node = this.treeNode.at(jsonPointer);
         if (node.isMissingNode()) {
             return null;
         }
@@ -38,9 +39,4 @@ public <T> T getProperty(String path, TypeReference<T> ref) {
             throw new RuntimeException("problem getting property", e);
         }
     }
-
-    // todo: https://tools.ietf.org/html/rfc6901
-    private static String dotted2pointer(String in) {
-        return "/"+String.join("/", in.split("\\."));
-    }
 }
diff --git a/src/main/java/ua/co/k/yaml2dotnotation/DottedPropertiesInjector.java b/src/main/java/ua/co/k/yaml2dotnotation/DottedPropertiesInjector.java
@@ -1,7 +1,7 @@
 package ua.co.k.yaml2dotnotation;
 
 import com.fasterxml.jackson.core.type.TypeReference;
-import ua.co.k.yaml2dotnotation.annot.Prop;
+import ua.co.k.yaml2dotnotation.annot.Value;
 
 import java.beans.IntrospectionException;
 import java.beans.PropertyDescriptor;
@@ -34,7 +34,7 @@ public static abstract class FieldInformation implements Consumer<DottedProperti
         final String path;
         final TypeReference<?> valueTypeRef;
 
-        public FieldInformation(String path, TypeReference<?> valueTypeRef){
+        FieldInformation(String path, TypeReference<?> valueTypeRef){
             this.path = path;
             this.valueTypeRef = valueTypeRef;
         }
@@ -57,7 +57,7 @@ public static void injectAnnotatedFields(Object target, DottedProperties props)
         fieldsToInject.forEach(el -> el.accept(props));
     }
 
-    static Function<List<Field>, List<FieldInformation>> getCandidateFieldMapper(Object target) {
+    private static Function<List<Field>, List<FieldInformation>> getCandidateFieldMapper(Object target) {
         return new Function<List<Field>, List<FieldInformation>>() {
             @Override
             public List<FieldInformation> apply(List<Field> fields) {
@@ -73,7 +73,7 @@ public List<FieldInformation> apply(List<Field> fields) {
 
             private FieldInformation getFieldInformation(Field field) {
 
-                Prop annotation = field.getAnnotation(Prop.class);
+                Value annotation = field.getAnnotation(Value.class);
                 if (annotation == null) {
                     return null;
                 }
@@ -126,7 +126,7 @@ void acceptThrows(DottedProperties elem) throws Exception {
         };
     }
 
-    public static List<FieldInformation> getFields(Class<?> startClass, Function<List<Field>, List<FieldInformation>> mapperToSetters) {
+    private static List<FieldInformation> getFields(Class<?> startClass, Function<List<Field>, List<FieldInformation>> mapperToSetters) {
 
         List<FieldInformation> currentClassFields = mapperToSetters.apply(Arrays.asList(startClass.getDeclaredFields()));
 
diff --git a/src/main/java/ua/co/k/yaml2dotnotation/annot/Value.java b/src/main/java/ua/co/k/yaml2dotnotation/annot/Value.java
@@ -10,6 +10,6 @@
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.FIELD)
-public @interface Prop {
+public @interface Value {
        String value();
 }
diff --git a/src/test/java/ua/co/k/yaml2dotnotation/DottedPropertiesInjectorTest.java b/src/test/java/ua/co/k/yaml2dotnotation/DottedPropertiesInjectorTest.java
@@ -1,7 +1,11 @@
 package ua.co.k.yaml2dotnotation;
 
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.core.type.TypeReference;
 import org.junit.Test;
-import ua.co.k.yaml2dotnotation.annot.Prop;
+import ua.co.k.yaml2dotnotation.annot.Value;
+
+import java.util.Objects;
 
 import static org.junit.Assert.*;
 
@@ -10,16 +14,32 @@
  */
 public class DottedPropertiesInjectorTest {
 
+    public static class InnerObject {
+        @JsonProperty("innerField")
+        public String a;
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj instanceof InnerObject) {
+                return Objects.equals(this.a, ((InnerObject) obj).a);
+            }
+            return false;
+        }
+    }
+
     public static class TestObjectFine {
-        @Prop("a")
+        @Value("a")
         public String as;
 
-        @Prop("b")
+        @Value("b")
         private Integer bas;
 
-        @Prop("c")
+        @Value("c")
         private Boolean das;
 
+        @Value("d")
+        private InnerObject inner;
+
         public void setBas(Integer bas) {
             this.bas = bas;
         }
@@ -35,23 +55,34 @@ public Boolean isDas() {
         public void setDas(Boolean das) {
             this.das = das;
         }
+
+        public InnerObject getInner() {
+            return inner;
+        }
+
+        public void setInner(InnerObject inner) {
+            this.inner = inner;
+        }
     }
 
     @Test
     public void testInjectFine() {
-        DottedProperties properties = Yaml2Props.create("{ a: 1, b: 3, c: true}");
+        DottedProperties properties = Yaml2Props.create("{ a: 1, b: 3, c: true, d: { innerField : 'inner object'}}");
         TestObjectFine to = new TestObjectFine();
         DottedPropertiesInjector.injectAnnotatedFields(to, properties);
         assertEquals("1", to.as);
         assertEquals(3, (int)to.bas);
         assertTrue(to.isDas());
+        // none that top-level properties use @Value annotation as this object is utilazed by our library
+        // but for nested we have to use JsonProperty as problems of writing proper type for value is Jackson responsibility
+        assertEquals("inner object", to.inner.a);
     }
 
     public static class TestObjectInvalidPrivatFieldUsed {
-        @Prop("a")
+        @Value("a")
         public String as;
 
-        @Prop("b")
+        @Value("b")
         private Integer bas;
     }
 
@@ -64,10 +95,10 @@ public void testInjectPrivateError() {
     }
 
     public static class TestObjectInvalidFinalFielsUsed {
-        @Prop("a")
+        @Value("a")
         public String as;
 
-        @Prop("b")
+        @Value("b")
         private final Integer bas;
 
         public TestObjectInvalidFinalFielsUsed() {
@@ -89,7 +120,7 @@ public void testInjectFinalError() {
 
 
     public static class MoreLevels extends TestObjectFine {
-        @Prop("d")
+        @Value("d")
         public String cas;
     }
 
@@ -103,4 +134,30 @@ public void testInjectFineWithInheritance() {
         assertTrue(to.isDas());
         assertEquals("42", to.cas);
     }
+
+    @Test
+    public void testGettingFine() {
+        // yaml is superset of json, so we can use either of them
+        DottedProperties properties = Yaml2Props.create("{ a: 1, b: 3, c: true, d: { innerField : 'inner object'}}");
+        String a = properties.getProperty("a").asString();
+        assertEquals("1", a);
+
+        Integer b = properties.getProperty("b").asInteger();
+        assertEquals(3L, b.longValue());
+
+        InnerObject inner = properties.getProperty("d", new TypeReference<InnerObject>() {}); // can be generics
+        InnerObject expectd = new InnerObject();
+        expectd.a = "inner object";
+        assertEquals(expectd, inner);
+
+        // all of them are valid and equal selectors:
+        // d.innerField
+        // d['innerField']
+        // ['d'].innerField
+        // ['d']['innerField']
+        String nestedValue = properties.getProperty("d['innerField']", String.class); // value will be converted to needed type, if conversion is possible
+
+        assertEquals("inner object", nestedValue);
+
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,6 @@`
`10`	`10`	`*/`
`11`	`11`	`@Retention(RetentionPolicy.RUNTIME)`
`12`	`12`	`@Target(ElementType.FIELD)`
`13`		`-public @interface Prop {`
	`13`	`+public @interface Value {`
`14`	`14`	`String value();`
`15`	`15`	`}`