five_leaves 0.2.0 → 0.2.1

data/README.md

@@ -2,6 +2,37 @@
 
 a collection of useful ruby methods
 
+## Examples
+
+For more examples, see the [unit tests](https://github.com/mattraibert/five_leaves/blob/master/test/)
+
+
+```
+require 'five_leaves/lazy_enum'
+
+def test_lazy_select_can_select_from_infinite_series
+  assert_equal [0, 2, 4, 6, 8], (0..(1.0/0.0)).lazy_select { |x| x % 2 == 0 }.take(5)
+end
+
+def test_lazy_map_can_map_inifinite_series
+  assert_equal [0, 2, 4, 6, 8], (0..(1.0/0.0)).lazy_map { |x| x * 2 }.take(5)
+end
+
+def test_series
+  assert_equal [0, 2, 4, 6, 8], series { |x| x * 2 }.take(5)
+  assert_equal [2, 4, 6, 8, 10], series(1) { |x| x * 2 }.take(5)
+end
+
+def test_lazy_zip_does
+  zip = series { |x| x }.lazy_zip(series { |x| x+1 })
+  assert_equal [0, 1], zip.next
+  assert_equal [1, 2], zip.next
+end
+```
+## Naming
+
+Five Leaves is named for a [restaurant](http://www.fiveleavesny.com/) in Brooklyn, NY.
+
 ## Copyright
 
 Copyright (c) 2012 Matt Raibert.

data/lib/five_leaves/items_following.rb

@@ -0,0 +1,7 @@
+class Array
+  def items_following(test)
+    index = self.index { |item| test === item }
+    first = index + 1
+    yield self[first..-1]
+  end
+end

data/lib/five_leaves/lazy_enum.rb

@@ -26,10 +26,12 @@ class Enumerator
   end
 end
 
-def series(init=0)
-  (init..(1.0/0.0)).lazy_map { |x| yield x }
-end
+module FiveLeaves
+  def self.series(init=0)
+    (init..(1.0/0.0)).lazy_map { |x| yield x }
+  end
 
-def find(init=0)
-  (init..(1.0/0.0)).find { |x| yield x }
+  def self.find(init=0)
+    (init..(1.0/0.0)).find { |x| yield x }
+  end
 end

data/lib/five_leaves/maximize.rb

@@ -1,6 +1,8 @@
 require 'five_leaves/lazy_enum'
 
+module FiveLeaves
 #find the input in the range which maximizes the result of the block
-def maximize(range = 1..1_000_000)
-  (range).lazy_map { |x| [yield(x), x] }.max[1]
+  def self.maximize(range = 1..1_000_000)
+    (range).lazy_map { |x| [yield(x), x] }.max[1]
+  end
 end

data/lib/five_leaves/palindromic.rb

@@ -1,6 +1,8 @@
 require 'five_leaves/enum_util'
 
-def palindromic?(n)
-  string = n.to_s
-  (0..string.size/2).all_match? { |i| string[i] == string[-1-i] }
+module FiveLeaves
+  def self.palindromic?(n)
+    string = n.to_s
+    (0..string.size/2).all_match? { |i| string[i] == string[-1-i] }
+  end
 end

data/lib/five_leaves/prime_util.rb

@@ -4,24 +4,26 @@ class Integer
   end
 
   def prime?
-    self > 1 && small_factors(self).size == 1
+    self > 1 && FiveLeaves.small_factors(self).size == 1
   end
 end
 
-def small_factors(n)
-  (Math.sqrt(n).truncate.downto 1).select { |x| x.divides? n }
-end
+module FiveLeaves
+  def self.small_factors(n)
+    (Math.sqrt(n).truncate.downto 1).select { |x| x.divides? n }
+  end
 
-def proper_factors(n)
-  sf = small_factors(n)
-  (sf.map { |x| n / x } + sf).uniq - [n]
-end
+  def self.proper_factors(n)
+    sf = small_factors(n)
+    (sf.map { |x| n / x } + sf).uniq - [n]
+  end
 
-def factors(n)
-  [n] + proper_factors(n)
-end
+  def self.factors(n)
+    [n] + proper_factors(n)
+  end
 
-def prime_factors(n)
-  small = small_factors(n)
-  (small.map { |f| n / f } + small).uniq.select { |x| x.prime? }
+  def self.prime_factors(n)
+    small = small_factors(n)
+    (small.map { |f| n / f } + small).uniq.select { |x| x.prime? }
+  end
 end

data/lib/five_leaves/range_util.rb

@@ -18,15 +18,15 @@ class Range
     stutter.lazy_zip squared
   end
 
-  def * n
+  def *(n)
     (size * n).times.lazy_map { |x| first + (x % size) }
   end
 
-  def ** n
+  def **(n)
     (size * n).times.lazy_map { |x| first + (x / n) }
   end
 
-  def pair_with range
+  def pair_with(range)
     (self * range.size).lazy_zip(range ** self.size)
   end
 end

data/test/items_following_test.rb

@@ -0,0 +1,17 @@
+require 'minitest/autorun'
+require 'five_leaves/items_following'
+
+class ItemsFollowingTest < MiniTest::Unit::TestCase
+  def test_items_following
+    data = %w(I want text that follows this THESE TWO NOT THIS)
+    result = []
+    data.items_following(/this/) do |items|
+      result << items[0]
+      result << items[1]
+    end
+    assert result.include? "THESE"
+    assert result.include? "TWO"
+    assert !result.include?("NOT")
+    assert !result.include?("this")
+  end
+end

data/test/lazy_enum_test.rb

@@ -11,12 +11,12 @@ class LazyEnumTest < MiniTest::Unit::TestCase
   end
 
   def test_series
-    assert_equal [0, 2, 4, 6, 8], series { |x| x * 2 }.take(5)
-    assert_equal [2, 4, 6, 8, 10], series(1) { |x| x * 2 }.take(5)
+    assert_equal [0, 2, 4, 6, 8], FiveLeaves.series { |x| x * 2 }.take(5)
+    assert_equal [2, 4, 6, 8, 10], FiveLeaves.series(1) { |x| x * 2 }.take(5)
   end
 
   def test_lazy_zip_does
-    zip = series { |x| x }.lazy_zip(series { |x| x+1 })
+    zip = FiveLeaves.series { |x| x }.lazy_zip(FiveLeaves.series { |x| x+1 })
     assert_equal [0, 1], zip.next
     assert_equal [1, 2], zip.next
   end

data/test/maximize_test.rb

@@ -3,9 +3,9 @@ require 'five_leaves/maximize'
 
 class MaximizeTest < MiniTest::Unit::TestCase
   def test_maximize
-    assert_equal 5, maximize(-10..10) { |x| (x - 5) * (-x + 5) }
-    assert_equal 5, maximize(-10..10) { |x| -x*x + 10*x }
-    assert_equal 10, maximize(-10..10) { |x| -x*x + 25*x }
-    assert_equal -10, maximize(-10..10) { |x| -x*x - 25*x }
+    assert_equal 5, FiveLeaves.maximize(-10..10) { |x| (x - 5) * (-x + 5) }
+    assert_equal 5, FiveLeaves.maximize(-10..10) { |x| -x*x + 10*x }
+    assert_equal 10, FiveLeaves.maximize(-10..10) { |x| -x*x + 25*x }
+    assert_equal -10, FiveLeaves.maximize(-10..10) { |x| -x*x - 25*x }
   end
 end

data/test/palindromic_test.rb

@@ -3,11 +3,11 @@ require 'five_leaves/palindromic'
 
 class PalindromicTest < MiniTest::Unit::TestCase
   def test_palindrome
-    assert(palindromic?(nil))
-    assert(palindromic?(9009))
-    assert(!palindromic?(1234))
-    assert(!palindromic?(1224))
-    assert(palindromic?(11211))
-    assert(!palindromic?(11238))
+    assert(FiveLeaves.palindromic?(nil))
+    assert(FiveLeaves.palindromic?(9009))
+    assert(!FiveLeaves.palindromic?(1234))
+    assert(!FiveLeaves.palindromic?(1224))
+    assert(FiveLeaves.palindromic?(11211))
+    assert(!FiveLeaves.palindromic?(11238))
   end
 end

data/test/prime_util_test.rb

@@ -3,31 +3,31 @@ require 'five_leaves/prime_util'
 
 class PrimeUtilTest < MiniTest::Unit::TestCase
   def test_small_factors_skips_factors_above_sqrt
-    assert_equal [2, 1], small_factors(6)
-    assert_equal [2, 1], small_factors(14)
+    assert_equal [2, 1], FiveLeaves.small_factors(6)
+    assert_equal [2, 1], FiveLeaves.small_factors(14)
   end
 
   def test_factors_finds_all_factors
-    assert_equal [6, 3, 2, 1], factors(6)
-    assert_equal [9, 3, 1], factors(9)
-    assert_equal [14, 7, 2, 1], factors(14)
-    assert_equal [25, 5, 1], factors(25)
+    assert_equal [6, 3, 2, 1], FiveLeaves.factors(6)
+    assert_equal [9, 3, 1], FiveLeaves.factors(9)
+    assert_equal [14, 7, 2, 1], FiveLeaves.factors(14)
+    assert_equal [25, 5, 1], FiveLeaves.factors(25)
   end
 
   def test_proper_factors
-    assert_equal [], proper_factors(1)
-    assert_equal [1], proper_factors(2)
-    assert_equal [3, 2, 1], proper_factors(6)
-    assert_equal [3, 1], proper_factors(9)
-    assert_equal [7, 2, 1], proper_factors(14)
-    assert_equal [5, 1], proper_factors(25)
+    assert_equal [], FiveLeaves.proper_factors(1)
+    assert_equal [1], FiveLeaves.proper_factors(2)
+    assert_equal [3, 2, 1], FiveLeaves.proper_factors(6)
+    assert_equal [3, 1], FiveLeaves.proper_factors(9)
+    assert_equal [7, 2, 1], FiveLeaves.proper_factors(14)
+    assert_equal [5, 1], FiveLeaves.proper_factors(25)
   end
 
   def test_prime_factors_finds_all_prime_factors
-    assert_equal [3, 2], prime_factors(6)
-    assert_equal [7, 2], prime_factors(14)
-    assert_equal [5], prime_factors(25)
-    assert_equal [7, 2], prime_factors(28)
+    assert_equal [3, 2], FiveLeaves.prime_factors(6)
+    assert_equal [7, 2], FiveLeaves.prime_factors(14)
+    assert_equal [5], FiveLeaves.prime_factors(25)
+    assert_equal [7, 2], FiveLeaves.prime_factors(28)
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: five_leaves
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-08 00:00:00.000000000 Z
+date: 2012-09-14 00:00:00.000000000 Z
 dependencies: []
 description: A collection of methods for creating series and iterators
 email: mattraibert@gmail.com
@@ -25,11 +25,13 @@ files:
 - lib/five_leaves/sum.rb
 - lib/five_leaves/range_util.rb
 - lib/five_leaves/maximize.rb
+- lib/five_leaves/items_following.rb
 - lib/five_leaves/lazy_enum.rb
 - lib/five_leaves/digits.rb
 - lib/five_leaves/enum_util.rb
 - lib/five_leaves/palindromic.rb
 - test/maximize_test.rb
+- test/items_following_test.rb
 - test/test_helper.rb
 - test/range_util_test.rb
 - test/lazy_enum_test.rb
@@ -51,6 +53,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 3540236943800449797
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -65,6 +70,7 @@ specification_version: 3
 summary: Some helpful methods
 test_files:
 - test/maximize_test.rb
+- test/items_following_test.rb
 - test/test_helper.rb
 - test/range_util_test.rb
 - test/lazy_enum_test.rb