generate.gradle

//Sample tasks used by reactor.

//A complete RS commons coverage minus the lite core
def excludingCoreScope =  [						   'completablefuture',
													  'subscribeonother',
						   'blockingfuture', 'windowbatch',
						   'empty', 'just',
						   'blockingiterable', 'bufferboundaryandsize',
						   'windowbeginend', /*'windowboundaryandsize',*/
						   'lift', //Already managed by reactor-core
												 ]

//Common reactor helper references
def reactorCommon = ['api-single'           : 'reactor.core.publisher.Mono',
					 'api-single-operator'  : 'reactor.core.publisher.MonoSource',
					 'api-inner'            : '',
					 'test-type'            : false,
					 'extra-packages'       : 'reactor.core',
					 'header'               : '@since 3.0',
					 'SubscriptionHelper'   : 'Operators',
					 'BackpressureHelper'   : 'Operators',
					 'packageScope'         : true,
					 'test-coverage'         : true,
					 'FunctionHelper'       : 'FunctionUtils',
					 'DrainHelper'          : 'DrainUtils',
					 'ExceptionHelper'      : 'Exceptions',
					 'ObserveOn'            : 'PublishOn',
					 'UnsignalledExceptions': 'Exceptions',
					 'tabs'                 : 1,
					 'DirectProcessor'      : 'reactor.core.publisher.DirectProcessor',
					 'SerializedSubscriber': 'reactor.core.publisher.SerializedSubscriber',
					 'UnicastProcessor'     : 'UnicastProcessor']

//Reactor Core configuration
def reactorCore = ['api'                 : 'reactor.core.publisher.Flux',
				   'api-package'         : 'reactor.core.publisher',
				   'api-operator'        : 'FluxSource',
				   'SerializedSubscriber': false,
				   'exclude'             : excludingCoreScope ] + reactorCommon


def targets = [
        'reactor-core' : reactorCore
]

def defaultTarget = reactorCore

// ----------------------------------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------------------------
// Generation Script - Inlining Reactive Streams Commons
// ----------------------------------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------------------------

def defaultSingleAPI = ['empty',
						'just',
						'error',
						'single',
						'future',
						'ignoreelements',
						'callable',
						'completablefuture',
						'timer',
						'first',
						'aggregate',
						'next',
						'collect',
						'streamcollector',
						'reduce',
						'all',
						'any',
						'count',
						'elementat',
						'haselements',
						'reduce',

]

task generateTargetAPI(type: Sync) {
  description = 'Deploy Reactive Streams Commons source code to the target API, effectively generating source code in' +
		  ' target directory.'

  outputs.upToDateWhen { false }
  includeEmptyDirs = false

  def target = targets[project.hasProperty('library') ? library : defaultTarget] ?: defaultTarget


  def license = "\n/**\n * @see <a href=\"https://github.com/reactor/reactive-streams-commons\">https://github.com/reactor/reactive-streams-commons</a>\n * $target.header\n */"
  def apiBarrierClass = target['api-operator']
  def apiClass = target['api']
  def splitted = apiClass.split('\\.')
  def apiClassName = splitted[splitted.length - 1]

  from 'src/main/java/rsc/publisher'
  into "build/generated_api/${target['api-package'].replaceAll('\\.', '/')}"

  if (target.include) {
	include { details ->
	  !details.file.name
			  .startsWith('Publisher') || details.file.name
			  .replaceAll('Publisher', '')
			  .replaceAll(".java", '')
			  .toLowerCase() in target.include
	}
  }


  exclude { details ->
	def name = details.file.name
			.replaceAll('Publisher', '')
			.replaceAll(".java", '')
			.toLowerCase()

	details.file.name
			.contains('Publisher') && (name in target.exclude || name in defaultSingleAPI)
  }

  exclude 'Px.java'
  exclude 'ConnectablePublisher.java'

  if(target['api-operator']){
	exclude 'PublisherSource.java'
  }

  rename { String fileName ->

	if(target['ObserveOn'] && fileName.contains('ObserveOn')){
	  fileName =fileName.replace('ObserveOn', target['ObserveOn'])
	}

	fileName.replace('ConnectablePublisher.java', 'Connectable' +apiClassName+ '.java')
			.replace('ConnectablePublisher', 'Connectable' + apiClassName)
			.replace('Publisher', apiClassName)
  }

  filter { String line -> replaceLine(line, target, license, apiClassName, apiBarrierClass, apiClass)
  }
}

task generateTestCoverage(type: Sync) {
  description = 'Deploy Reactive Streams Commons source code to the target API, effectively generating source code in' +
		  ' target directory.'

  outputs.upToDateWhen { false }
  includeEmptyDirs = false

  def target = targets[project.hasProperty('library') ? library : defaultTarget] ?: defaultTarget


  def license = "\n/**\n * @see <a href=\"https://github.com/reactor/reactive-streams-commons\">Reactive-Streams-Commons</a>\n * $target.header\n */"
  def apiBarrierClass = target['api-operator']
  def apiClass = target['api']
  def splitted = apiClass.split('\\.')
  def apiClassName = splitted[splitted.length - 1]

  from 'src/test/java/rsc/publisher'
  into "build/generated_api/test/${target['api-package'].replaceAll('\\.', '/')}"

  if (target.include) {
	include { details ->
	  !details.file.name
			  .contains('Publisher') || details.file.name
			  .replaceAll('Publisher', '')
			  .replaceAll('Test', '')
			  .replaceAll(".java", '')
			  .toLowerCase() in target.include
	}
  }


  exclude { details ->
	def name = details.file.name
			.replaceAll('Publisher', '')
			.replaceAll(".java", '')
			.replaceAll('Test', '')
			.toLowerCase()

	details.file.name
			.contains('Publisher') && (name in target.exclude || name in defaultSingleAPI)
  }

  exclude 'Px.java'

  if(target['api-operator']){
	exclude 'PublisherSource.java'
  }

  rename { String fileName ->

	if(target['ObserveOn'] && fileName.contains('ObserveOn')){
	  fileName =fileName.replace('ObserveOn', target['ObserveOn'])
	}

	fileName.replace('ConnectablePublisher.java', 'Connectable' +apiClassName+ '.java')
			.replace('ConnectablePublisher', apiClassName)
			.replace('Publisher', apiClassName)
  }

  filter { String line -> replaceLine(line, target, license, apiClassName, apiBarrierClass, apiClass)
  }
}

task generateTargetSingleAPI(type: Copy) {
  description = 'Generate Single type artifacts for target integration'

  includeEmptyDirs = false

  def target = targets[project.hasProperty('library') ? library: defaultTarget] ?: defaultTarget

  def apiSingleClass = target['api-single']
  def apiSingleBarrierClass = target['api-single-operator']
  def splitted = apiSingleClass.split('\\.')
  def apiSingleClassName = splitted[splitted.length - 1]

  def license = "\n/**\n * @see <a href=\"https://github.com/reactor/reactive-streams-commons\">Reactive-Streams-Commons</a>\n * $target.header\n */"

  from 'src/main/java/rsc/publisher'
  into "build/generated_api/${target['api-package'].replaceAll('\\.', '/')}"

  include { details ->
	def name = details.file.name
			.replaceAll('Publisher', '')
			.replaceAll(".java", '')
			.toLowerCase()
	!details.file.name
			.contains('Publisher') || (( !target.include || name in target.include) && name in defaultSingleAPI)
  }


  exclude 'Px.java'

  exclude { details ->
	def name = details.file.name
			.replaceAll('Publisher', '')
			.replaceAll(".java", '')
			.toLowerCase()

	details.file.name
			.contains('Publisher') && (name in target.exclude)
  }

  rename { String fileName ->
	fileName.replace('ConnectablePublisher.java', 'Connectable' + apiSingleClassName + '.java')
			.replace('ConnectablePublisher', 'Connectable' + apiSingleClassName)
			.replace('Publisher', apiSingleClassName)
  }

  filter { line -> replaceLine(line, target, license, apiSingleClassName, apiSingleBarrierClass, apiSingleClass)
  }
}

task generateSingleTestCoverage(type: Copy) {
  description = 'Generate Single type artifacts for target integration'

  includeEmptyDirs = false

  def target = targets[project.hasProperty('library') ? library: defaultTarget] ?: defaultTarget

  def apiSingleClass = target['api-single']
  def apiSingleBarrierClass = target['api-single-operator']
  def splitted = apiSingleClass.split('\\.')
  def apiSingleClassName = splitted[splitted.length - 1]

  def license = "\n/**\n * @see <a href=\"https://github.com/reactor/reactive-streams-commons\">Reactive-Streams-Commons</a>\n * $target.header\n */"

  from 'src/test/java/rsc/publisher'
  into "build/generated_api/test/${target['api-package'].replaceAll('\\.', '/')}"

  include { details ->
	def name = details.file.name
			.replaceAll('Publisher', '')
			.replaceAll(".java", '')
			.replaceAll("Test", '')
			.toLowerCase()

	!details.file.name
			.contains('Publisher') || (( !target.include || name in target.include) && name in defaultSingleAPI)
  }


  exclude { details ->
	def name = details.file.name
			.replaceAll('Publisher', '')
			.replaceAll(".java", '')
			.replaceAll("Test", '')
			.toLowerCase()

	details.file.name
			.contains('Publisher') && (name in target.exclude)
  }

  rename { String fileName ->
	fileName.replace('ConnectablePublisher.java', 'Connectable' + apiSingleClassName + '.java')
			.replace('ConnectablePublisher', apiSingleClassName)
			.replace('Publisher', apiSingleClassName)
  }

  filter { line -> replaceLine(line, target, license, apiSingleClassName, apiSingleBarrierClass, apiSingleClass)
  }
}

task generateExtra(type: Copy) {
  description = 'Generate extra package (subscriber, subscription, processor, util) for target integration'

  def target = targets[project.hasProperty('library') ? library : defaultTarget] ?: defaultTarget
  includeEmptyDirs = false

  def license = "\n/**\n * @see <a href=\"https://github.com/reactor/reactive-streams-commons\">Reactive-Streams-Commons</a>\n * $target.header\n */"
  def apiBarrierClass = target['api-operator']
  def apiClass = target['api']
  def splitted = apiClass.split('\\.')
  def apiClassName = splitted[splitted.length - 1]

  from 'src/main/java/rsc'
  into "build/generated_api/${target['extra-packages']?.replaceAll('\\.', '/')}"

  exclude '**/publisher/**'

  if (target.containsKey('test-type') && !target['test-type']) {
	exclude '**/subscriber/test/**'
  }

  if (target.containsKey('SerializedSubscriber') && !target['SerializedSubscriber']) {
	exclude '**/subscriber/SerializedSubscriber.java'
  }

  if (target.UnicastProcessor) {
	exclude '**/UnicastProcessor.java'
  }

  if (target.SubscriptionHelper) {
	exclude '**/SubscriptionHelper.java'
  }

  if (target.DrainHelper) {
	exclude '**/DrainHelper.java'
  }

  if (target.FunctionHelper) {
	exclude '**/FunctionHelper.java'
  }

  if (target.BackpressureHelper) {
	exclude '**/BackpressureHelper.java'
  }

  if (target.UnsignalledExceptions) {
	exclude '**/UnsignalledExceptions.java'
  }

  if (target.ExceptionHelper) {
	exclude '**/ExceptionHelper.java'
  }

  filter { line -> replaceLine(line, target, license, apiClassName, apiBarrierClass, apiClass)
  }
}

private replaceLine(line, target, license, apiClassName, apiBarrierClass, apiClass) {
  if (line.trim().startsWith('package')) {
	if (target['extra-packages'] && !line.contains("publisher")) {
	  return line.replace('rsc', target['extra-packages'])
	}
	else if (target['api-package']) {
	  return line.replace('rsc.publisher', target['api-package'])
	}
	else {
	  return line
	}
  }

  def l = line
  if(target['ObserveOn']) {
	l = l.replaceAll('ObserveOn', target['ObserveOn'])
  }

  if (l.trim().startsWith('import')) {
	if(l.contains("org.reactivestreams")){
	  return l
	}
	if (target.DirectProcessor) {
	  l = l.replace("rsc.processor.DirectProcessor", target.DirectProcessor)
	}
	if (target.UnicastProcessor) {
	  l = l.replace("rsc.processor.UnicastProcessor", target.UnicastProcessor)
	}

	if (target['fn-backport']) {
	  l = l.replace('java.util.function', target['fn-backport'])
	}

	if (target['api-package']) {
	  l = l.replace('rsc.publisher', target['api-package'])
	}

	if (target['SerializedSubscriber']) {
	  l = l.replace('rsc.subscriber.SerializedSubscriber', target['SerializedSubscriber'])
	}

	if (target['extra-packages']) {
	  l = l.replace('rsc', target['extra-packages'])
	}

	if (l.contains('BackpressureHelper') && target['BackpressureHelper']) {
	  l = l.replace('BackpressureHelper', target['BackpressureHelper'])
	}
	else if (l.contains('SubscriptionHelper') && target['SubscriptionHelper']) {
	  l = l.replace('SubscriptionHelper', target['SubscriptionHelper'])
	}
	else if (l.contains('UnsignalledExceptions') && target['UnsignalledExceptions']) {
	  l = l.replace('UnsignalledExceptions', target['UnsignalledExceptions'])
	}
	else if (l.contains('ExceptionHelper') && target['ExceptionHelper']) {
	  l = l.replace('ExceptionHelper', target['ExceptionHelper'])
	}
	else if (l.contains('DrainHelper') && target['DrainHelper']) {
	  return null
	}

	l = l.replaceFirst('Publisher', apiClassName)
	l = l.replaceAll('Publisher([^ ]*)Subscriber', target['api-inner']+'$1Subscriber') //naive double reference
	// workaround

	return l;
  }

  if(target['tabs']){
	l = l.replaceAll(' '*4, '\t' * target['tabs'])
  }

  if (target.containsKey('api-inner')) {
	l = l.replaceAll('Publisher([^ ]*)Main', target['api-inner']+'$1Main')
	l = l.replaceAll('Publisher([^ ]*)Main', target['api-inner']+'$1Main') //naive double reference workaround
	l = l.replaceAll('Publisher([^ ]*)Coordinator', target['api-inner']+'$1Coordinator')
	l = l.replaceAll('Publisher([^ ]*)Coordinator', target['api-inner']+'$1Coordinator')
	l = l.replaceAll('Publisher([^ ]*)Other', target['api-inner']+'$1Other')
	l = l.replaceAll('Publisher([^ ]*)Other', target['api-inner']+'$1Other')
	l = l.replaceAll('Publisher([^ ]*)Inner', target['api-inner']+'$1Inner')
	l = l.replaceAll('Publisher([^ ]*)Inner', target['api-inner']+'$1Inner')
	l = l.replaceAll('Publisher([^ ]*)OnClassic', target['api-inner']+'$1OnClassic')
	l = l.replaceAll('Publisher([^ ]*)OnClassic', target['api-inner']+'$1OnClassic')
	l = l.replaceAll('Publisher([^ ]*)EagerDirect', target['api-inner']+'$1EagerDirect')
	l = l.replaceAll('Publisher([^ ]*)EagerDirect', target['api-inner']+'$1EagerDirect')
	l = l.replaceAll('Publisher([^ ]*)NonEager', target['api-inner']+'$1NonEager')
	l = l.replaceAll('Publisher([^ ]*)NonEager', target['api-inner']+'$1NonEager')
	l = l.replaceAll('Publisher([^ ]*)Subscriber', target['api-inner']+'$1Subscriber')
	l = l.replaceAll('Publisher([^ ]*)Subscriber', target['api-inner']+'$1Subscriber')
  }

  if(l.startsWith("@")){
	return null
  }

  l = l
		  .replace("PublisherSource", apiBarrierClass)
		  .replace("Px", apiClass)
		  .replace("extends ConnectablePublisher", 'extends Connectable'+apiClassName)
		  .replaceAll("implements Publisher([^,]*),", "extends $apiClass\$1 implements")
		  .replace("implements Publisher", "extends $apiClass")
		  .replace('public final class Publisher', "$license\n${target.packageScope ? '' : 'public '}final class " + "$apiClassName")
		  .replace('public abstract class ConnectablePublisher', "$license\npublic abstract class " +
		  "Connectable$apiClassName")
		  .replace('public final class ConnectablePublisher', "$license\n${target.packageScope ? '' : 'public '}final" +
		  " class " +
		  "$apiClassName")

  //Special case for just/empty
  if (l.contains('implements Supplier<T>, Publisher<T>')) {
	return l.replace(', Publisher<T>', '').replace('Just<T>', "Just<T> extends $apiClass<T>")
  }

  l = l.replaceAll('ConnectablePublisher', "$apiClassName")
  l = l.replaceAll('GroupedPublisher', "Grouped$apiClassName")
  l = l.replaceAll('Publisher([A-Z][^A-Z]*)', "$apiClassName\$1")

  if (l.contains('SerializedSubscriber') && target['SerializedSubscriber']) {
	l = l.replace('SerializedSubscriber', target['SerializedSubscriber'])
  }

  if (l.contains('BackpressureHelper') && target['BackpressureHelper']) {
	l = l.replace('BackpressureHelper', target['BackpressureHelper'])
  }
  else if (l.contains('SubscriptionHelper') && target['SubscriptionHelper']) {
	l = l.replace('SubscriptionHelper', target['SubscriptionHelper'])
  }
  else if (l.contains('ExceptionHelper') && target['ExceptionHelper']) {
	l = l.replace('ExceptionHelper', target['ExceptionHelper'])
  }
  else if (l.contains('UnsignalledExceptions') && target['UnsignalledExceptions']) {
	l = l.replace('UnsignalledExceptions', target['UnsignalledExceptions'])
  }
  else if (l.contains('DrainHelper') && target['DrainHelper']) {
	l = l.replace('DrainHelper', target['DrainHelper'])
  }

  if (target.SimpleProcessor) {
	l = l.replace('new DirectProcessor<>', target.SimpleProcessor+'.create')
	l = l.replace('DirectProcessor', target.SimpleProcessor)
  }

  if (target.UnicastProcessor) {
	l = l.replace('UnicastProcessor', target.UnicastProcessor)
  }

  return l.replace("extends ConnectablePublisher", "extends Connectable$apiClassName")
}



task inlineCommons {
  description = 'Generate all necessary artifacts for target integration'

  delete "build/generated_api"

  dependsOn generateTargetAPI


  def target = targets[project.hasProperty('library') ? library: defaultTarget] ?: defaultTarget
  if (target['extra-packages']) {
	dependsOn generateExtra
  }

  if (target['api-single']) {
	dependsOn generateTargetSingleAPI
  }
  if (target['test-coverage']) {
	dependsOn generateTestCoverage
	dependsOn generateSingleTestCoverage
  }
}