TerribleDev/LinqRb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add chunk

Browse Source
This commit is contained in:
Tommy Parnell
2015-11-01 09:29:58 -05:00
parent 4613ed97c9
commit a18728474b
5 changed files with 235 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Readme.md
View File

@@ -27,6 +27,12 @@ Cycle will run an action for every element in an IEnumerable. This will run fore
this will print `1,2,3,4,1,2,3,4`
## Chunk
Chunk will take the current array and make child arrays, setting the size of the child array to be the specified chunk size
`new List<int>() { 1,2,3,4,5,6}.Chunk(2))` => `[[1,2], [3,4] [5,6]]`
## ForEach
I hope I dont have to explain this one. `ListOfThings.ForEach(a=>a.DoSomething())`

149
src/LinqRb.UnitTests/EnumerableTest.cs
View File

@@ -6,73 +6,94 @@ using Xunit;
namespace LinqRb.UnitTests
{
public class EnumerableTest
{
[Fact]
public void TestRejectSuccessful()
{
var range = Enumerable.Range(1, 5);
var rejected = range.Reject(a => a == 3);
foreach(var number in rejected)
{
Assert.NotEqual(number, 3);
}
Assert.True(rejected.Count() == 4);
}
public class EnumerableTest
{
[Fact]
public void TestRejectSuccessful()
{
var range = Enumerable.Range(1, 5);
var rejected = range.Reject(a => a == 3);
foreach (var number in rejected)
{
Assert.NotEqual(number, 3);
}
Assert.True(rejected.Count() == 4);
}
[Fact]
public void TestAssoc()
{
var outer = new List<List<string>>();
outer.Add(new List<string>() { "books", "school", "apple", "playtime" });
outer.Add(new List<string>() { "star", "wars", "vader" });
var assc = outer.AssocFirstOrDefault("wars");
Assert.True(assc.Count() == 3);
var assc2 = outer.AssocFirstOrDefault("poop");
Assert.True(assc2 == null);
}
[Fact]
public void TestAssoc()
{
var outer = new List<List<string>>();
outer.Add(new List<string>() { "books", "school", "apple", "playtime" });
outer.Add(new List<string>() { "star", "wars", "vader" });
var assc = outer.AssocFirstOrDefault("wars");
Assert.True(assc.Count() == 3);
var assc2 = outer.AssocFirstOrDefault("poop");
Assert.True(assc2 == null);
}
[Fact]
public void TestCycle()
{
var p = new List<string> { "a", "b" };
var count = 0;
p.Cycle(a => count++, 2);
Assert.True(count == 4);
}
[Fact]
public void TestCycle()
{
var p = new List<string> { "a", "b" };
var count = 0;
p.Cycle(a => count++, 2);
Assert.True(count == 4);
}
[Fact]
public void TestForEach()
{
var counter = 0;
Enumerable.Range(1, 4).ForEach(a => counter++);
Assert.Equal(counter, 4);
}
[Fact]
public void TestForEach()
{
var counter = 0;
Enumerable.Range(1, 4).ForEach(a => counter++);
Assert.Equal(counter, 4);
}
[Fact]
public void TestForEachIndex()
{
var counter = 0;
Enumerable.Range(1, 4).ForEach((a, index) =>
{
Assert.Equal(counter, index);
counter++;
});
Assert.Equal(counter, 4);
}
[Fact]
public void TestForEachIndex()
{
var counter = 0;
Enumerable.Range(1, 4).ForEach((a, index) =>
{
Assert.Equal(counter, index);
counter++;
});
Assert.Equal(counter, 4);
}
[Fact]
public void TestDistinct()
{
var items = new List<Tuple<string, string>>();
items.Add(Tuple.Create("awesom", "1"));
items.Add(Tuple.Create("awesom", "7"));
items.Add(Tuple.Create("awesom", "6"));
items.Add(Tuple.Create("awzomes", "2"));
items.Add(Tuple.Create("pwned", "3"));
items.Add(Tuple.Create("kewlbz", "4"));
var result = items.Distinct(a => a.Item1);
Assert.True(result.Count() == 4);
}
}
[Fact]
public void TestDistinct()
{
var items = new List<Tuple<string, string>>();
items.Add(Tuple.Create("awesom", "1"));
items.Add(Tuple.Create("awesom", "7"));
items.Add(Tuple.Create("awesom", "6"));
items.Add(Tuple.Create("awzomes", "2"));
items.Add(Tuple.Create("pwned", "3"));
items.Add(Tuple.Create("kewlbz", "4"));
var result = items.Distinct(a => a.Item1);
Assert.True(result.Count() == 4);
}
[Fact]
public void TestChunks()
{
var t = new List<string>();
var data = Enumerable.Range(1, 20).Select((a) => "ts").Chunk(4).ToList();
Assert.Equal(data.Count, 5);
foreach (var childData in data)
{
Assert.Equal(childData.Count(), 4);
}
}
[Fact]
public void TestOddSizeChunks()
{
var t = new List<string>();
var data = Enumerable.Range(1, 22).Select((a) => "ts").Chunk(4).ToList();
Assert.Equal(data.Count, 6);
Assert.True(data.First(a => a.Count() < 4).Count() == 2);
}
}
}

7
src/LinqRb.UnitTests/project.json
View File

@@ -15,13 +15,6 @@
},
"frameworks": {
"dnxcore50": {
},
"dnx50": {
},
"dnx451": {
}
}
}

279
src/LinqRb/Extensions/IEnumerable.cs
View File

@@ -2,149 +2,152 @@
namespace System.Linq
{
public static class IEnumerable
{
/// <summary>
/// Return Enumerable where action is not true
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="predicate"></param>
/// <returns></returns>
public static IEnumerable<T> Reject<T>(this IEnumerable<T> source, Func<T, bool> predicate)
{
foreach(T element in source)
{
if(!predicate(element)) yield return element;
}
}
/// <summary>
/// Break a list of items into chunks of a specific size
/// </summary>
public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int chunksize)
{
var enumerator = source.GetEnumerator();
var arr = new List<T>(chunksize);
while (enumerator.MoveNext())
{
arr.Add(enumerator.Current);
if(arr.Count >= chunksize)
{
yield return arr;
arr = new List<T>(chunksize);
}
}
}
/// <summary>
/// Returns the first array that contains the object
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="obj"></param>
/// <returns></returns>
public static IEnumerable<T> AssocFirstOrDefault<T>(this IEnumerable<IEnumerable<T>> source, T obj)
{
var outer = source.GetEnumerator();
while(outer.MoveNext())
{
var inner = outer.Current.GetEnumerator();
while(inner.MoveNext())
{
if(inner.Current.Equals(obj))
{
return outer.Current;
}
}
}
return null;
}
public static class IEnumerable
{
/// <summary>
/// Return Enumerable where action is not true
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="predicate"></param>
/// <returns></returns>
public static IEnumerable<T> Reject<T>(this IEnumerable<T> source, Func<T, bool> predicate)
{
foreach (T element in source)
{
if (!predicate(element)) yield return element;
}
}
/// <summary>
/// Remove all nulls
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
public static IEnumerable<T> Compact<T>(this IEnumerable<T> source)
where T : class
{
foreach(var item in source)
{
if(item != null)
{
yield return item;
}
}
}
/// <summary>
/// Break a list of items into chunks of a specific size
/// </summary>
/// <param name="source"></param>
/// <param name="chunkSize">How big you wish your chunks to be</param>
public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int chunkSize)
{
var enumerator = source.GetEnumerator();
var arr = new List<T>(chunkSize);
while (enumerator.MoveNext())
{
arr.Add(enumerator.Current);
if (arr.Count >= chunkSize)
{
yield return arr;
arr = new List<T>(chunkSize);
}
}
yield return arr;
}
/// <summary>
/// Run action over array x times
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="action"></param>
/// <param name="times">Times we should enumerate over the array</param>
public static void Cycle<T>(this IEnumerable<T> source, Action<T> action, int times)
{
for(int i = 0; i < times; i++)
{
Enumerate(source, action);
}
}
/// <summary>
/// Returns the first array that contains the object
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="obj"></param>
/// <returns></returns>
public static IEnumerable<T> AssocFirstOrDefault<T>(this IEnumerable<IEnumerable<T>> source, T obj)
{
var outer = source.GetEnumerator();
while (outer.MoveNext())
{
var inner = outer.Current.GetEnumerator();
while (inner.MoveNext())
{
if (inner.Current.Equals(obj))
{
return outer.Current;
}
}
}
return null;
}
/// <summary>
/// Infinate loop over Enumerable calling the action over each one
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="action"></param>
public static void Cycle<T>(this IEnumerable<T> source, Action<T> action)
{
while(true)
{
Enumerate(source, action);
}
}
/// <summary>
/// Remove all nulls
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
public static IEnumerable<T> Compact<T>(this IEnumerable<T> source)
where T : class
{
foreach (var item in source)
{
if (item != null)
{
yield return item;
}
}
}
public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
{
Enumerate(source, action);
}
/// <summary>
/// Run action over array x times
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="action"></param>
/// <param name="times">Times we should enumerate over the array</param>
public static void Cycle<T>(this IEnumerable<T> source, Action<T> action, int times)
{
for (int i = 0; i < times; i++)
{
Enumerate(source, action);
}
}
public static void ForEach<T>(this IEnumerable<T> source, Action<T, int> action)
{
var index = 0;
var enumerator = source.GetEnumerator();
while(enumerator.MoveNext())
{
action?.Invoke(enumerator.Current, index);
index++;
}
}
/// <summary>
/// Infinate loop over Enumerable calling the action over each one
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="action"></param>
public static void Cycle<T>(this IEnumerable<T> source, Action<T> action)
{
while (true)
{
Enumerate(source, action);
}
}
public static IEnumerable<T> Distinct<T>(this IEnumerable<T> source, Func<T, object> comparer)
{
var items = new HashSet<object>();
foreach(var item in source)
{
var comparedItem = comparer?.Invoke(item);
if(!items.Contains(comparedItem))
{
items.Add(comparedItem);
yield return item;
}
}
}
public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
{
Enumerate(source, action);
}
private static void Enumerate<T>(IEnumerable<T> source, Action<T> action)
{
var enumerator = source.GetEnumerator();
while(enumerator.MoveNext())
{
action?.Invoke(enumerator.Current);
}
}
}
public static void ForEach<T>(this IEnumerable<T> source, Action<T, int> action)
{
var index = 0;
var enumerator = source.GetEnumerator();
while (enumerator.MoveNext())
{
action?.Invoke(enumerator.Current, index);
index++;
}
}
public static IEnumerable<T> Distinct<T>(this IEnumerable<T> source, Func<T, object> comparer)
{
var items = new HashSet<object>();
foreach (var item in source)
{
var comparedItem = comparer?.Invoke(item);
if (!items.Contains(comparedItem))
{
items.Add(comparedItem);
yield return item;
}
}
}
private static void Enumerate<T>(IEnumerable<T> source, Action<T> action)
{
var enumerator = source.GetEnumerator();
while (enumerator.MoveNext())
{
action?.Invoke(enumerator.Current);
}
}
}
}

6
src/LinqRb/project.json
View File

@@ -1,5 +1,5 @@
{
"version": "1.1.0",
"version": "1.2.0",
"description": "Add additional Linq extensions familiar to ruby ppl",
"authors": [ "Tommy Parnell" ],
"tags": [ "Linq" ],
@@ -8,7 +8,7 @@
"frameworks": {
"dnx50": {
},
"dnxcore50": {
"dnxcore50": {
"dependencies": {
"System.Collections": "4.0.11-beta-*",
"System.Linq": "4.0.1-beta-*",
@@ -26,7 +26,7 @@
},
"net452": {
},
"net46": {
"net46": {
}
}
}