How to use

MethodInfo

in

br.com.objectos.way.code

public String name() {
 return methodInfo.fieldName();
}

 @Override
 public boolean apply(MethodInfo input) {
  return !input.hasModifierInfo(modifierInfo);
 }
}

 @Override
 public boolean apply(MethodInfo input) {
  return !input.hasName(name);
 }
}

public boolean hasSameSignature(MethodInfo other) {
 return name().equals(other.name())
   && toSimpleTypeList(parameterInfoList()).equals(toSimpleTypeList(other.parameterInfoList()));
}

@Override
public String toString() {
 return name() + "(" + Joiner.on(", ").join(parameterInfoList()) + ")";
}

@Override
public boolean isEqual(MethodInfo that) {
 return Testables.isEqualHelper()
   .equal(name(), that.name())
   .equal(accessInfo(), that.accessInfo())
   .equal(modifierInfoSet(), that.modifierInfoSet())
   .equal(returnTypeInfo(), that.returnTypeInfo())
   .equal(annotationInfoMap(), that.annotationInfoMap())
   .equal(parameterInfoList(), that.parameterInfoList())
   .result();
}

private static List<Property> of0(PojoInfo pojoInfo) {
 return pojoInfo.methodInfoStream()
   .filter(m -> m.hasModifierInfo(ModifierInfo.ABSTRACT))
   .filter(m -> !m.hasReturnTypeInfo(SimpleTypePrimitives.VOID))
   .filter(m -> m.hasParameterInfoListSize(0))
   .filter(m -> !m.hasAnnotation(Invalidate.class))
   .map(m -> new Property(pojoInfo, m))
   .collect(MoreCollectors.toImmutableList());
}

public ToMustacheHelper toMustacheHelper() {
 List<? extends ParameterInfo> parameterInfoList = parameterInfoList();
 List<IndexedParameterInfo> parameters = WayIterables.from(parameterInfoList)
   .transform(ParameterInfoToIndexedParameterInfo.get(parameterInfoList.size()))
   .toImmutableList();
 return Mustaches.toMustacheHelper()
   .add("name", name())
   .add("methodName", name())
   .add("toClassName", getClassName())
   .add("fieldName", fieldName())
   .add("fieldToClassName", WayCode.upperCaseFirstChar(fieldName()))
   .add("access", accessInfo())
   .add("returnType", returnTypeInfo())
   .add("parameters", parameters)
   .add("parametersIsEmpty", parameters.isEmpty());
}

@Override
public Contribution execute(PojoInfo pojoInfo) {
 return pojoInfo.methodInfoStream()
   .filter(m -> m.hasName("isEqualTo"))
   .filter(m -> m.hasParameterInfoListSize(1))
   .filter(m -> !m.hasModifierInfo(ModifierInfo.ABSTRACT))
   .findFirst()
   .map(m -> Contribution.empty())
   .orElseGet(() -> execute0(pojoInfo));
}

private static Optional<InvalidateMethod> of1(TypeInfo typeInfo, MethodInfo method, AnnotationInfo annotation) {
 String annotationName = annotation.simpleName();
 if (method.hasModifierInfo(ModifierInfo.FINAL)) {
  method.compilationError("@%s method cannot be final", annotationName);
  return Optional.empty();
 }
 if (method.hasAccessInfo(AccessInfo.PRIVATE)) {
  method.compilationError("@%s method cannot be private", annotationName);
  return Optional.empty();
 }
 SimpleTypeInfo returnTypeInfo = method.returnTypeInfo();
 boolean self = returnTypeInfo.equals(typeInfo.toSimpleTypeInfo());
 if (!returnTypeInfo.equals(SimpleTypePrimitives.VOID) && !self) {
  method.compilationError("@%s method must return void or self", annotationName);
  return Optional.empty();
 }
 InvalidateMethod invalidateMethod = new InvalidateMethod(method, annotation, self);
 return Optional.of(invalidateMethod);
}

private ParameterSpec parameter(MethodInfo input) {
 SimpleTypeInfo returnTypeInfo = input.returnTypeInfo();
 return ParameterSpec.builder(returnTypeInfo.typeName(), input.fieldName()).build();
}

void accept(TypeSpec.Builder type) {
 MethodInfoOverrideWriter writer = methodInfo.overrideWriter();
 if (!methodInfo.hasModifierInfo(ModifierInfo.ABSTRACT)) {
  writer.addStatement("super.$L()", methodInfo.name());
 }
 contributionList.forEach(contribution -> contribution.accept(writer));
 if (self) {
  writer.addStatement("return this");
 }
 type.addMethod(writer.write());
}

public SimpleTypeInfo returnTypeInfo() {
 return methodInfo.returnTypeInfo();
}

@Override
public String apply(MethodInfo input) {
 return input.name();
}

@Override
public MethodSpec apply(MethodInfo input) {
 return MethodSpec.methodBuilder(input.name())
   .returns(input.returnTypeInfo().typeName())
   .addCode(body(input))
   .build();
}

public String fieldName() {
 String prefix = getterPrefix();
 String field = name().replace(prefix, "");
 return WayCode.lowerCaseFirstChar(field);
}

@AutoFunctional
public Set<ImportInfo> toImportInfoSet() {
 return WayIterables.from(parameterInfoList())
   .transformAndConcat(ParameterInfoToImportInfo.get())
   .addAll(returnTypeInfo().toImportInfo())
   .toImmutableSet();
}

 @Override
 public boolean apply(MethodInfo input) {
  return !input.hasParameterInfoListSize(size);
 }
}

 @Override
 public boolean apply(MethodInfo input) {
  return !input.hasAnnotation(annotationType);
 }
}

 @Override
 public MethodSpec apply(MethodInfo input) {
  CodeBlock statement = input.statementWriter()
    .add("return $L")
    .setFieldName()
    .write();
  return input.overrideWriter()
    .addCode(statement)
    .write();
 }
}