Merge from Netflix

.gitignore

@@ -39,6 +39,7 @@ Thumbs.db
 # Gradle Files #
 ################
 .gradle
+.gradletasknamecache
 .m2
 
 # Build output directies
@@ -62,6 +63,9 @@ bin/
 
 # NetBeans specific files/directories
 .nbattrs
+/.nb-gradle/profiles/private/
+.nb-gradle-properties
 
 # Scala build
 *.cache
+/.nb-gradle/private/

README.md

@@ -1,4 +1,4 @@
-# RxJava: Functional Reactive Programming on the JVM
+# RxJava: Reactive Extensions for the JVM
 
 This library is a Java implementation of <a href="https://rx.codeplex.com">Rx Observables</a>.
 

build.gradle

@@ -9,80 +9,136 @@ apply from: file('gradle/release.gradle')
 buildscript {
     repositories {
         mavenLocal()
-        mavenCentral() // maven { url 'http://jcenter.bintray.com' }
+        mavenCentral()
+        jcenter()
     }
-    apply from: file('gradle/buildscript.gradle'), to: buildscript 
+
+    apply from: file('gradle/buildscript.gradle'), to: buildscript
 }
 
 allprojects {
     apply plugin: 'eclipse'
     apply plugin: 'idea'
     repositories { 
         mavenLocal()
-        mavenCentral() // maven { url: 'http://jcenter.bintray.com' }
+        mavenCentral()
     }
 }
 
 subprojects {
     apply plugin: 'java'
+    apply plugin: 'shadow'
     group = "com.netflix.rxjava"
 
     // make 'examples' use the same classpath
     configurations { 
         examplesCompile.extendsFrom compile
         examplesRuntime.extendsFrom runtime
-	    perfCompile.extendsFrom compile
-	    perfRuntime.extendsFrom runtime
+        perfCompile.extendsFrom compile
+        perfRuntime.extendsFrom runtime
     }
 
 
     tasks.withType(Javadoc).each {
         it.classpath = sourceSets.main.compileClasspath
     }
 
-    sourceSets { 
-		//include /src/examples folder
+    sourceSets {
         examples
-		//include /src/perf folder
         perf {
-            java {
-                srcDir 'src/perf/java'
-                compileClasspath += main.output
-                runtimeClasspath += main.output
-            }
+            compileClasspath += sourceSets.main.output
         }
     }
 
+    tasks.build { 
+        //include 'examples' in build task
+        dependsOn(examplesClasses)
+        dependsOn(perfClasses)
+    }
+
+    task perfJar(type: Jar, dependsOn: perfClasses) {
+        from sourceSets.perf.output + sourceSets.main.output
+    }
+
     dependencies {
-        perfCompile 'org.openjdk.jmh:jmh-core:0.2'
+        perfCompile 'org.openjdk.jmh:jmh-core:0.5.3'
+        perfCompile 'org.openjdk.jmh:jmh-generator-annprocess:0.5.3'
+        //perfCompile project
     }
 
-    tasks.build { 
-		//include 'examples' in build task
-        dependsOn(examplesClasses)
-		//include 'perf' in build task
-        // dependsOn(perfClasses)  //-> Not working so commented out
+    artifacts {
+        perfRuntime perfJar
     }
 
     eclipse {  
-        classpath {  
-            // include 'provided' dependencies on the classpath
-            plusConfigurations += configurations.provided
+        classpath {
             plusConfigurations += configurations.perfCompile
 
             downloadSources = true
             downloadJavadoc = true
         }
     }
-    
+
     idea {
         module {
-            // include 'provided' dependencies on the classpath
-            scopes.PROVIDED.plus += configurations.provided
-            // TODO not sure what to add it to
-            //scopes.PROVIDED.plus += configurations.perfCompile
+            scopes.PROVIDED.plus  += configurations.perfCompile
+            scopes.PROVIDED.minus += configurations.compile
+        }
+    }
+
+    /**
+     * By default: Run without arguments this will execute all benchmarks that are found (can take a long time).
+     *
+     * Optionally pass arguments for custom execution. Example:
+     *
+     *  ../gradlew benchmarks '-Pjmh=-f 1 -tu ns -bm avgt -wi 5 -i 5 -r 1 .*OperatorSerializePerf.*'
+     *
+     * To see all options:
+     *
+     *  ../gradlew benchmarks '-Pjmh=-h'
+     */
+    task benchmarks(type: JavaExec) {
+        main = 'org.openjdk.jmh.Main'
+        classpath = sourceSets.perf.runtimeClasspath + sourceSets.main.output
+        maxHeapSize = "512m"
+
+        if (project.hasProperty('jmh')) {
+            args(jmh.split(' '))
+        } else {
+            //args '-h' // help output
+            args '-f' // fork
+            args '1'
+            args '-tu' // time unit
+            args 'ns'
+            args '-bm' // benchmark mode
+            args 'avgt'
+            args '-wi' // warmup iterations
+            args '5'
+            args '-i' // test iterations
+            args '5'
+            args '-r' // time per execution in seconds
+            args '5'
+            //args '-prof' // profilers
+            //args 'HS_GC' // HotSpot (tm) memory manager (GC) profiling via implementation-specific MBeans
+            //args 'HS_RT' // HotSpot (tm) runtime profiling via implementation-specific MBeans
+            //args 'HS_THR' // HotSpot (tm) threading subsystem via implementation-specific MBeans
+            //args 'HS_COMP' // HotSpot (tm) JIT compiler profiling via implementation-specific MBeans
+            //args 'HS_CL' // HotSpot (tm) classloader profiling via implementation-specific MBeans
+            //args 'STACK' // Simple and naive Java stack profiler
+            args '.*OperatorSerializePerf.*' // for running only a specific test
         }
     }
+
+    shadow {
+        classifier = "benchmarks"
+        includeDependenciesFor = ["runtime", "perfRuntime"]
+
+        transformer(com.github.jengelman.gradle.plugins.shadow.transformers.ManifestResourceTransformer) {
+            mainClass = "org.openjdk.jmh.Main"
+        }
+    }
+
+    shadowJar.dependsOn perfJar
 }
 
 project(':rxjava-core') {

gradle.properties

@@ -1 +1 @@
-version=0.17.0-RC4-SNAPSHOT
+version=0.18.4-SNAPSHOT

gradle/buildscript.gradle

@@ -2,10 +2,16 @@
 repositories {
     // Repo in addition to maven central
     repositories { maven { url 'http://dl.bintray.com/content/netflixoss/external-gradle-plugins/' } } // For gradle-release
+    maven {
+        //FIXME: waiting for https://github.com/johnrengelman/shadow/pull/38 to merge
+        name 'Shadow'
+        url 'http://dl.bintray.com/content/gvsmirnov/gradle-plugins'
+    }
 }
 dependencies {
     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.1.5'
     classpath 'org.ajoberstar:gradle-git:0.5.0'
+    classpath 'com.github.jengelman.gradle.plugins:shadow:0.8.1'
 }

language-adaptors/rxjava-clojure/README.md

@@ -1,10 +1,96 @@
-# Clojure Adaptor for RxJava
+Clojure bindings for RxJava.
 
+# Binaries
+
+Binaries and dependency information for Maven, Ivy, Gradle and others can be found at [http://search.maven.org](http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22rxjava-clojure%22).
+
+Example for Leiningen:
+
+```clojure
+[com.netflix.rxjava/rxjava-clojure "x.y.z"]
+```
+
+and for Gradle:
+
+```groovy
+compile 'com.netflix.rxjava:rxjava-clojure:x.y.z'
+```
+
+and for Maven:
+
+```xml
+<dependency>
+    <groupId>com.netflix.rxjava</groupId>
+    <artifactId>rxjava-clojure</artifactId>
+    <version>x.y.z</version>
+</dependency>
+```
+
+and for Ivy:
+
+```xml
+<dependency org="com.netflix.rxjava" name="rxjava-clojure" rev="x.y.z" />
+```
+
+# Clojure Bindings
+This library provides convenient, idiomatic Clojure bindings for RxJava.
+
+The bindings try to present an API that will be comfortable and familiar to a Clojure programmer that's familiar with the sequence operations in `clojure.core`. It "fixes" several issues with using RxJava with raw Java interop, for example:
+
+* Argument lists are in the "right" order. So in RxJava, the function applied in `Observable.map` is the second argument, while here it's the first argument with one or more Observables as trailing arguments
+* Operators take normal Clojure functions as arguments, bypassing need for the interop described below
+* Predicates accomodate Clojure's notion of truth
+* Operators are generally names as they would be in `clojure.core` rather than the Rx names
+
+There is no object wrapping going on. That is, all functions return normal `rx.Observable` objects, so you can always drop back to Java interop for anything that's missing in this wrapper.
+
+## Basic Usage
+Most functionality resides in the `rx.lang.clojure.core` namespace and for the most part looks like normal Clojure sequence manipulation:
+
+```clojure
+(require '[rx.lang.clojure.core :as rx])
+
+(->> my-observable
+     (rx/map (comp clojure.string/lower-case :first-name))
+     (rx/map clojure.string/lower-case)
+     (rx/filter #{"bob"})
+     (rx/distinct)
+     (rx/into []))
+;=> An Observable that emits a single vector of names
+```
+
+Blocking operators, which are useful for testing, but should otherwise be avoided, reside in `rx.lang.clojure.blocking`. For example:
+
+```clojure
+(require '[rx.lang.clojure.blocking :as rxb])
+
+(rxb/doseq [{:keys [first-name]} users-observable]
+  (println "Hey," first-name))
+;=> nil
+```
+
+## Open Issues
+
+* The missing stuff mentioned below
+* `group-by` val-fn variant isn't implemented in RxJava
+* There are some functions for defining customer Observables and Operators (`subscriber`, `operator*`, `observable*`). I don't think these are really enough for serious operator implementation, but I'm hesitant to guess at an abstraction at this point. These will probably change dramatically.
+
+## What's Missing
+This library is an ongoing work in progress driven primarily by the needs of one team at Netflix. As such some things are currently missing:
+
+* Highly-specific operators that we felt cluttered the API and were easily composed from existing operators, especially since we're in not-Java land. For example, `Observable.sumLong()`.
+* Most everything involving schedulers
+* Most everything involving time
+* `Observable.window` and `Observable.buffer`. Who knows which parts of these beasts to wrap?
+
+Of course, contributions that cover these cases are welcome.
+
+# Low-level Interop
 This adaptor provides functions and macros to ease Clojure/RxJava interop. In particular, there are functions and macros for turning Clojure functions and code into RxJava `Func*` and `Action*` interfaces without the tedium of manually reifying the interfaces.
 
-# Basic Usage
+## Basic Usage
 
-## Requiring the interop namespace
+### Requiring the interop namespace
 The first thing to do is to require the namespace:
 
 ```clojure
@@ -19,23 +105,23 @@ or, at the REPL:
 (require '[rx.lang.clojure.interop :as rx])
 ```
 
-## Using rx/fn
-Once the namespace is required, you can use the `rx/fn` macro anywhere RxJava wants a `rx.util.functions.Func` object. The syntax is exactly the same as `clojure.core/fn`:
+### Using rx/fn
+Once the namespace is required, you can use the `rx/fn` macro anywhere RxJava wants a `rx.functions.Func` object. The syntax is exactly the same as `clojure.core/fn`:
 
 ```clojure
 (-> my-observable
     (.map (rx/fn [v] (* 2 v))))
 ```
 
-If you already have a plain old Clojure function you'd like to use, you can pass it to the `rx/fn*` function to get a new object that implements `rx.util.functions.Func`:
+If you already have a plain old Clojure function you'd like to use, you can pass it to the `rx/fn*` function to get a new object that implements `rx.functions.Func`:
 
 ```clojure
 (-> my-numbers
     (.reduce (rx/fn* +)))
 ```
 
-## Using rx/action
-The `rx/action` macro is identical to `rx/fn` except that the object returned implements `rx.util.functions.Action` interfaces. It's used in `subscribe` and other side-effect-y contexts:
+### Using rx/action
+The `rx/action` macro is identical to `rx/fn` except that the object returned implements `rx.functions.Action` interfaces. It's used in `subscribe` and other side-effect-y contexts:
 
 ```clojure
 (-> my-observable
@@ -46,8 +132,8 @@ The `rx/action` macro is identical to `rx/fn` except that the object returned im
                 (rx/action [] (println "Sequence complete"))))
 ```
 
-## Using Observable/create
-As of 0.17, `rx.Observable/create` takes an implementation of `rx.Observable$OnSubscribe` which is basically an alias for `rx.util.functions.Action1` that takes an `rx.Subscriber` as its argument. Thus, you can just use `rx/action` when creating new observables:
+### Using Observable/create
+As of 0.17, `rx.Observable/create` takes an implementation of `rx.Observable$OnSubscribe` which is basically an alias for `rx.functions.Action1` that takes an `rx.Subscriber` as its argument. Thus, you can just use `rx/action` when creating new observables:
 
 ```clojure
 ; A simple observable that emits 0..9 taking unsubscribe into account
@@ -59,35 +145,10 @@ As of 0.17, `rx.Observable/create` takes an implementation of `rx.Observable$OnS
                      (.onCompleted s)))
 ```
 
-# Gotchas
+## Gotchas
 Here are a few things to keep in mind when using this interop:
 
 * Keep in mind the (mostly empty) distinction between `Func` and `Action` and which is used in which contexts
 * If there are multiple Java methods overloaded by `Func` arity, you'll need to use a type hint to let the compiler know which one to choose.
 * Methods that take a predicate (like filter) expect the predicate to return a boolean value. A function that returns a non-boolean value will result in a `ClassCastException`.
 
-# Binaries
-
-Binaries and dependency information for Maven, Ivy, Gradle and others can be found at [http://search.maven.org](http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22rxjava-clojure%22).
-
-Example for Maven:
-
-```xml
-<dependency>
-    <groupId>com.netflix.rxjava</groupId>
-    <artifactId>rxjava-clojure</artifactId>
-    <version>x.y.z</version>
-</dependency>
-```
-
-and for Ivy:
-
-```xml
-<dependency org="com.netflix.rxjava" name="rxjava-clojure" rev="x.y.z" />
-```
-
-and for Leiningen:
-
-```clojure
-[com.netflix.rxjava/rxjava-clojure "x.y.z"]
-```