scalaxb.compiler.wsdl11.GenSource.scala Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of scalaxb_2.13 Show documentation
Show all versions of scalaxb_2.13 Show documentation
scalaxb is an XML data-binding tool for Scala that supports W3C XML Schema (xsd) and wsdl.
The newest version!
/*
* Copyright (c) 2011 e.e d3si9n
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package scalaxb.compiler.wsdl11
import scalaxb.compiler.ConfigEntry.HttpClientStyle
trait GenSource {
import masked.scalaxb.DataRecord
import wsdl11._
import scalaxb.compiler.{Config, Log, Module, ReferenceNotFound, ScalaNames, Snippet}
import Module.{NL, camelCase}
import scala.xml.Node
import scalaxb.compiler.xsd.{AnyType, BuiltInSimpleTypeSymbol, Cardinality, ComplexTypeDecl, Multiple, Optional, ReferenceTypeSymbol, SimpleTypeDecl, Single, XsTypeSymbol}
val WSDL_SOAP11 = "http://schemas.xmlsoap.org/wsdl/soap/"
val WSDL_SOAP12 = "http://schemas.xmlsoap.org/wsdl/soap12/"
val WSDL_HTTP = "http://schemas.xmlsoap.org/wsdl/http"
val SOAP_MEP_REQUEST_RESPONSE = "http://www.w3.org/2003/05/soap/mep/request-response"
val SOAP_MEP_SOAP_RESPONSE = "http://www.w3.org/2003/05/soap/mep/soap-response"
val encodedErrorMessage = "rpc/encoded wsdls are not supported in scalaxb"
private val logger = Log.forName("wsdl.GenSource")
def config: Config
def context: WsdlContext
def scope: scala.xml.NamespaceBinding
def schemas = context.xsdcontext.schemas.toList
def xsdgenerator: scalaxb.compiler.xsd.GenSource
lazy val targetNamespace: Option[String] = xsdgenerator.schema.targetNamespace
lazy val pkg = xsdgenerator.packageName(targetNamespace, xsdgenerator.context)
lazy val scalaNames: ScalaNames = new ScalaNames {}
sealed trait SoapBindingStyle {}
case object DocumentStyle extends SoapBindingStyle
case object RpcStyle extends SoapBindingStyle
// this is the top-level entry point for wsdl code generation.
def generate(definition: XDefinitionsType, bindings: Seq[XBindingType]): Snippet = {
logger.debug("generate")
Snippet(
(soap11Bindings(bindings) map {makeSoap11Binding}) ++
(soap12Bindings(bindings) map {makeSoap12Binding}): _*)
}
def soap12Bindings(bindings: Seq[XBindingType]) =
bindings filter { binding =>
binding.any exists {
case DataRecord(_, _, node: Node) => node.scope.getURI((node.prefix)) == WSDL_SOAP12
case _ => false
}
}
def soap11Bindings(bindings: Seq[XBindingType]) =
if (!soap12Bindings(bindings).isEmpty) Nil
else bindings filter { binding =>
binding.any exists {
case DataRecord(_, _, node: Node) => node.scope.getURI((node.prefix)) == WSDL_SOAP11
case _ => false
}
}
// called by generate.
def makeSoap11Binding(binding: XBindingType): Snippet = {
val name = makeBindingName(binding)
val taglessTypeConstraint = if(config.httpClientStyle == HttpClientStyle.Tagless) "[F[_]]" else ""
val taglessTypeParam = if(config.httpClientStyle == HttpClientStyle.Tagless) "[F]" else ""
logger.debug("makeSoap11Binding: " + name)
val interfaceType = context.interfaces(splitTypeName(binding.typeValue))
val interfaceTypeName = interfaceType.name.capitalize
val interfaceTypeFQN = xsdgenerator.buildFullyQualifiedNameFromPackage(pkg, interfaceTypeName)
val port = findPort(binding).headOption
val address = port flatMap {_.any flatMap {
case DataRecord(_, _, node: Node) if node.scope.getURI((node.prefix)) == WSDL_SOAP11 =>
Some((node \ "@location").text)
case _ => None
}}
val soapBindingStyle = parseSoapBindingStyle(binding.any.headOption, DocumentStyle)
val addressString = address map {"""def baseAddress = new java.net.URI("%s")""".format(_)} getOrElse {""}
val operationOutputs = binding.operation flatMap { makeOperationOutput(_, interfaceType, soapBindingStyle, false) }
val operations = binding.operation map { opBinding => makeOperation(opBinding, interfaceType, soapBindingStyle, false) }
val bindingOps = binding.operation map { opBinding => makeSoapOpBinding(opBinding, interfaceType, soapBindingStyle, false) }
val importsString = config.httpClientStyle match {
case HttpClientStyle.Sync => ""
case HttpClientStyle.Future => "import scala.concurrent.{ Future, ExecutionContext }" + NL
case HttpClientStyle.Tagless => "import cats._, cats.implicits._" + NL
}
val selfType = config.httpClientStyle match {
case HttpClientStyle.Sync => "scalaxb.Soap11Clients with scalaxb.HttpClients"
case HttpClientStyle.Future => "scalaxb.Soap11ClientsAsync with scalaxb.HttpClientsAsync"
case HttpClientStyle.Tagless => "scalaxb.Soap11ClientsF[F] with scalaxb.HttpClientsF[F]"
}
val mapK: String = if(config.mapK && config.taglessClient) {
val mapkOperations: Seq[String] = binding.operation map { opBinding =>
makeMapKOperation(opBinding, interfaceType, soapBindingStyle, false)
}
s"def mapK[G[_]](fk: F ~> G): ${interfaceTypeName}[G] = new ${interfaceTypeName}[G] {" + NL + " " +
{mapkOperations.mkString(NL + " ")} +
"}"
} else ""
val interfaceTrait =
{importsString}
trait {interfaceTypeName}{taglessTypeConstraint} {{ self =>
{operations.mkString(NL + " ")}
{mapK}
}}
{operationOutputs.mkString(NL + NL)}
val bindingTrait =
trait {name}s{taglessTypeConstraint} {{ this: {selfType} =>
{if(config.httpClientStyle == HttpClientStyle.Tagless) "implicit protected def F: ApplicativeError[F, Throwable]" else ""}
lazy val targetNamespace: Option[String] = { xsdgenerator.quote(targetNamespace) }
lazy val service: {interfaceTypeFQN}{taglessTypeParam} = new {name} {{}}
{addressString}
trait {name} extends {interfaceTypeFQN}{taglessTypeParam} {{
import scalaxb.ElemName._
{bindingOps.mkString(NL + " ")}
}}
}}
Snippet(interfaceTrait,
{importsString}
trait {interfaceTypeName}{taglessTypeConstraint} {{ self =>
{operations.mkString(NL + " ")}
{mapK}
}}
{operationOutputs.mkString(NL + NL)}
val bindingTrait =
trait {name}s{taglessTypeConstraint} {{ this: {selfType} =>
{if(config.httpClientStyle == HttpClientStyle.Tagless) "implicit protected def F: ApplicativeError[F, Throwable]" else ""}
lazy val targetNamespace: Option[String] = { xsdgenerator.quote(targetNamespace) }
lazy val service: {interfaceTypeFQN}{taglessTypeParam} = new {name} {{}}
{addressString}
trait {name} extends {interfaceTypeFQN}{taglessTypeParam} {{
import scalaxb.ElemName._
{bindingOps.mkString(NL + " ")}
}}
}}
Snippet(interfaceTrait,
// 5
// 5.0
//
case (DocumentStyle, Some(elementQName)) =>
val elem = xsdgenerator.elements(splitTypeName(elementQName))
"""({
scala.xml.Elem(null, "Body", scala.xml.Null, defaultScope, true, body.toSeq: _*)
} \ "%s").head""".format(elem.name)
case (DocumentStyle, None) =>
"""body.head"""
case (RpcStyle, Some(elementQName)) =>
val elem = xsdgenerator.elements(splitTypeName(elementQName))
"""(body.head \ "%s").head""".format(elem.name)
case (RpcStyle, None) =>
"""(body.head \ "%s").head""".format(p.name.get)
}
buildPartArg(p, v) + (soapBindingStyle match {
case DocumentStyle =>
singleOutputType(output, soapBindingStyle) map { elem =>
val param = xsdgenerator.buildParam(elem)
"." + param.toParamName
} getOrElse {""}
case _ => ""
})
}) ++ (headerParts map { p =>
val v =
if (p.element.isDefined) """({header} \ "%s").head""".format(p.element.get.getLocalPart)
else """({header} \ "%s").head""".format(p.name.get)
buildPartArg(p, v)
})
if (!multipart) fromXmls.head
else s"${xsdgenerator.buildFullyQualifiedNameFromPackage(pkg, makeOperationOutputWrapperName(op))}(${fromXmls.mkString("," + NL + " ")})"
}
}
def buildPartArg(part: XPartType, selector: String): String =
(part.typeValue, part.element) match {
case (Some(typeValueQName), _) =>
val typeSymbol = toTypeSymbol(typeValueQName)
xsdgenerator.buildArg(xsdgenerator.buildTypeName(typeSymbol), selector, Single, None)
case (_, Some(elementQName)) =>
val elem = xsdgenerator.elements(splitTypeName(elementQName))
xsdgenerator.buildArg(elem, selector, None, false)
case _ => sys.error("part does not have either type or element: " + part.toString)
}
def paramMessage(input: XParamType): XMessageType = context.messages(splitTypeName(input.message))
def escapeKeyWord(name: String) = if(scalaNames.isKeyword(name)) s"`$name`" else name
case class ParamCache(paramName: String, typeSymbol: XsTypeSymbol, cardinality: Cardinality, nillable: Boolean, seqParam: Boolean) {
def singleTypeName: String =
if (nillable) "Option[" + baseTypeName + "]"
else baseTypeName
def typeName: String =
cardinality match {
case Single => singleTypeName
case Optional => "Option[" + singleTypeName + "]"
case Multiple => if (config.useLists) "List[" + singleTypeName + "]" else "Seq[" + singleTypeName + "]"
}
def baseTypeName: String = xsdgenerator.buildTypeName(typeSymbol)
def toParamName: String = escapeKeyWord(paramName)
def toScalaCode: String = s"${toParamName}: ${typeName}"
def toVarg: String =
if (seqParam) toParamName + ": _*"
else toParamName
}
def buildRPCStyleArg(part: XPartType): ParamCache = toParamCache(part)
def buildRPCStyleArgs(input: XParamType): List[ParamCache] = paramMessage(input).part.toList map {buildRPCStyleArg}
def buildIRIStyleArgs(input: XParamType): List[ParamCache] = paramMessage(input).part.headOption map { part =>
val paramName = part.name getOrElse {"in"}
val pc = toParamCache(part)
pc.typeSymbol match {
case symbol: BuiltInSimpleTypeSymbol =>
List(pc)
case symbol@ReferenceTypeSymbol(decl: SimpleTypeDecl) =>
List(pc)
case ReferenceTypeSymbol(decl: ComplexTypeDecl) =>
import scalaxb.compiler.xsd.{AllDecl, CompContExtensionDecl, CompContRestrictionDecl, ComplexContentDecl, Multiple}
val flatParticles = xsdgenerator.flattenElements(decl)
val attributes = xsdgenerator.flattenAttributes(decl)
val list = List.concat(flatParticles, attributes)
val primary = decl.content match {
case ComplexContentDecl(CompContRestrictionDecl(_, x, _)) => x
case ComplexContentDecl(CompContExtensionDecl(_, x, _)) => x
case _ => None
}
val longAll: Boolean = primary match {
case Some(all: AllDecl) if xsdgenerator.isLongAll(all, decl.namespace, decl.family) => true
case _ => false
}
list map { x =>
val param = xsdgenerator.buildParam(x) map {camelCase}
val seqParam = (list.size == 1) && (param.cardinality == Multiple) &
(attributes.size == 0) && (!decl.mixed) && (!longAll)
ParamCache(param.toParamName, param.typeSymbol, param.cardinality, param.nillable, seqParam)
}
case AnyType(symbol) =>
List(pc)
case x => sys.error("unexpected type: " + x)
}
} getOrElse {sys.error("unexpected input: " + input)}
def buildPartsArg(input: XParamType): String = (paramMessage(input).part map { part =>
s"${part.name getOrElse {"in"}}: ${toParamCache(part).typeName}"
}).mkString(", ")
def toParamCache(part: XPartType): ParamCache =
part.typeValue map { typeValue =>
val name = camelCase(part.name getOrElse "in")
ParamCache(name, toTypeSymbol(typeValue), Single, false, false)
} getOrElse {
part.element map { element =>
val param = xsdgenerator.buildParam(xsdgenerator.elements(splitTypeName(element))) map {camelCase}
ParamCache(param.toParamName, param.typeSymbol, param.cardinality, param.nillable, false)
} getOrElse {sys.error("part does not have either type or element: " + part.toString)}
}
def toTypeSymbol(qname: javax.xml.namespace.QName): XsTypeSymbol = {
import scalaxb.compiler.xsd.{ReferenceTypeSymbol, TypeSymbolParser}
val symbol = TypeSymbolParser.fromQName(qname)
symbol match {
case symbol: ReferenceTypeSymbol =>
val (namespace, typeName) = splitTypeName(qname)
symbol.decl = xsdgenerator.getTypeGlobally(namespace, typeName, context.xsdcontext)
case _ =>
}
symbol
}
def toElement(part: XPartType) = part.element map { element =>
xsdgenerator.elements(splitTypeName(element))
} getOrElse {sys.error("part does not have an element: " + part.toString)}
def singleOutputPart(output: XParamType): Option[XPartType] =
paramMessage(output).part.headOption
def singleOutputType(output: XParamType, soapBindingStyle: SoapBindingStyle): Option[scalaxb.compiler.xsd.ElemDecl] =
soapBindingStyle match {
case DocumentStyle =>
paramMessage(output).part.headOption map { part =>
import scalaxb.compiler.xsd.{ComplexTypeDecl, ReferenceTypeSymbol, Single}
toParamCache(part).typeSymbol match {
case ReferenceTypeSymbol(decl: ComplexTypeDecl) =>
val flatParticles = xsdgenerator.flattenElements(decl)
val attributes = xsdgenerator.flattenAttributes(decl)
if (decl.mixed) None
else if (flatParticles.size == 1 && attributes.size == 0) {
val head = flatParticles.head
if (xsdgenerator.buildParam(head).cardinality == Single) Some(head)
else None
}
else None
case x => None
}
} getOrElse {None}
case RpcStyle => None
}
def faultsToTypeName(faults: Seq[XFaultType], soap12: Boolean): String =
s"${if (soap12) "scalaxb.Fault" else "scalaxb.Soap11Fault"}[${faultsToFaultParamTypeName(faults) match {
case (x, true) => s"""Option[$x]"""
case (x, _) => x
}}]"
// param type and nillable
def faultParamTypeName(fault: XFaultType): (String, Boolean) = {
val msg = context.messages(splitTypeName(fault.message))
msg.part.headOption map { part =>
val pc = toParamCache(part)
(pc.baseTypeName, pc.nillable)
} getOrElse ("Any", false)
}
def faultsToFaultParamTypeName(faults: Seq[XFaultType]): (String, Boolean) = faults.toList match {
case x :: _ => faultParamTypeName(x)
case _ => ("Any", false)
}
def makeBindingName(binding: XBindingType): String = {
val name = xsdgenerator.makeTypeName(binding.name)
if (name.endsWith("Binding")) name
else name + "Binding"
}
def findPort(binding: XBindingType) =
for {
service <- context.services.valuesIterator.toList
port <- service.port if binding == context.bindings(splitTypeName(port.binding))
} yield port
def elements(namespace: Option[String], name: String) =
(for (schema <- schemas;
if schema.targetNamespace == namespace;
if schema.topElems.contains(name))
yield schema.topElems(name)) match {
case x :: xs => x
case Nil => throw new ReferenceNotFound("element" , namespace, name)
}
def splitTypeName(qname: javax.xml.namespace.QName) = (Option[String](qname.getNamespaceURI), qname.getLocalPart)
implicit def boolToOption(b: Boolean): Option[Unit] = if (b) Some(()) else None
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy