Merge and work on RefCount

Author: johnhmarks

CHANGES.md

@@ -1,5 +1,119 @@
 # RxJava Releases #
 
+### Version 0.12.2 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.12.2%22)) ###
+
+* [Pull 352](https://github.com/Netflix/RxJava/pull/352) Groovy Language Adaptor: Add Func5-9 and N to the wrapper
+
+### Version 0.12.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.12.1%22)) ###
+
+* [Pull 350](https://github.com/Netflix/RxJava/pull/350) Swing module enhancements
+* [Pull 351](https://github.com/Netflix/RxJava/pull/351) Fix Observable.window static/instance bug
+
+### Version 0.12.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.12.0%22)) ###
+
+This version adds to the static typing changes in 0.11 and adds covariant/contravariant typing via super/extends generics.
+
+Additional cleanup was done, particularly related to `BlockingObservable`. Also the `window` operator was added.
+
+The largest breaking change is that `Observable.create` now accepts an `OnSubscribeFunc` rather than a `Func1`.
+
+This means that instead of this:
+
+```java
+public static <T> Observable<T> create(Func1<? super Observer<? super T>, ? extends Subscription> func)
+```
+
+it is now:
+
+```java
+public static <T> Observable<T> create(OnSubscribeFunc<T> func)
+```
+
+This was done to simplify the usage of `Observable.create` which was already verbose but made far worse by the `? super` generics.
+
+For example, instead of writing this:
+
+```java
+Observable.create(new Func1<Observer<? super SomeType>, Subscription>() {
+   /// body here
+}
+```
+
+it is now written as:
+
+```java
+Observable.create(new OnSubscribeFunc<SomeType>() {
+   /// body here
+}
+```
+
+* [Pull 343](https://github.com/Netflix/RxJava/pull/343) Covariant Support with super/extends and `OnSubscribeFunc` as type for `Observable.create`
+* [Pull 337](https://github.com/Netflix/RxJava/pull/337) Operator: `window`
+* [Pull 348](https://github.com/Netflix/RxJava/pull/348) Rename `switchDo` to `switchOnNext` (deprecate `switchDo` for eventual deletion)
+* [Pull 348](https://github.com/Netflix/RxJava/pull/348) Delete `switchDo` instance method in preference for static
+* [Pull 346](https://github.com/Netflix/RxJava/pull/346) Remove duplicate static methods from `BlockingObservable` 
+* [Pull 346](https://github.com/Netflix/RxJava/pull/346) `BlockingObservable` no longer extends from `Observable`
+* [Pull 345](https://github.com/Netflix/RxJava/pull/345) Remove unnecessary constructor from `Observable`
+
+### Version 0.11.2 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.11.2%22)) ###
+
+* [Commit ccf53e8]( https://github.com/Netflix/RxJava/commit/ccf53e84835d99136cce80a4c508bae787d5da45) Update to Scala 2.10.2
+
+### Version 0.11.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.11.1%22)) ###
+
+* [Pull 325](https://github.com/Netflix/RxJava/pull/325) Clojure: Preserve metadata on fn and action macros
+
+### Version 0.11.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.11.0%22)) ###
+
+This is a major refactor of rxjava-core and the language adaptors. 
+
+Note that there are *breaking changes* in this release. Details are below.
+
+After this refactor it is expected that the API will settle down and allow us to stabilize towards a 1.0 release.
+
+* [Pull 332](https://github.com/Netflix/RxJava/pull/332) Refactor Core to be Statically Typed
+
+RxJava was written from the beginning to target the JVM, not any specific language.
+
+As a side-effect of Java not having lambdas/clojures yet (and other considerations), Netflix used dynamic languages with it predominantly for the year of its existence prior to open sourcing.
+
+To bridge the rxjava-core written in Java with the various languages a FunctionalLanguageAdaptor was registered at runtime for each language of interest.
+
+To enable these language adaptors methods are overloaded with `Object` in the API since `Object` is the only super-type that works across all languages for their various implementations of lambdas and closures.
+
+This downside of this has been that it breaks static typing for Java, Scala and other statically-typed languages. More can be read on this issue and discussion of the subject here: https://groups.google.com/forum/#!topic/rxjava/bVZoKSsb1-o
+
+This release:
+
+- removes all `Object` overload methods from rxjava-core so it is statically typed
+- removes dynamic FunctionalLanguageAdaptors 
+- uses idiomatic approaches for each language adaptor 
+  - Java core is statically typed and has no knowledge of other languages
+  - Scala uses implicits
+  - Groovy uses an ExtensionModule
+  - Clojure adds a new macro ([NOTE: this requires code changes](https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-clojure#basic-usage))
+  - JRuby has been temporarily disabled (discussing new implementation at https://github.com/Netflix/RxJava/issues/320)
+- language supports continue to be additive
+  - the rxjava-core will always be required and then whichever language modules are desired such as rxjava-scala, rxjava-clojure, rxjava-groovy are added to the classpath
+- deletes deprecated methods
+- deletes redundant static methods on `Observable` that cluttered the API and in some cases caused dynamic languages trouble choosing which method to invoke
+- deletes redundant methods on `Scheduler` that gave dynamic languages a hard time choosing which method to invoke
+
+The benefits of this are:
+
+1) Everything is statically typed so compile-time checks for Java, Scala, etc work correctly
+2) Method dispatch is now done via native Java bytecode using types rather than going via `Object` which then has to do a lookup in a map. Memoization helped with the performance but each method invocation still required looking in a map for the correct adaptor. With this approach the appropriate methods will be compiled into the `rx.Observable` class to correctly invoke the right adaptor without lookups. 
+3) Interaction from each language should work as expected idiomatically for that language.
+
+Further history on the various discussions and different attempts at solutions can be seen at https://github.com/Netflix/RxJava/pull/304, https://github.com/Netflix/RxJava/issues/204 and https://github.com/Netflix/RxJava/issues/208
+
+
+### Version 0.10.1 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.10.1%22)) ###
+
+A new contrib module for Android: https://github.com/Netflix/RxJava/tree/master/rxjava-contrib/rxjava-android
+
+* [Pull 318](https://github.com/Netflix/RxJava/pull/318) rxjava-android module with Android Schedulers
+
 ### Version 0.10.0 ([Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.netflix.rxjava%22%20AND%20v%3A%220.10.0%22)) ###
 
 This release includes a breaking change as it changes `onError(Exception)` to `onError(Throwable)`. This decision was made via discussion at https://github.com/Netflix/RxJava/issues/296.

README.md

@@ -9,10 +9,9 @@ Some of the goals of RxJava are:
 - Target the JVM not a language. The first languages supported (beyond Java itself) are 
 <a href="https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-groovy">Groovy</a>, 
 <a href="https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-clojure">Clojure</a>, 
-<a href="https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-scala">Scala</a> 
-and <a href="https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-jruby">JRuby</a>. 
+and <a href="https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-scala">Scala</a>. 
 New language adapters can be <a href="https://github.com/Netflix/RxJava/wiki/How-to-Contribute">contributed</a>.
-- Support Java 5 (to include Android support) and higher with an eventual goal to target a build for Java 8 with its lambda support.
+- Support Java 6+ (to include Android support) 
 
 Learn more about Rx on the <a href="https://github.com/Netflix/RxJava/wiki">Wiki Home</a> and the <a href="http://techblog.netflix.com/2013/02/rxjava-netflix-api.html">Netflix TechBlog post</a> where RxJava was introduced.
 
@@ -53,7 +52,6 @@ Once we hit 1.0 it will follow the normal major.minor.patch semantic versioning
 - <a href="https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-groovy">Groovy Adaptor</a> 
 - <a href="https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-clojure">Clojure Adaptor</a> 
 - <a href="https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-scala">Scala Adaptor</a> 
-- <a href="https://github.com/Netflix/RxJava/tree/master/language-adaptors/rxjava-jruby">JRuby Adaptor</a>   
 
 ## Binaries
 

build.gradle

@@ -1,28 +1,73 @@
-ext.githubProjectName = rootProject.name
+ext.githubProjectName = 'RxJava'
+
+apply from: file('gradle/convention.gradle')
+apply from: file('gradle/maven.gradle')
+//apply from: file('gradle/check.gradle')
+apply from: file('gradle/license.gradle')
+apply from: file('gradle/release.gradle')
 
 buildscript {
-    repositories { mavenCentral() }
+    repositories {
+        mavenLocal()
+        mavenCentral() // maven { url 'http://jcenter.bintray.com' }
+    }
     apply from: file('gradle/buildscript.gradle'), to: buildscript 
 }
 
 allprojects {
-    repositories { mavenCentral() }
+    repositories { 
+        mavenLocal()
+        mavenCentral() // maven { url: 'http://jcenter.bintray.com' }
+    }
 }
 
-apply from: file('gradle/convention.gradle')
-apply from: file('gradle/maven.gradle')
-//apply from: file('gradle/check.gradle')
-apply from: file('gradle/license.gradle')
-apply from: file('gradle/release.gradle')
-
 subprojects {
+    apply plugin: 'java'
+    apply plugin: 'eclipse'
+    apply plugin: 'idea'
 
-    group = "com.netflix.${githubProjectName}"
+    group = "com.netflix.rxjava"
+
+    // make 'examples' use the same classpath
+    configurations { 
+        examplesCompile.extendsFrom compile
+        examplesRuntime.extendsFrom runtime
+    }
 
     sourceSets.test.java.srcDir 'src/main/java'
 
     tasks.withType(Javadoc).each {
         it.classpath = sourceSets.main.compileClasspath
     }
+
+    //include /src/examples folder
+    sourceSets { 
+        examples
+    }
+    
+    //include 'examples' in build task
+    tasks.build { 
+        dependsOn(examplesClasses)
+    }
+    
+    eclipse {  
+        classpath {  
+            // include 'provided' dependencies on the classpath
+            plusConfigurations += configurations.provided
+            
+            downloadSources = true
+            downloadJavadoc = true
+        }
+    }
+    
+    idea {
+        module {
+            // include 'provided' dependencies on the classpath
+            scopes.PROVIDED.plus += configurations.provided
+        }
+    }
 }
 
+project(':rxjava-core') {
+    sourceSets.test.java.srcDir 'src/test/java'
+}

codequality/checkstyle.xml

@@ -128,7 +128,6 @@
         <!-- Checks for common coding problems               -->
         <!-- See http://checkstyle.sf.net/config_coding.html -->
         <!-- <module name="AvoidInlineConditionals"/> -->
-        <module name="DoubleCheckedLocking"/>    <!-- MY FAVOURITE -->
         <module name="EmptyStatement"/>
         <module name="EqualsHashCode"/>
         <module name="HiddenField">

gradle.properties

@@ -1 +1 @@
-version=0.10.1-SNAPSHOT
+version=0.12.3-SNAPSHOT

gradle/buildscript.gradle

@@ -1,13 +1,11 @@
 // Executed in context of buildscript
 repositories {
     // Repo in addition to maven central
-    maven {
-        name 'build-repo'
-        url 'https://raw.github.com/Netflix-Skunkworks/build-repo/master/releases/' // gradle-release/gradle-release/1.0-SNAPSHOT/gradle-release-1.0-SNAPSHOT.jar
-    }
+    repositories { maven { url 'http://dl.bintray.com/content/netflixoss/external-gradle-plugins/' } } // For gradle-release
 }
 dependencies {
-    classpath 'nl.javadude.gradle.plugins:license-gradle-plugin:0.6.0'
+    classpath 'nl.javadude.gradle.plugins:license-gradle-plugin:0.6.1'
     classpath 'com.mapvine:gradle-cobertura-plugin:0.1'
-    classpath 'gradle-release:gradle-release:1.0-SNAPSHOT'
+    classpath 'gradle-release:gradle-release:1.1.5'
+    classpath 'org.ajoberstar:gradle-git:0.5.0'
 }

gradle/check.gradle

@@ -1,25 +1,26 @@
 subprojects {
-    // Checkstyle
-    apply plugin: 'checkstyle'
-    tasks.withType(Checkstyle) { ignoreFailures = true }
-    checkstyle {
-        ignoreFailures = true // Waiting on GRADLE-2163
-        configFile = rootProject.file('codequality/checkstyle.xml')
-    }
+// Checkstyle
+apply plugin: 'checkstyle'
+checkstyle {
+    ignoreFailures = true 
+    configFile = rootProject.file('codequality/checkstyle.xml')
+}
 
-    // FindBugs
-    apply plugin: 'findbugs'
-    //tasks.withType(Findbugs) { reports.html.enabled true }
+// FindBugs
+apply plugin: 'findbugs'
+findbugs {
+    ignoreFailures = true
+}
 
-    // PMD
-    apply plugin: 'pmd'
-    //tasks.withType(Pmd) { reports.html.enabled true }
+// PMD
+apply plugin: 'pmd'
+//tasks.withType(Pmd) { reports.html.enabled true }
 
-    apply plugin: 'cobertura'
-    cobertura {
-        sourceDirs = sourceSets.main.java.srcDirs
-        format = 'html'
-        includes = ['**/*.java', '**/*.groovy']
-        excludes = []
-    }
+apply plugin: 'cobertura'
+cobertura {
+    sourceDirs = sourceSets.main.java.srcDirs
+    format = 'html'
+    includes = ['**/*.java', '**/*.groovy']
+    excludes = []
+}
 }

gradle/convention.gradle

@@ -1,15 +1,12 @@
-
-// For Artifactory
-rootProject.status = version.contains('-SNAPSHOT')?'snapshot':'release'
+// GRADLE-2087 workaround, perform after java plugin
+status = project.hasProperty('preferredStatus')?project.preferredStatus:(version.contains('SNAPSHOT')?'snapshot':'release')
 
 subprojects { project ->
     apply plugin: 'java' // Plugin as major conventions
 
-    version = rootProject.version
-
     sourceCompatibility = 1.6
 
-    // GRADLE-2087 workaround, perform after java plugin
+    // Restore status after Java plugin
     status = rootProject.status
 
     task sourcesJar(type: Jar, dependsOn:classes) {
@@ -51,9 +48,6 @@ subprojects { project ->
         }
     }
 
-    // Ensure output is on a new line
-    javadoc.doFirst { println "" }
-
     configurations {
         provided {
             description = 'much like compile, but indicates you expect the JDK or a container to provide it. It is only available on the compilation classpath, and is not transitive.'
@@ -70,14 +64,38 @@ subprojects { project ->
     }
 }
 
-task aggregateJavadoc(type: Javadoc) {
-    description = 'Aggregate all subproject docs into a single docs directory'
-    source subprojects.collect {project -> project.sourceSets.main.allJava }
-    classpath = files(subprojects.collect {project -> project.sourceSets.main.compileClasspath})
-    destinationDir = new File(projectDir, 'doc')
+apply plugin: 'github-pages' // Used to create publishGhPages task
+
+def docTasks = [:]
+[Javadoc,ScalaDoc,Groovydoc].each{ Class docClass ->
+    def allSources = allprojects.tasks*.withType(docClass).flatten()*.source 
+    if (allSources) {
+        def shortName = docClass.simpleName.toLowerCase()
+        def docTask = task "aggregate${shortName.capitalize()}"(type: docClass, description: "Aggregate subproject ${shortName}s") {
+            source = allSources
+            destinationDir = file("${project.buildDir}/docs/${shortName}")
+            doFirst {
+                def classpaths = allprojects.findAll { it.plugins.hasPlugin(JavaPlugin) }.collect { it.sourceSets.main.compileClasspath }
+                classpath = files(classpaths)
+            }
+        }
+        docTasks[shortName] = docTask
+        processGhPages.dependsOn(docTask)
+    }
+}
+
+githubPages {
+    repoUri = "[email protected]:Netflix/${rootProject.githubProjectName}.git"
+    pages {
+        docTasks.each { shortName, docTask ->
+            from(docTask.outputs.files) {
+                into "docs/${shortName}"
+            }
+        }
+    }
 }
 
 // Generate wrapper, which is distributed as part of source to alleviate the need of installing gradle
 task createWrapper(type: Wrapper) {
-    gradleVersion = '1.1'
+    gradleVersion = '1.6'
 }

gradle/license.gradle

@@ -5,5 +5,6 @@ apply plugin: 'license' //nl.javadude.gradle.plugins.license.LicensePlugin
 license {
     header rootProject.file('codequality/HEADER')
     ext.year = Calendar.getInstance().get(Calendar.YEAR)
+    skipExistingHeaders true
 }
 }