SubPackageGinModule.java

/*
 * Copyright 2011 Google Inc.
 *
 * 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 com.google.gwt.inject.client.packageprivate.subpackage;

import com.google.gwt.inject.client.AbstractGinModule;
import com.google.gwt.inject.client.assistedinject.GinFactoryModuleBuilder;
import com.google.gwt.inject.client.packageprivate.PackagePrivateTest.ProvidedInSubpackage;
import com.google.gwt.inject.client.packageprivate.PackagePrivateTest.PublicAssisted;
import com.google.gwt.inject.client.packageprivate.PackagePrivateTest.PublicGeneric;
import com.google.gwt.inject.client.packageprivate.PackagePrivateTest.PublicInterface;
import com.google.gwt.inject.client.packageprivate.PackagePrivateTest.PublicProvidedClass;
import com.google.gwt.inject.client.packageprivate.subpackage.subsubpackage.SubSubPackageGinModule;
import com.google.gwt.inject.client.packageprivate.subpackage.subsubpackage.SubSubPackageGinModule.ChildPublicInterface;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.user.client.rpc.RemoteService;
import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;
import com.google.inject.Inject;
import com.google.inject.Provider;
import com.google.inject.Provides;
import com.google.inject.assistedinject.Assisted;
import com.google.inject.name.Named;
import com.google.inject.name.Names;

import java.util.List;

public class SubPackageGinModule extends AbstractGinModule {
  @Override
  public void configure() {
    install(new SubSubPackageGinModule());

    // Test binding a public interface to a package-private implementation.
    bind(PublicInterface.class).to(PrivateImplementation.class);

    // Test binding a package-private class as an eager singleton.
    bind(HiddenSingleton.class).asEagerSingleton();

    // Test binding a public class to a package-private provider.
    bind(PublicProvidedClass.class).toProvider(HiddenProvider.class);

    install(new GinFactoryModuleBuilder().build(HiddenAssisted.Factory.class));
    GinFactoryModuleBuilder builder = new GinFactoryModuleBuilder()
        .implement(PublicAssisted.class, Names.named("a"), PublicAssistedImplementation.class);
    SubSubPackageGinModule.implementB(builder);
    install(builder.build(PublicAssisted.Factory.class));
  }

  @Provides
  public List<HiddenDependency> provideHiddenDependencyList() {
    return null;
  }

  public static class PublicImplementation {
    // Test that a public class can depend on package-private classes.
    @Inject
    PublicImplementation(
        ChildPublicInterface childPublicInterface,
        HiddenDependency hiddenDependency, HiddenSingleton hiddenSingleton,
        // Verify that nothing screwy happens if a public generic is
        // parameterized on a non-public type.  Also testing with List because
        // there were issues with java.util classes specifically.
        List<HiddenDependency> hiddenList, PublicGeneric<HiddenDependency> hiddenGeneric,
        // Early versions of this code would
        // put provider creators in com.google.inject, preventing them from
        // referencing private classes.  Verify that this works:
        Provider<HiddenDependency> hiddenDependencyProvider,
        @Named("providerClass") ProvidedInSubpackage providedByProviderClass,
        @Named("providerMethod") ProvidedInSubpackage providedByProviderMethod) {
    }

    // Allows subclasses to be created that don't know about hidden parts (see
    // PackagePrivateTest.CrossPackageExtender).
    protected PublicImplementation() {
    }

    // Verify that method injection compiles with package-private methods.
    @Inject
    void setHiddenDependency(HiddenDependency hiddenDependency) {
    }

    // Verify that field injection compiles with package-private fields.
    @Inject
    HiddenDependency hiddenDependency;

    // Verify that we can inject a static, package-private value.
    @Inject
    static HiddenDependency staticHiddenDependency;
  }

  static class PrivateImplementation implements PublicInterface {
  }

  static class HiddenSingleton {
    @Inject
    HiddenSingleton(HiddenDependency hiddenDependency) {
    }
  }

  // Verify that the hidden classes can inject hidden dependencies.
  static class HiddenDependency {
  }

  static class HiddenProvider implements Provider<PublicProvidedClass> {
    @Override
    public PublicProvidedClass get() {
      return new PublicProvidedClass();
    }
  }

  // Verify that hidden classes can be created with assisted injection.
  static class HiddenAssisted {
    @Inject
    HiddenAssisted(HiddenDependency dep, @Assisted HiddenDependency assisted) {
    }

    interface Factory {
      HiddenAssisted create(HiddenDependency assisted);
    }
  }

  // Verify that hidden classes with public interfaces and hidden dependencies
  // can be created with assisted injection.

  static class PublicAssistedImplementation implements PublicAssisted {
    @Inject
    PublicAssistedImplementation(HiddenDependency dep, @Assisted long value) {
    }
  }

  // Check that we can have a hidden synchronous RPC interface linking to a
  // public asynchronous RPC interface.
  @RemoteServiceRelativePath("subpackageRemoteService")
  interface PublicService extends RemoteService {
    String hello(String name);
  }

  public interface PublicServiceAsync {
    void hello(String name, AsyncCallback<String> callback);
  }
}