br.com.objectos.way.pojo.plugin.BuilderInterface Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of pojo-plugin Show documentation
There is a newer version: 0.6.0
/*
 * Copyright 2014-2015 Objectos, Fábrica de Software LTDA.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package br.com.objectos.way.pojo.plugin;

import java.util.List;

import javax.lang.model.element.Modifier;

import br.com.objectos.way.code.Artifact;
import br.com.objectos.way.code.MethodInfo;
import br.com.objectos.way.code.TypeInfo;

import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.TypeSpec;

/**
 * @author [email protected] (Marcio Endo)
 */
class BuilderInterface {

  private final StandardBuilderConfiguration builder;
  private final TypeSpec.Builder type;

  private BuilderInterface(StandardBuilderConfiguration builder, TypeSpec.Builder type) {
    this.builder = builder;
    this.type = type;
  }

  public static BuilderInterface of(StandardBuilderConfiguration builder) {
    TypeInfo typeInfo = builder.typeInfo();
    Naming naming = builder.naming();

    TypeSpec.Builder type = TypeSpec.interfaceBuilder(naming.builderInterfaceSimpleName())
        .addModifiers(typeInfo.accessInfo().modifiers());
    naming.typeVariableNameListTo(type);

    return new BuilderInterface(builder, type);
  }

  public Artifact execute() {
    return builder.artifact(type());
  }

  private TypeSpec.Builder type() {
    Naming naming = builder.naming();
    List propertyList = builder.propertyList();
    List pluginList = builder.builderPropertyPluginList();

    TypeSpec.Builder iface = type;

    for (Property property : propertyList) {
      for (BuilderPropertyPlugin plugin : pluginList) {
        if (plugin.test(property)) {
          plugin.accept(builder);

          BuilderProperty execution = plugin.execute(property);
          if (execution.skip()) {
            break;
          }
          execution.acceptBuilder(iface);

          MethodInfo methodInfo = property.methodInfo();
          String nextName = naming.builderInnerSimpleName(methodInfo);
          TypeSpec.Builder next = TypeSpec.interfaceBuilder(nextName)
              .addModifiers(Modifier.PUBLIC, Modifier.STATIC);
          naming.typeVariableNameListTo(next);

          if (type != iface) {
            type.addType(iface.build());
          }

          iface = next;
          break;
        }
      }
    }

    iface.addMethod(build());
    if (iface != type) {
      type.addType(iface.build());
    }

    return type;
  }

  private MethodSpec build() {
    return MethodSpec.methodBuilder("build")
        .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
        .returns(builder.naming().superClassTypeNameUnbounded())
        .build();
  }

}