import org.jnarrate.fit.fixture.expertise.Clerk;

    PerformableAsA<ROLE> doThisAction = sme.howDoI(new ActionName(doThis), new Clerk(thisInformation));

package org.jnarrate.fit.fixture.expertise;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.jnarrate.fit.fixture.entityname.MethodName;

import org.jnarrate.fit.fixture.expertise.misuse.InvokedCodeComplainedComplaint;

import org.jnarrate.fit.fixture.expertise.misuse.UnableToFillInDetailsComplaint;

public class Clerk {

  private static final String BEFORE_THE_FIRST_QUOTE = "^(.*) \"";

  private static final String INSIDE_QUOTES = "\"(.*)\"";

  private final String value;

  private final MethodName methodName;

  public Clerk(String fromThisSentenceFragment) {

    methodName = new MethodName(theText(BEFORE_THE_FIRST_QUOTE,fromThisSentenceFragment));

    value = theText(INSIDE_QUOTES, fromThisSentenceFragment);

  }

  private String theText(String thisPattern, String fromThisSentenceFragment) {

    Pattern valuePattern = Pattern.compile(thisPattern);

    Matcher matcher = valuePattern.matcher(fromThisSentenceFragment);

    matcher.find();

    return matcher.group(1);

  }

  public <T> T addTheDetailsTo(T lookedUpAction) {

    try {

      Method method = lookedUpAction.getClass().getMethod(methodName.toString(), String.class);

      method.invoke(lookedUpAction, value);

      return lookedUpAction;

    }

    catch (NoSuchMethodException e) {

      throw new UnableToFillInDetailsComplaint(lookedUpAction, methodName, e);

    }

    catch (InvocationTargetException e) {

      throw new InvokedCodeComplainedComplaint(lookedUpAction, methodName, e);

    }

    catch (SecurityException e) {

      throw new RuntimeException("TODO - Handle this exception better",e);

    }

    catch (IllegalArgumentException e) {

      throw new RuntimeException("TODO - Handle this exception better",e);

    }

    catch (IllegalAccessException e) {

      throw new RuntimeException("TODO - Handle this exception better",e);

    }

  }

  @Override

  public int hashCode() {

    final int prime = 31;

    int result = 1;

    result = prime * result + ((methodName == null) ? 0 : methodName.hashCode());

    result = prime * result + ((value == null) ? 0 : value.hashCode());

    return result;

  }

  @Override

  public boolean equals(Object obj) {

    if (this == obj)

      return true;

    if (obj == null)

      return false;

    if (getClass() != obj.getClass())

      return false;

    Clerk other = (Clerk) obj;

    if (methodName == null) {

      if (other.methodName != null)

        return false;

    }

    else if (!methodName.equals(other.methodName))

      return false;

    if (value == null) {

      if (other.value != null)

        return false;

    }

    else if (!value.equals(other.value))

      return false;

    return true;

  }

}

  public <ROLE> PerformableAsA<ROLE> howDoI(ActionName actionName, Clerk information) {

    return information.addTheDetailsTo(action);

package org.jnarrate.fit.fixture.expertise.misuse;

import java.lang.reflect.InvocationTargetException;

import org.jnarrate.fit.fixture.entityname.MethodName;

public class InvokedCodeComplainedComplaint extends RuntimeException {

  public InvokedCodeComplainedComplaint(Object invokedAction, MethodName methodName, InvocationTargetException wrappedException) {

    super("The method ["+ methodName +"] on the class ["+ invokedAction.getClass().getCanonicalName() +"] complained with ["+ wrappedException.getCause().getClass().getSimpleName() +"]", wrappedException.getCause() );

  }

}

package org.jnarrate.fit.fixture.expertise.misuse;

import org.jnarrate.fit.fixture.entityname.MethodName;

public class UnableToFillInDetailsComplaint extends RuntimeException {

  public UnableToFillInDetailsComplaint(Object invokedAction, MethodName methodName, Exception wrappedException) {

    super("Unable to find a method called [" + methodName + "] with a String parameter on the class [" + invokedAction.getClass().getCanonicalName() + "]. Maybe you should create it", wrappedException);

  }

}

import org.jnarrate.fit.fixture.expertise.Clerk;

    andThatItIsAsked(sme.howDoI(new ActionName(doThis), new Clerk(thisInformation))).thenReturn((PerformableAsA) action);

package org.jnarrate.fit.fixture.entityname;

import static org.hamcrest.CoreMatchers.instanceOf;

import static org.hamcrest.CoreMatchers.is;

import static org.junit.Assert.assertThat;

import static org.mockito.Mockito.doThrow;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.verify;

import org.jnarrate.fit.fixture.entityname.information.ObjectWithAMethodName;

import org.jnarrate.fit.fixture.expertise.Clerk;

import org.jnarrate.fit.fixture.expertise.misuse.InvokedCodeComplainedComplaint;

import org.jnarrate.fit.fixture.expertise.misuse.UnableToFillInDetailsComplaint;

import org.junit.Test;

public class ClerkShould {

  @Test

  public void informTheThing() throws Exception {

    String withTheseDetails = "aMethodName \"a value\"";

    ObjectWithAMethodName theThing = mock(ObjectWithAMethodName.class);

    Clerk clerk = new Clerk(withTheseDetails);

    ObjectWithAMethodName informedThing = clerk.addTheDetailsTo(theThing);

    verify(theThing).aMethodName("a value");

    assertThat(informedThing, is(instanceOf(ObjectWithAMethodName.class)));

  }

  @Test

  public void informTheThingWithADifferentValue() throws Exception {

    String withTheseDetails = "aMethodName \"a different value\"";

    ObjectWithAMethodName theThing = mock(ObjectWithAMethodName.class);

    Clerk clerk = new Clerk(withTheseDetails);

    ObjectWithAMethodName informedThing = clerk.addTheDetailsTo(theThing);

    verify(theThing).aMethodName("a different value");

    assertThat(informedThing, is(instanceOf(ObjectWithAMethodName.class)));

  }

  @Test

  public void informTheThingWithADifferentMethod() throws Exception {

    String withTheseDetails = "a Different Method Name \"a value\"";

    ObjectWithAMethodName theThing = mock(ObjectWithAMethodName.class);

    Clerk clerk = new Clerk(withTheseDetails);

    ObjectWithAMethodName informedThing = clerk.addTheDetailsTo(theThing);

    verify(theThing).aDifferentMethodName("a value");

    assertThat(informedThing, is(instanceOf(ObjectWithAMethodName.class)));

  }

  @Test

  public void complainWhenNoAppropriateMethod() throws Exception {

    Clerk clerk = new Clerk("a method that is \"not there\"");

    ObjectWithAMethodName thing = mock(ObjectWithAMethodName.class);

    Exception thrown = null;

    try {

      clerk.addTheDetailsTo(thing);

    }

    catch (Exception caught) {

      thrown = caught;

    }

    assertThat(thrown, is(instanceOf(UnableToFillInDetailsComplaint.class)));

  }

  @Test

  public void complainWhenCalledMethodComplains() throws Exception {

    Clerk clerk = new Clerk("a method name \"but it complains\"");

    ObjectWithAMethodName thing = mock(ObjectWithAMethodName.class);

    doThrow(new UnsupportedOperationException("Whoops!")).when(thing).aMethodName("but it complains");

    Exception thrown = null;

    try {

      clerk.addTheDetailsTo(thing);

    }

    catch (Exception caught) {

      thrown = caught;

    }

    assertThat(thrown, is(instanceOf(InvokedCodeComplainedComplaint.class)));

  }

}

package org.jnarrate.fit.fixture.entityname.information;

public interface ObjectWithAMethodName {

  void aMethodName(String aValue);

  void aDifferentMethodName(String string);

  void aMethodWithNoParameter();

}

	  Clerk information = mock(Clerk.class);

    when(information.addTheDetailsTo(lookedUpAction)).thenReturn(informedAction);

	  verify(information).addTheDetailsTo(lookedUpAction);