build.gradle

version = '0.2.0'

buildscript {
	repositories {
		ivy { url '../repository' }
		ivy { url 'http://unity-technologies.github.com/kaizen/repositories/unstable' }
		mavenCentral()
	}
	dependencies {
		classpath 'kaizen:kaizen:0.3.2'
	}
}

allprojects {
	apply plugin: 'vs2010'
}

/*
project(':CodeEditor.Text.UI.Unity.Editor') {
	vs {
		project {
			postBuildEvent {
				task ':updateUnityProject'
			}
		}
	}
}
*/

vs {
	solutions {
		def frameworkProjects = [
			':CodeEditor.Collections',
			':CodeEditor.Composition',
			':CodeEditor.ContentTypes',
			':CodeEditor.IO',
			':CodeEditor.IO.Unity.Editor',
			':CodeEditor.Testing',
			':CodeEditor.ServiceClient',
			':CodeEditor.ServiceHost',
			':CodeEditor.Reactive',
			':CodeEditor.Logging',
		]

		def remaining = subprojects
		def categorize = { condition ->
			def result = remaining.findAll(condition)
			remaining = remaining.minus(result)
			result
		}

		def framework = categorize { p -> frameworkProjects.any({ p.path.startsWith(it) }) }
		def monitoring = categorize { it.name.contains('Monitoring') }
		def navigateTo = categorize { it.name.contains('NavigateTo') }
		def language = categorize { it.name.contains('Languages') }

		CodeEditor {
			folder('Frameworks') { f ->
				framework.each {
					f.project(it.path)
				}
			}
			folder('Features') { features ->
				features.folder('NavigateTo') { f ->
					navigateTo.each {
						f.project(it.path)
					}
				}
				features.folder('Monitoring') { f ->
					monitoring.each {
						f.project(it.path)
					}
				}
			}
			folder('Languages') { f ->
				language.each {
					f.project(it.path)
				}
			}
			remaining.each {
				project(it.path)
			}
		}
	}
}

allprojects {
	repositories {
		ivy { url 'http://unity-technologies.github.com/kaizen/repositories/unstable' }
	}
	apply plugin: 'nuget'
}

configurations {
	editor {
		description "Configuration for editor extension artifacts."
	}
	tests {
		description "Configuration for testing artifacts."
	}
	serviceHost {
		description "Configuration for service artifacts."
	}
}

apply plugin: 'assembly-bundle'
apply plugin: 'project-refactorings'
apply plugin: 'nunit'
apply plugin: 'idea'

def rxDependency(rxPackage, rxAssembly, rxConfiguration) {
	['group': rxPackage, 'name': rxAssembly, 'version': '1.0.2856.0', 'configuration': rxConfiguration]
}

def serviceStack(assembly, pkg = 'ServiceStack') {
	['group': pkg, 'name': assembly, 'version':	'3.9.38', 'configuration': 'net35']
}

def unityAssembly(assembly) {
	['group': 'Unity', 'name': assembly, version: '4.0+', configuration: 'editor']
}

ext {
	rxCore = { assemblyName, configuration = 'Net35' -> rxDependency('Rx-Core-old', assemblyName, configuration) }
	rxMain = { assemblyName, configuration = 'Net35' -> rxDependency('Rx-Main', assemblyName, configuration) }
	references = [
		'nunitFramework': "nunit:nunit.framework:${nunit.version}",
		'moq': 'Moq:Moq:4.0+',
		'adt': 'boo-extensions:Boo.Adt:0.1.3+',
		'ometa': 'boo-extensions:Boo.OMeta:0.1.3+',
		'boo': { assembly -> "boo:$assembly:0.9.7+" },
		'unityEngine': unityAssembly('UnityEngine'),
		'unityEditor': [
			unityAssembly('UnityEngine'),
			unityAssembly('UnityEditor')
		],
		'frameworks': [
			project(':CodeEditor.IO'),
			project(':CodeEditor.Logging'),
			project(':CodeEditor.Composition'),
			project(':CodeEditor.Reactive')
		],
		'languagesCommon': [
			project(':CodeEditor.Composition'),
			project(':CodeEditor.ContentTypes'),
			project(':CodeEditor.Text.Data'),
			project(':CodeEditor.Text.Logic'),
			project(':CodeEditor.Text.UI'),
			project(':CodeEditor.Languages.Common')
		],
		'rx35': [
			rxMain('System.Reactive'),
			rxCore('System.Observable'),
			rxCore('System.CoreEx'),
			rxCore('System.Threading'),
		],
		'rx40': [
			rxMain('System.Reactive', 'Net4'),
			rxCore('System.CoreEx', 'Net4'),
		],
		'serviceStack': [
			serviceStack('ServiceStack'),
			serviceStack('ServiceStack.ServiceInterface'),
			serviceStack('ServiceStack.Common', 'ServiceStack.Common'),
			serviceStack('ServiceStack.Interfaces', 'ServiceStack.Common'),
			serviceStack('ServiceStack.Text', 'ServiceStack.Text')
		],
		'serviceStackInterfaces': [
			serviceStack('ServiceStack.Interfaces', 'ServiceStack.Common'),
		],
		'serviceStackClient': [
			serviceStack('ServiceStack.Interfaces', 'ServiceStack.Common'),
			serviceStack('ServiceStack.Text', 'ServiceStack.Text'),
			serviceStack('ServiceStack.Common', 'ServiceStack.Common')
		],
	]
}

def bundleDependency(configuration, subProject) {
	dependencies.add(configuration, dependencies.project(path: subProject.path))
}

subprojects { subProject ->
	switch (subProject.name) {
	case ~/.+\.Tests$/:
		apply plugin: 'nunit-assembly'
		def subjectPath = subProject.path[0..-('.Tests'.length() + 1)]
		dependencies {
			// Foo.Bar.Tests depends on Foo.Bar
			if (rootProject.findProject(subjectPath)) {
				'default' project(subjectPath)
			}
			'default' project(':CodeEditor.Testing')
			'default' rootProject.references.moq
		}
		bundleDependency('tests', subProject)
		break
	case ~/.+\.ServiceHost$/:
	case ~/.+\.Services($|\..+)/:
		bundleDependency('serviceHost', subProject)
		break
	case ~/.+\.(Testing|Fixtures)$/:
		break
	default:
		bundleDependency('editor', subProject)
	}
}

task publish {
	dependsOn uploadEditor
	project.configurations.editor.dependencies.each {
		dependsOn ":$it.name:uploadDefault" 
	}
}

class UpdateDir extends DefaultTask {

	def destinationDir

	def setDestinationDir(destinationDir) {
		this.destinationDir = project.file(destinationDir)
		outputs.dir this.destinationDir
	}

	@TaskAction
	def update() {
		logger.info("Updating $destinationDir")
		def destDir = destinationDir
		inputs.sourceFiles.each { f ->
			project.copy {
				from project.zipTree(f)
				into destDir
				include '*.dll'
				include '*.exe'
				exclude 'UnityE*'
			}
		}
	}
}

def unityProjectDir = project.properties.get('unityProjectDir', 'UnityProject')
def unityExecutable = project.hasProperty('unityExecutable') ? 
                      project.property ('unityExecutable') :
                      rootProject.extensions.unity.executable

task updateUnityProjectEditorConfig(type: UpdateDir) {
	description 'Builds and copies required assemblies to the configured Unity project (unityProjectDir)'
	inputs.source project.configurations.editor
	destinationDir = "$unityProjectDir/Assets/kaizen/lib/Editor"
}

task updateUnityProjectServiceHostConfig(type: UpdateDir) {
	description 'Builds and copies required assemblies to the configured Unity project (unityProjectDir)'
	inputs.source project.configurations.serviceHost
	destinationDir = "$unityProjectDir/Library/CodeEditor/ServiceHost"
}

task updateUnityProject {
	dependsOn updateUnityProjectEditorConfig
	dependsOn updateUnityProjectServiceHostConfig
}

task open {
	dependsOn updateUnityProject
	doFirst {
		project.exec {
			executable unityExecutable
			args '-projectPath'
			args file(unityProjectDir)
		}
	}
}