├── .travis.yml
├── LICENSE
├── README.md
├── pom.xml
└── src
    ├── test
        └── java
        │   └── net
        │       └── codestory
        │           └── FluentTest.java
    └── main
        └── java
            └── net
                └── codestory
                    └── Fluent.java


/.travis.yml:
--------------------------------------------------------------------------------
 1 | # Use docker-based build environment
 2 | sudo: false
 3 | 
 4 | language: java
 5 | jdk:
 6 |   - oraclejdk8
 7 | 
 8 | cache:
 9 |   directories:
10 |     - '$HOME/.m2/repository'


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (C) 2013 all@code-story.net
 2 | 
 3 | Licensed under the Apache License, Version 2.0 (the "License");
 4 | you may not use this file except in compliance with the License.
 5 | You may obtain a copy of the License at
 6 | 
 7 |         http://www.apache.org/licenses/LICENSE-2.0
 8 | 
 9 | Unless required by applicable law or agreed to in writing, software
10 | distributed under the License is distributed on an "AS IS" BASIS,
11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | See the License for the specific language governing permissions and
13 | limitations under the License
14 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Fluent
 2 | 
 3 | Java 8 Streams and Iterables on Steroids.
 4 | 
 5 | # Build status
 6 | 
 7 | [![Build Status](https://api.travis-ci.org/CodeStory/fluent.png)](https://travis-ci.org/CodeStory/fluent)
 8 | 
 9 | # Environment
10 | 
11 | - `java-1.8`
12 | 
13 | ## Maven
14 | 
15 | Release versions are deployed on Maven Central:
16 | 
17 | ```xml
18 | <dependency>
19 |   <groupId>net.code-story</groupId>
20 |   <artifactId>fluent</artifactId>
21 |   <version>1.4</version>
22 | </dependency>
23 | ```
24 | 
25 | # Build
26 | 
27 | ```bash
28 | mvn clean verify
29 | ```
30 | 
31 | # Deploy on Maven Central
32 | 
33 | Build the release:
34 | 
35 | ```bash
36 | mvn release:clean release:prepare release:perform
37 | ```
38 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3 |   <modelVersion>4.0.0</modelVersion>
  4 | 
  5 |   <groupId>net.code-story</groupId>
  6 |   <artifactId>fluent</artifactId>
  7 |   <version>1.5-SNAPSHOT</version>
  8 |   <packaging>jar</packaging>
  9 | 
 10 |   <name>CodeStory - Fluent Stream/Iterable</name>
 11 |   <description>Streams and Iterables on Steroids</description>
 12 |   <url>https://github.com/CodeStory/fluent</url>
 13 | 
 14 |   <parent>
 15 |     <groupId>org.sonatype.oss</groupId>
 16 |     <artifactId>oss-parent</artifactId>
 17 |     <version>9</version>
 18 |     <relativePath />
 19 |   </parent>
 20 | 
 21 |   <scm>
 22 |     <connection>scm:git:git@github.com:CodeStory/fluent.git</connection>
 23 |     <url>scm:git:git@github.com:CodeStory/fluent.git</url>
 24 |     <developerConnection>scm:git:git@github.com:CodeStory/fluent.git</developerConnection>
 25 |     <tag>HEAD</tag>
 26 |   </scm>
 27 | 
 28 |   <licenses>
 29 |     <license>
 30 |       <name>Apache 2</name>
 31 |       <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
 32 |       <distribution>repo</distribution>
 33 |       <comments>A business-friendly OSS license</comments>
 34 |     </license>
 35 |   </licenses>
 36 | 
 37 |   <prerequisites>
 38 |     <maven>3.0.4</maven>
 39 |   </prerequisites>
 40 | 
 41 |   <properties>
 42 |     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 43 |     <maven.compiler.source>1.8</maven.compiler.source>
 44 |     <maven.compiler.target>1.8</maven.compiler.target>
 45 |   </properties>
 46 | 
 47 |   <profiles>
 48 |     <profile>
 49 |       <id>release</id>
 50 |       <build>
 51 |         <plugins>
 52 |           <plugin>
 53 |             <artifactId>maven-gpg-plugin</artifactId>
 54 |             <version>1.5</version>
 55 |             <executions>
 56 |               <execution>
 57 |                 <id>sign-artifacts</id>
 58 |                 <phase>verify</phase>
 59 |                 <goals>
 60 |                   <goal>sign</goal>
 61 |                 </goals>
 62 |               </execution>
 63 |             </executions>
 64 |           </plugin>
 65 |         </plugins>
 66 |       </build>
 67 |     </profile>
 68 |   </profiles>
 69 | 
 70 |   <build>
 71 |     <pluginManagement>
 72 |       <plugins>
 73 |         <plugin>
 74 |           <artifactId>maven-clean-plugin</artifactId>
 75 |           <version>2.5</version>
 76 |         </plugin>
 77 |         <plugin>
 78 |           <artifactId>maven-compiler-plugin</artifactId>
 79 |           <version>3.1</version>
 80 |         </plugin>
 81 |         <plugin>
 82 |           <artifactId>maven-deploy-plugin</artifactId>
 83 |           <version>2.8.1</version>
 84 |         </plugin>
 85 |         <plugin>
 86 |           <artifactId>maven-install-plugin</artifactId>
 87 |           <version>2.5.1</version>
 88 |         </plugin>
 89 |         <plugin>
 90 |           <artifactId>maven-jar-plugin</artifactId>
 91 |           <version>2.5</version>
 92 |         </plugin>
 93 |         <plugin>
 94 |           <artifactId>maven-resources-plugin</artifactId>
 95 |           <version>2.6</version>
 96 |         </plugin>
 97 |         <plugin>
 98 |           <artifactId>maven-site-plugin</artifactId>
 99 |           <version>3.4</version>
100 |         </plugin>
101 |         <plugin>
102 |           <artifactId>maven-source-plugin</artifactId>
103 |           <version>2.3</version>
104 |         </plugin>
105 |         <plugin>
106 |           <artifactId>maven-release-plugin</artifactId>
107 |           <version>2.5</version>
108 |         </plugin>
109 |         <plugin>
110 |           <artifactId>maven-surefire-plugin</artifactId>
111 |           <version>2.17</version>
112 |         </plugin>
113 |       </plugins>
114 |     </pluginManagement>
115 |     <plugins>
116 |       <plugin>
117 |         <groupId>org.sonatype.plugins</groupId>
118 |         <artifactId>nexus-staging-maven-plugin</artifactId>
119 |         <version>1.6.2</version>
120 |         <extensions>true</extensions>
121 |         <configuration>
122 |           <serverId>ossrh</serverId>
123 |           <nexusUrl>https://oss.sonatype.org/</nexusUrl>
124 |           <autoReleaseAfterClose>true</autoReleaseAfterClose>
125 |         </configuration>
126 |       </plugin>
127 |       <plugin>
128 |         <artifactId>maven-release-plugin</artifactId>
129 |         <configuration>
130 |           <releaseProfiles>release</releaseProfiles>
131 |         </configuration>
132 |       </plugin>
133 |       <plugin>
134 |         <artifactId>maven-source-plugin</artifactId>
135 |         <executions>
136 |           <execution>
137 |             <id>attach-sources</id>
138 |             <goals>
139 |               <goal>jar</goal>
140 |             </goals>
141 |           </execution>
142 |         </executions>
143 |       </plugin>
144 |       <plugin>
145 |         <inherited>false</inherited>
146 |         <groupId>com.mycila.maven-license-plugin</groupId>
147 |         <artifactId>maven-license-plugin</artifactId>
148 |         <version>1.9.0</version>
149 |         <configuration>
150 |           <header>${project.basedir}/LICENSE</header>
151 |           <failIfMissing>true</failIfMissing>
152 |           <strictCheck>true</strictCheck>
153 |           <aggregate>true</aggregate>
154 |           <includes>
155 |             <include>**/*.java</include>
156 |           </includes>
157 |           <mapping>
158 |             <java>JAVADOC_STYLE</java>
159 |           </mapping>
160 |         </configuration>
161 |         <executions>
162 |           <execution>
163 |             <id>enforce-license-headers</id>
164 |             <phase>validate</phase>
165 |             <goals>
166 |               <goal>check</goal>
167 |             </goals>
168 |           </execution>
169 |         </executions>
170 |       </plugin>
171 |     </plugins>
172 |   </build>
173 | 
174 |   <dependencies>
175 |     <!-- Test dependencies -->
176 |     <dependency>
177 |       <groupId>junit</groupId>
178 |       <artifactId>junit</artifactId>
179 |       <version>4.12-beta-2</version>
180 |       <scope>test</scope>
181 |     </dependency>
182 |     <dependency>
183 |       <groupId>org.assertj</groupId>
184 |       <artifactId>assertj-core</artifactId>
185 |       <version>1.7.0</version>
186 |       <scope>test</scope>
187 |     </dependency>
188 |   </dependencies>
189 | </project>
190 | 


--------------------------------------------------------------------------------
/src/test/java/net/codestory/FluentTest.java:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Copyright (C) 2013 all@code-story.net
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *         http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License
 15 |  */
 16 | package net.codestory;
 17 | 
 18 | import org.junit.Test;
 19 | 
 20 | import java.util.*;
 21 | import java.util.stream.*;
 22 | 
 23 | import static org.assertj.core.api.Assertions.assertThat;
 24 | 
 25 | public class FluentTest {
 26 |   @Test
 27 |   public void create_empty() {
 28 |     Iterable<String> empty = Fluent.of();
 29 | 
 30 |     assertThat(empty).isEmpty();
 31 |   }
 32 | 
 33 |   @Test
 34 |   public void create_for_array() {
 35 |     Iterable<String> values = Fluent.of("FIRST", "SECOND");
 36 | 
 37 |     assertThat(values).containsExactly("FIRST", "SECOND");
 38 |   }
 39 | 
 40 |   @Test
 41 |   public void create_for_iterable() {
 42 |     Iterable<String> values = Fluent.of(Arrays.asList("FIRST", "SECOND"));
 43 | 
 44 |     assertThat(values).containsExactly("FIRST", "SECOND");
 45 |   }
 46 | 
 47 |   @Test
 48 |   public void create_for_self() {
 49 |     Fluent<String> fluent = Fluent.of(Arrays.asList("FIRST", "SECOND"));
 50 |     Iterable<String> values = Fluent.of(fluent);
 51 | 
 52 |     assertThat((Object) values).isSameAs(fluent);
 53 |   }
 54 | 
 55 |   @Test
 56 |   public void create_for_iterator() {
 57 |     Fluent<String> fluent = Fluent.of(Arrays.asList("FIRST", "SECOND").iterator());
 58 | 
 59 |     assertThat(fluent.toList()).containsExactly("FIRST", "SECOND");
 60 |     assertThat(fluent.toList()).isEmpty();
 61 |   }
 62 | 
 63 |   @Test
 64 |   public void create_for_stream() {
 65 |     Fluent<String> fluent = Fluent.of(Stream.of("FIRST", "SECOND"));
 66 | 
 67 |     assertThat(fluent.toList()).containsExactly("FIRST", "SECOND");
 68 |   }
 69 | 
 70 |   @Test
 71 |   public void create_for_int_array() {
 72 |     int[] ints = {1, 2, 3, 4, 5};
 73 | 
 74 |     Iterable<Integer> values = Fluent.of(ints);
 75 | 
 76 |     assertThat(values).containsExactly(1, 2, 3, 4, 5);
 77 |   }
 78 | 
 79 |   @Test
 80 |   public void create_for_long_array() {
 81 |     long[] longs = {1L, 2L, 3L, 4L, 5L};
 82 | 
 83 |     Iterable<Long> values = Fluent.of(longs);
 84 | 
 85 |     assertThat(values).containsExactly(1L, 2L, 3L, 4L, 5L);
 86 |   }
 87 | 
 88 |   @Test
 89 |   public void create_for_double_array() {
 90 |     double[] doubles = {1, 2, 3, 4, 5};
 91 | 
 92 |     Iterable<Double> values = Fluent.of(doubles);
 93 | 
 94 |     assertThat(values).containsExactly(1D, 2D, 3D, 4D, 5D);
 95 |   }
 96 | 
 97 |   @Test
 98 |   public void transform_values() {
 99 |     Iterable<String> values = Fluent.of("a", "b").map(String::toUpperCase);
100 | 
101 |     assertThat(values).containsExactly("A", "B");
102 |   }
103 | 
104 |   @Test
105 |   public void filter_values() {
106 |     Iterable<Integer> values = Fluent.of(1, 2, 3, 4, 5).filter(v -> v > 3);
107 | 
108 |     assertThat(values).containsExactly(4, 5);
109 |   }
110 | 
111 |   @Test
112 |   public void exclude_values() {
113 |     Iterable<Integer> values = Fluent.of(1, 2, 3, 4, 5).exclude(v -> v > 3);
114 | 
115 |     assertThat(values).containsExactly(1, 2, 3);
116 |   }
117 | 
118 |   @Test
119 |   public void count_values() {
120 |     long count = Fluent.of(1, 2, 3, 4, 5).size();
121 | 
122 |     assertThat(count).isEqualTo(5L);
123 |   }
124 | 
125 |   @Test
126 |   public void count_with_predicate() {
127 |     long count = Fluent.of(1, 2, 3, 4, 5).count(v -> v > 3);
128 | 
129 |     assertThat(count).isEqualTo(2L);
130 |   }
131 | 
132 |   @Test
133 |   public void first_value() {
134 |     Optional<Integer> first = Fluent.of(1, 2, 3, 4, 5).first();
135 | 
136 |     assertThat(first.get()).isEqualTo(1);
137 |   }
138 | 
139 |   @Test
140 |   public void no_first_value() {
141 |     Optional<Object> first = Fluent.of().first();
142 | 
143 |     assertThat(first.isPresent()).isFalse();
144 |   }
145 | 
146 |   @Test(expected = NullPointerException.class)
147 |   public void first_null_value() {
148 |     Fluent.of((Object) null).first();
149 |   }
150 | 
151 |   @Test
152 |   public void last_value() {
153 |     Optional<Integer> last = Fluent.of(1, 2, 3, 4, 5).last();
154 | 
155 |     assertThat(last.get()).isEqualTo(5);
156 |   }
157 | 
158 |   @Test
159 |   public void no_last_value() {
160 |     Optional<Object> last = Fluent.of().last();
161 | 
162 |     assertThat(last.isPresent()).isFalse();
163 |   }
164 | 
165 |   @Test(expected = NullPointerException.class)
166 |   public void last_null_value() {
167 |     Fluent.of((Object) null).last();
168 |   }
169 | 
170 |   @Test
171 |   public void empty() {
172 |     assertThat(Fluent.of().isEmpty()).isTrue();
173 |     assertThat(Fluent.of("VALUE").isEmpty()).isFalse();
174 |   }
175 | 
176 |   @Test
177 |   public void contains() {
178 |     Fluent<Integer> values = Fluent.of(1, 2);
179 | 
180 |     assertThat(values.contains(1)).isTrue();
181 |     assertThat(values.contains(2)).isTrue();
182 |     assertThat(values.contains(3)).isFalse();
183 |     assertThat(values.contains(null)).isFalse();
184 |     assertThat(values.contains("DIFFERENT TYPE")).isFalse();
185 |   }
186 | 
187 |   @Test
188 |   public void index() {
189 |     Fluent<Integer> values = Fluent.of(1, 2);
190 | 
191 |     assertThat(values.indexOf(1)).isEqualTo(0);
192 |     assertThat(values.indexOf(2)).isEqualTo(1);
193 |     assertThat(values.indexOf(3)).isEqualTo(-1);
194 |     assertThat(values.indexOf(null)).isEqualTo(-1);
195 |     assertThat(values.indexOf("DIFFERENT TYPE")).isEqualTo(-1);
196 |   }
197 | 
198 |   @Test
199 |   public void to_array() {
200 |     Fluent<Integer> values = Fluent.of(1, 2, 3, 4, 5);
201 | 
202 |     Integer[] array = values.toArray(Integer[]::new);
203 | 
204 |     assertThat(array).containsExactly(1, 2, 3, 4, 5);
205 |   }
206 | 
207 |   @Test
208 |   public void to_list() {
209 |     Fluent<Integer> values = Fluent.of(1, 2, 3, 4, 5);
210 | 
211 |     List<Integer> list = values.toList();
212 | 
213 |     assertThat(list).containsExactly(1, 2, 3, 4, 5);
214 |   }
215 | 
216 |   @Test
217 |   public void to_set() {
218 |     Fluent<Integer> values = Fluent.of(1, 2, 3, 4, 5);
219 | 
220 |     Set<Integer> set = values.toSet();
221 | 
222 |     assertThat(set).containsOnly(1, 2, 3, 4, 5);
223 |   }
224 | 
225 |   @Test
226 |   public void any_match() {
227 |     Fluent<Integer> values = Fluent.of(1, 2, 3, 4, 5);
228 | 
229 |     assertThat(values.anyMatch(v -> v > 5)).isFalse();
230 |     assertThat(values.anyMatch(v -> v < 5)).isTrue();
231 |   }
232 | 
233 |   @Test
234 |   public void all_match() {
235 |     Fluent<Integer> values = Fluent.of(1, 2, 3, 4, 5);
236 | 
237 |     assertThat(values.allMatch(v -> v < 5)).isFalse();
238 |     assertThat(values.allMatch(v -> v < 6)).isTrue();
239 |   }
240 | 
241 |   @Test
242 |   public void none_match() {
243 |     Fluent<Integer> values = Fluent.of(1, 2, 3, 4, 5);
244 | 
245 |     assertThat(values.noneMatch(v -> v < 6)).isFalse();
246 |     assertThat(values.noneMatch(v -> v > 6)).isTrue();
247 |   }
248 | 
249 |   @Test
250 |   public void collect() {
251 |     Fluent<Integer> values = Fluent.of(1, 2, 3, 4, 5);
252 | 
253 |     Long count = values.collect(Collectors.counting());
254 | 
255 |     assertThat(count).isEqualTo(5L);
256 |   }
257 | 
258 |   @Test
259 |   public void copy_into() {
260 |     List<Integer> list = Fluent.of(1, 2, 3, 4, 5).copyInto(new ArrayList<>());
261 | 
262 |     assertThat(list).containsExactly(1, 2, 3, 4, 5);
263 |   }
264 | 
265 |   @Test
266 |   public void join_with_separator() {
267 |     Fluent<Integer> values = Fluent.of(1, null, 3, 4, 5);
268 | 
269 |     String string = values.join(", ");
270 | 
271 |     assertThat(string).isEqualTo("1, null, 3, 4, 5");
272 |   }
273 | 
274 |   @Test
275 |   public void join() {
276 |     Fluent<Integer> values = Fluent.of(1, 2, 3, 4, 5);
277 | 
278 |     String string = values.join();
279 | 
280 |     assertThat(string).isEqualTo("12345");
281 |   }
282 | 
283 |   @Test
284 |   public void exclude_nulls() {
285 |     Fluent<Integer> values = Fluent.of(1, null, 3).notNulls();
286 | 
287 |     assertThat(values).containsExactly(1, 3);
288 |   }
289 | 
290 |   @Test
291 |   public void limit() {
292 |     Iterable<Integer> values = Fluent.of(1, 2, 3, 4, 5).limit(2);
293 | 
294 |     assertThat(values).containsExactly(1, 2);
295 |   }
296 | 
297 |   @Test
298 |   public void first_match() {
299 |     Optional<Integer> firstMatch = Fluent.of(1, 2, 3, 4, 5).firstMatch(v -> v == 4);
300 | 
301 |     assertThat(firstMatch.get()).isEqualTo(4);
302 |   }
303 | 
304 |   @Test
305 |   public void of_type() {
306 |     Fluent<Integer> integers = Fluent.of("a", 2, "b", 3).filter(Integer.class);
307 | 
308 |     assertThat(integers).containsExactly(2, 3);
309 |   }
310 | 
311 |   @Test
312 |   public void cycle() {
313 |     Iterable<Integer> integers = Fluent.of(0, 1).cycle().limit(6);
314 | 
315 |     assertThat(integers).containsExactly(0, 1, 0, 1, 0, 1);
316 |   }
317 | 
318 |   @Test
319 |   public void for_each() {
320 |     List<String> list = new ArrayList<>();
321 | 
322 |     Fluent.of("a", "b", "c").forEach(list::add);
323 | 
324 |     assertThat(list).containsExactly("a", "b", "c");
325 |   }
326 | 
327 |   @Test
328 |   public void for_each_with_index() {
329 |     List<String> list = new ArrayList<>();
330 | 
331 |     Fluent.of("a", "b", "c").forEachWithIndex((index, value) -> list.add(index + "-" + value));
332 | 
333 |     assertThat(list).containsExactly("0-a", "1-b", "2-c");
334 |   }
335 | 
336 |   @Test
337 |   public void to_stream() {
338 |     Stream<String> stream = Fluent.of("0", "1", "2").stream();
339 | 
340 |     assertThat(stream.toArray()).containsExactly("0", "1", "2");
341 |   }
342 | 
343 |   @Test
344 |   public void to_int_stream() {
345 |     IntStream stream = Fluent.of("0", "1", "2").intStream(Integer::parseInt);
346 | 
347 |     assertThat(stream.iterator()).containsExactly(0, 1, 2);
348 |   }
349 | 
350 |   @Test
351 |   public void to_long_stream() {
352 |     LongStream stream = Fluent.of("0", "1", "2").longStream(Long::parseLong);
353 | 
354 |     assertThat(stream.iterator()).containsExactly(0L, 1L, 2L);
355 |   }
356 | 
357 |   @Test
358 |   public void to_double_stream() {
359 |     DoubleStream stream = Fluent.of("0", "1", "2").doubleStream(Double::parseDouble);
360 | 
361 |     assertThat(stream.iterator()).containsExactly(0D, 1D, 2D);
362 |   }
363 | 
364 |   @Test
365 |   public void min() {
366 |     Optional<Integer> min = Fluent.of(4, 3, 1, 5).min((v1, v2) -> (v1 - v2));
367 | 
368 |     assertThat(min.get()).isEqualTo(1);
369 |   }
370 | 
371 |   @Test
372 |   public void max() {
373 |     Optional<Integer> min = Fluent.of(4, 3, 1, 5).max((v1, v2) -> (v1 - v2));
374 | 
375 |     assertThat(min.get()).isEqualTo(5);
376 |   }
377 | 
378 |   @Test
379 |   public void reduce() {
380 |     int sum = Fluent.of(1, 2, 3, 4).reduce(0, (a, b) -> a + b);
381 | 
382 |     assertThat(sum).isEqualTo(10);
383 |   }
384 | 
385 |   @Test
386 |   public void reduce_without_initial_value() {
387 |     Optional<Integer> sum = Fluent.of(1, 2, 3, 4).reduce((a, b) -> a + b);
388 | 
389 |     assertThat(sum.get()).isEqualTo(10);
390 |   }
391 | 
392 |   @Test
393 |   public void reduce_without_values() {
394 |     Optional<Integer> sum = Fluent.<Integer>of().reduce((a, b) -> a + b);
395 | 
396 |     assertThat(sum.isPresent()).isFalse();
397 |   }
398 | 
399 |   @Test
400 |   public void sorted_list() {
401 |     List<Integer> sorted = Fluent.of(5, 4, 3, 2, 1).toSortedList(Comparator.naturalOrder());
402 | 
403 |     assertThat(sorted).containsExactly(1, 2, 3, 4, 5);
404 |   }
405 | 
406 |   @Test
407 |   public void sorted_set() {
408 |     SortedSet<Integer> sortedSet = Fluent.of(5, 4, 3, 2, 1).toSortedSet(Comparator.naturalOrder());
409 | 
410 |     assertThat(sortedSet).containsExactly(1, 2, 3, 4, 5);
411 |   }
412 | 
413 |   @Test
414 |   public void unique_index_by() {
415 |     Map<Integer, String> index = Fluent.of("1", "22", "333").uniqueIndex(String::length);
416 | 
417 |     assertThat(index).containsEntry(1, "1").containsEntry(2, "22").containsEntry(3, "333");
418 |   }
419 | 
420 |   @Test(expected = IllegalArgumentException.class)
421 |   public void key_conflict() {
422 |     Fluent.of("a", "b").uniqueIndex(String::length);
423 |   }
424 | 
425 |   @Test
426 |   public void index_by() {
427 |     Map<Integer, List<String>> index = Fluent.of("a", "b", "cc", "dd").index(String::length);
428 | 
429 |     assertThat(index).containsEntry(1, Arrays.asList("a", "b")).containsEntry(2, Arrays.asList("cc", "dd"));
430 |   }
431 | 
432 |   @Test
433 |   public void to_map() {
434 |     Map<String, Integer> map = Fluent.of("a", "bb").toMap(String::length);
435 | 
436 |     assertThat(map).containsEntry("a", 1).containsEntry("bb", 2);
437 |   }
438 | 
439 |   @Test
440 |   public void get() {
441 |     Fluent<String> values = Fluent.of("a", "bb");
442 | 
443 |     assertThat(values.get(0)).isEqualTo("a");
444 |     assertThat(values.get(1)).isEqualTo("bb");
445 |   }
446 | 
447 |   @Test(expected = ArrayIndexOutOfBoundsException.class)
448 |   public void get_out_of_bounds() {
449 |     Fluent.of("a", "bb").get(3);
450 |   }
451 | 
452 |   @Test(expected = IllegalArgumentException.class)
453 |   public void get_negative() {
454 |     Fluent.of("a", "bb").get(-1);
455 |   }
456 | 
457 |   @Test
458 |   public void concatenate_array() {
459 |     Fluent<String> concatenated = Fluent.of("a", "bb").concat("cc", "dd");
460 | 
461 |     assertThat(concatenated).containsExactly("a", "bb", "cc", "dd");
462 |   }
463 | 
464 |   @Test
465 |   public void concatenate_iterable() {
466 |     Fluent<String> concatenated = Fluent.of("a", "b").concat(Fluent.of("c", "d"));
467 | 
468 |     assertThat(concatenated).containsExactly("a", "b", "c", "d");
469 |   }
470 | 
471 |   @Test
472 |   public void flat_map() {
473 |     Fluent<String> letters = Fluent.of("a-a-a", "b-b").flatMap(s -> Arrays.asList(s.split("-")));
474 | 
475 |     assertThat(letters).containsExactly("a", "a", "a", "b", "b");
476 |   }
477 | 
478 |   @Test
479 |   public void get_only_element() {
480 |     String only = Fluent.of("ONLY").getOnlyElement();
481 | 
482 |     assertThat(only).isEqualTo("ONLY");
483 |   }
484 | 
485 |   @Test(expected = NoSuchElementException.class)
486 |   public void get_only_element_of_empty_list() {
487 |     Fluent.of().getOnlyElement();
488 |   }
489 | 
490 |   @Test
491 |   public void iterate_on_characters() {
492 |     Fluent<String> chars = Fluent.ofChars("ABCDE");
493 | 
494 |     assertThat(chars.toList()).containsExactly("A", "B", "C", "D", "E");
495 |   }
496 | 
497 |   @Test
498 |   public void iterate_on_zero_characters() {
499 |     Fluent<String> chars = Fluent.ofChars("");
500 | 
501 |     assertThat(chars.toList()).isEmpty();
502 |   }
503 | 
504 |   @Test
505 |   public void split_string() {
506 |     Fluent<String> letters = Fluent.split("A,B,C,D", ",");
507 | 
508 |     assertThat(letters.toList()).containsExactly("A", "B", "C", "D");
509 |   }
510 | }
511 | 


--------------------------------------------------------------------------------
/src/main/java/net/codestory/Fluent.java:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Copyright (C) 2013 all@code-story.net
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *         http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License
 15 |  */
 16 | package net.codestory;
 17 | 
 18 | import java.util.*;
 19 | import java.util.concurrent.ConcurrentHashMap;
 20 | import java.util.concurrent.atomic.AtomicInteger;
 21 | import java.util.function.*;
 22 | import java.util.regex.Pattern;
 23 | import java.util.stream.*;
 24 | 
 25 | import static java.util.Objects.requireNonNull;
 26 | 
 27 | @FunctionalInterface
 28 | public interface Fluent<T> extends Iterable<T> {
 29 |   Stream<T> stream();
 30 | 
 31 |   static <T> Fluent<T> of() {
 32 |     return Stream::empty;
 33 |   }
 34 | 
 35 |   @SafeVarargs
 36 |   static <T> Fluent<T> of(T... values) {
 37 |     requireNonNull(values);
 38 |     return () -> Stream.of(values);
 39 |   }
 40 | 
 41 |   static Fluent<Integer> of(int[] values) {
 42 |     requireNonNull(values);
 43 |     return () -> IntStream.of(values).boxed();
 44 |   }
 45 | 
 46 |   static Fluent<Double> of(double[] values) {
 47 |     requireNonNull(values);
 48 |     return () -> DoubleStream.of(values).boxed();
 49 |   }
 50 | 
 51 |   static Fluent<Long> of(long[] values) {
 52 |     requireNonNull(values);
 53 |     return () -> LongStream.of(values).boxed();
 54 |   }
 55 | 
 56 |   static <T> Fluent<T> of(Iterable<T> values) {
 57 |     requireNonNull(values);
 58 |     return (values instanceof Fluent<?>) ? (Fluent<T>) values : () -> StreamSupport.stream(values.spliterator(), false);
 59 |   }
 60 | 
 61 |   static <T> Fluent<T> of(Iterator<T> values) {
 62 |     requireNonNull(values);
 63 |     return () -> StreamSupport.stream(Spliterators.spliteratorUnknownSize(values, 0), false);
 64 |   }
 65 | 
 66 |   static <T> Fluent<T> of(Stream<T> stream) {
 67 |     requireNonNull(stream);
 68 |     return () -> stream;
 69 |   }
 70 | 
 71 |   static Fluent<String> ofChars(String text) {
 72 |     requireNonNull(text);
 73 | 
 74 |     return of(Stream.generate(new Supplier<String>() {
 75 |       int index = 0;
 76 | 
 77 |       @Override
 78 |       public String get() {
 79 |         return text.substring(index, ++index);
 80 |       }
 81 |     })).limit(text.length());
 82 |   }
 83 | 
 84 |   static Fluent<String> split(String text, String regex) {
 85 |     requireNonNull(text);
 86 |     requireNonNull(regex);
 87 |     return of(Pattern.compile(regex).splitAsStream(text));
 88 |   }
 89 | 
 90 |   public default void forEach(Consumer<? super T> action) {
 91 |     requireNonNull(action);
 92 |     stream().forEach(action);
 93 |   }
 94 | 
 95 |   public default <R> Fluent<R> map(Function<? super T, ? extends R> transform) {
 96 |     requireNonNull(transform);
 97 |     return () -> stream().map(transform);
 98 |   }
 99 | 
100 |   public default IntStream mapToInt(ToIntFunction<? super T> transform) {
101 |     requireNonNull(transform);
102 |     return stream().mapToInt(transform);
103 |   }
104 | 
105 |   public default LongStream mapToLong(ToLongFunction<? super T> transform) {
106 |     requireNonNull(transform);
107 |     return stream().mapToLong(transform);
108 |   }
109 | 
110 |   public default DoubleStream mapToDouble(ToDoubleFunction<? super T> transform) {
111 |     requireNonNull(transform);
112 |     return stream().mapToDouble(transform);
113 |   }
114 | 
115 |   public default IntStream flatMapToInt(Function<? super T, ? extends IntStream> transform) {
116 |     requireNonNull(transform);
117 |     return stream().flatMapToInt(transform);
118 |   }
119 | 
120 |   public default LongStream flatMapToLong(Function<? super T, ? extends LongStream> transform) {
121 |     requireNonNull(transform);
122 |     return stream().flatMapToLong(transform);
123 |   }
124 | 
125 |   public default DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> transform) {
126 |     requireNonNull(transform);
127 |     return stream().flatMapToDouble(transform);
128 |   }
129 | 
130 |   public default Fluent<T> filter(Predicate<? super T> predicate) {
131 |     requireNonNull(predicate);
132 |     return () -> stream().filter(predicate);
133 |   }
134 | 
135 |   public default Fluent<T> exclude(Predicate<? super T> predicate) {
136 |     requireNonNull(predicate);
137 |     return () -> stream().filter(predicate.negate());
138 |   }
139 | 
140 |   @SuppressWarnings("unchecked")
141 |   public default <R> Fluent<R> filter(Class<R> type) {
142 |     requireNonNull(type);
143 |     return (Fluent<R>) filter(value -> type.isInstance(value));
144 |   }
145 | 
146 |   public default long size() {
147 |     return stream().count();
148 |   }
149 | 
150 |   public default long count(Predicate<? super T> predicate) {
151 |     requireNonNull(predicate);
152 |     return stream().filter(predicate).count();
153 |   }
154 | 
155 |   public default Optional<T> first() {
156 |     return stream().findFirst();
157 |   }
158 | 
159 |   public default Optional<T> any() {
160 |     return stream().findAny();
161 |   }
162 | 
163 |   public default Fluent<T> skip(long n) {
164 |     return () -> stream().skip(n);
165 |   }
166 | 
167 |   public default Optional<T> firstMatch(Predicate<? super T> predicate) {
168 |     requireNonNull(predicate);
169 |     return stream().filter(predicate).findFirst();
170 |   }
171 | 
172 |   public default Optional<T> last() {
173 |     return stream().reduce((l, r) -> r);
174 |   }
175 | 
176 |   public default boolean isEmpty() {
177 |     return !iterator().hasNext();
178 |   }
179 | 
180 |   public default String join(CharSequence delimiter) {
181 |     requireNonNull(delimiter);
182 |     StringJoiner joiner = new StringJoiner(delimiter);
183 |     forEach(value -> joiner.add(String.valueOf(value)));
184 |     return joiner.toString();
185 |   }
186 | 
187 |   public default String join() {
188 |     return join("");
189 |   }
190 | 
191 |   public default boolean contains(Object element) {
192 |     return stream().anyMatch(Predicate.isEqual(element));
193 |   }
194 | 
195 |   public default int indexOf(Object element) {
196 |     int index = 0;
197 |     for (T value : this) {
198 |       if (Objects.equals(value, element)) {
199 |         return index;
200 |       }
201 |       index++;
202 |     }
203 |     return -1;
204 |   }
205 | 
206 |   public default T[] toArray(IntFunction<T[]> generator) {
207 |     requireNonNull(generator);
208 |     return stream().toArray(generator);
209 |   }
210 | 
211 |   public default List<T> toList() {
212 |     return copyInto(new ArrayList<>());
213 |   }
214 | 
215 |   public default List<T> toList(int size) {
216 |     return copyInto(new ArrayList<>(size));
217 |   }
218 | 
219 |   public default List<T> toSortedList(Comparator<? super T> comparator) {
220 |     requireNonNull(comparator);
221 |     List<T> list = copyInto(new ArrayList<>());
222 |     Collections.sort(list, comparator);
223 |     return list;
224 |   }
225 | 
226 |   public default SortedSet<T> toSortedSet(Comparator<? super T> comparator) {
227 |     requireNonNull(comparator);
228 |     return copyInto(new TreeSet<>(comparator));
229 |   }
230 | 
231 |   public default Set<T> toSet() {
232 |     return copyInto(new HashSet<>());
233 |   }
234 | 
235 |   public default boolean anyMatch(Predicate<? super T> predicate) {
236 |     requireNonNull(predicate);
237 |     return stream().anyMatch(predicate);
238 |   }
239 | 
240 |   public default boolean allMatch(Predicate<? super T> predicate) {
241 |     requireNonNull(predicate);
242 |     return stream().allMatch(predicate);
243 |   }
244 | 
245 |   public default boolean noneMatch(Predicate<? super T> predicate) {
246 |     requireNonNull(predicate);
247 |     return stream().noneMatch(predicate);
248 |   }
249 | 
250 |   public default <R, A> R collect(Collector<? super T, A, ? extends R> collector) {
251 |     requireNonNull(collector);
252 |     return stream().collect(collector);
253 |   }
254 | 
255 |   public default Fluent<T> limit(int limitSize) {
256 |     if (limitSize < 0) {
257 |       throw new IllegalArgumentException("limit is negative");
258 |     }
259 |     return () -> stream().limit(limitSize);
260 |   }
261 | 
262 |   public default Fluent<T> cycle() {
263 |     return () -> Stream.generate(() -> stream()).flatMap(s -> s);
264 |   }
265 | 
266 |   public default void forEachWithIndex(BiConsumer<Integer, T> consumer) {
267 |     requireNonNull(consumer);
268 |     if (isParallel()) {
269 |       AtomicInteger index = new AtomicInteger(0);
270 |       forEach(value -> consumer.accept(index.getAndIncrement(), value));
271 |     } else {
272 |       int index = 0;
273 |       for (T value : this) {
274 |         consumer.accept(index++, value);
275 |       }
276 |     }
277 |   }
278 | 
279 |   public default Fluent<T> peek(Consumer<? super T> action) {
280 |     requireNonNull(action);
281 |     return () -> stream().peek(action);
282 |   }
283 | 
284 |   public default void forEachOrdered(Consumer<? super T> action) {
285 |     requireNonNull(action);
286 |     stream().forEachOrdered(action);
287 |   }
288 | 
289 |   public default Iterator<T> iterator() {
290 |     return stream().iterator();
291 |   }
292 | 
293 |   public default Spliterator<T> spliterator() {
294 |     return stream().spliterator();
295 |   }
296 | 
297 |   public default boolean isParallel() {
298 |     return stream().isParallel();
299 |   }
300 | 
301 |   public default Fluent<T> sequential() {
302 |     return () -> stream().sequential();
303 |   }
304 | 
305 |   public default Fluent<T> unordered() {
306 |     return () -> stream().unordered();
307 |   }
308 | 
309 |   public default IntStream intStream(ToIntFunction<? super T> mapper) {
310 |     requireNonNull(mapper);
311 |     return stream().mapToInt(mapper);
312 |   }
313 | 
314 |   public default LongStream longStream(ToLongFunction<? super T> mapper) {
315 |     requireNonNull(mapper);
316 |     return stream().mapToLong(mapper);
317 |   }
318 | 
319 |   public default DoubleStream doubleStream(ToDoubleFunction<? super T> mapper) {
320 |     requireNonNull(mapper);
321 |     return stream().mapToDouble(mapper);
322 |   }
323 | 
324 |   public default Optional<T> min(Comparator<? super T> comparator) {
325 |     requireNonNull(comparator);
326 |     return stream().min(comparator);
327 |   }
328 | 
329 |   public default Optional<T> max(Comparator<? super T> comparator) {
330 |     requireNonNull(comparator);
331 |     return stream().max(comparator);
332 |   }
333 | 
334 |   public default <C extends Collection<T>> C copyInto(C collection) {
335 |     requireNonNull(collection);
336 |     return stream().collect(Collectors.toCollection(() -> collection));
337 |   }
338 | 
339 |   public default T reduce(T identity, BinaryOperator<T> accumulator) {
340 |     requireNonNull(accumulator);
341 |     return stream().reduce(identity, accumulator);
342 |   }
343 | 
344 |   public default Optional<T> reduce(BinaryOperator<T> accumulator) {
345 |     requireNonNull(accumulator);
346 |     return stream().reduce(accumulator);
347 |   }
348 | 
349 |   public default <K> Map<K, T> uniqueIndex(Function<? super T, K> toKey) {
350 |     requireNonNull(toKey);
351 | 
352 |     Map<K, T> map = isParallel() ? new ConcurrentHashMap<>() : new HashMap<>();
353 | 
354 |     forEach(value -> {
355 |       K key = toKey.apply(value);
356 |       if (null != map.put(key, value)) {
357 |         throw new IllegalArgumentException("Same key used twice " + key + " " + value);
358 |       }
359 |     });
360 | 
361 |     return map;
362 |   }
363 | 
364 |   public default <K> Map<K, List<T>> index(Function<? super T, K> toKey) {
365 |     requireNonNull(toKey);
366 | 
367 |     Map<K, List<T>> multiMap = isParallel() ? new ConcurrentHashMap<>() : new HashMap<>();
368 | 
369 |     forEach(value -> {
370 |       K key = toKey.apply(value);
371 | 
372 |       List<T> list = multiMap.computeIfAbsent(key, k -> new ArrayList<T>());
373 |       list.add(value);
374 |     });
375 | 
376 |     return multiMap;
377 |   }
378 | 
379 |   public default <V> Map<T, V> toMap(Function<? super T, V> toValue) {
380 |     return toMap(k -> k, toValue);
381 |   }
382 | 
383 |   public default <K, V> Map<K, V> toMap(Function<? super T, K> toKey, Function<? super T, V> toValue) {
384 |     return MapUtils.toMap(this, toKey, toValue, isParallel() ? ConcurrentHashMap::new : HashMap::new);
385 |   }
386 | 
387 |   public default <K, V> Map<K, V> toLenientMap(Function<? super T, K> toKey, Function<? super T, V> toValue) {
388 |     return MapUtils.toLenientMap(this, toKey, toValue, isParallel() ? ConcurrentHashMap::new : HashMap::new);
389 |   }
390 | 
391 |   @SuppressWarnings("unchecked")
392 |   public default <K, V> SortedMap<K, V> toSortedMap(Function<? super T, K> toKey, Function<? super T, V> toValue) {
393 |     if (isParallel()) {
394 |       return (TreeMap) MapUtils.toMap(this, toKey, toValue, () -> Collections.synchronizedMap(new TreeMap<>()));
395 |     } else {
396 |       return (TreeMap) MapUtils.toMap(this, toKey, toValue, TreeMap::new);
397 |     }
398 |   }
399 | 
400 |   public default <K, V> SortedMap<K, V> toLenientSortedMap(Function<? super T, K> toKey, Function<? super T, V> toValue) {
401 |     if (isParallel()) {
402 |       return (TreeMap) MapUtils.toLenientMap(this, toKey, toValue, () -> Collections.synchronizedMap(new TreeMap<>()));
403 |     } else {
404 |       return (TreeMap) MapUtils.toLenientMap(this, toKey, toValue, TreeMap::new);
405 |     }
406 |   }
407 | 
408 |   public default T get(int index) {
409 |     if (index < 0) {
410 |       throw new IllegalArgumentException("index is negative");
411 |     }
412 | 
413 |     int current = 0;
414 |     for (T next : this) {
415 |       if (current == index) {
416 |         return next;
417 |       }
418 |       current++;
419 |     }
420 |     throw new ArrayIndexOutOfBoundsException();
421 |   }
422 | 
423 |   public default <V, L extends Collection<V>> Fluent<V> flatMap(Function<? super T, L> toCollection) {
424 |     requireNonNull(toCollection);
425 |     return () -> {
426 |       Function<? super L, Stream<V>> toStream = l -> l.stream();
427 |       Function<? super T, Stream<V>> toListAndThenToStream = toCollection.andThen(toStream);
428 |       return stream().flatMap(toListAndThenToStream);
429 |     };
430 |   }
431 | 
432 |   public default Fluent<T> parallel() {
433 |     return () -> stream().parallel();
434 |   }
435 | 
436 |   public default Fluent<T> sorted() {
437 |     return () -> stream().sorted();
438 |   }
439 | 
440 |   public default Fluent<T> distinct() {
441 |     return () -> stream().distinct();
442 |   }
443 | 
444 |   public default Fluent<T> sorted(Comparator<? super T> comparator) {
445 |     requireNonNull(comparator);
446 |     return () -> stream().sorted(comparator);
447 |   }
448 | 
449 |   public default Fluent<T> reversed(Comparator<? super T> comparator) {
450 |     requireNonNull(comparator);
451 |     return () -> stream().sorted(comparator.reversed());
452 |   }
453 | 
454 |   public default <C extends Comparable<? super C>> Fluent<T> sortedOn(Function<? super T, C> comparator) {
455 |     requireNonNull(comparator);
456 |     return () -> stream().sorted((l, r) -> comparator.apply(l).compareTo(comparator.apply(r)));
457 |   }
458 | 
459 |   public default <C extends Comparable<? super C>> Fluent<T> reversedOn(Function<? super T, C> comparator) {
460 |     requireNonNull(comparator);
461 |     return () -> stream().sorted((l, r) -> comparator.apply(r).compareTo(comparator.apply(l)));
462 |   }
463 | 
464 |   //@SafeVarargs
465 |   public default Fluent<T> concat(T... values) {
466 |     requireNonNull(values);
467 |     return () -> Stream.concat(stream(), Stream.of(values));
468 |   }
469 | 
470 |   public default Fluent<T> concat(Iterable<T> values) {
471 |     requireNonNull(values);
472 |     return () -> Stream.concat(stream(), StreamSupport.stream(values.spliterator(), false));
473 |   }
474 | 
475 |   public default T getOnlyElement() {
476 |     return first().get();
477 |   }
478 | 
479 |   public default Fluent<T> notNulls() {
480 |     return filter(v -> v != null);
481 |   }
482 | 
483 |   public default <K> Map<K, List<T>> groupBy(Function<? super T, ? extends K> classifier) {
484 |     requireNonNull(classifier);
485 |     return stream().collect(Collectors.groupingBy(classifier, HashMap::new, Collectors.toList()));
486 |   }
487 | 
488 |   public default <K, M extends Map<K, List<T>>> Map<K, List<T>> groupBy(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory) {
489 |     requireNonNull(classifier);
490 |     return stream().collect(Collectors.groupingBy(classifier, mapFactory, Collectors.toList()));
491 |   }
492 | 
493 |   class MapUtils {
494 |     private MapUtils() {
495 |       // Static class
496 |     }
497 | 
498 |     private static <T, K, V> Map<K, V> toMap(Iterable<T> values, Function<? super T, K> toKey, Function<? super T, V> toValue, Supplier<? extends Map<K, V>> mapSupplier) {
499 |       requireNonNull(toKey);
500 |       requireNonNull(toValue);
501 | 
502 |       Map<K, V> map = mapSupplier.get();
503 | 
504 |       values.forEach(item -> {
505 |         K key = toKey.apply(item);
506 |         V value = toValue.apply(item);
507 |         if (null != map.put(key, value)) {
508 |           throw new IllegalArgumentException("Same key used twice " + key + " " + value);
509 |         }
510 |       });
511 | 
512 |       return map;
513 |     }
514 | 
515 |     private static <T, K, V> Map<K, V> toLenientMap(Iterable<T> values, Function<? super T, K> toKey, Function<? super T, V> toValue, Supplier<? extends Map<K, V>> mapSupplier) {
516 |       requireNonNull(toKey);
517 |       requireNonNull(toValue);
518 | 
519 |       Map<K, V> map = mapSupplier.get();
520 | 
521 |       values.forEach(item -> {
522 |         K key = toKey.apply(item);
523 |         V value = toValue.apply(item);
524 |         map.put(key, value);
525 |       });
526 | 
527 |       return map;
528 |     }
529 |   }
530 | }
531 | 


--------------------------------------------------------------------------------