nutella 0.11.1 → 0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a987835f74115420358299ced5270af19f6f07d
-  data.tar.gz: edb583cff27a3152e6482bd88850a3bba3803dce
+  metadata.gz: ef8876f7754fa5b0b422e9ab7ca092e9298ee436
+  data.tar.gz: 63636995f8ba8417326f52026f07ff0c5fc33272
 SHA512:
-  metadata.gz: 0435310cb4a5e2589766dd4cc2330409bc9dfaf9043b557df8dd8a49053523770af93fe800961b1fd785f7adeda115ff16034e3d969743342521985c771d69a9
-  data.tar.gz: fe0f174e16f1919b1e57ec5dbe0f4829b536b7ae489616a622dde02c56fba391b539a3f2f4fd03d3b53011efc9daea44f548d929c94501791e1dcf4ad9886b35
+  metadata.gz: 77c51d26b2d0af83884a6e188993e5c4e58d3b4e71bd3bb59310660820c37082dbcdba45e31529c02c50c0346d6927ea09374c9aaa29c5e3d4b2e250e50ed68b
+  data.tar.gz: bd3e50152263964033c4cf070c8d7c4c2208b2f32d319f56f47164026cf85d07aabace679a7816d7bd264c5acfb7e58d7d8a79ef3795c7d40611720295915ece

data/lib/nutella/core_ext/module.rb

@@ -0,0 +1,41 @@
+class Module
+  # A DRYer way to create a constructor where all of its arguments are assigned
+  # to instance variables of the same name.
+  #
+  # @example Comparison of constructor creation with and without Nutella
+  #   # Pure Ruby
+  #   class Test
+  #     def initialize(a, b, c, d)
+  #       @a, @b, @c, @d = a, b, c, d
+  #     end
+  #   end
+  #   Test.new(0, 0, 0, 0).instance_variables # => [:@a, :@b, :@c, :@d]
+  #
+  #   # Ruby with Nutella
+  #   class Test
+  #     initializer *%i[a b c d]
+  #   end
+  #   Test.new(0, 0, 0, 0).instance_variables # => [:@a, :@b, :@c, :@d]
+  #
+  #   # It can also take a block with additional code to run
+  #   class Test
+  #     initializer :a, :b do
+  #       @in_block = 0
+  #     end
+  #   end
+  #   Test.new(0, 0).instance_variables # => [:@a, :@b, :@in_block]
+  #
+  # @param [Array] args the names of the arguments to the constructor as symbols
+  # @yield code to be executed on construction
+  def initializer(*args, &block)
+    define_method :initialize do |*input|
+      (input.last.is_a?(Hash) \
+       ? input[-1]
+       : Hash[args.zip input]).each do |name, value|
+        instance_variable_set "@#{name}", value
+      end
+
+      instance_eval(&block) if block_given?
+    end
+  end
+end

data/lib/nutella/core_ext/string/heredoc.rb

@@ -13,8 +13,12 @@ class String
   #
   # @return [String] the string with excess leading whitespace stripped
   def heredoc
-    gsub /^[ \t]{#{scan(/^[ \t]*(?=\S)/).min.size}}/, ""
+    gsub /^[ \t]{#{scan(/^[ \t]*(?=\S)/).min.size || 0}}/, ""
   end
   alias format_heredoc heredoc
   alias strip_heredoc heredoc
+
+  def in_heredoc indentation
+    lines[1..-1].map { |line| line.prepend " " * indentation }.join "\n"
+  end
 end

data/lib/nutella/version.rb

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

data/nutella.gemspec

@@ -20,10 +20,10 @@ Gem::Specification.new do |gem|
   ]
 
   gem.required_ruby_version = "~> 2.0"
-  gem.add_development_dependency "fuubar", "~> 1.1"
+  gem.add_development_dependency "fuubar", "~> 2.0"
   gem.add_development_dependency "rake", "~> 10.0"
   gem.add_development_dependency "redcarpet", "~> 2.2"
   gem.add_development_dependency "rdoc", "~> 3.12"
-  gem.add_development_dependency "rspec", "~> 2.11"
+  gem.add_development_dependency "rspec", "~> 3.1"
   gem.add_development_dependency "yard", "~> 0.8"
 end

data/spec/nutella/core_ext/enumerable_spec.rb

@@ -15,19 +15,19 @@ describe Enumerable do
 
     it "works for a function that takes one argument" do
       testers.apply :increment_value
-      testers.map(&:value).should == [6] * 5
+      expect(testers.map(&:value)).to eq([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 }
+        multi.each { |arr| expect(arr.first.value).to eq(7) }
       end
 
       it "allows multiple arguments" do
         testers.apply :increment_value, 2
-        testers.map(&:value).should == [7] * 5
+        expect(testers.map(&:value)).to eq([7] * 5)
       end
     end
 
@@ -35,58 +35,58 @@ describe Enumerable 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 }
+        multi.each { |arr| expect(arr.first.value).to eq(9) }
       end
 
       it "allows multiple arguments" do
         testers.apply :increment_value, 2, 2
-        testers.map(&:value).should == [9] * 5
+        expect(testers.map(&:value)).to eq([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 }
+        multi.each { |arr| expect(arr.first.value).to eq(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
+      expect([1, 2, 3].exclude?(4)).to be_truthy
     end
 
     it "returns false if the collection contains the input" do
-      [1, 2, 3].exclude?(2).should be_false
+      expect([1, 2, 3].exclude?(2)).to be_falsey
     end
   end
 
   describe "#group" do
     it "groups elements" do
-      [].group(2).should == []
-      [1, 2].group(2).should == [[1, 2]]
-      (1..4).group(2).should == [[1, 2], [3, 4]]
-      (1..9).group(3).should == [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+      expect([].group(2)).to eq([])
+      expect([1, 2].group(2)).to eq([[1, 2]])
+      expect((1..4).group(2)).to eq([[1, 2], [3, 4]])
+      expect((1..9).group(3)).to eq([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
     end
 
     it "puts all excess into the last group" do
-      [1, 2].group(4).should == [[1, 2]]
-      (1..8).group(3).should == [[1, 2, 3], [4, 5, 6], [7, 8]]
+      expect([1, 2].group(4)).to eq([[1, 2]])
+      expect((1..8).group(3)).to eq([[1, 2, 3], [4, 5, 6], [7, 8]])
     end
 
     it "discards all excess if instructed to" do
-      (1..3).group(2, true).should == [[1, 2]]
-      (1..8).group(3, true).should == [[1, 2, 3], [4, 5, 6]]
+      expect((1..3).group(2, true)).to eq([[1, 2]])
+      expect((1..8).group(3, true)).to eq([[1, 2, 3], [4, 5, 6]])
     end
 
     it "does not discard anything if there is no excess" do
-      (1..4).group(2, true).should == [[1, 2], [3, 4]]
+      expect((1..4).group(2, true)).to eq([[1, 2], [3, 4]])
     end
 
     it "does not modify in place" do
       arr = (1..10).to_a
       arr.group 2
-      arr.should == (1..10).to_a
+      expect(arr).to eq((1..10).to_a)
     end
   end
 
@@ -98,18 +98,18 @@ describe Enumerable do
     end
 
     it "returns the modified string" do
-      arr.group!(2).should == arr
+      expect(arr.group!(2)).to eq(arr)
     end
 
     it "returns nil if nothing was modified" do
-      [].group!(2).should be_nil
+      expect([].group!(2)).to 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
+      expect([1, 2, 3].map(:succ)).to eq([2, 3, 4])
+      expect((1..10).map(:succ)).to eq((2..11).to_a)
     end
 
     it "passes additional arguments into the method in the first argument" do
@@ -117,49 +117,49 @@ describe Enumerable do
       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 }
+      expect(arr.map(:gsub, *args)).to eq(arr.map { |e| e.gsub *args })
+      expect(alpha.map(:gsub, *args)).to eq(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]
+        expect([1, 2, 3].map { |n| n + 1 }).to eq([2, 3, 4])
       end
 
       it "doesn't break when passing in Proc" do
-        [1, 2, 3].map(&:succ).should == [2, 3, 4]
+        expect([1, 2, 3].map(&:succ)).to eq([2, 3, 4])
       end
     end
   end
 
   describe "#sum" do
     it "returns the sum of elements" do
-      [].sum.should == 0
-      [5].sum.should == 5
-      [1, 2, 3].sum.should == 6
-      (1..4).sum.should == 10
+      expect([].sum).to eq(0)
+      expect([5].sum).to eq(5)
+      expect([1, 2, 3].sum).to eq(6)
+      expect((1..4).sum).to eq(10)
     end
 
     it "flattens the elements before adding" do
-      [[4, 5], 1].sum.should == 10
-      [[1, 2, 3], [4, 5]].sum.should == 15
+      expect([[4, 5], 1].sum).to eq(10)
+      expect([[1, 2, 3], [4, 5]].sum).to eq(15)
     end
 
     it "filters out all non-numbers" do
-      { a: 2, b: 4 }.sum.should == 6
-      [1, "str", 4].sum.should == 5
-      ["no numbers"].sum.should == 0
+      expect({ a: 2, b: 4 }.sum).to eq(6)
+      expect([1, "str", 4].sum).to eq(5)
+      expect(["no numbers"].sum).to eq(0)
     end
 
     context "with a block" do
       it "returns the sum of the elements that pass the filter block" do
-        (1..10).sum(&:even?).should == 30
-        (1..10).sum { |n| n % 3 == 0 }.should == 18
+        expect((1..10).sum(&:even?)).to eq(30)
+        expect((1..10).sum { |n| n % 3 == 0 }).to eq(18)
       end
 
       it "still filters out all non-numbers" do
-        { a: 1, b: 2, c: 3 }.sum(&:odd?).should == 4
-        [2, "str", 4, 7].sum(&:even?).should == 6
+        expect({ a: 1, b: 2, c: 3 }.sum(&:odd?)).to eq(4)
+        expect([2, "str", 4, 7].sum(&:even?)).to eq(6)
       end
     end
   end

data/spec/nutella/core_ext/file_spec.rb

@@ -6,41 +6,41 @@ describe File do
   describe "::human_size" do
     context "when given a Numeric" do
       it "does not change bytes" do
-        File.human_size(150.bytes).should == "150 Bytes"
+        expect(File.human_size(150.bytes)).to eq("150 Bytes")
       end
 
       it "changes kilobytes" do
-        File.human_size(1.5.kilobytes).should == "1.5 KB"
+        expect(File.human_size(1.5.kilobytes)).to eq("1.5 KB")
       end
 
       it "changes megabytes" do
-        File.human_size(1.5.megabytes).should == "1.5 MB"
+        expect(File.human_size(1.5.megabytes)).to eq("1.5 MB")
       end
 
       it "changes gigabytes" do
-        File.human_size(1.5.gigabytes).should == "1.5 GB"
+        expect(File.human_size(1.5.gigabytes)).to eq("1.5 GB")
       end
 
       it "rounds down properly to the tenths" do
-        File.human_size(1.72.megabytes).should == "1.7 MB"
+        expect(File.human_size(1.72.megabytes)).to eq("1.7 MB")
       end
 
       it "rounds up properly to the tenths" do
-        File.human_size(1.78.megabytes).should == "1.8 MB"
+        expect(File.human_size(1.78.megabytes)).to eq("1.8 MB")
       end
 
       it "has a singular unit for 1 byte" do
-        File.human_size(1.byte).should == "1 Byte"
+        expect(File.human_size(1.byte)).to eq("1 Byte")
       end
 
       it "returns 'Empty' for an empty file or a blank parameter" do
-        File.human_size(0).should == "Empty"
-        File.human_size(nil).should == "Empty"
+        expect(File.human_size(0)).to eq("Empty")
+        expect(File.human_size(nil)).to eq("Empty")
       end
 
       it "displays whole numbers without a decimal" do
-        File.human_size(1.megabyte).should == "1 MB"
-        File.human_size(24.gigabytes).should == "24 GB"
+        expect(File.human_size(1.megabyte)).to eq("1 MB")
+        expect(File.human_size(24.gigabytes)).to eq("24 GB")
       end
     end
 
@@ -48,7 +48,7 @@ describe File do
       it "detects empty files properly" do
         begin
           f = File.new("temp", "w")
-          File.human_size(f).should == "Empty"
+          expect(File.human_size(f)).to eq("Empty")
         ensure
           File.delete "temp"
         end
@@ -57,10 +57,10 @@ describe File do
       it "detects the file size properly" do
         begin
           File.truncate(f = File.new("temp", "w"), 1.5.kilobytes)
-          File.human_size(f).should == "1.5 KB"
+          expect(File.human_size(f)).to eq("1.5 KB")
 
           File.truncate(f = File.new("temp", "w"), 3.kilobytes)
-          File.human_size(f).should == "3 KB"
+          expect(File.human_size(f)).to eq("3 KB")
         ensure
           File.delete "temp"
         end
@@ -71,10 +71,10 @@ describe File do
       it "detects the file size properly" do
         begin
           File.truncate(f = File.new("temp", "w"), 1.5.kilobytes)
-          File.human_size("temp").should == "1.5 KB"
+          expect(File.human_size("temp")).to eq("1.5 KB")
 
           File.truncate(f = File.new("temp", "w"), 3.kilobytes)
-          File.human_size("temp").should == "3 KB"
+          expect(File.human_size("temp")).to eq("3 KB")
         ensure
           File.delete "temp"
         end
@@ -85,7 +85,7 @@ describe File do
   describe "#human_size" do
     it "detects empty files properly" do
       begin
-        File.new("temp", "w").human_size.should == "Empty"
+        expect(File.new("temp", "w").human_size).to eq("Empty")
       ensure
         File.delete "temp"
       end
@@ -94,10 +94,10 @@ describe File do
     it "detects the file size properly" do
       begin
         File.truncate(f = File.new("temp", "w"), 1.5.kilobytes)
-        f.human_size.should == "1.5 KB"
+        expect(f.human_size).to eq("1.5 KB")
 
         File.truncate(f = File.new("temp", "w"), 3.kilobytes)
-        f.human_size.should == "3 KB"
+        expect(f.human_size).to eq("3 KB")
       ensure
         File.delete "temp"
       end

data/spec/nutella/core_ext/hash_spec.rb

@@ -11,17 +11,17 @@ describe Hash do
 
   describe "#grab" do
     it "selects the given items from a hash" do
-      hash.slice(:a, :c).should == {a: 1, c: 3}
+      expect(hash.slice(:a, :c)).to eq({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}
+      expect(hash.slice(:a, :d, :f)).to eq({a: 1, d: 4})
     end
 
     it "does not modify in place" do
       start = hash
       hash.slice :a, :b
-      hash.should == start
+      expect(hash).to eq(start)
     end
   end
 
@@ -31,11 +31,11 @@ describe Hash do
     end
 
     it "returns the removed pairs" do
-      hash.slice!(:a, :c).should == {b: 2, d: 4}
+      expect(hash.slice!(:a, :c)).to eq({b: 2, d: 4})
     end
 
     it "does not return pairs that did not affect the hash" do
-      hash.slice!(:a, :c, :g).should == {b: 2, d: 4}
+      expect(hash.slice!(:a, :c, :g)).to eq({b: 2, d: 4})
     end
   end
 end

data/spec/nutella/core_ext/integer_spec.rb

@@ -9,147 +9,147 @@ describe Integer do
 
   describe "#digits" do
     it "returns an array of the digits in the integer" do
-      (0..9).each { |n| n.digits.should == [n] }
-      10.digits.should == [1, 0]
-      349.digits.should == [3, 4, 9]
-      1000.digits.should == [1, 0, 0, 0]
+      (0..9).each { |n| expect(n.digits).to eq([n]) }
+      expect(10.digits).to eq([1, 0])
+      expect(349.digits).to eq([3, 4, 9])
+      expect(1000.digits).to eq([1, 0, 0, 0])
     end
 
     it "trims the '-' from negative numbers" do
-      -3.digits.should == [3]
-      -20.digits.should == [2, 0]
+      expect(-3.digits).to eq([3])
+      expect(-20.digits).to eq([2, 0])
     end
   end
 
   describe "#ordinalize" do
     NUMBER_FORMATS.each do |cardinal, ordinal|
       it "returns the ordinal #{ordinal} for the integer #{cardinal}" do
-        cardinal.ordinalize.should == ordinal
+        expect(cardinal.ordinalize).to eq(ordinal)
       end
     end
   end
 
   describe "#goes_into?" do
     it "returns true if the number goes evenly into the argument" do
-      5.goes_into?(10).should be_true
-      3.goes_into?(21).should be_true
-      25.goes_into?(100).should be_true
+      expect(5.goes_into?(10)).to be_truthy
+      expect(3.goes_into?(21)).to be_truthy
+      expect(25.goes_into?(100)).to be_truthy
     end
 
     it "returns false if the number does not go evenly in" do
-      3.goes_into?(10).should be_false
-      9.goes_into?(40).should be_false
-      10.goes_into?(5).should be_false
+      expect(3.goes_into?(10)).to be_falsey
+      expect(9.goes_into?(40)).to be_falsey
+      expect(10.goes_into?(5)).to be_falsey
     end
 
     context "when passing in zero" do
       it "returns false if one tries to divide by zero" do
-        0.goes_into?(20).should be_false
-        0.goes_into?(30).should be_false
+        expect(0.goes_into?(20)).to be_falsey
+        expect(0.goes_into?(30)).to be_falsey
       end
 
       it "allows zero to go into zero" do
-        0.goes_into?(0).should be_true
+        expect(0.goes_into?(0)).to be_truthy
       end
     end
 
     context "with multiple arguments" do
       it "returns true if all arguments succeed" do
-        5.goes_into?(10, 15, 50).should be_true
-        2.goes_into?(2, 4, 10).should be_true
+        expect(5.goes_into?(10, 15, 50)).to be_truthy
+        expect(2.goes_into?(2, 4, 10)).to be_truthy
       end
 
       it "returns false if only some arguments succeed" do
-        5.goes_into?(10, 12, 15).should be_false
-        8.goes_into?(4, 16).should be_false
+        expect(5.goes_into?(10, 12, 15)).to be_falsey
+        expect(8.goes_into?(4, 16)).to be_falsey
       end
 
       it "returns false if no arguments succeed" do
-        3.goes_into?(8, 16, 20).should be_false
-        6.goes_into?(5, 10, 15).should be_false
+        expect(3.goes_into?(8, 16, 20)).to be_falsey
+        expect(6.goes_into?(5, 10, 15)).to be_falsey
       end
     end
   end
 
   describe "#goes_into_any?" do
     it "returns true if all arguments succeed" do
-      5.goes_into_any?(10, 15, 50).should be_true
-      2.goes_into_any?(2, 4, 10).should be_true
+      expect(5.goes_into_any?(10, 15, 50)).to be_truthy
+      expect(2.goes_into_any?(2, 4, 10)).to be_truthy
     end
 
     it "returns true if only some arguments succeed" do
-      5.goes_into_any?(10, 12, 15).should be_true
-      8.goes_into_any?(4, 16).should be_true
+      expect(5.goes_into_any?(10, 12, 15)).to be_truthy
+      expect(8.goes_into_any?(4, 16)).to be_truthy
     end
 
     it "returns false if no arguments succeed" do
-      3.goes_into_any?(8, 16, 20).should be_false
-      6.goes_into_any?(5, 10, 15).should be_false
+      expect(3.goes_into_any?(8, 16, 20)).to be_falsey
+      expect(6.goes_into_any?(5, 10, 15)).to be_falsey
     end
   end
 
   describe "#multiple_of?" do
     it "returns true if the number is evenly divisible" do
-      5.should be_multiple_of(5)
-      15.should be_multiple_of(5)
-      10.should be_multiple_of(2)
-      6000.should be_multiple_of(6)
+      expect(5).to be_multiple_of(5)
+      expect(15).to be_multiple_of(5)
+      expect(10).to be_multiple_of(2)
+      expect(6000).to be_multiple_of(6)
     end
 
     it "returns false if the number is not evenly divisible" do
-      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)
+      expect(20).not_to be_multiple_of(7)
+      expect(4).not_to be_multiple_of(3)
+      expect(5).not_to be_multiple_of(15)
+      expect(100).not_to be_multiple_of(3)
     end
 
     context "when passing in zero" do
       it "returns false if one tries to divide by zero" do
-        20.should_not be_multiple_of(0)
-        30.should_not be_multiple_of(0)
+        expect(20).not_to be_multiple_of(0)
+        expect(30).not_to be_multiple_of(0)
       end
 
       it "allows zero to go into zero" do
-        0.should be_multiple_of(0)
+        expect(0).to be_multiple_of(0)
       end
     end
 
     context "with multiple arguments" do
       it "returns true if evenly divisible by all arguments" do
-        15.should be_multiple_of(3, 15)
-        100.should be_multiple_of(2, 5, 25)
-        0.should be_multiple_of(0, 1, 2)
+        expect(15).to be_multiple_of(3, 15)
+        expect(100).to be_multiple_of(2, 5, 25)
+        expect(0).to be_multiple_of(0, 1, 2)
       end
 
       it "returns false if evenly divisible by only some arguments" do
-        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)
+        expect(15).not_to be_multiple_of(2, 3)
+        expect(12).not_to be_multiple_of(3, 4, 6, 8)
+        expect(10).not_to be_multiple_of(0, 5)
       end
 
       it "returns false if evenly divisible by none of the arguments" do
-        6.should_not be_multiple_of(4, 5)
-        17.should_not be_multiple_of(2, 4)
+        expect(6).not_to be_multiple_of(4, 5)
+        expect(17).not_to be_multiple_of(2, 4)
       end
     end
   end
 
   describe "#multiple_of_any?" do
     it "returns true if evenly divisible by all arguments" do
-      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)
+      expect(15).to be_multiple_of_any(3, 15)
+      expect(100).to be_multiple_of_any(2, 5, 25)
+      expect(0).to be_multiple_of_any(0, 1, 2)
     end
 
     it "returns true if evenly divisible by only some arguments" do
-      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)
+      expect(15).to be_multiple_of_any(2, 3)
+      expect(12).to be_multiple_of_any(3, 4, 6, 8)
+      expect(10).to be_multiple_of_any(0, 5)
     end
 
     it "returns false if evenly divisible by none of the arguments" do
-      6.should_not be_multiple_of_any(4, 5)
-      17.should_not be_multiple_of_any(2, 4)
+      expect(6).not_to be_multiple_of_any(4, 5)
+      expect(17).not_to be_multiple_of_any(2, 4)
     end
   end
 end

data/spec/nutella/core_ext/module_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+require "nutella/core_ext/module"
+
+describe Module do
+  describe "initializer" do
+    it "defines the instance variables" do
+      expect(InitTest.new *INIT_VALUES).
+        to have_instance_variables(*INIT_INSTANCE_VARS)
+    end
+
+    context "with a block" do
+      let!(:t) { InitBlockTest.new *INIT_VALUES }
+
+      it "defines the instance variables" do
+        expect(t).to have_instance_variables(*INIT_INSTANCE_VARS)
+      end
+
+      it "runs the block" do
+        expect(t.block_run?).to be true
+      end
+    end
+  end
+end

data/spec/nutella/core_ext/numeric_spec.rb

@@ -11,57 +11,57 @@ describe Numeric do
 
   describe "#percent" do
     it "returns the percent for an integer" do
-      5.percent.should == 0.05
-      15.percent.should == 0.15
-      50.percent.should == 0.5
-      125.percent.should == 1.25
+      expect(5.percent).to eq(0.05)
+      expect(15.percent).to eq(0.15)
+      expect(50.percent).to eq(0.5)
+      expect(125.percent).to eq(1.25)
     end
 
     it "returns an integer for multiples of 100" do
-      100.percent.should == 1
-      500.percent.should == 5
+      expect(100.percent).to eq(1)
+      expect(500.percent).to eq(5)
     end
 
     it "returns the percent for a floating point" do
-      0.5.percent.should == 0.005
-      5.5.percent.should == 0.055
-      10.5.percent.should == 0.105
+      expect(0.5.percent).to eq(0.005)
+      expect(5.5.percent).to eq(0.055)
+      expect(10.5.percent).to eq(0.105)
     end
 
     it "returns an integer for floating point multiples of 100" do
-      100.0.percent.should == 1
+      expect(100.0.percent).to eq(1)
     end
 
     it "returns zero for 0" do
-      0.percent.should be_zero
+      expect(0.percent).to be_zero
     end
   end
 
   describe "#sanity_check_min" do
     it "returns the parameter if the number is lower" do
-      5.sanity_check_min(7).should == 7
+      expect(5.sanity_check_min(7)).to eq(7)
     end
 
     it "doesn't change anything if the number is equal" do
-      5.sanity_check_min(5).should == 5
+      expect(5.sanity_check_min(5)).to eq(5)
     end
 
     it "returns the number if the number is higher" do
-      5.sanity_check_min(2).should == 5
+      expect(5.sanity_check_min(2)).to eq(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
+      expect(5.sanity_check_max(2)).to eq(2)
     end
 
     it "doesn't change anything if the number is equal" do
-      5.sanity_check_max(5).should == 5
+      expect(5.sanity_check_max(5)).to eq(5)
     end
 
     it "returns the number if the number is lower" do
-      5.sanity_check_max(7).should == 5
+      expect(5.sanity_check_max(7)).to eq(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.should be_blank
+      expect(nil).to be_blank
     end
 
     it "is blank when false" do
-      false.should be_blank
+      expect(false).to be_blank
     end
 
     it "is not blank when true" do
-      true.should_not be_blank
+      expect(true).not_to be_blank
     end
 
     it "is not blank when numeric" do
-      [0, 1].each { |n| n.should_not be_blank }
+      [0, 1].each { |n| expect(n).not_to be_blank }
     end
 
     context "when a string" do
       it "is blank if the string is empty" do
-        "".should be_blank
+        expect("").to be_blank
       end
 
       it "is blank if only whitespace" do
-        ["  ", "\n  \t"].each { |str| str.should be_blank }
-        "  something here  ".should_not be_blank
+        ["  ", "\n  \t"].each { |str| expect(str).to be_blank }
+        expect("  something here  ").not_to be_blank
       end
 
       it "is not blank if the string has content" do
-        "string".should_not be_blank
+        expect("string").not_to be_blank
       end
     end
 
     context "when a collection" do
       it "is blank if the collection is empty" do
-        [[], {}].each { |collection| collection.should be_blank }
+        [[], {}].each { |collection| expect(collection).to 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.should_not be_blank
+          expect(collection).not_to be_blank
         end
       end
     end
@@ -53,22 +53,22 @@ describe Object do
 
   describe "#present?" do
     it "is the inverse of #blank?" do
-      [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 }
+      [0, 1].each { |n| expect(n).to be_present }
+      [[], {}].each { |collection| expect(collection).not_to be_present }
+      ["", "  "].each { |str| expect(str).not_to be_present }
+      ["str", "  str "].each { |str| expect(str).to be_present }
     end
   end
 
   describe "#presence" do
     it "returns the object if the object is present" do
-      1.presence.should == 1
-      "str".presence.should == "str"
+      expect(1.presence).to eq(1)
+      expect("str".presence).to eq("str")
     end
 
     it "returns nil if the object is not present" do
-      "".presence.should be_nil
-      false.presence.should be_nil
+      expect("".presence).to be_nil
+      expect(false.presence).to be_nil
     end
   end
 end

data/spec/nutella/core_ext/string_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "nutella/core_ext/string"
 
-describe Enumerable do
+describe String do
   describe "aliases" do
     test_alias String, :contains?, :include?
     test_alias String, :includes?, :include?
@@ -15,11 +15,11 @@ describe Enumerable do
 
   describe "#exclude?" do
     it "returns true if the string does not contain the input string" do
-      "hello".exclude?("test").should be_true
+      expect("hello".exclude?("test")).to be_truthy
     end
 
     it "returns false if the string contains the input string" do
-      "hello".exclude?("llo").should be_false
+      expect("hello".exclude?("llo")).to be_falsey
     end
   end
 
@@ -35,7 +35,7 @@ describe Enumerable do
         Left-aligned again.
       EOS
 
-      test.should == <<EOS
+      expect(test).to eq <<EOS
 This is a test of String#heredoc.
 This text should be left-aligned.
     This text is indented by four spaces.
@@ -45,5 +45,32 @@ This text should be left-aligned.
 Left-aligned again.
 EOS
     end
+
+=begin
+    it "works with string interpolation" do
+      short = "Test"
+      inner = <<-EOS.heredoc.strip
+        This text should be left-aligned.
+          This is indented by two.
+        Last line of the inner string, left-aligned.
+      EOS
+
+      test = <<-EOS.heredoc
+        Testing short in-line: #{short}
+        Testing next-line:
+        #{inner.in_heredoc 8}
+        Ending interpolation test.
+      EOS
+
+      test.should == <<EOS
+Testing short in-line: Test
+Testing next-line:
+This text should be left-aligned.
+  This is indented by two.
+Last line of the inner string, left-aligned.
+Ending interpolation test.
+EOS
+    end
+=end
   end
 end

data/spec/support/alias.rb

@@ -2,7 +2,7 @@
 def test_alias(cls, method_a, method_b)
   describe "##{method_a.to_s}" do
     it "is an alias of ##{method_b.to_s}" do
-      cls.instance_method(method_a).should === cls.instance_method(method_b)
+      expect(cls.instance_method method_a).to eq(cls.instance_method(method_b))
     end
   end
 end

data/spec/support/initializer_testers.rb

@@ -0,0 +1,20 @@
+require "nutella/core_ext/module"
+
+INIT_ARGS = %i[a b c]
+INIT_INSTANCE_VARS = INIT_ARGS.map { |arg| arg.to_s.prepend("@").to_sym }
+
+INIT_VALUES = [0] * INIT_ARGS.size
+
+class InitTest
+  initializer *INIT_ARGS
+end
+
+class InitBlockTest
+  initializer *INIT_ARGS do
+    @block_run = true
+  end
+
+  def block_run?
+    @block_run
+  end
+end

data/spec/support/matchers.rb

@@ -0,0 +1,17 @@
+RSpec::Matchers.define :have_instance_variables do |*vars|
+  match do |target|
+    (vars - target.instance_variables).empty?
+  end
+
+  failure_message do |target|
+    "expected #{target.inspect} to have all of the following instance variables: " +
+    "\n  #{vars.inspect}" +
+    "\nInstead it contains:\n  #{target.instance_variables.inspect}"
+  end
+
+  failure_message_when_negated do |target|
+    "expected #{target.inspect} to not have any of the following instance variables: " +
+    "\n  #{vars.inspect}" +
+    "\nIt contains:\n  #{target.instance_variables.inspect}"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nutella
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: '0.12'
 platform: ruby
 authors:
 - Vinny Diehl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-15 00:00:00.000000000 Z
+date: 2014-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fuubar
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -104,6 +104,7 @@ files:
 - lib/nutella/version.rb
 - lib/nutella/input.rb
 - lib/nutella/core_ext/enumerable.rb
+- lib/nutella/core_ext/module.rb
 - lib/nutella/core_ext/string.rb
 - lib/nutella/core_ext/string/exclude.rb
 - lib/nutella/core_ext/string/colour.rb
@@ -130,6 +131,7 @@ files:
 - lib/nutella.rb
 - spec/nutella/core_ext/file_spec.rb
 - spec/nutella/core_ext/string_spec.rb
+- spec/nutella/core_ext/module_spec.rb
 - spec/nutella/core_ext/enumerable_spec.rb
 - spec/nutella/core_ext/numeric_spec.rb
 - spec/nutella/core_ext/hash_spec.rb
@@ -138,6 +140,8 @@ files:
 - spec/support/alias.rb
 - spec/support/number_formats.rb
 - spec/support/apply_tester.rb
+- spec/support/matchers.rb
+- spec/support/initializer_testers.rb
 - spec/spec_helper.rb
 - .rspec
 - LICENSE
@@ -171,6 +175,7 @@ summary: Spread some Nutella on Ruby to sweeten up its functionality.
 test_files:
 - spec/nutella/core_ext/file_spec.rb
 - spec/nutella/core_ext/string_spec.rb
+- spec/nutella/core_ext/module_spec.rb
 - spec/nutella/core_ext/enumerable_spec.rb
 - spec/nutella/core_ext/numeric_spec.rb
 - spec/nutella/core_ext/hash_spec.rb
@@ -179,5 +184,7 @@ test_files:
 - spec/support/alias.rb
 - spec/support/number_formats.rb
 - spec/support/apply_tester.rb
+- spec/support/matchers.rb
+- spec/support/initializer_testers.rb
 - spec/spec_helper.rb
 has_rdoc: