void validate(Binder binder) {
      // TODO: Set source from Struts XML.
      if (hasScope(interceptorClass)) {
        binder.addError(
            "Scoping interceptors is not currently supported."
                + " Please remove the scope annotation from "
                + interceptorClass.getName()
                + ".");
      }

      // Make sure it implements Interceptor.
      if (!Interceptor.class.isAssignableFrom(interceptorClass)) {
        binder.addError(
            interceptorClass.getName() + " must implement " + Interceptor.class.getName() + ".");
      }
    }
Esempio n. 2
0
 private static void checkTypeAndAnnotations(Binder binder, Class<?> type) {
   if (!type.isInterface()) {
     binder.addError("Type %s must be an interface", type);
   }
   if (!Finders.class.isAssignableFrom(type)) {
     binder.addError("Type %s must be annotated with %s", type, Finders.class);
   }
   for (Method method : type.getMethods()) {
     if (!method.isAnnotationPresent(Finder.class)) {
       binder.addError("Method %s must be annotated with %s", method, Finder.class);
     }
     if (method.getReturnType() != Iterator.class) {
       binder.addError("Method %s must return an %s", method, Iterator.class);
     } else if (!resultType(method).isInterface()) {
       binder.addError("%s must be an interface on method %s", resultType(method), method);
     }
   }
 }
 public List<ProviderMethod<?>> getProviderMethods(Binder binder) {
   System.out.println("end");
   List<ProviderMethod<?>> result = Lists.newArrayList();
   Multimap<Signature, Method> methodsBySignature = HashMultimap.create();
   for (Class<?> c = delegate.getClass(); c != Object.class; c = c.getSuperclass()) {
     for (Method method : c.getDeclaredMethods()) {
       // private/static methods cannot override or be overridden by other methods, so there is no
       // point in indexing them.
       // Skip synthetic methods and bridge methods since java will automatically generate
       // synthetic overrides in some cases where we don't want to generate an error (e.g.
       // increasing visibility of a subclass).
       if (((method.getModifiers() & (Modifier.PRIVATE | Modifier.STATIC)) == 0)
           && !method.isBridge()
           && !method.isSynthetic()) {
         methodsBySignature.put(new Signature(method), method);
       }
       Optional<Annotation> annotation = isProvider(binder, method);
       if (annotation.isPresent()) {
         result.add(createProviderMethod(binder, method, annotation.get()));
       }
     }
   }
   // we have found all the providers and now need to identify if any were overridden
   // In the worst case this will have O(n^2) in the number of @Provides methods, but that is only
   // assuming that every method is an override, in general it should be very quick.
   for (ProviderMethod<?> provider : result) {
     Method method = provider.getMethod();
     for (Method matchingSignature : methodsBySignature.get(new Signature(method))) {
       // matching signature is in the same class or a super class, therefore method cannot be
       // overridding it.
       if (matchingSignature.getDeclaringClass().isAssignableFrom(method.getDeclaringClass())) {
         continue;
       }
       // now we know matching signature is in a subtype of method.getDeclaringClass()
       if (overrides(matchingSignature, method)) {
         String annotationString =
             provider.getAnnotation().annotationType() == Provides.class
                 ? "@Provides"
                 : "@" + provider.getAnnotation().annotationType().getCanonicalName();
         binder.addError(
             "Overriding "
                 + annotationString
                 + " methods is not allowed."
                 + "\n\t"
                 + annotationString
                 + " method: %s\n\toverridden by: %s",
             method,
             matchingSignature);
         break;
       }
     }
   }
   return result;
 }
Esempio n. 4
0
 private static <T> void bind(Binder binder, Class<T> type) {
   ImmutableMap.Builder<Method, Call> methods = ImmutableMap.builder();
   for (Method method : type.getMethods()) {
     try {
       Call call = new Call(method, binder.getProvider(Storage.class));
       methods.put(method, call);
     } catch (ParseException e) {
       binder.addError("%s\n%s", method, e.getMessage());
     }
   }
   binder.bind(type).toInstance(proxy(type, methods.build()));
 }
  private <T> ProviderMethod<T> createProviderMethod(
      Binder binder, Method method, Annotation annotation) {
    binder = binder.withSource(method);
    Errors errors = new Errors(method);

    // prepare the parameter providers
    InjectionPoint point = InjectionPoint.forMethod(method, typeLiteral);
    List<Dependency<?>> dependencies = point.getDependencies();
    List<Provider<?>> parameterProviders = Lists.newArrayList();
    for (Dependency<?> dependency : point.getDependencies()) {
      parameterProviders.add(binder.getProvider(dependency));
    }

    @SuppressWarnings("unchecked") // Define T as the method's return type.
    TypeLiteral<T> returnType = (TypeLiteral<T>) typeLiteral.getReturnType(method);
    Key<T> key = getKey(errors, returnType, method, method.getAnnotations());
    try {
      key = scanner.prepareMethod(binder, annotation, key, point);
    } catch (Throwable t) {
      binder.addError(t);
    }
    Class<? extends Annotation> scopeAnnotation =
        Annotations.findScopeAnnotation(errors, method.getAnnotations());
    for (Message message : errors.getMessages()) {
      binder.addError(message);
    }
    return ProviderMethod.create(
        key,
        method,
        delegate,
        ImmutableSet.copyOf(dependencies),
        parameterProviders,
        scopeAnnotation,
        skipFastClassGeneration,
        annotation);
  }
 /**
  * Returns true if the method is a provider.
  *
  * <p>Synthetic bridge methods are excluded. Starting with JDK 8, javac copies annotations onto
  * bridge methods (which always have erased signatures).
  */
 private Optional<Annotation> isProvider(Binder binder, Method method) {
   if (method.isBridge() || method.isSynthetic()) {
     return Optional.absent();
   }
   Annotation annotation = null;
   for (Class<? extends Annotation> annotationClass : scanner.annotationClasses()) {
     Annotation foundAnnotation = method.getAnnotation(annotationClass);
     if (foundAnnotation != null) {
       if (annotation != null) {
         binder.addError(
             "More than one annotation claimed by %s on method %s."
                 + " Methods can only have one annotation claimed per scanner.",
             scanner, method);
         return Optional.absent();
       }
       annotation = foundAnnotation;
     }
   }
   return Optional.fromNullable(annotation);
 }
Esempio n. 7
0
  @Override
  protected void setup(Binder binder) {
    RecipeConfig recipes = buildConfigObject(RecipeConfig.class);

    Multibinder<HttpService> httpServices = Multibinder.newSetBinder(binder, HttpService.class);
    httpServices.addBinding().to(RecipeHttpService.class).in(Scopes.SINGLETON);

    if (recipes.getRecipes() == null) {
      return;
    }

    boolean set_default = false;
    for (String recipeConfig : recipes.getRecipes()) {
      URI recipeUri;
      try {
        recipeUri = new URI(recipeConfig);
      } catch (URISyntaxException e) {
        throw Throwables.propagate(
            new InvalidConfigurationException("The value of 'recipe' config must be an URI."));
      }

      String path = "/" + recipeUri.getHost() + recipeUri.getPath();
      InputStream stream;
      switch (recipeUri.getScheme()) {
        case "file":
          try {
            stream = new FileInputStream(path);
          } catch (FileNotFoundException e) {
            throw Throwables.propagate(e);
          }
          break;
        case "resources":
          stream = getClass().getResourceAsStream(path);
          if (stream == null) {
            throw new IllegalArgumentException("Recipe file couldn't found: " + recipeUri);
          }
          break;
        case "http":
        case "https":
          try {
            stream = recipeUri.toURL().openStream();
          } catch (IOException e) {
            binder.addError("The value of 'recipe' property '%s' is not an URL");
            return;
          }
          break;
        default:
          binder.addError(
              "The scheme of 'recipe' %s is not valid", recipeConfig, recipeUri.getScheme());
          return;
      }

      ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
      mapper.registerModule(
          new SimpleModule() {
            @Override
            public void setupModule(SetupContext context) {
              context.insertAnnotationIntrospector(new SwaggerAnnotationIntrospector_());
            }
          });
      Recipe recipe;
      try {
        recipe = mapper.readValue(stream, Recipe.class);
      } catch (IOException e) {
        binder.addError("'recipes' file %s couldn't parsed: %s", recipeConfig, e.getMessage());
        return;
      }

      switch (recipe.getStrategy()) {
        case DEFAULT:
          if (set_default) {
            binder.addError("Only one recipe can use DEFAULT strategy.");
            return;
          }
          binder.bind(Recipe.class).toInstance(recipe);
          binder.bind(RecipeLoader.class).asEagerSingleton();
          binder.bind(RecipeHandler.class).in(Scopes.SINGLETON);
          set_default = true;
          break;
        case SPECIFIC:
          Multibinder<InjectionHook> hooks = Multibinder.newSetBinder(binder, InjectionHook.class);
          hooks.addBinding().toInstance(new RecipeLoaderSingle(recipe));
          break;
        default:
          throw new IllegalStateException();
      }
    }
  }
Esempio n. 8
0
 @Override
 public void addError(Message message) {
   binder.addError(message);
 }
Esempio n. 9
0
 @Override
 public void addError(Throwable t) {
   binder.addError(t);
 }
Esempio n. 10
0
 @Override
 public void addError(String message, Object... arguments) {
   binder.addError(message, arguments);
 }