use of org.gradle.language.swift.SwiftStaticLibrary in project gradle by gradle.
the class DefaultSwiftLibrary method addStaticLibrary.
public SwiftStaticLibrary addStaticLibrary(String nameSuffix, boolean testable, SwiftPlatform targetPlatform, NativeToolChainInternal toolChain, PlatformToolProvider platformToolProvider, NativeVariantIdentity identity) {
SwiftStaticLibrary result = objectFactory.newInstance(DefaultSwiftStaticLibrary.class, getName() + StringUtils.capitalize(nameSuffix), getModule(), testable, getSwiftSource(), getImplementationDependencies(), targetPlatform, toolChain, platformToolProvider, identity);
getBinaries().add(result);
return result;
}
use of org.gradle.language.swift.SwiftStaticLibrary in project gradle by gradle.
the class SwiftLibraryPlugin method apply.
@Override
public void apply(final Project project) {
project.getPluginManager().apply(SwiftBasePlugin.class);
final ConfigurationContainer configurations = project.getConfigurations();
final ObjectFactory objectFactory = project.getObjects();
final DefaultSwiftLibrary library = componentFactory.newInstance(SwiftLibrary.class, DefaultSwiftLibrary.class, "main");
project.getExtensions().add(SwiftLibrary.class, "library", library);
project.getComponents().add(library);
// Setup component
final Property<String> module = library.getModule();
module.set(GUtil.toCamelCase(project.getName()));
project.afterEvaluate(new Action<Project>() {
@Override
public void execute(final Project project) {
// TODO: Implement os for Swift
// library.getOperatingSystems().lockNow();
// library.getOperatingSystems().get();
Set<OperatingSystemFamily> operatingSystemFamilies = Sets.newHashSet(objectFactory.named(OperatingSystemFamily.class, DefaultNativePlatform.getCurrentOperatingSystem().toFamilyName()));
if (operatingSystemFamilies.isEmpty()) {
throw new IllegalArgumentException("An operating system needs to be specified for the application.");
}
library.getLinkage().lockNow();
Set<Linkage> linkages = library.getLinkage().get();
if (linkages.isEmpty()) {
throw new IllegalArgumentException("A linkage needs to be specified for the library.");
}
Usage runtimeUsage = objectFactory.named(Usage.class, Usage.NATIVE_RUNTIME);
Usage linkUsage = objectFactory.named(Usage.class, Usage.NATIVE_LINK);
for (BuildType buildType : BuildType.DEFAULT_BUILD_TYPES) {
for (OperatingSystemFamily operatingSystem : operatingSystemFamilies) {
for (Linkage linkage : linkages) {
String operatingSystemSuffix = createDimensionSuffix(operatingSystem, operatingSystemFamilies);
String linkageSuffix = createDimensionSuffix(linkage, linkages);
String variantName = buildType.getName() + linkageSuffix + operatingSystemSuffix;
Provider<String> group = project.provider(new Callable<String>() {
@Override
public String call() throws Exception {
return project.getGroup().toString();
}
});
Provider<String> version = project.provider(new Callable<String>() {
@Override
public String call() throws Exception {
return project.getVersion().toString();
}
});
AttributeContainer runtimeAttributes = attributesFactory.mutable();
runtimeAttributes.attribute(Usage.USAGE_ATTRIBUTE, runtimeUsage);
runtimeAttributes.attribute(DEBUGGABLE_ATTRIBUTE, buildType.isDebuggable());
runtimeAttributes.attribute(OPTIMIZED_ATTRIBUTE, buildType.isOptimized());
runtimeAttributes.attribute(LINKAGE_ATTRIBUTE, linkage);
runtimeAttributes.attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, operatingSystem);
AttributeContainer linkAttributes = attributesFactory.mutable();
linkAttributes.attribute(Usage.USAGE_ATTRIBUTE, linkUsage);
linkAttributes.attribute(DEBUGGABLE_ATTRIBUTE, buildType.isDebuggable());
linkAttributes.attribute(OPTIMIZED_ATTRIBUTE, buildType.isOptimized());
linkAttributes.attribute(LINKAGE_ATTRIBUTE, linkage);
linkAttributes.attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, operatingSystem);
NativeVariantIdentity variantIdentity = new NativeVariantIdentity(variantName, library.getModule(), group, version, buildType.isDebuggable(), buildType.isOptimized(), operatingSystem, new DefaultUsageContext(variantName + "Link", linkUsage, linkAttributes), new DefaultUsageContext(variantName + "Runtime", runtimeUsage, runtimeAttributes));
if (DefaultNativePlatform.getCurrentOperatingSystem().toFamilyName().equals(operatingSystem.getName())) {
ToolChainSelector.Result<SwiftPlatform> result = toolChainSelector.select(SwiftPlatform.class);
if (linkage == Linkage.SHARED) {
SwiftSharedLibrary sharedLibrary = library.addSharedLibrary(variantName, buildType == BuildType.DEBUG, result.getTargetPlatform(), result.getToolChain(), result.getPlatformToolProvider(), variantIdentity);
// Use the debug shared library as the development binary
if (buildType == BuildType.DEBUG) {
library.getDevelopmentBinary().set(sharedLibrary);
}
} else {
SwiftStaticLibrary staticLibrary = library.addStaticLibrary(variantName, buildType == BuildType.DEBUG, result.getTargetPlatform(), result.getToolChain(), result.getPlatformToolProvider(), variantIdentity);
if (!linkages.contains(Linkage.SHARED) && buildType == BuildType.DEBUG) {
// Use the debug static library as the development binary
library.getDevelopmentBinary().set(staticLibrary);
}
}
}
}
}
}
library.getBinaries().whenElementKnown(SwiftSharedLibrary.class, new Action<SwiftSharedLibrary>() {
@Override
public void execute(SwiftSharedLibrary sharedLibrary) {
Names names = ((ComponentWithNames) sharedLibrary).getNames();
Configuration apiElements = configurations.create(names.withSuffix("SwiftApiElements"));
// TODO This should actually extend from the api dependencies, but since Swift currently
// requires all dependencies to be treated like api dependencies (with transitivity) we just
// use the implementation dependencies here. See https://bugs.swift.org/browse/SR-1393.
apiElements.extendsFrom(((DefaultSwiftSharedLibrary) sharedLibrary).getImplementationDependencies());
apiElements.setCanBeResolved(false);
apiElements.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, objectFactory.named(Usage.class, Usage.SWIFT_API));
apiElements.getAttributes().attribute(LINKAGE_ATTRIBUTE, Linkage.SHARED);
apiElements.getAttributes().attribute(DEBUGGABLE_ATTRIBUTE, sharedLibrary.isDebuggable());
apiElements.getAttributes().attribute(OPTIMIZED_ATTRIBUTE, sharedLibrary.isOptimized());
apiElements.getAttributes().attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, objectFactory.named(OperatingSystemFamily.class, ((OperatingSystemInternal) sharedLibrary.getTargetPlatform().getOperatingSystem()).toFamilyName()));
apiElements.getOutgoing().artifact(sharedLibrary.getModuleFile());
}
});
library.getBinaries().whenElementKnown(SwiftStaticLibrary.class, new Action<SwiftStaticLibrary>() {
@Override
public void execute(SwiftStaticLibrary staticLibrary) {
Names names = ((ComponentWithNames) staticLibrary).getNames();
Configuration apiElements = configurations.create(names.withSuffix("SwiftApiElements"));
// TODO This should actually extend from the api dependencies, but since Swift currently
// requires all dependencies to be treated like api dependencies (with transitivity) we just
// use the implementation dependencies here. See https://bugs.swift.org/browse/SR-1393.
apiElements.extendsFrom(((DefaultSwiftStaticLibrary) staticLibrary).getImplementationDependencies());
apiElements.setCanBeResolved(false);
apiElements.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, objectFactory.named(Usage.class, Usage.SWIFT_API));
apiElements.getAttributes().attribute(LINKAGE_ATTRIBUTE, Linkage.STATIC);
apiElements.getAttributes().attribute(DEBUGGABLE_ATTRIBUTE, staticLibrary.isDebuggable());
apiElements.getAttributes().attribute(OPTIMIZED_ATTRIBUTE, staticLibrary.isOptimized());
apiElements.getAttributes().attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, objectFactory.named(OperatingSystemFamily.class, ((OperatingSystemInternal) staticLibrary.getTargetPlatform().getOperatingSystem()).toFamilyName()));
apiElements.getOutgoing().artifact(staticLibrary.getModuleFile());
}
});
library.getBinaries().realizeNow();
}
});
}
use of org.gradle.language.swift.SwiftStaticLibrary in project gradle by gradle.
the class SwiftBasePlugin method apply.
@Override
public void apply(final ProjectInternal project) {
project.getPluginManager().apply(NativeBasePlugin.class);
project.getPluginManager().apply(SwiftCompilerPlugin.class);
final TaskContainerInternal tasks = project.getTasks();
final DirectoryProperty buildDirectory = project.getLayout().getBuildDirectory();
final ProviderFactory providers = project.getProviders();
project.getDependencies().getAttributesSchema().attribute(Usage.USAGE_ATTRIBUTE).getCompatibilityRules().add(SwiftCppUsageCompatibilityRule.class);
project.getComponents().withType(DefaultSwiftBinary.class, new Action<DefaultSwiftBinary>() {
@Override
public void execute(final DefaultSwiftBinary binary) {
final Names names = binary.getNames();
SwiftCompile compile = tasks.create(names.getCompileTaskName("swift"), SwiftCompile.class);
compile.getModules().from(binary.getCompileModules());
compile.getSource().from(binary.getSwiftSource());
compile.getDebuggable().set(binary.isDebuggable());
compile.getOptimized().set(binary.isOptimized());
if (binary.isTestable()) {
compile.getCompilerArgs().add("-enable-testing");
}
if (binary.getTargetPlatform().getOperatingSystem().isMacOsX()) {
compile.getCompilerArgs().add("-sdk");
compile.getCompilerArgs().add(locator.find().getAbsolutePath());
}
compile.getModuleName().set(binary.getModule());
compile.getObjectFileDir().set(buildDirectory.dir("obj/" + names.getDirName()));
compile.getModuleFile().set(buildDirectory.file(providers.provider(new Callable<String>() {
@Override
public String call() {
return "modules/" + names.getDirName() + binary.getModule().get() + ".swiftmodule";
}
})));
compile.getSourceCompatibility().set(binary.getSourceCompatibility());
binary.getModuleFile().set(compile.getModuleFile());
compile.getTargetPlatform().set(binary.getTargetPlatform());
// TODO - make this lazy
compile.getToolChain().set(binary.getToolChain());
binary.getCompileTask().set(compile);
binary.getObjectsDir().set(compile.getObjectFileDir());
}
});
project.getComponents().withType(SwiftSharedLibrary.class, new Action<SwiftSharedLibrary>() {
@Override
public void execute(SwiftSharedLibrary library) {
// Specific compiler arguments
library.getCompileTask().get().getCompilerArgs().add("-parse-as-library");
}
});
project.getComponents().withType(SwiftStaticLibrary.class, new Action<SwiftStaticLibrary>() {
@Override
public void execute(SwiftStaticLibrary library) {
// Specific compiler arguments
library.getCompileTask().get().getCompilerArgs().add("-parse-as-library");
}
});
project.getComponents().withType(DefaultSwiftComponent.class, new Action<DefaultSwiftComponent>() {
@Override
public void execute(final DefaultSwiftComponent component) {
project.afterEvaluate(new Action<Project>() {
@Override
public void execute(Project project) {
component.getSourceCompatibility().lockNow();
}
});
component.getBinaries().whenElementKnown(DefaultSwiftBinary.class, new Action<DefaultSwiftBinary>() {
@Override
public void execute(final DefaultSwiftBinary binary) {
Provider<SwiftVersion> swiftLanguageVersionProvider = project.provider(new Callable<SwiftVersion>() {
@Override
public SwiftVersion call() throws Exception {
SwiftVersion swiftSourceCompatibility = component.getSourceCompatibility().getOrNull();
if (swiftSourceCompatibility == null) {
return toSwiftVersion(binary.getPlatformToolProvider().getCompilerMetadata(ToolType.SWIFT_COMPILER).getVersion());
}
return swiftSourceCompatibility;
}
});
binary.getSourceCompatibility().set(swiftLanguageVersionProvider);
}
});
}
});
project.getComponents().withType(ProductionSwiftComponent.class, new Action<ProductionSwiftComponent>() {
@Override
public void execute(final ProductionSwiftComponent component) {
project.afterEvaluate(new Action<Project>() {
@Override
public void execute(Project project) {
DefaultSwiftComponent componentInternal = (DefaultSwiftComponent) component;
publicationRegistry.registerPublication(project.getPath(), new DefaultProjectPublication(componentInternal.getDisplayName(), new SwiftPmTarget(component.getModule().get()), false));
}
});
}
});
}
Aggregations