nutella 0.8 → 0.9

data/lib/nutella/core_ext/enumerable/apply.rb

@@ -0,0 +1,29 @@
+module Enumerable
+  # Applies a method to the collection of various arguments.
+  #
+  # @example Requires multiple files
+  #   # Without Nutella:
+  #   %w[several libs to include].each { |r| require r }
+  #   # With Nutella:
+  #   %w[several libs to include].apply :require
+  #
+  # @example Passes in multiple arguments
+  #   # Without Nutella:
+  #   [1, 2, 3].each { |n| foo n, 5 }
+  #   # With Nutella:
+  #   [1, 2, 3].apply :foo, 5
+  #
+  # @example Uses a multi-dimensional array to get the extra arguments
+  #   arr = [[1, 2], [3, 4], [5, 6]]
+  #   # Without Nutella:
+  #   arr.each { |a, b| foo a, b }
+  #   # With Nutella:
+  #   arr.apply :foo
+  #
+  # @param [Symbol] method the method to apply
+  # @param [*Object] args any extra arguments to use
+  # @return [Array] a list of the return values of the method calls
+  def apply(method, *args)
+    map { |elem| method(method).(*elem, *args) }
+  end
+end

data/lib/nutella/core_ext/enumerable/group.rb

@@ -0,0 +1,30 @@
+module Enumerable
+  # Groups an array into smaller arrays of +size+ elements. Remaining elements
+  # at the end will be put into a smaller group if necessary, unless
+  # +discard_excess+ is true, in which case they will be discarded.
+  #
+  # @example Groups numbers 1..4 into groups of 2
+  #   (1..4).group(2)       # => [[1, 2], [3, 4]]
+  # @example Groups numbers 1..8 into groups of 3
+  #   (1..8).group(3)       # => [[1, 2, 3], [4, 5, 6], [7, 8]]
+  # @example Groups numbers 1..8 into groups of 3, discarding excess elements
+  #   (1..8).group(3, true) # => [[1, 2, 3], [4, 5, 6]]
+  #
+  # @param [Integer] size the size of the groups to create
+  # @param [Boolean] discard_excess whether or not to discard extra elements
+  # @return [Array] an array of the groups
+  def group(size, discard_excess = false)
+    groups = each_slice(size).to_a
+    groups[0..(discard_excess && groups.last.size < size ? -2 : -1)]
+  end
+
+  # Modifies the collection in place as described for
+  # <tt>Enumerable#group</tt>. Returns the modified collection, or nil if no
+  # modifications were made.
+  #
+  # @see Enumerable#group
+  def group!(size, discard_excess = false)
+    return nil if empty?
+    self.replace group(size, discard_excess)
+  end
+end

data/lib/nutella/core_ext/enumerable/map.rb

@@ -0,0 +1,30 @@
+module Enumerable
+  alias old_map map
+
+  # Allows mapping of a method with parameters across a collection.
+  #
+  # You no longer have to open up a block just because the method that you're
+  # mapping needs parameters. This method is still behaves just as it used to
+  # otherwise.
+  #
+  # @example Replaces all vowels with <tt>"x"</tt> in a list of strings
+  #   %w[Ann Mary Paul].map :gsub, /[aeiou]/i, "x" # => ["xnn", "Mxry", "Pxul"]
+  def map(*args, &block)
+    block_given? ? old_map(&block) : old_map { |elem| elem.send *args }
+  end
+end
+
+# TODO: See if there is a DRYer way to make this work with Array also.
+# Array doesn't inherit Enumerable's #map, so I'm forced to do this. Is there a
+# better way to make Array inherit the modified #map?
+
+class Array
+  alias old_map map
+
+  # Allows mapping of a method with parameters across an array.
+  #
+  # @see Enumerable#map
+  def map(*args, &block)
+    block_given? ? old_map(&block) : old_map { |elem| elem.send *args }
+  end
+end

data/lib/nutella/core_ext/enumerable/search.rb

@@ -0,0 +1,13 @@
+module Enumerable
+  alias contains? include?
+  alias includes? include?
+
+  # The inverse of <tt>Enumerable#include?</tt>.
+  #
+  # @param [Object] object the object to test for exclusion
+  # @return [Boolean] whether or not the collection excludes +object+
+  def exclude?(object)
+    !include? object
+  end
+  alias excludes? exclude?
+end

data/lib/nutella/core_ext/enumerable/sum.rb

@@ -0,0 +1,24 @@
+module Enumerable
+  # Add together all numeric elements in the collection. When using a block,
+  # adds together all numeric elements that pass the predicate in that block.
+  #
+  # @example Sums up the elements of an array
+  #   [1, 2, 3].sum         # => 6
+  # @example Sums up the elements of a 2-dimensional array
+  #   [[1, 2], [3, 4]].sum  # => 10
+  # @example Sums up the numeric elements of a hash
+  #   { a: 4, b: 5 }.sum    # => 9
+  # @example Ignores the non-numeric element in the array
+  #   [2, "string", 9].sum  # => 11
+  # @example Sums up the even numbers from 1 to 10
+  #   (1..10).sum &:even?
+  # @example Sums up the numbers from 1 to 100 that are multiples of 3
+  #   (1..100).sum { |n| n % 3 == 0 }
+  #
+  # @return [Numeric] the sum of all numeric elements in the collection
+  def sum(&block)
+    # TODO: Two selects in a row, how to DRY this up?
+    flat = respond_to?(:flatten) ? flatten : self
+    flat.select { |e| e.is_a? Numeric }.select(&block).inject(:+) || 0
+  end
+end

data/lib/nutella/core_ext/enumerable.rb

@@ -1,65 +1 @@
-module Enumerable
-  alias_method :contains?, :include?
-  alias_method :includes?, :include?
-
-  # The inverse of <tt>Enumerable#include?</tt>.
-  #
-  # @param [Object] object the object to test for exclusion
-  # @return [Boolean] whether or not the collection excludes +object+
-  def exclude?(object)
-    !include? object
-  end
-  alias_method :excludes?, :exclude?
-
-  # Groups an array into smaller arrays of +size+ elements. Remaining elements
-  # at the end will be put into a smaller group if necessary, unless
-  # +discard_excess+ is true, in which case they will be discarded.
-  #
-  # @example Groups numbers 1..4 into groups of 2
-  #   (1..4).group(2)       # => [[1, 2], [3, 4]]
-  # @example Groups numbers 1..8 into groups of 3
-  #   (1..8).group(3)       # => [[1, 2, 3], [4, 5, 6], [7, 8]]
-  # @example Groups numbers 1..8 into groups of 3, discarding excess elements
-  #   (1..8).group(3, true) # => [[1, 2, 3], [4, 5, 6]]
-  #
-  # @param [Integer] size the size of the groups to create
-  # @param [Boolean] discard_excess whether or not to discard extra elements
-  # @return [Array] an array of the groups
-  def group(size, discard_excess = false)
-    groups = each_slice(size).to_a
-    groups[0..(discard_excess && groups.last.size < size ? -2 : -1)]
-  end
-
-  # Modifies the collection in place as described for
-  # <tt>Enumerable#group</tt>. Returns the modified collection, or nil if no
-  # modifications were made.
-  #
-  # @see Enumerable#group
-  def group!(size, discard_excess = false)
-    return nil if empty?
-    self.replace group(size, discard_excess)
-  end
-
-  # Add together all numeric elements in the collection. When using a block,
-  # adds together all numeric elements that pass the predicate in that block.
-  #
-  # @example Sums up the elements of an array
-  #   [1, 2, 3].sum         # => 6
-  # @example Sums up the elements of a 2-dimensional array
-  #   [[1, 2], [3, 4]].sum  # => 10
-  # @example Sums up the numeric elements of a hash
-  #   { a: 4, b: 5 }.sum    # => 9
-  # @example Ignores the non-numeric element in the array
-  #   [2, "string", 9].sum  # => 11
-  # @example Sums up the even numbers from 1 to 10
-  #   (1..10).sum &:even?
-  # @example Sums up the numbers from 1 to 100 that are multiples of 3
-  #   (1..100).sum { |n| n % 3 == 0 }
-  #
-  # @return [Numeric] the sum of all numeric elements in the collection
-  def sum(&block)
-    # TODO: Two selects in a row, how to DRY this up?
-    flat = respond_to?(:flatten) ? flatten : self
-    flat.select { |e| e.is_a? Numeric }.select(&block).inject(:+) || 0
-  end
-end
+Dir[File.expand_path("../enumerable/**/*.rb", __FILE__)].each { |f| require f }

data/lib/nutella/core_ext/hash.rb

@@ -20,7 +20,7 @@ class Hash
   def slice(*keys)
     select { |k, v| keys.include? k }
   end
-  alias_method :grab, :slice
+  alias grab slice
 
   # Acts on the hash as described in Hash#slice, but modifies the hash in
   # place.
@@ -38,5 +38,5 @@ class Hash
   end
   # #grab! doesn't sound quite semantically correct, but keeping it for the
   # sake of being consistent with #slice/#grab.
-  alias_method :grab!, :slice!
+  alias grab! slice!
 end

data/lib/nutella/core_ext/integer/format.rb

@@ -8,12 +8,8 @@ class Integer
   #
   # @return [String] the ordinal form of the integer
   def ordinalize
-    suffixes = { 1 => "st", 2 => "nd", 3 => "rd" }
-
-    self.to_s + if (11..13).include?(self.abs % 100)
-      "th"
-    elsif suffixes.keys.include? (last_digit = self.abs % 10)
-      suffixes[last_digit]
+    self.to_s + if abs % 100 / 10 != 1 && (1..3).include?(last = abs % 10)
+      {1 => "st", 2 => "nd", 3 => "rd"}[last]
     else
       "th"
     end

data/lib/nutella/core_ext/integer/multiples.rb

@@ -46,7 +46,7 @@ class Integer
   def multiple_of?(*nums)
     nums.all? { |n| (!n.zero? && self % n == 0) || zero? }
   end
-  alias_method :divisible_by?, :multiple_of?
+  alias divisible_by? multiple_of?
 
   # Checks whether the integer is evenly divisible by any of the arguments.
   #
@@ -59,5 +59,5 @@ class Integer
   def multiple_of_any?(*nums)
     nums.any? { |n| multiple_of? n }
   end
-  alias_method :divisible_by_any?, :multiple_of_any?
+  alias divisible_by_any? multiple_of_any?
 end

data/lib/nutella/core_ext/numeric/bytes.rb

@@ -0,0 +1,43 @@
+class Numeric
+  KILOBYTE = 1024
+  MEGABYTE = KILOBYTE * 1024
+  GIGABYTE = MEGABYTE * 1024
+  TERABYTE = GIGABYTE * 1024
+  PETABYTE = TERABYTE * 1024
+  EXABYTE  = PETABYTE * 1024
+
+  def bytes
+    self
+  end
+  alias byte bytes
+
+  def kilobytes
+    self * KILOBYTE
+  end
+  alias kilobyte kilobytes
+
+  def megabytes
+    self * MEGABYTE
+  end
+  alias megabyte megabytes
+
+  def gigabytes
+    self * GIGABYTE
+  end
+  alias gigabyte gigabytes
+
+  def terabytes
+    self * TERABYTE
+  end
+  alias terabyte terabytes
+
+  def petabytes
+    self * PETABYTE
+  end
+  alias petabyte petabytes
+
+  def exabytes
+    self * EXABYTE
+  end
+  alias exabyte exabytes
+end

data/lib/nutella/core_ext/numeric/sanity_check.rb

@@ -0,0 +1,23 @@
+class Numeric
+  # Checks that the number is at least a given minimum.
+  #
+  # @example Makes sure that a variable +num+ is a minimum of 5
+  #   num = num.sanity_check_min 5
+  #
+  # @param [Numeric] minimum the minimum that the number can be
+  # @return [Numeric] what the number must be in order to satisfy the minimum
+  def sanity_check_min(minimum)
+    [self, minimum].max
+  end
+
+  # Checks that the number is at most a given maximum.
+  #
+  # @example Makes sure that a variable +num+ is a maximum of 5
+  #   num = num.sanity_check_max 5
+  #
+  # @param [Numeric] maximum the maximum that the number can be
+  # @return [Numeric] what the number must be in order to satisfy the maximum
+  def sanity_check_max(maximum)
+    [self, maximum].min
+  end
+end

data/lib/nutella/core_ext/numeric.rb

@@ -1,43 +1 @@
-class Numeric
-  KILOBYTE = 1024
-  MEGABYTE = KILOBYTE * 1024
-  GIGABYTE = MEGABYTE * 1024
-  TERABYTE = GIGABYTE * 1024
-  PETABYTE = TERABYTE * 1024
-  EXABYTE  = PETABYTE * 1024
-
-  def bytes
-    self
-  end
-  alias_method :byte, :bytes
-
-  def kilobytes
-    self * KILOBYTE
-  end
-  alias_method :kilobyte, :kilobytes
-
-  def megabytes
-    self * MEGABYTE
-  end
-  alias_method :megabyte, :megabytes
-
-  def gigabytes
-    self * GIGABYTE
-  end
-  alias_method :gigabyte, :gigabytes
-
-  def terabytes
-    self * TERABYTE
-  end
-  alias_method :terabyte, :terabytes
-
-  def petabytes
-    self * PETABYTE
-  end
-  alias_method :petabyte, :petabytes
-
-  def exabytes
-    self * EXABYTE
-  end
-  alias_method :exabyte, :exabytes
-end
+Dir[File.expand_path("../numeric/**/*.rb", __FILE__)].each { |f| require f }

data/lib/nutella/core_ext/object/aliases.rb

@@ -1,3 +1,3 @@
 class Object
-  alias_method :is_an?, :is_a?
+  alias is_an? is_a?
 end

data/lib/nutella/core_ext/string.rb

@@ -1,8 +1,8 @@
 class String
-  alias_method :contains?, :include?
-  alias_method :includes?, :include?
+  alias contains? include?
+  alias includes? include?
 
-  alias_method :each, :each_char
+  alias each each_char
 
   # The inverse of <tt>String#include?</tt>.
   #
@@ -11,7 +11,7 @@ class String
   def exclude?(str)
     !include? str
   end
-  alias_method :excludes?, :exclude?
+  alias excludes? exclude?
 
   # Left-aligns a heredoc by finding the least indented line in the string, and
   # removing that amount of leading whitespace from each line.
@@ -29,6 +29,6 @@ class String
   def heredoc
     gsub /^[ \t]{#{scan(/^[ \t]*(?=\S)/).min.size}}/, ""
   end
-  alias_method :format_heredoc, :heredoc
-  alias_method :strip_heredoc, :heredoc
+  alias format_heredoc heredoc
+  alias strip_heredoc heredoc
 end

data/lib/nutella/version.rb

@@ -1,4 +1,4 @@
 module Nutella
   # The current version of Nutella.
-  VERSION = "0.8"
+  VERSION = "0.9"
 end

data/spec/nutella/core_ext/enumerable_spec.rb

@@ -8,6 +8,49 @@ describe Enumerable do
     test_alias Enumerable, :excludes?, :exclude?
   end
 
+  describe "#apply" do
+    let(:testers) do
+      5.times.map { ApplyTester.new(5) }
+    end
+
+    it "works for a function that takes one argument" do
+      testers.apply :increment_value
+      testers.map(&:value).should == [6] * 5
+    end
+
+    context "with a function that takes two arguments" do
+      it "allows multi-dimensional arrays" do
+        multi = testers.zip([2] * 5)
+        multi.apply :increment_value
+        multi.each { |arr| arr.first.value.should == 7 }
+      end
+
+      it "allows multiple arguments" do
+        testers.apply :increment_value, 2
+        testers.map(&:value).should == [7] * 5
+      end
+    end
+
+    context "with a function that takes many arguments" do
+      it "allows multi-dimensional arrays" do
+        multi = testers.map { |elem| [elem, 2, 2] }
+        multi.apply :increment_value
+        multi.each { |arr| arr.first.value.should == 9 }
+      end
+
+      it "allows multiple arguments" do
+        testers.apply :increment_value, 2, 2
+        testers.map(&:value).should == [9] * 5
+      end
+
+      it "allows multi-dimensional arrays with multiple arguments" do
+        multi = testers.zip([2] * 5)
+        multi.apply :increment_value, 2
+        multi.each { |arr| arr.first.value.should == 9 }
+      end
+    end
+  end
+
   describe "#exclude?" do
     it "returns true if the collection does not contain the input" do
       [1, 2, 3].exclude?(4).should be_true
@@ -51,18 +94,41 @@ describe Enumerable do
     let(:arr) { (1..10).to_a }
 
     it "modifies in place" do
-      arr.group! 2
-      arr.should == (1..10).group(2)
+      expect { arr.group! 2 }.to change { arr }.to (1..10).group(2)
     end
 
     it "returns the modified string" do
-      return_catcher = arr.group! 2
-      return_catcher.should == arr
+      arr.group!(2).should == arr
     end
 
     it "returns nil if nothing was modified" do
-      return_catcher = [].group! 2
-      return_catcher.should be_nil
+      [].group!(2).should be_nil
+    end
+  end
+
+  describe "#map" do
+    it "takes a symbol and maps that method" do
+      [1, 2, 3].map(:succ).should == [2, 3, 4]
+      (1..10).map(:succ).should == (2..11).to_a
+    end
+
+    it "passes additional arguments into the method in the first argument" do
+      arr = %w[Alice Bob Charlie Dennis]
+      alpha = ("a".."z")
+      args = [/[aeiou]/, "x"]
+
+      arr.map(:gsub, *args).should == arr.map { |e| e.gsub *args }
+      alpha.map(:gsub, *args).should == alpha.map { |e| e.gsub *args }
+    end
+
+    context "when using as the original #map" do
+      it "doesn't break passing in blocks" do
+        [1, 2, 3].map { |n| n + 1 }.should == [2, 3, 4]
+      end
+
+      it "doesn't break when passing in Proc" do
+        [1, 2, 3].map(&:succ).should == [2, 3, 4]
+      end
     end
   end
 

data/spec/nutella/core_ext/hash_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "nutella/core_ext/hash"
 
 describe Hash do
-  let(:hash) { { a: 1, b: 2, c: 3, d: 4 } }
+  let(:hash) { {a: 1, b: 2, c: 3, d: 4} }
 
   describe "aliases" do
     test_alias Hash, :slice, :grab
@@ -11,11 +11,11 @@ describe Hash do
 
   describe "#grab" do
     it "selects the given items from a hash" do
-      hash.slice(:a, :c).should == { a: 1, c: 3 }
+      hash.slice(:a, :c).should == {a: 1, c: 3}
     end
 
     it "skips items that do not exist in the hash" do
-      hash.slice(:a, :d, :f).should == { a: 1, d: 4 }
+      hash.slice(:a, :d, :f).should == {a: 1, d: 4}
     end
 
     it "does not modify in place" do
@@ -27,17 +27,15 @@ describe Hash do
 
   describe "#grab!" do
     it "modifies in place" do
-      hash.slice! :a, :c
-      hash.should == { a: 1, c: 3 }
+      expect { hash.slice! :a, :c }.to change { hash }.to({a: 1, c: 3})
     end
 
     it "returns the removed pairs" do
-      hash.slice!(:a, :c).should == { b: 2, d: 4 }
+      hash.slice!(:a, :c).should == {b: 2, d: 4}
     end
 
-    it "ignores pairs that did not affect the hash" do
-      hash.slice!(:a, :c, :g).should == { b: 2, d: 4 }
-      hash.should == { a: 1, c: 3 }
+    it "does not return pairs that did not affect the hash" do
+      hash.slice!(:a, :c, :g).should == {b: 2, d: 4}
     end
   end
 end

data/spec/nutella/core_ext/integer_spec.rb

@@ -8,8 +8,8 @@ describe Integer do
   end
 
   describe "#ordinalize" do
-    it "returns the ordinal form of the integer" do
-      NUMBER_FORMATS.each do |cardinal, ordinal|
+    NUMBER_FORMATS.each do |cardinal, ordinal|
+      it "returns the ordinal #{ordinal} for the integer #{cardinal}" do
         cardinal.ordinalize.should == ordinal
       end
     end
@@ -76,66 +76,66 @@ describe Integer do
 
   describe "#multiple_of?" do
     it "returns true if the number is evenly divisible" do
-      5.multiple_of?(5).should be_true
-      15.multiple_of?(5).should be_true
-      10.multiple_of?(2).should be_true
-      6000.multiple_of?(6).should be_true
+      5.should be_multiple_of(5)
+      15.should be_multiple_of(5)
+      10.should be_multiple_of(2)
+      6000.should be_multiple_of(6)
     end
 
     it "returns false if the number is not evenly divisible" do
-      20.multiple_of?(7).should be_false
-      4.multiple_of?(3).should be_false
-      5.multiple_of?(15).should be_false
-      100.multiple_of?(3).should be_false
+      20.should_not be_multiple_of(7)
+      4.should_not be_multiple_of(3)
+      5.should_not be_multiple_of(15)
+      100.should_not be_multiple_of(3)
     end
 
     context "when passing in zero" do
       it "returns false if one tries to divide by zero" do
-        20.multiple_of?(0).should be_false
-        30.multiple_of?(0).should be_false
+        20.should_not be_multiple_of(0)
+        30.should_not be_multiple_of(0)
       end
 
       it "allows zero to go into zero" do
-        0.multiple_of?(0).should be_true
+        0.should be_multiple_of(0)
       end
     end
 
     context "with multiple arguments" do
       it "returns true if evenly divisible by all arguments" do
-        15.multiple_of?(3, 15).should be_true
-        100.multiple_of?(2, 5, 25).should be_true
-        0.multiple_of?(0, 1, 2).should be_true
+        15.should be_multiple_of(3, 15)
+        100.should be_multiple_of(2, 5, 25)
+        0.should be_multiple_of(0, 1, 2)
       end
 
       it "returns false if evenly divisible by only some arguments" do
-        15.multiple_of?(2, 3).should be_false
-        12.multiple_of?(3, 4, 6, 8).should be_false
-        10.multiple_of?(0, 5).should be_false
+        15.should_not be_multiple_of(2, 3)
+        12.should_not be_multiple_of(3, 4, 6, 8)
+        10.should_not be_multiple_of(0, 5)
       end
 
       it "returns false if evenly divisible by none of the arguments" do
-        6.multiple_of?(4, 5).should be_false
-        17.multiple_of?(2, 4).should be_false
+        6.should_not be_multiple_of(4, 5)
+        17.should_not be_multiple_of(2, 4)
       end
     end
   end
 
   describe "#multiple_of_any?" do
     it "returns true if evenly divisible by all arguments" do
-      15.multiple_of_any?(3, 15).should be_true
-      100.multiple_of_any?(2, 5, 25).should be_true
-      0.multiple_of_any?(0, 1, 2).should be_true
+      15.should be_multiple_of_any(3, 15)
+      100.should be_multiple_of_any(2, 5, 25)
+      0.should be_multiple_of_any(0, 1, 2)
     end
 
     it "returns true if evenly divisible by only some arguments" do
-      15.multiple_of_any?(2, 3).should be_true
-      12.multiple_of_any?(3, 4, 6, 8).should be_true
-      10.multiple_of_any?(0, 5).should be_true
+      15.should be_multiple_of_any(2, 3)
+      12.should be_multiple_of_any(3, 4, 6, 8)
+      10.should be_multiple_of_any(0, 5)
     end
 
     it "returns false if evenly divisible by none of the arguments" do
-      6.multiple_of_any?(4, 5).should be_false
-      17.multiple_of_any?(2, 4).should be_false
+      6.should_not be_multiple_of_any(4, 5)
+      17.should_not be_multiple_of_any(2, 4)
     end
   end
 end

data/spec/nutella/core_ext/numeric_spec.rb

@@ -8,4 +8,32 @@ describe Numeric do
       test_alias Numeric, (name = "#{prefix}byte").to_sym, "#{name}s".to_sym
     end
   end
+
+  describe "#sanity_check_min" do
+    it "returns the parameter if the number is lower" do
+      5.sanity_check_min(7).should == 7
+    end
+
+    it "doesn't change anything if the number is equal" do
+      5.sanity_check_min(5).should == 5
+    end
+
+    it "returns the number if the number is higher" do
+      5.sanity_check_min(2).should == 5
+    end
+  end
+
+  describe "#sanity_check_max" do
+    it "returns the parameter if the number is higher" do
+      5.sanity_check_max(2).should == 2
+    end
+
+    it "doesn't change anything if the number is equal" do
+      5.sanity_check_max(5).should == 5
+    end
+
+    it "returns the number if the number is lower" do
+      5.sanity_check_max(7).should == 5
+    end
+  end
 end

data/spec/nutella/core_ext/object_spec.rb

@@ -8,44 +8,44 @@ describe Object do
 
   describe "#blank?" do
     it "is blank when nil" do
-      nil.blank?.should be_true
+      nil.should be_blank
     end
 
     it "is blank when false" do
-      false.blank?.should be_true
+      false.should be_blank
     end
 
     it "is not blank when true" do
-      true.blank?.should be_false
+      true.should_not be_blank
     end
 
     it "is not blank when numeric" do
-      [0, 1].each { |n| n.blank?.should be_false }
+      [0, 1].each { |n| n.should_not be_blank }
     end
 
     context "when a string" do
       it "is blank if the string is empty" do
-        "".blank?.should be_true
+        "".should be_blank
       end
 
       it "is blank if only whitespace" do
-        ["  ", "\n  \t"].each { |str| str.blank?.should be_true }
-        "  something here  ".blank?.should be_false
+        ["  ", "\n  \t"].each { |str| str.should be_blank }
+        "  something here  ".should_not be_blank
       end
 
       it "is not blank if the string has content" do
-        "string".blank?.should be_false
+        "string".should_not be_blank
       end
     end
 
     context "when a collection" do
       it "is blank if the collection is empty" do
-        [[], {}].each { |collection| collection.blank?.should be_true }
+        [[], {}].each { |collection| collection.should be_blank }
       end
 
       it "is not blank if there are elements in the collection" do
         [[1, 2, 3], { 1 => 2, 3 => 4 }].each do |collection|
-          collection.blank?.should be_false
+          collection.should_not be_blank
         end
       end
     end
@@ -53,10 +53,10 @@ describe Object do
 
   describe "#present?" do
     it "is the inverse of #blank?" do
-      [0, 1].each { |n| n.present?.should be_true }
-      [[], {}].each { |collection| collection.present?.should be_false }
-      ["", "  "].each { |str| str.present?.should be_false }
-      ["str", "  str "].each { |str| str.present?.should be_true }
+      [0, 1].each { |n| n.should be_present }
+      [[], {}].each { |collection| collection.should_not be_present }
+      ["", "  "].each { |str| str.should_not be_present }
+      ["str", "  str "].each { |str| str.should be_present }
     end
   end
 

data/spec/nutella/core_ext/string_spec.rb

@@ -24,9 +24,8 @@ describe Enumerable do
   end
 
   describe "#heredoc" do
-    test = expected = ""
-
-    let(:test) do <<-EOS.heredoc
+    it "strips all excess whitespace from the left" do
+      test = <<-EOS.heredoc
         This is a test of String#heredoc.
         This text should be left-aligned.
             This text is indented by four spaces.
@@ -35,9 +34,8 @@ describe Enumerable do
          now one space...
         Left-aligned again.
       EOS
-    end
 
-    let(:expected) do <<EOS
+      test.should == <<EOS
 This is a test of String#heredoc.
 This text should be left-aligned.
     This text is indented by four spaces.
@@ -47,9 +45,5 @@ This text should be left-aligned.
 Left-aligned again.
 EOS
     end
-
-    it "strips all excess whitespace from the left" do
-      test.should == expected
-    end
   end
 end

data/spec/support/apply_tester.rb

@@ -0,0 +1,11 @@
+class ApplyTester
+  attr_accessor :value
+
+  def initialize(start_value)
+    @value = start_value
+  end
+end
+
+def increment_value(tester, amount = 1, extra_arg = 0)
+  tester.value += amount + extra_arg
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nutella
 version: !ruby/object:Gem::Version
-  version: '0.8'
+  version: '0.9'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-27 00:00:00.000000000 Z
+date: 2012-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fuubar
@@ -122,14 +122,22 @@ files:
 - lib/nutella/core_ext/object.rb
 - lib/nutella/core_ext/string.rb
 - lib/nutella/core_ext/file.rb
+- lib/nutella/core_ext/enumerable/group.rb
+- lib/nutella/core_ext/enumerable/sum.rb
+- lib/nutella/core_ext/enumerable/apply.rb
+- lib/nutella/core_ext/enumerable/map.rb
+- lib/nutella/core_ext/enumerable/search.rb
 - lib/nutella/core_ext/integer.rb
 - lib/nutella/core_ext/hash.rb
 - lib/nutella/core_ext/object/blank.rb
 - lib/nutella/core_ext/object/aliases.rb
+- lib/nutella/core_ext/numeric/sanity_check.rb
+- lib/nutella/core_ext/numeric/bytes.rb
 - lib/nutella/core_ext/enumerable.rb
 - lib/nutella/core_ext.rb
 - spec/support/alias.rb
 - spec/support/number_formats.rb
+- spec/support/apply_tester.rb
 - spec/nutella/core_ext/object_spec.rb
 - spec/nutella/core_ext/hash_spec.rb
 - spec/nutella/core_ext/numeric_spec.rb
@@ -164,7 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2449410360859195033
+      hash: 830849630549550428
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -174,6 +182,7 @@ summary: Spread some Nutella on Ruby to sweeten up its functionality.
 test_files:
 - spec/support/alias.rb
 - spec/support/number_formats.rb
+- spec/support/apply_tester.rb
 - spec/nutella/core_ext/object_spec.rb
 - spec/nutella/core_ext/hash_spec.rb
 - spec/nutella/core_ext/numeric_spec.rb