InstanceBuilder.java

package net.thucydides.core.csv;

import net.thucydides.core.csv.converters.TypeConverter;
import net.thucydides.core.csv.converters.TypeConverters;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * Helper class for finding and invoking constructors.
 */
public final class InstanceBuilder {

    private Object targetObject;

    private  <T> InstanceBuilder(final T newObject) {
        this.targetObject = newObject;
    }

    public static <T> T newInstanceOf(final Class<T> clazz,
                                      final Object... constructorArgs)
            throws InstantiationException, IllegalAccessException, InvocationTargetException {

        if ((constructorArgs.length == 0) &&(thereIsADefaultConstructorFor(clazz))) {
            return clazz.newInstance();
        } else {
            return invokeConstructorFor(clazz, constructorArgs);
        }
    }

    @SuppressWarnings("unchecked")
    public static <T> T invokeConstructorFor(final Class<T> clazz, final Object[] constructorArgs)
            throws InvocationTargetException, IllegalAccessException, InstantiationException {

        Constructor<?>[] constructors = clazz.getDeclaredConstructors();

        for(Constructor<?> constructor : constructors) {
            if (constructor.getParameterTypes().length == constructorArgs.length) {
                return (T) constructor.newInstance(constructorArgs);
            }
        }
        throw new IllegalStateException("No matching constructor found for " + clazz
                + " with arguments: " + ArrayUtils.toString(constructorArgs));

    }

    private static <T> boolean thereIsADefaultConstructorFor(final Class<T> clazz) {

        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
        for(Constructor<?> constructor : constructors) {
            if (constructor.getParameterTypes().length == 0) {
                return true;
            }
        }
        return false;
    }

    public void setPropertyValue(final String property,
                                 final String value) {
        if (!setProperty(property, value)) {
            throw new FailedToInitializeTestData("Could not find property field " + property);
        }
    }

    private boolean setProperty(String property, String value) {
        try {
            Method setter = findSetter(property);
            if (setter != null) {
               return setViaSetter(setter, value);
            }
            Field field = findField(property);
            if (field != null) {
                return setViaField(field, value);
            }
            return false;
        } catch (Exception e) {
            throw new FailedToInitializeTestData("Could not assign property value", e);
        }
    }

    private boolean setViaField(Field field, String value) throws IllegalAccessException {
        TypeConverter converter = TypeConverters.getTypeConverterFor(field.getType());
        Object valueToSet = converter.valueOf(value);
        field.set(targetObject, valueToSet);
        return true;
    }

    private boolean setViaSetter(Method setter, String value) throws InvocationTargetException, IllegalAccessException {
        TypeConverter converter = TypeConverters.getTypeConverterFor(setter.getParameterTypes()[0]);
        Object valueToSet = converter.valueOf(value);
        setter.invoke(targetObject, valueToSet);
        return true;
    }

    private Method findSetter(final String property) {
        Method[] methods = targetObject.getClass().getMethods();
        String setterMethod = "set" + StringUtils.capitalize(property);
        for(Method method : methods) {
            if (method.getName().equals(setterMethod)) {
                return method;
            }
        }
        return null;
    }

    private Field findField(final String property) {
        List<Field> fields = getAllDeclaredFieldsIn(targetObject.getClass());
        for(Field field :fields) {
            if (field.getName().compareToIgnoreCase(property) == 0) {
                field.setAccessible(true);
                return field;
            }
        }
        return null;
    }

    private List<Field> getAllDeclaredFieldsIn(Class targetClass) {
        List<Field> parentFields
                = (targetClass.getSuperclass() != null) ? getAllDeclaredFieldsIn(targetClass.getSuperclass()) : Collections.EMPTY_LIST;

        List<Field> localFields = Arrays.asList(targetClass.getDeclaredFields());
        List<Field> allFields = new ArrayList<Field>(localFields);
        allFields.addAll(parentFields);
        return allFields;
    }

    public static <T> InstanceBuilder inObject(final T newObject) {
        return new InstanceBuilder(newObject);
    }
}