added a rule interface in which we can be selective in what to map and what to skip. this is needed for my patch release in restify

Author: Jeroen van Schagen

src/main/java/io/beanmapper/BeanMapper.java

@@ -12,7 +12,16 @@
 import io.beanmapper.core.converter.collections.CollectionListConverter;
 import io.beanmapper.core.converter.collections.CollectionMapConverter;
 import io.beanmapper.core.converter.collections.CollectionSetConverter;
-import io.beanmapper.core.converter.impl.*;
+import io.beanmapper.core.converter.impl.NumberToNumberConverter;
+import io.beanmapper.core.converter.impl.ObjectToStringConverter;
+import io.beanmapper.core.converter.impl.PrimitiveConverter;
+import io.beanmapper.core.converter.impl.StringToBigDecimalConverter;
+import io.beanmapper.core.converter.impl.StringToBooleanConverter;
+import io.beanmapper.core.converter.impl.StringToEnumConverter;
+import io.beanmapper.core.converter.impl.StringToIntegerConverter;
+import io.beanmapper.core.converter.impl.StringToLongConverter;
+import io.beanmapper.core.rule.BeanMapperRule;
+import io.beanmapper.core.rule.ConstantMapperRule;
 import io.beanmapper.core.unproxy.BeanUnproxy;
 import io.beanmapper.core.unproxy.DefaultBeanUnproxy;
 import io.beanmapper.core.unproxy.SkippingBeanUnproxy;
@@ -91,11 +100,27 @@ public <S, T> T map(S source, Class<T> targetClass) {
         return map(source, targetClass, beanInitializer, false);
     }
 
+    /**
+     * Copies the values from the source object to a newly constructed target instance
+     * @param source source instance of the properties
+     * @param targetClass class of the target, needs to be constructed as the target instance
+     * @param converterChoosable when {@code true} a plain conversion is checked before mapping
+     * @param <S> The instance from which the properties get copied
+     * @param <T> the instance to which the properties get copied
+     * @return the target instance containing all applicable properties
+     * @throws BeanMappingException
+     */
+    @SuppressWarnings("unchecked")
+    public <S, T> T map(S source, Class<T> targetClass, boolean converterChoosable) {
+        return map(source, targetClass, beanInitializer, converterChoosable);
+    }
+    
     /**
      * Copies the values from the source object to a newly constructed target instance
      * @param source source instance of the properties
      * @param targetClass class of the target, needs to be constructed as the target instance
      * @param beanInitializer initializes the beans
+     * @param converterChoosable when {@code true} a plain conversion is checked before mapping
      * @param <S> The instance from which the properties get copied
      * @param <T> the instance to which the properties get copied
      * @return the target instance containing all applicable properties
@@ -115,22 +140,33 @@ public <S, T> T map(S source, Class<T> targetClass, BeanInitializer beanInitiali
         return map(source, target);
     }
 
-    public <S, T> T mapForListElement(S source, Class<T> targetClass) {
-        return map(source, targetClass, beanInitializer, true);
-    }
-
     /**
      * Maps a list of source items to a list of target items with a specific class
      * @param sourceItems the items to be mapped
      * @param targetClass the class type of the items in the returned list
-     * @param <S> source
-     * @param <T> target
+     * @param <S> the instance from which the properties get copied.
+     * @param <T> the instance to which the properties get copied
      * @return the list of mapped items with class T
      * @throws BeanMappingException
      */
     @SuppressWarnings("unchecked")
     public <S, T> Collection<T> map(Collection<S> sourceItems, Class<T> targetClass) {
-        Collection<T> targetItems = (Collection<T>) beanInitializer.instantiate(sourceItems.getClass());
+        return map(sourceItems, targetClass, sourceItems.getClass());
+    }
+    
+    /**
+     * Maps a list of source items to a list of target items with a specific class
+     * @param sourceItems the items to be mapped
+     * @param targetClass the class type of the items in the returned list
+     * @param collectionClass the collection class
+     * @param <S> the instance from which the properties get copied.
+     * @param <T> the instance to which the properties get copied
+     * @return the list of mapped items with class T
+     * @throws BeanMappingException
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public <S, T> Collection<T> map(Collection<S> sourceItems, Class<T> targetClass, Class<? extends Collection> collectionClass) {
+        Collection<T> targetItems = (Collection<T>) beanInitializer.instantiate(collectionClass);
         for (S source : sourceItems) {
             targetItems.add(map(source, targetClass));
         }
@@ -141,13 +177,27 @@ public <S, T> Collection<T> map(Collection<S> sourceItems, Class<T> targetClass)
      * Copies the values from the source object to an existing target instance
      * @param source source instance of the properties
      * @param target target instance for the properties
-     * @param <S> The instance from which the properties get copied.
+     * @param <S> the instance from which the properties get copied.
      * @param <T> the instance to which the properties get copied
      * @return the original target instance containing all applicable properties
      * @throws BeanMappingException
      */
     public <S, T> T map(S source, T target) {
-        return matchSourceToTarget(source, target);
+        return map(source, target, new ConstantMapperRule(true));
+    }
+    
+    /**
+     * Copies the values from the source object to an existing target instance
+     * @param source source instance of the properties
+     * @param target target instance for the properties
+     * @param rule the matching rule
+     * @param <S> the instance from which the properties get copied.
+     * @param <T> the instance to which the properties get copied
+     * @return the original target instance containing all applicable properties
+     * @throws BeanMappingException
+     */
+    public <S, T> T map(S source, T target, BeanMapperRule rule) {
+        return matchSourceToTarget(source, target, rule);
     }
 
     /**
@@ -163,12 +213,14 @@ public <S, T> T map(S source, T target) {
      * @return A filled target object.
      * @throws BeanMappingException
      */
-    private <S, T> T matchSourceToTarget(S source, T target) {
+    private <S, T> T matchSourceToTarget(S source, T target, BeanMapperRule rule) {
         BeanMatch beanMatch = getBeanMatch(source, target);
         for (String fieldName : beanMatch.getTargetNode().keySet()) {
             BeanField sourceField = beanMatch.getSourceNode().get(fieldName);
             BeanField targetField = beanMatch.getTargetNode().get(fieldName);
-            processField(new BeanFieldMatch(source, target, sourceField, targetField, fieldName));
+            if (rule.isAllowed(sourceField, targetField)) {
+                processField(new BeanFieldMatch(source, target, sourceField, targetField, fieldName), rule);
+            }
         }
         return target;
     }
@@ -184,7 +236,7 @@ private <T, S> BeanMatch getBeanMatch(S source, T target) {
      * @param beanFieldMatch contains the fields belonging to the source/target field match
      * @throws BeanMappingException
      */
-    private void processField(BeanFieldMatch beanFieldMatch) {
+    private void processField(BeanFieldMatch beanFieldMatch, BeanMapperRule rule) {
         if (!beanFieldMatch.hasMatchingSource()) {
             dealWithNonMatchingNode(beanFieldMatch);
             return;
@@ -194,7 +246,7 @@ private void processField(BeanFieldMatch beanFieldMatch) {
                                 isMappableClass(beanFieldMatch.getTargetClass()) &&
                                 beanFieldMatch.getSourceObject() != null) {
 
-            dealWithMappableNestedClass(beanFieldMatch);
+            dealWithMappableNestedClass(beanFieldMatch, rule);
             return;
         }
         if (beanFieldMatch.isMappable()) {
@@ -239,13 +291,14 @@ private void copySourceToTarget(BeanFieldMatch beanFieldMatch) {
      * If the field is a class which can itself be mapped to another class, it must be treated
      * as such. The matching process is called recursively to deal with this pair.
      * @param beanFieldMatch contains the fields belonging to the source/target field match
+     * @param rule the matching rule
      * @throws BeanMappingException
      */
-    private void dealWithMappableNestedClass(BeanFieldMatch beanFieldMatch) {
+    private void dealWithMappableNestedClass(BeanFieldMatch beanFieldMatch, BeanMapperRule rule) {
         Object encapsulatedSource = beanFieldMatch.getSourceObject();
         if (encapsulatedSource != null) {
             Object encapsulatedTarget = beanFieldMatch.getOrCreateTargetObject();
-            matchSourceToTarget(encapsulatedSource, encapsulatedTarget);
+            matchSourceToTarget(encapsulatedSource, encapsulatedTarget, rule);
         }
     }
 

src/main/java/io/beanmapper/core/converter/collections/AbstractCollectionConverter.java

@@ -63,7 +63,7 @@ private T getTargetCollection(BeanFieldMatch beanFieldMatch) {
     }
 
     private Object convertElement(Object source, BeanFieldMatch beanFieldMatch) {
-        return beanMapper.mapForListElement(source, beanFieldMatch.getCollectionInstructions().getCollectionMapsTo());
+        return beanMapper.map(source, beanFieldMatch.getCollectionInstructions().getCollectionMapsTo(), true);
     }
 
     @Override

src/main/java/io/beanmapper/core/rule/BeanMapperRule.java

@@ -0,0 +1,25 @@
+/*
+ * (C) 2014 42 bv (www.42.nl). All rights reserved.
+ */
+package io.beanmapper.core.rule;
+
+import io.beanmapper.core.BeanField;
+
+/**
+ * Determines if a field should be mapped or not.
+ *
+ * @author Jeroen van Schagen
+ * @since Nov 6, 2015
+ */
+public interface BeanMapperRule {
+    
+    /**
+     * Determines if a certain field match should be performed.
+     * 
+     * @param sourceField the source field
+     * @param targetField the target field
+     * @return {@code true} if the map should be performed, else {@code false}
+     */
+    boolean isAllowed(BeanField sourceField, BeanField targetField);
+    
+}

src/main/java/io/beanmapper/core/rule/ConstantMapperRule.java

@@ -0,0 +1,30 @@
+/*
+ * (C) 2014 42 bv (www.42.nl). All rights reserved.
+ */
+package io.beanmapper.core.rule;
+
+import io.beanmapper.core.BeanField;
+
+/**
+ * Allows each property to be mapped.
+ *
+ * @author Jeroen van Schagen
+ * @since Nov 6, 2015
+ */
+public class ConstantMapperRule implements BeanMapperRule {
+    
+    private final boolean allowed;
+    
+    public ConstantMapperRule(boolean allowed) {
+        this.allowed = allowed;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean isAllowed(BeanField sourceField, BeanField targetField) {
+        return allowed;
+    }
+    
+}

src/main/java/io/beanmapper/core/rule/SourceFieldMapperRule.java

@@ -0,0 +1,44 @@
+/*
+ * (C) 2014 42 bv (www.42.nl). All rights reserved.
+ */
+package io.beanmapper.core.rule;
+
+import io.beanmapper.core.BeanField;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Maps each property when the source field is included.
+ *
+ * @author Jeroen van Schagen
+ * @since Nov 6, 2015
+ */
+public class SourceFieldMapperRule implements BeanMapperRule {
+    
+    private final Set<String> fieldNames;
+
+    public SourceFieldMapperRule(Collection<String> fieldNames) {
+        this.fieldNames = new HashSet<String>(fieldNames);
+    }
+    
+    public SourceFieldMapperRule(String... fieldNames) {
+        this(Arrays.asList(fieldNames));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean isAllowed(BeanField sourceField, BeanField targetField) {
+        boolean allowed = false;
+        if (sourceField != null) {
+            String fieldName = sourceField.getName();
+            allowed = fieldNames.contains(fieldName);
+        }
+        return allowed;
+    }
+    
+}

src/test/java/io/beanmapper/BeanMapperTest.java

@@ -1,11 +1,23 @@
 package io.beanmapper;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 import io.beanmapper.core.converter.impl.LocalDateTimeToLocalDate;
 import io.beanmapper.core.converter.impl.LocalDateToLocalDateTime;
 import io.beanmapper.core.converter.impl.NestedSourceClassToNestedTargetClassConverter;
 import io.beanmapper.core.converter.impl.ObjectToStringConverter;
+import io.beanmapper.core.rule.SourceFieldMapperRule;
 import io.beanmapper.exceptions.BeanMappingException;
-import io.beanmapper.testmodel.collections.*;
+import io.beanmapper.testmodel.collections.CollectionListSource;
+import io.beanmapper.testmodel.collections.CollectionListTarget;
+import io.beanmapper.testmodel.collections.CollectionListTargetClear;
+import io.beanmapper.testmodel.collections.CollectionMapSource;
+import io.beanmapper.testmodel.collections.CollectionMapTarget;
+import io.beanmapper.testmodel.collections.CollectionSetSource;
+import io.beanmapper.testmodel.collections.CollectionSetTarget;
+import io.beanmapper.testmodel.collections.SourceWithListGetter;
+import io.beanmapper.testmodel.collections.TargetWithListPublicField;
 import io.beanmapper.testmodel.converter.SourceWithDate;
 import io.beanmapper.testmodel.converter.TargetWithDateTime;
 import io.beanmapper.testmodel.converterbetweennestedclasses.NestedSourceClass;
@@ -16,8 +28,14 @@
 import io.beanmapper.testmodel.defaults.TargetWithDefaults;
 import io.beanmapper.testmodel.emptyobject.EmptySource;
 import io.beanmapper.testmodel.emptyobject.EmptyTarget;
+import io.beanmapper.testmodel.emptyobject.NestedEmptySource;
 import io.beanmapper.testmodel.emptyobject.NestedEmptyTarget;
-import io.beanmapper.testmodel.encapsulate.*;
+import io.beanmapper.testmodel.encapsulate.Address;
+import io.beanmapper.testmodel.encapsulate.Country;
+import io.beanmapper.testmodel.encapsulate.House;
+import io.beanmapper.testmodel.encapsulate.ResultManyToMany;
+import io.beanmapper.testmodel.encapsulate.ResultManyToOne;
+import io.beanmapper.testmodel.encapsulate.ResultOneToMany;
 import io.beanmapper.testmodel.encapsulate.sourceAnnotated.Car;
 import io.beanmapper.testmodel.encapsulate.sourceAnnotated.CarDriver;
 import io.beanmapper.testmodel.encapsulate.sourceAnnotated.Driver;
@@ -57,11 +75,6 @@
 import io.beanmapper.testmodel.similarsubclasses.SimilarSubclass;
 import io.beanmapper.testmodel.tostring.SourceWithNonString;
 import io.beanmapper.testmodel.tostring.TargetWithString;
-import mockit.Expectations;
-import mockit.Mocked;
-import mockit.Verifications;
-import org.junit.Before;
-import org.junit.Test;
 
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -70,7 +83,12 @@
 import java.util.List;
 import java.util.TreeSet;
 
-import static org.junit.Assert.*;
+import mockit.Expectations;
+import mockit.Mocked;
+import mockit.Verifications;
+
+import org.junit.Before;
+import org.junit.Test;
 
 public class BeanMapperTest {
 
@@ -269,6 +287,26 @@ public void emptySourceToExistingTarget() {
         assertNull(mappedTarget.nestedEmptyClass.name);
         assertNull(mappedTarget.nestedEmpty);
     }
+    
+    @Test
+    public void sourceToTargetPatch() {
+        EmptySource source = new EmptySource();
+        source.name = "My new name";
+        source.bool = false;
+        source.nestedEmpty = new NestedEmptySource();
+        source.nestedEmpty.name = "My new nested name";
+        
+        EmptyTarget target = new EmptyTarget();
+        target.name = "My name";
+        target.bool = true;
+        target.nestedEmpty = new NestedEmptyTarget();
+        target.nestedEmpty.name = "My nested name";
+
+        beanMapper.map(source, target, new SourceFieldMapperRule("name", "nestedEmpty", "nestedEmpty.name"));
+        assertEquals("My new name", target.name); // Overwritten
+        assertEquals(true, target.bool); // Not overwritten because not in rule
+        assertEquals("My new nested name", target.nestedEmpty.name); // Overwritten (nested)
+    }
 
     @Test
     public void copyToExistingTargetInstance() {